tests/include/ApiTest.php

   1 <?php
   2 /**
   3  * ApiTest class.
   4  */
   5
   6 namespace Friendica\Test;
   7
   8 use Friendica\BaseObject;
   9 use Friendica\Core\Config;
  10 use Friendica\Core\PConfig;
  11 use Friendica\Core\Protocol;
  12 use Friendica\Core\System;
  13 use Friendica\Network\HTTPException;
  14
  15 require_once __DIR__ . '/../../include/api.php';
  16
  17 /**
  18  * Tests for the API functions.
  19  *
  20  * Functions that use header() need to be tested in a separate process.
  21  * @see https://phpunit.de/manual/5.7/en/appendixes.annotations.html#appendixes.annotations.runTestsInSeparateProcesses
  22  */
  23 class ApiTest extends DatabaseTest
  24 {
  25         /**
  26          * Create variables used by tests.
  27          */
  28         public function setUp()
  29         {
  30                 parent::setUp();
  31
  32                 $this->app = BaseObject::getApp();
  33
  34                 // User data that the test database is populated with
  35                 $this->selfUser = [
  36                         'id' => 42,
  37                         'name' => 'Self contact',
  38                         'nick' => 'selfcontact',
  39                         'nurl' => 'http://localhost/profile/selfcontact'
  40                 ];
  41                 $this->friendUser = [
  42                         'id' => 44,
  43                         'name' => 'Friend contact',
  44                         'nick' => 'friendcontact',
  45                         'nurl' => 'http://localhost/profile/friendcontact'
  46                 ];
  47                 $this->otherUser = [
  48                         'id' => 43,
  49                         'name' => 'othercontact',
  50                         'nick' => 'othercontact',
  51                         'nurl' => 'http://localhost/profile/othercontact'
  52                 ];
  53
  54                 // User ID that we know is not in the database
  55                 $this->wrongUserId = 666;
  56
  57                 // Most API require login so we force the session
  58                 $_SESSION = [
  59                         'allow_api' => true,
  60                         'authenticated' => true,
  61                         'uid' => $this->selfUser['id']
  62                 ];
  63
  64                 Config::set('system', 'url', 'http://localhost');
  65                 Config::set('system', 'hostname', 'localhost');
  66                 Config::set('system', 'worker_dont_fork', true);
  67
  68                 // Default config
  69                 Config::set('config', 'hostname', 'localhost');
  70                 Config::set('system', 'throttle_limit_day', 100);
  71                 Config::set('system', 'throttle_limit_week', 100);
  72                 Config::set('system', 'throttle_limit_month', 100);
  73                 Config::set('system', 'theme', 'system_theme');
  74         }
  75
  76         /**
  77          * Cleanup variables used by tests.
  78          */
  79         protected function tearDown()
  80         {
  81                 parent::tearDown();
  82
  83                 $this->app->argc = 1;
  84                 $this->app->argv = ['home'];
  85         }
  86
  87         /**
  88          * Assert that an user array contains expected keys.
  89          * @param array $user User array
  90          * @return void
  91          */
  92         private function assertSelfUser(array $user)
  93         {
  94                 $this->assertEquals($this->selfUser['id'], $user['uid']);
  95                 $this->assertEquals($this->selfUser['id'], $user['cid']);
  96                 $this->assertEquals(1, $user['self']);
  97                 $this->assertEquals('DFRN', $user['location']);
  98                 $this->assertEquals($this->selfUser['name'], $user['name']);
  99                 $this->assertEquals($this->selfUser['nick'], $user['screen_name']);
 100                 $this->assertEquals('dfrn', $user['network']);
 101                 $this->assertTrue($user['verified']);
 102         }
 103
 104         /**
 105          * Assert that an user array contains expected keys.
 106          * @param array $user User array
 107          * @return void
 108          */
 109         private function assertOtherUser(array $user)
 110         {
 111                 $this->assertEquals($this->otherUser['id'], $user['id']);
 112                 $this->assertEquals($this->otherUser['id'], $user['id_str']);
 113                 $this->assertEquals(0, $user['self']);
 114                 $this->assertEquals($this->otherUser['name'], $user['name']);
 115                 $this->assertEquals($this->otherUser['nick'], $user['screen_name']);
 116                 $this->assertFalse($user['verified']);
 117         }
 118
 119         /**
 120          * Assert that a status array contains expected keys.
 121          * @param array $status Status array
 122          * @return void
 123          */
 124         private function assertStatus(array $status)
 125         {
 126                 $this->assertInternalType('string', $status['text']);
 127                 $this->assertInternalType('int', $status['id']);
 128                 // We could probably do more checks here.
 129         }
 130
 131         /**
 132          * Assert that a list array contains expected keys.
 133          * @param array $list List array
 134          * @return void
 135          */
 136         private function assertList(array $list)
 137         {
 138                 $this->assertInternalType('string', $list['name']);
 139                 $this->assertInternalType('int', $list['id']);
 140                 $this->assertInternalType('string', $list['id_str']);
 141                 $this->assertContains($list['mode'], ['public', 'private']);
 142                 // We could probably do more checks here.
 143         }
 144
 145         /**
 146          * Assert that the string is XML and contain the root element.
 147          * @param string $result       XML string
 148          * @param string $root_element Root element name
 149          * @return void
 150          */
 151         private function assertXml($result, $root_element)
 152         {
 153                 $this->assertStringStartsWith('<?xml version="1.0"?>', $result);
 154                 $this->assertContains('<'.$root_element, $result);
 155                 // We could probably do more checks here.
 156         }
 157
 158         /**
 159          * Get the path to a temporary empty PNG image.
 160          * @return string Path
 161          */
 162         private function getTempImage()
 163         {
 164                 $tmpFile = tempnam(sys_get_temp_dir(), 'tmp_file');
 165                 file_put_contents(
 166                         $tmpFile,
 167                         base64_decode(
 168                                 // Empty 1x1 px PNG image
 169                                 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=='
 170                         )
 171                 );
 172
 173                 return $tmpFile;
 174         }
 175
 176         /**
 177          * Test the api_user() function.
 178          * @return void
 179          */
 180         public function testApiUser()
 181         {
 182                 $this->assertEquals($this->selfUser['id'], api_user());
 183         }
 184
 185         /**
 186          * Test the api_user() function with an unallowed user.
 187          * @return void
 188          */
 189         public function testApiUserWithUnallowedUser()
 190         {
 191                 $_SESSION = ['allow_api' => false];
 192                 $this->assertEquals(false, api_user());
 193         }
 194
 195         /**
 196          * Test the api_source() function.
 197          * @return void
 198          */
 199         public function testApiSource()
 200         {
 201                 $this->assertEquals('api', api_source());
 202         }
 203
 204         /**
 205          * Test the api_source() function with a Twidere user agent.
 206          * @return void
 207          */
 208         public function testApiSourceWithTwidere()
 209         {
 210                 $_SERVER['HTTP_USER_AGENT'] = 'Twidere';
 211                 $this->assertEquals('Twidere', api_source());
 212         }
 213
 214         /**
 215          * Test the api_source() function with a GET parameter.
 216          * @return void
 217          */
 218         public function testApiSourceWithGet()
 219         {
 220                 $_GET['source'] = 'source_name';
 221                 $this->assertEquals('source_name', api_source());
 222         }
 223
 224         /**
 225          * Test the api_date() function.
 226          * @return void
 227          */
 228         public function testApiDate()
 229         {
 230                 $this->assertEquals('Wed Oct 10 00:00:00 +0000 1990', api_date('1990-10-10'));
 231         }
 232
 233         /**
 234          * Test the api_register_func() function.
 235          * @return void
 236          */
 237         public function testApiRegisterFunc()
 238         {
 239                 global $API;
 240                 $this->assertNull(
 241                         api_register_func(
 242                                 'api_path',
 243                                 function () {
 244                                 },
 245                                 true,
 246                                 'method'
 247                         )
 248                 );
 249                 $this->assertTrue($API['api_path']['auth']);
 250                 $this->assertEquals('method', $API['api_path']['method']);
 251                 $this->assertTrue(is_callable($API['api_path']['func']));
 252         }
 253
 254         /**
 255          * Test the api_login() function without any login.
 256          * @return void
 257          * @runInSeparateProcess
 258          * @expectedException Friendica\Network\HTTPException\UnauthorizedException
 259          */
 260         public function testApiLoginWithoutLogin()
 261         {
 262                 api_login($this->app);
 263         }
 264
 265         /**
 266          * Test the api_login() function with a bad login.
 267          * @return void
 268          * @runInSeparateProcess
 269          * @expectedException Friendica\Network\HTTPException\UnauthorizedException
 270          */
 271         public function testApiLoginWithBadLogin()
 272         {
 273                 $_SERVER['PHP_AUTH_USER'] = 'user@server';
 274                 api_login($this->app);
 275         }
 276
 277         /**
 278          * Test the api_login() function with oAuth.
 279          * @return void
 280          */
 281         public function testApiLoginWithOauth()
 282         {
 283                 $this->markTestIncomplete('Can we test this easily?');
 284         }
 285
 286         /**
 287          * Test the api_login() function with authentication provided by an addon.
 288          * @return void
 289          */
 290         public function testApiLoginWithAddonAuth()
 291         {
 292                 $this->markTestIncomplete('Can we test this easily?');
 293         }
 294
 295         /**
 296          * Test the api_login() function with a correct login.
 297          * @return void
 298          * @runInSeparateProcess
 299          */
 300         public function testApiLoginWithCorrectLogin()
 301         {
 302                 $_SERVER['PHP_AUTH_USER'] = 'Test user';
 303                 $_SERVER['PHP_AUTH_PW'] = 'password';
 304                 api_login($this->app);
 305         }
 306
 307         /**
 308          * Test the api_login() function with a remote user.
 309          * @return void
 310          * @runInSeparateProcess
 311          * @expectedException Friendica\Network\HTTPException\UnauthorizedException
 312          */
 313         public function testApiLoginWithRemoteUser()
 314         {
 315                 $_SERVER['REDIRECT_REMOTE_USER'] = '123456dXNlcjpwYXNzd29yZA==';
 316                 api_login($this->app);
 317         }
 318
 319         /**
 320          * Test the api_check_method() function.
 321          * @return void
 322          */
 323         public function testApiCheckMethod()
 324         {
 325                 $this->assertFalse(api_check_method('method'));
 326         }
 327
 328         /**
 329          * Test the api_check_method() function with a correct method.
 330          * @return void
 331          */
 332         public function testApiCheckMethodWithCorrectMethod()
 333         {
 334                 $_SERVER['REQUEST_METHOD'] = 'method';
 335                 $this->assertTrue(api_check_method('method'));
 336         }
 337
 338         /**
 339          * Test the api_check_method() function with a wildcard.
 340          * @return void
 341          */
 342         public function testApiCheckMethodWithWildcard()
 343         {
 344                 $this->assertTrue(api_check_method('*'));
 345         }
 346
 347         /**
 348          * Test the api_call() function.
 349          * @return void
 350          * @runInSeparateProcess
 351          */
 352         public function testApiCall()
 353         {
 354                 global $API;
 355                 $API['api_path'] = [
 356                         'method' => 'method',
 357                         'func' => function () {
 358                                 return ['data' => ['some_data']];
 359                         }
 360                 ];
 361                 $_SERVER['REQUEST_METHOD'] = 'method';
 362                 $_GET['callback'] = 'callback_name';
 363
 364                 $this->app->query_string = 'api_path';
 365                 $this->assertEquals(
 366                         'callback_name(["some_data"])',
 367                         api_call($this->app)
 368                 );
 369         }
 370
 371         /**
 372          * Test the api_call() function with the profiled enabled.
 373          * @return void
 374          * @runInSeparateProcess
 375          */
 376         public function testApiCallWithProfiler()
 377         {
 378                 global $API;
 379                 $API['api_path'] = [
 380                         'method' => 'method',
 381                         'func' => function () {
 382                                 return ['data' => ['some_data']];
 383                         }
 384                 ];
 385                 $_SERVER['REQUEST_METHOD'] = 'method';
 386                 Config::set('system', 'profiler', true);
 387                 Config::set('rendertime', 'callstack', true);
 388                 $this->app->callstack = [
 389                         'database' => ['some_function' => 200],
 390                         'database_write' => ['some_function' => 200],
 391                         'cache' => ['some_function' => 200],
 392                         'cache_write' => ['some_function' => 200],
 393                         'network' => ['some_function' => 200]
 394                 ];
 395
 396                 $this->app->query_string = 'api_path';
 397                 $this->assertEquals(
 398                         '["some_data"]',
 399                         api_call($this->app)
 400                 );
 401         }
 402
 403         /**
 404          * Test the api_call() function without any result.
 405          * @return void
 406          * @runInSeparateProcess
 407          */
 408         public function testApiCallWithNoResult()
 409         {
 410                 global $API;
 411                 $API['api_path'] = [
 412                         'method' => 'method',
 413                         'func' => function () {
 414                                 return false;
 415                         }
 416                 ];
 417                 $_SERVER['REQUEST_METHOD'] = 'method';
 418
 419                 $this->app->query_string = 'api_path';
 420                 $this->assertEquals(
 421                         '{"status":{"error":"Internal Server Error","code":"500 Internal Server Error","request":"api_path"}}',
 422                         api_call($this->app)
 423                 );
 424         }
 425
 426         /**
 427          * Test the api_call() function with an unimplemented API.
 428          * @return void
 429          * @runInSeparateProcess
 430          */
 431         public function testApiCallWithUninplementedApi()
 432         {
 433                 $this->assertEquals(
 434                         '{"status":{"error":"Not Implemented","code":"501 Not Implemented","request":""}}',
 435                         api_call($this->app)
 436                 );
 437         }
 438
 439         /**
 440          * Test the api_call() function with a JSON result.
 441          * @return void
 442          * @runInSeparateProcess
 443          */
 444         public function testApiCallWithJson()
 445         {
 446                 global $API;
 447                 $API['api_path'] = [
 448                         'method' => 'method',
 449                         'func' => function () {
 450                                 return ['data' => ['some_data']];
 451                         }
 452                 ];
 453                 $_SERVER['REQUEST_METHOD'] = 'method';
 454
 455                 $this->app->query_string = 'api_path.json';
 456                 $this->assertEquals(
 457                         '["some_data"]',
 458                         api_call($this->app)
 459                 );
 460         }
 461
 462         /**
 463          * Test the api_call() function with an XML result.
 464          * @return void
 465          * @runInSeparateProcess
 466          */
 467         public function testApiCallWithXml()
 468         {
 469                 global $API;
 470                 $API['api_path'] = [
 471                         'method' => 'method',
 472                         'func' => function () {
 473                                 return 'some_data';
 474                         }
 475                 ];
 476                 $_SERVER['REQUEST_METHOD'] = 'method';
 477
 478                 $this->app->query_string = 'api_path.xml';
 479                 $this->assertEquals(
 480                         'some_data',
 481                         api_call($this->app)
 482                 );
 483         }
 484
 485         /**
 486          * Test the api_call() function with an RSS result.
 487          * @return void
 488          * @runInSeparateProcess
 489          */
 490         public function testApiCallWithRss()
 491         {
 492                 global $API;
 493                 $API['api_path'] = [
 494                         'method' => 'method',
 495                         'func' => function () {
 496                                 return 'some_data';
 497                         }
 498                 ];
 499                 $_SERVER['REQUEST_METHOD'] = 'method';
 500
 501                 $this->app->query_string = 'api_path.rss';
 502                 $this->assertEquals(
 503                         '<?xml version="1.0" encoding="UTF-8"?>'."\n".
 504                                 'some_data',
 505                         api_call($this->app)
 506                 );
 507         }
 508
 509         /**
 510          * Test the api_call() function with an Atom result.
 511          * @return void
 512          * @runInSeparateProcess
 513          */
 514         public function testApiCallWithAtom()
 515         {
 516                 global $API;
 517                 $API['api_path'] = [
 518                         'method' => 'method',
 519                         'func' => function () {
 520                                 return 'some_data';
 521                         }
 522                 ];
 523                 $_SERVER['REQUEST_METHOD'] = 'method';
 524
 525                 $this->app->query_string = 'api_path.atom';
 526                 $this->assertEquals(
 527                         '<?xml version="1.0" encoding="UTF-8"?>'."\n".
 528                                 'some_data',
 529                         api_call($this->app)
 530                 );
 531         }
 532
 533         /**
 534          * Test the api_call() function with an unallowed method.
 535          * @return void
 536          * @runInSeparateProcess
 537          */
 538         public function testApiCallWithWrongMethod()
 539         {
 540                 global $API;
 541                 $API['api_path'] = ['method' => 'method'];
 542
 543                 $this->app->query_string = 'api_path';
 544                 $this->assertEquals(
 545                         '{"status":{"error":"Method Not Allowed","code":"405 Method Not Allowed","request":"api_path"}}',
 546                         api_call($this->app)
 547                 );
 548         }
 549
 550         /**
 551          * Test the api_call() function with an unauthorized user.
 552          * @return void
 553          * @runInSeparateProcess
 554          */
 555         public function testApiCallWithWrongAuth()
 556         {
 557                 global $API;
 558                 $API['api_path'] = [
 559                         'method' => 'method',
 560                         'auth' => true
 561                 ];
 562                 $_SERVER['REQUEST_METHOD'] = 'method';
 563                 $_SESSION['authenticated'] = false;
 564
 565                 $this->app->query_string = 'api_path';
 566                 $this->assertEquals(
 567                         '{"status":{"error":"This API requires login","code":"401 Unauthorized","request":"api_path"}}',
 568                         api_call($this->app)
 569                 );
 570         }
 571
 572         /**
 573          * Test the api_error() function with a JSON result.
 574          * @return void
 575          * @runInSeparateProcess
 576          */
 577         public function testApiErrorWithJson()
 578         {
 579                 $this->assertEquals(
 580                         '{"status":{"error":"error_message","code":"200 Friendica\\\\Network\\\\HTTP","request":""}}',
 581                         api_error('json', new HTTPException('error_message'))
 582                 );
 583         }
 584
 585         /**
 586          * Test the api_error() function with an XML result.
 587          * @return void
 588          * @runInSeparateProcess
 589          */
 590         public function testApiErrorWithXml()
 591         {
 592                 $this->assertEquals(
 593                         '<?xml version="1.0"?>'."\n".
 594                         '<status xmlns="http://api.twitter.com" xmlns:statusnet="http://status.net/schema/api/1/" '.
 595                                 'xmlns:friendica="http://friendi.ca/schema/api/1/" '.
 596                                 'xmlns:georss="http://www.georss.org/georss">'."\n".
 597                         '  <error>error_message</error>'."\n".
 598                         '  <code>200 Friendica\Network\HTTP</code>'."\n".
 599                         '  <request/>'."\n".
 600                         '</status>'."\n",
 601                         api_error('xml', new HTTPException('error_message'))
 602                 );
 603         }
 604
 605         /**
 606          * Test the api_error() function with an RSS result.
 607          * @return void
 608          * @runInSeparateProcess
 609          */
 610         public function testApiErrorWithRss()
 611         {
 612                 $this->assertEquals(
 613                         '<?xml version="1.0"?>'."\n".
 614                         '<status xmlns="http://api.twitter.com" xmlns:statusnet="http://status.net/schema/api/1/" '.
 615                                 'xmlns:friendica="http://friendi.ca/schema/api/1/" '.
 616                                 'xmlns:georss="http://www.georss.org/georss">'."\n".
 617                         '  <error>error_message</error>'."\n".
 618                         '  <code>200 Friendica\Network\HTTP</code>'."\n".
 619                         '  <request/>'."\n".
 620                         '</status>'."\n",
 621                         api_error('rss', new HTTPException('error_message'))
 622                 );
 623         }
 624
 625         /**
 626          * Test the api_error() function with an Atom result.
 627          * @return void
 628          * @runInSeparateProcess
 629          */
 630         public function testApiErrorWithAtom()
 631         {
 632                 $this->assertEquals(
 633                         '<?xml version="1.0"?>'."\n".
 634                         '<status xmlns="http://api.twitter.com" xmlns:statusnet="http://status.net/schema/api/1/" '.
 635                                 'xmlns:friendica="http://friendi.ca/schema/api/1/" '.
 636                                 'xmlns:georss="http://www.georss.org/georss">'."\n".
 637                         '  <error>error_message</error>'."\n".
 638                         '  <code>200 Friendica\Network\HTTP</code>'."\n".
 639                         '  <request/>'."\n".
 640                         '</status>'."\n",
 641                         api_error('atom', new HTTPException('error_message'))
 642                 );
 643         }
 644
 645         /**
 646          * Test the api_rss_extra() function.
 647          * @return void
 648          */
 649         public function testApiRssExtra()
 650         {
 651                 $user_info = ['url' => 'user_url', 'lang' => 'en'];
 652                 $result = api_rss_extra($this->app, [], $user_info);
 653                 $this->assertEquals($user_info, $result['$user']);
 654                 $this->assertEquals($user_info['url'], $result['$rss']['alternate']);
 655                 $this->assertArrayHasKey('self', $result['$rss']);
 656                 $this->assertArrayHasKey('base', $result['$rss']);
 657                 $this->assertArrayHasKey('updated', $result['$rss']);
 658                 $this->assertArrayHasKey('atom_updated', $result['$rss']);
 659                 $this->assertArrayHasKey('language', $result['$rss']);
 660                 $this->assertArrayHasKey('logo', $result['$rss']);
 661         }
 662
 663         /**
 664          * Test the api_rss_extra() function without any user info.
 665          * @return void
 666          * @runInSeparateProcess
 667          */
 668         public function testApiRssExtraWithoutUserInfo()
 669         {
 670                 $result = api_rss_extra($this->app, [], null);
 671                 $this->assertInternalType('array', $result['$user']);
 672                 $this->assertArrayHasKey('alternate', $result['$rss']);
 673                 $this->assertArrayHasKey('self', $result['$rss']);
 674                 $this->assertArrayHasKey('base', $result['$rss']);
 675                 $this->assertArrayHasKey('updated', $result['$rss']);
 676                 $this->assertArrayHasKey('atom_updated', $result['$rss']);
 677                 $this->assertArrayHasKey('language', $result['$rss']);
 678                 $this->assertArrayHasKey('logo', $result['$rss']);
 679         }
 680
 681         /**
 682          * Test the api_unique_id_to_nurl() function.
 683          * @return void
 684          */
 685         public function testApiUniqueIdToNurl()
 686         {
 687                 $this->assertFalse(api_unique_id_to_nurl($this->wrongUserId));
 688         }
 689
 690         /**
 691          * Test the api_unique_id_to_nurl() function with a correct ID.
 692          * @return void
 693          */
 694         public function testApiUniqueIdToNurlWithCorrectId()
 695         {
 696                 $this->assertEquals($this->otherUser['nurl'], api_unique_id_to_nurl($this->otherUser['id']));
 697         }
 698
 699         /**
 700          * Test the api_get_user() function.
 701          * @return void
 702          * @runInSeparateProcess
 703          */
 704         public function testApiGetUser()
 705         {
 706                 $user = api_get_user($this->app);
 707                 $this->assertSelfUser($user);
 708                 $this->assertEquals('708fa0', $user['profile_sidebar_fill_color']);
 709                 $this->assertEquals('6fdbe8', $user['profile_link_color']);
 710                 $this->assertEquals('ededed', $user['profile_background_color']);
 711         }
 712
 713         /**
 714          * Test the api_get_user() function with a Frio schema.
 715          * @return void
 716          * @runInSeparateProcess
 717          */
 718         public function testApiGetUserWithFrioSchema()
 719         {
 720                 PConfig::set($this->selfUser['id'], 'frio', 'schema', 'red');
 721                 $user = api_get_user($this->app);
 722                 $this->assertSelfUser($user);
 723                 $this->assertEquals('708fa0', $user['profile_sidebar_fill_color']);
 724                 $this->assertEquals('6fdbe8', $user['profile_link_color']);
 725                 $this->assertEquals('ededed', $user['profile_background_color']);
 726         }
 727
 728         /**
 729          * Test the api_get_user() function with a custom Frio schema.
 730          * @return void
 731          * @runInSeparateProcess
 732          */
 733         public function testApiGetUserWithCustomFrioSchema()
 734         {
 735                 $ret1 = PConfig::set($this->selfUser['id'], 'frio', 'schema', '---');
 736                 $ret2 = PConfig::set($this->selfUser['id'], 'frio', 'nav_bg', '#123456');
 737                 $ret3 = PConfig::set($this->selfUser['id'], 'frio', 'link_color', '#123456');
 738                 $ret4 = PConfig::set($this->selfUser['id'], 'frio', 'background_color', '#123456');
 739                 $user = api_get_user($this->app);
 740                 $this->assertSelfUser($user);
 741                 $this->assertEquals('123456', $user['profile_sidebar_fill_color']);
 742                 $this->assertEquals('123456', $user['profile_link_color']);
 743                 $this->assertEquals('123456', $user['profile_background_color']);
 744         }
 745
 746         /**
 747          * Test the api_get_user() function with an empty Frio schema.
 748          * @return void
 749          * @runInSeparateProcess
 750          */
 751         public function testApiGetUserWithEmptyFrioSchema()
 752         {
 753                 PConfig::set($this->selfUser['id'], 'frio', 'schema', '---');
 754                 $user = api_get_user($this->app);
 755                 $this->assertSelfUser($user);
 756                 $this->assertEquals('708fa0', $user['profile_sidebar_fill_color']);
 757                 $this->assertEquals('6fdbe8', $user['profile_link_color']);
 758                 $this->assertEquals('ededed', $user['profile_background_color']);
 759         }
 760
 761         /**
 762          * Test the api_get_user() function with an user that is not allowed to use the API.
 763          * @return void
 764          * @runInSeparateProcess
 765          */
 766         public function testApiGetUserWithoutApiUser()
 767         {
 768                 $_SERVER['PHP_AUTH_USER'] = 'Test user';
 769                 $_SERVER['PHP_AUTH_PW'] = 'password';
 770                 $_SESSION['allow_api'] = false;
 771                 $this->assertFalse(api_get_user($this->app));
 772         }
 773
 774         /**
 775          * Test the api_get_user() function with an user ID in a GET parameter.
 776          * @return void
 777          * @runInSeparateProcess
 778          */
 779         public function testApiGetUserWithGetId()
 780         {
 781                 $_GET['user_id'] = $this->otherUser['id'];
 782                 $this->assertOtherUser(api_get_user($this->app));
 783         }
 784
 785         /**
 786          * Test the api_get_user() function with a wrong user ID in a GET parameter.
 787          * @return void
 788          * @runInSeparateProcess
 789          * @expectedException Friendica\Network\HTTPException\BadRequestException
 790          */
 791         public function testApiGetUserWithWrongGetId()
 792         {
 793                 $_GET['user_id'] = $this->wrongUserId;
 794                 $this->assertOtherUser(api_get_user($this->app));
 795         }
 796
 797         /**
 798          * Test the api_get_user() function with an user name in a GET parameter.
 799          * @return void
 800          * @runInSeparateProcess
 801          */
 802         public function testApiGetUserWithGetName()
 803         {
 804                 $_GET['screen_name'] = $this->selfUser['nick'];
 805                 $this->assertSelfUser(api_get_user($this->app));
 806         }
 807
 808         /**
 809          * Test the api_get_user() function with a profile URL in a GET parameter.
 810          * @return void
 811          * @runInSeparateProcess
 812          */
 813         public function testApiGetUserWithGetUrl()
 814         {
 815                 $_GET['profileurl'] = $this->selfUser['nurl'];
 816                 $this->assertSelfUser(api_get_user($this->app));
 817         }
 818
 819         /**
 820          * Test the api_get_user() function with an user ID in the API path.
 821          * @return void
 822          * @runInSeparateProcess
 823          */
 824         public function testApiGetUserWithNumericCalledApi()
 825         {
 826                 global $called_api;
 827                 $called_api = ['api_path'];
 828                 $this->app->argv[1] = $this->otherUser['id'].'.json';
 829                 $this->assertOtherUser(api_get_user($this->app));
 830         }
 831
 832         /**
 833          * Test the api_get_user() function with the $called_api global variable.
 834          * @return void
 835          * @runInSeparateProcess
 836          */
 837         public function testApiGetUserWithCalledApi()
 838         {
 839                 global $called_api;
 840                 $called_api = ['api', 'api_path'];
 841                 $this->assertSelfUser(api_get_user($this->app));
 842         }
 843
 844         /**
 845          * Test the api_get_user() function with a valid user.
 846          * @return void
 847          * @runInSeparateProcess
 848          */
 849         public function testApiGetUserWithCorrectUser()
 850         {
 851                 $this->assertOtherUser(api_get_user($this->app, $this->otherUser['id']));
 852         }
 853
 854         /**
 855          * Test the api_get_user() function with a wrong user ID.
 856          * @return void
 857          * @runInSeparateProcess
 858          * @expectedException Friendica\Network\HTTPException\BadRequestException
 859          */
 860         public function testApiGetUserWithWrongUser()
 861         {
 862                 $this->assertOtherUser(api_get_user($this->app, $this->wrongUserId));
 863         }
 864
 865         /**
 866          * Test the api_get_user() function with a 0 user ID.
 867          * @return void
 868          * @runInSeparateProcess
 869          */
 870         public function testApiGetUserWithZeroUser()
 871         {
 872                 $this->assertSelfUser(api_get_user($this->app, 0));
 873         }
 874
 875         /**
 876          * Test the api_item_get_user() function.
 877          * @return void
 878          * @runInSeparateProcess
 879          */
 880         public function testApiItemGetUser()
 881         {
 882                 $users = api_item_get_user($this->app, []);
 883                 $this->assertSelfUser($users[0]);
 884         }
 885
 886         /**
 887          * Test the api_item_get_user() function with a different item parent.
 888          * @return void
 889          */
 890         public function testApiItemGetUserWithDifferentParent()
 891         {
 892                 $users = api_item_get_user($this->app, ['thr-parent' => 'item_parent', 'uri' => 'item_uri']);
 893                 $this->assertSelfUser($users[0]);
 894                 $this->assertEquals($users[0], $users[1]);
 895         }
 896
 897         /**
 898          * Test the api_walk_recursive() function.
 899          * @return void
 900          */
 901         public function testApiWalkRecursive()
 902         {
 903                 $array = ['item1'];
 904                 $this->assertEquals(
 905                         $array,
 906                         api_walk_recursive(
 907                                 $array,
 908                                 function () {
 909                                         // Should we test this with a callback that actually does something?
 910                                         return true;
 911                                 }
 912                         )
 913                 );
 914         }
 915
 916         /**
 917          * Test the api_walk_recursive() function with an array.
 918          * @return void
 919          */
 920         public function testApiWalkRecursiveWithArray()
 921         {
 922                 $array = [['item1'], ['item2']];
 923                 $this->assertEquals(
 924                         $array,
 925                         api_walk_recursive(
 926                                 $array,
 927                                 function () {
 928                                         // Should we test this with a callback that actually does something?
 929                                         return true;
 930                                 }
 931                         )
 932                 );
 933         }
 934
 935         /**
 936          * Test the api_reformat_xml() function.
 937          * @return void
 938          */
 939         public function testApiReformatXml()
 940         {
 941                 $item = true;
 942                 $key = '';
 943                 $this->assertTrue(api_reformat_xml($item, $key));
 944                 $this->assertEquals('true', $item);
 945         }
 946
 947         /**
 948          * Test the api_reformat_xml() function with a statusnet_api key.
 949          * @return void
 950          */
 951         public function testApiReformatXmlWithStatusnetKey()
 952         {
 953                 $item = '';
 954                 $key = 'statusnet_api';
 955                 $this->assertTrue(api_reformat_xml($item, $key));
 956                 $this->assertEquals('statusnet:api', $key);
 957         }
 958
 959         /**
 960          * Test the api_reformat_xml() function with a friendica_api key.
 961          * @return void
 962          */
 963         public function testApiReformatXmlWithFriendicaKey()
 964         {
 965                 $item = '';
 966                 $key = 'friendica_api';
 967                 $this->assertTrue(api_reformat_xml($item, $key));
 968                 $this->assertEquals('friendica:api', $key);
 969         }
 970
 971         /**
 972          * Test the api_create_xml() function.
 973          * @return void
 974          */
 975         public function testApiCreateXml()
 976         {
 977                 $this->assertEquals(
 978                         '<?xml version="1.0"?>'."\n".
 979                         '<root_element xmlns="http://api.twitter.com" xmlns:statusnet="http://status.net/schema/api/1/" '.
 980                                 'xmlns:friendica="http://friendi.ca/schema/api/1/" '.
 981                                 'xmlns:georss="http://www.georss.org/georss">'."\n".
 982                                 '  <data>some_data</data>'."\n".
 983                         '</root_element>'."\n",
 984                         api_create_xml(['data' => ['some_data']], 'root_element')
 985                 );
 986         }
 987
 988         /**
 989          * Test the api_create_xml() function without any XML namespace.
 990          * @return void
 991          */
 992         public function testApiCreateXmlWithoutNamespaces()
 993         {
 994                 $this->assertEquals(
 995                         '<?xml version="1.0"?>'."\n".
 996                         '<ok>'."\n".
 997                                 '  <data>some_data</data>'."\n".
 998                         '</ok>'."\n",
 999                         api_create_xml(['data' => ['some_data']], 'ok')
1000                 );
1001         }
1002
1003         /**
1004          * Test the api_format_data() function.
1005          * @return void
1006          */
1007         public function testApiFormatData()
1008         {
1009                 $data = ['some_data'];
1010                 $this->assertEquals($data, api_format_data('root_element', 'json', $data));
1011         }
1012
1013         /**
1014          * Test the api_format_data() function with an XML result.
1015          * @return void
1016          */
1017         public function testApiFormatDataWithXml()
1018         {
1019                 $this->assertEquals(
1020                         '<?xml version="1.0"?>'."\n".
1021                         '<root_element xmlns="http://api.twitter.com" xmlns:statusnet="http://status.net/schema/api/1/" '.
1022                                 'xmlns:friendica="http://friendi.ca/schema/api/1/" '.
1023                                 'xmlns:georss="http://www.georss.org/georss">'."\n".
1024                                 '  <data>some_data</data>'."\n".
1025                         '</root_element>'."\n",
1026                         api_format_data('root_element', 'xml', ['data' => ['some_data']])
1027                 );
1028         }
1029
1030         /**
1031          * Test the api_account_verify_credentials() function.
1032          * @return void
1033          */
1034         public function testApiAccountVerifyCredentials()
1035         {
1036                 $this->assertArrayHasKey('user', api_account_verify_credentials('json'));
1037         }
1038
1039         /**
1040          * Test the api_account_verify_credentials() function without an authenticated user.
1041          * @return void
1042          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1043          */
1044         public function testApiAccountVerifyCredentialsWithoutAuthenticatedUser()
1045         {
1046                 $_SESSION['authenticated'] = false;
1047                 api_account_verify_credentials('json');
1048         }
1049
1050         /**
1051          * Test the requestdata() function.
1052          * @return void
1053          */
1054         public function testRequestdata()
1055         {
1056                 $this->assertNull(requestdata('variable_name'));
1057         }
1058
1059         /**
1060          * Test the requestdata() function with a POST parameter.
1061          * @return void
1062          */
1063         public function testRequestdataWithPost()
1064         {
1065                 $_POST['variable_name'] = 'variable_value';
1066                 $this->assertEquals('variable_value', requestdata('variable_name'));
1067         }
1068
1069         /**
1070          * Test the requestdata() function with a GET parameter.
1071          * @return void
1072          */
1073         public function testRequestdataWithGet()
1074         {
1075                 $_GET['variable_name'] = 'variable_value';
1076                 $this->assertEquals('variable_value', requestdata('variable_name'));
1077         }
1078
1079         /**
1080          * Test the api_statuses_mediap() function.
1081          * @return void
1082          */
1083         public function testApiStatusesMediap()
1084         {
1085                 $this->app->argc = 2;
1086
1087                 $_FILES = [
1088                         'media' => [
1089                                 'id' => 666,
1090                                 'size' => 666,
1091                                 'width' => 666,
1092                                 'height' => 666,
1093                                 'tmp_name' => $this->getTempImage(),
1094                                 'name' => 'spacer.png',
1095                                 'type' => 'image/png'
1096                         ]
1097                 ];
1098                 $_GET['status'] = '<b>Status content</b>';
1099
1100                 $result = api_statuses_mediap('json');
1101                 $this->assertStatus($result['status']);
1102         }
1103
1104         /**
1105          * Test the api_statuses_mediap() function without an authenticated user.
1106          * @return void
1107          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1108          */
1109         public function testApiStatusesMediapWithoutAuthenticatedUser()
1110         {
1111                 $_SESSION['authenticated'] = false;
1112                 api_statuses_mediap('json');
1113         }
1114
1115         /**
1116          * Test the api_statuses_update() function.
1117          * @return void
1118          */
1119         public function testApiStatusesUpdate()
1120         {
1121                 $_GET['status'] = 'Status content #friendica';
1122                 $_GET['in_reply_to_status_id'] = -1;
1123                 $_GET['lat'] = 48;
1124                 $_GET['long'] = 7;
1125                 $_FILES = [
1126                         'media' => [
1127                                 'id' => 666,
1128                                 'size' => 666,
1129                                 'width' => 666,
1130                                 'height' => 666,
1131                                 'tmp_name' => $this->getTempImage(),
1132                                 'name' => 'spacer.png',
1133                                 'type' => 'image/png'
1134                         ]
1135                 ];
1136
1137                 $result = api_statuses_update('json');
1138                 $this->assertStatus($result['status']);
1139         }
1140
1141         /**
1142          * Test the api_statuses_update() function with an HTML status.
1143          * @return void
1144          */
1145         public function testApiStatusesUpdateWithHtml()
1146         {
1147                 $_GET['htmlstatus'] = '<b>Status content</b>';
1148
1149                 $result = api_statuses_update('json');
1150                 $this->assertStatus($result['status']);
1151         }
1152
1153         /**
1154          * Test the api_statuses_update() function without an authenticated user.
1155          * @return void
1156          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1157          */
1158         public function testApiStatusesUpdateWithoutAuthenticatedUser()
1159         {
1160                 $_SESSION['authenticated'] = false;
1161                 api_statuses_update('json');
1162         }
1163
1164         /**
1165          * Test the api_statuses_update() function with a parent status.
1166          * @return void
1167          */
1168         public function testApiStatusesUpdateWithParent()
1169         {
1170                 $this->markTestIncomplete('This triggers an exit() somewhere and kills PHPUnit.');
1171         }
1172
1173         /**
1174          * Test the api_statuses_update() function with a media_ids parameter.
1175          * @return void
1176          */
1177         public function testApiStatusesUpdateWithMediaIds()
1178         {
1179                 $this->markTestIncomplete();
1180         }
1181
1182         /**
1183          * Test the api_statuses_update() function with the throttle limit reached.
1184          * @return void
1185          */
1186         public function testApiStatusesUpdateWithDayThrottleReached()
1187         {
1188                 $this->markTestIncomplete();
1189         }
1190
1191         /**
1192          * Test the api_media_upload() function.
1193          * @return void
1194          * @expectedException Friendica\Network\HTTPException\BadRequestException
1195          */
1196         public function testApiMediaUpload()
1197         {
1198                 api_media_upload();
1199         }
1200
1201         /**
1202          * Test the api_media_upload() function without an authenticated user.
1203          * @return void
1204          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1205          */
1206         public function testApiMediaUploadWithoutAuthenticatedUser()
1207         {
1208                 $_SESSION['authenticated'] = false;
1209                 api_media_upload();
1210         }
1211
1212         /**
1213          * Test the api_media_upload() function with an invalid uploaded media.
1214          * @return void
1215          * @expectedException Friendica\Network\HTTPException\InternalServerErrorException
1216          */
1217         public function testApiMediaUploadWithMedia()
1218         {
1219                 $_FILES = [
1220                         'media' => [
1221                                 'id' => 666,
1222                                 'tmp_name' => 'tmp_name'
1223                         ]
1224                 ];
1225                 api_media_upload();
1226         }
1227
1228         /**
1229          * Test the api_media_upload() function with an valid uploaded media.
1230          * @return void
1231          */
1232         public function testApiMediaUploadWithValidMedia()
1233         {
1234                 $_FILES = [
1235                         'media' => [
1236                                 'id' => 666,
1237                                 'size' => 666,
1238                                 'width' => 666,
1239                                 'height' => 666,
1240                                 'tmp_name' => $this->getTempImage(),
1241                                 'name' => 'spacer.png',
1242                                 'type' => 'image/png'
1243                         ]
1244                 ];
1245                 $app = \get_app();
1246                 $app->argc = 2;
1247
1248                 $result = api_media_upload();
1249                 $this->assertEquals('image/png', $result['media']['image']['image_type']);
1250                 $this->assertEquals(1, $result['media']['image']['w']);
1251                 $this->assertEquals(1, $result['media']['image']['h']);
1252                 $this->assertNotEmpty($result['media']['image']['friendica_preview_url']);
1253         }
1254
1255         /**
1256          * Test the api_status_show() function.
1257          * @return void
1258          */
1259         public function testApiStatusShow()
1260         {
1261                 $result = api_status_show('json');
1262                 $this->assertStatus($result['status']);
1263         }
1264
1265         /**
1266          * Test the api_status_show() function with an XML result.
1267          * @return void
1268          */
1269         public function testApiStatusShowWithXml()
1270         {
1271                 $result = api_status_show('xml');
1272                 $this->assertXml($result, 'statuses');
1273         }
1274
1275         /**
1276          * Test the api_status_show() function with a raw result.
1277          * @return void
1278          */
1279         public function testApiStatusShowWithRaw()
1280         {
1281                 $this->assertStatus(api_status_show('raw'));
1282         }
1283
1284         /**
1285          * Test the api_users_show() function.
1286          * @return void
1287          */
1288         public function testApiUsersShow()
1289         {
1290                 $result = api_users_show('json');
1291                 // We can't use assertSelfUser() here because the user object is missing some properties.
1292                 $this->assertEquals($this->selfUser['id'], $result['user']['cid']);
1293                 $this->assertEquals('DFRN', $result['user']['location']);
1294                 $this->assertEquals($this->selfUser['name'], $result['user']['name']);
1295                 $this->assertEquals($this->selfUser['nick'], $result['user']['screen_name']);
1296                 $this->assertEquals('dfrn', $result['user']['network']);
1297                 $this->assertTrue($result['user']['verified']);
1298         }
1299
1300         /**
1301          * Test the api_users_show() function with an XML result.
1302          * @return void
1303          */
1304         public function testApiUsersShowWithXml()
1305         {
1306                 $result = api_users_show('xml');
1307                 $this->assertXml($result, 'statuses');
1308         }
1309
1310         /**
1311          * Test the api_users_search() function.
1312          * @return void
1313          */
1314         public function testApiUsersSearch()
1315         {
1316                 $_GET['q'] = 'othercontact';
1317                 $result = api_users_search('json');
1318                 $this->assertOtherUser($result['users'][0]);
1319         }
1320
1321         /**
1322          * Test the api_users_search() function with an XML result.
1323          * @return void
1324          */
1325         public function testApiUsersSearchWithXml()
1326         {
1327                 $_GET['q'] = 'othercontact';
1328                 $result = api_users_search('xml');
1329                 $this->assertXml($result, 'users');
1330         }
1331
1332         /**
1333          * Test the api_users_search() function without a GET q parameter.
1334          * @return void
1335          * @expectedException Friendica\Network\HTTPException\BadRequestException
1336          */
1337         public function testApiUsersSearchWithoutQuery()
1338         {
1339                 api_users_search('json');
1340         }
1341
1342         /**
1343          * Test the api_users_lookup() function.
1344          * @return void
1345          * @expectedException Friendica\Network\HTTPException\NotFoundException
1346          */
1347         public function testApiUsersLookup()
1348         {
1349                 api_users_lookup('json');
1350         }
1351
1352         /**
1353          * Test the api_users_lookup() function with an user ID.
1354          * @return void
1355          */
1356         public function testApiUsersLookupWithUserId()
1357         {
1358                 $_REQUEST['user_id'] = $this->otherUser['id'];
1359                 $result = api_users_lookup('json');
1360                 $this->assertOtherUser($result['users'][0]);
1361         }
1362
1363         /**
1364          * Test the api_search() function.
1365          * @return void
1366          */
1367         public function testApiSearch()
1368         {
1369                 $_REQUEST['q'] = 'reply';
1370                 $_REQUEST['max_id'] = 10;
1371                 $result = api_search('json');
1372                 foreach ($result['status'] as $status) {
1373                         $this->assertStatus($status);
1374                         $this->assertContains('reply', $status['text'], null, true);
1375                 }
1376         }
1377
1378         /**
1379          * Test the api_search() function a count parameter.
1380          * @return void
1381          */
1382         public function testApiSearchWithCount()
1383         {
1384                 $_REQUEST['q'] = 'reply';
1385                 $_REQUEST['count'] = 20;
1386                 $result = api_search('json');
1387                 foreach ($result['status'] as $status) {
1388                         $this->assertStatus($status);
1389                         $this->assertContains('reply', $status['text'], null, true);
1390                 }
1391         }
1392
1393         /**
1394          * Test the api_search() function with an rpp parameter.
1395          * @return void
1396          */
1397         public function testApiSearchWithRpp()
1398         {
1399                 $_REQUEST['q'] = 'reply';
1400                 $_REQUEST['rpp'] = 20;
1401                 $result = api_search('json');
1402                 foreach ($result['status'] as $status) {
1403                         $this->assertStatus($status);
1404                         $this->assertContains('reply', $status['text'], null, true);
1405                 }
1406         }
1407
1408         /**
1409          * Test the api_search() function with an q parameter contains hashtag.
1410          * @return void
1411          */
1412         public function testApiSearchWithHashtag()
1413         {
1414                 $_REQUEST['q'] = '%23friendica';
1415                 $result = api_search('json');
1416                 foreach ($result['status'] as $status) {
1417                         $this->assertStatus($status);
1418                         $this->assertContains('#friendica', $status['text'], null, true);
1419                 }
1420         }
1421
1422         /**
1423          * Test the api_search() function with an exclude_replies parameter.
1424          * @return void
1425          */
1426         public function testApiSearchWithExcludeReplies()
1427         {
1428                 $_REQUEST['max_id'] = 10;
1429                 $_REQUEST['exclude_replies'] = true;
1430                 $_REQUEST['q'] = 'friendica';
1431                 $result = api_search('json');
1432                 foreach ($result['status'] as $status) {
1433                         $this->assertStatus($status);
1434                 }
1435         }
1436
1437         /**
1438          * Test the api_search() function without an authenticated user.
1439          * @return void
1440          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1441          */
1442         public function testApiSearchWithUnallowedUser()
1443         {
1444                 $_SESSION['allow_api'] = false;
1445                 $_GET['screen_name'] = $this->selfUser['nick'];
1446                 api_search('json');
1447         }
1448
1449         /**
1450          * Test the api_search() function without any GET query parameter.
1451          * @return void
1452          * @expectedException Friendica\Network\HTTPException\BadRequestException
1453          */
1454         public function testApiSearchWithoutQuery()
1455         {
1456                 api_search('json');
1457         }
1458
1459         /**
1460          * Test the api_statuses_home_timeline() function.
1461          * @return void
1462          */
1463         public function testApiStatusesHomeTimeline()
1464         {
1465                 $_REQUEST['max_id'] = 10;
1466                 $_REQUEST['exclude_replies'] = true;
1467                 $_REQUEST['conversation_id'] = 1;
1468                 $result = api_statuses_home_timeline('json');
1469                 $this->assertNotEmpty($result['status']);
1470                 foreach ($result['status'] as $status) {
1471                         $this->assertStatus($status);
1472                 }
1473         }
1474
1475         /**
1476          * Test the api_statuses_home_timeline() function with a negative page parameter.
1477          * @return void
1478          */
1479         public function testApiStatusesHomeTimelineWithNegativePage()
1480         {
1481                 $_REQUEST['page'] = -2;
1482                 $result = api_statuses_home_timeline('json');
1483                 $this->assertNotEmpty($result['status']);
1484                 foreach ($result['status'] as $status) {
1485                         $this->assertStatus($status);
1486                 }
1487         }
1488
1489         /**
1490          * Test the api_statuses_home_timeline() with an unallowed user.
1491          * @return void
1492          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1493          */
1494         public function testApiStatusesHomeTimelineWithUnallowedUser()
1495         {
1496                 $_SESSION['allow_api'] = false;
1497                 $_GET['screen_name'] = $this->selfUser['nick'];
1498                 api_statuses_home_timeline('json');
1499         }
1500
1501         /**
1502          * Test the api_statuses_home_timeline() function with an RSS result.
1503          * @return void
1504          */
1505         public function testApiStatusesHomeTimelineWithRss()
1506         {
1507                 $result = api_statuses_home_timeline('rss');
1508                 $this->assertXml($result, 'statuses');
1509         }
1510
1511         /**
1512          * Test the api_statuses_public_timeline() function.
1513          * @return void
1514          */
1515         public function testApiStatusesPublicTimeline()
1516         {
1517                 $_REQUEST['max_id'] = 10;
1518                 $_REQUEST['conversation_id'] = 1;
1519                 $result = api_statuses_public_timeline('json');
1520                 $this->assertNotEmpty($result['status']);
1521                 foreach ($result['status'] as $status) {
1522                         $this->assertStatus($status);
1523                 }
1524         }
1525
1526         /**
1527          * Test the api_statuses_public_timeline() function with the exclude_replies parameter.
1528          * @return void
1529          */
1530         public function testApiStatusesPublicTimelineWithExcludeReplies()
1531         {
1532                 $_REQUEST['max_id'] = 10;
1533                 $_REQUEST['exclude_replies'] = true;
1534                 $result = api_statuses_public_timeline('json');
1535                 $this->assertNotEmpty($result['status']);
1536                 foreach ($result['status'] as $status) {
1537                         $this->assertStatus($status);
1538                 }
1539         }
1540
1541         /**
1542          * Test the api_statuses_public_timeline() function with a negative page parameter.
1543          * @return void
1544          */
1545         public function testApiStatusesPublicTimelineWithNegativePage()
1546         {
1547                 $_REQUEST['page'] = -2;
1548                 $result = api_statuses_public_timeline('json');
1549                 $this->assertNotEmpty($result['status']);
1550                 foreach ($result['status'] as $status) {
1551                         $this->assertStatus($status);
1552                 }
1553         }
1554
1555         /**
1556          * Test the api_statuses_public_timeline() function with an unallowed user.
1557          * @return void
1558          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1559          */
1560         public function testApiStatusesPublicTimelineWithUnallowedUser()
1561         {
1562                 $_SESSION['allow_api'] = false;
1563                 $_GET['screen_name'] = $this->selfUser['nick'];
1564                 api_statuses_public_timeline('json');
1565         }
1566
1567         /**
1568          * Test the api_statuses_public_timeline() function with an RSS result.
1569          * @return void
1570          */
1571         public function testApiStatusesPublicTimelineWithRss()
1572         {
1573                 $result = api_statuses_public_timeline('rss');
1574                 $this->assertXml($result, 'statuses');
1575         }
1576
1577         /**
1578          * Test the api_statuses_networkpublic_timeline() function.
1579          * @return void
1580          */
1581         public function testApiStatusesNetworkpublicTimeline()
1582         {
1583                 $_REQUEST['max_id'] = 10;
1584                 $result = api_statuses_networkpublic_timeline('json');
1585                 $this->assertNotEmpty($result['status']);
1586                 foreach ($result['status'] as $status) {
1587                         $this->assertStatus($status);
1588                 }
1589         }
1590
1591         /**
1592          * Test the api_statuses_networkpublic_timeline() function with a negative page parameter.
1593          * @return void
1594          */
1595         public function testApiStatusesNetworkpublicTimelineWithNegativePage()
1596         {
1597                 $_REQUEST['page'] = -2;
1598                 $result = api_statuses_networkpublic_timeline('json');
1599                 $this->assertNotEmpty($result['status']);
1600                 foreach ($result['status'] as $status) {
1601                         $this->assertStatus($status);
1602                 }
1603         }
1604
1605         /**
1606          * Test the api_statuses_networkpublic_timeline() function with an unallowed user.
1607          * @return void
1608          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1609          */
1610         public function testApiStatusesNetworkpublicTimelineWithUnallowedUser()
1611         {
1612                 $_SESSION['allow_api'] = false;
1613                 $_GET['screen_name'] = $this->selfUser['nick'];
1614                 api_statuses_networkpublic_timeline('json');
1615         }
1616
1617         /**
1618          * Test the api_statuses_networkpublic_timeline() function with an RSS result.
1619          * @return void
1620          */
1621         public function testApiStatusesNetworkpublicTimelineWithRss()
1622         {
1623                 $result = api_statuses_networkpublic_timeline('rss');
1624                 $this->assertXml($result, 'statuses');
1625         }
1626
1627         /**
1628          * Test the api_statuses_show() function.
1629          * @return void
1630          * @expectedException Friendica\Network\HTTPException\BadRequestException
1631          */
1632         public function testApiStatusesShow()
1633         {
1634                 api_statuses_show('json');
1635         }
1636
1637         /**
1638          * Test the api_statuses_show() function with an ID.
1639          * @return void
1640          */
1641         public function testApiStatusesShowWithId()
1642         {
1643                 $this->app->argv[3] = 1;
1644                 $result = api_statuses_show('json');
1645                 $this->assertStatus($result['status']);
1646         }
1647
1648         /**
1649          * Test the api_statuses_show() function with the conversation parameter.
1650          * @return void
1651          */
1652         public function testApiStatusesShowWithConversation()
1653         {
1654                 $this->app->argv[3] = 1;
1655                 $_REQUEST['conversation'] = 1;
1656                 $result = api_statuses_show('json');
1657                 $this->assertNotEmpty($result['status']);
1658                 foreach ($result['status'] as $status) {
1659                         $this->assertStatus($status);
1660                 }
1661         }
1662
1663         /**
1664          * Test the api_statuses_show() function with an unallowed user.
1665          * @return void
1666          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1667          */
1668         public function testApiStatusesShowWithUnallowedUser()
1669         {
1670                 $_SESSION['allow_api'] = false;
1671                 $_GET['screen_name'] = $this->selfUser['nick'];
1672                 api_statuses_show('json');
1673         }
1674
1675         /**
1676          * Test the api_conversation_show() function.
1677          * @return void
1678          * @expectedException Friendica\Network\HTTPException\BadRequestException
1679          */
1680         public function testApiConversationShow()
1681         {
1682                 api_conversation_show('json');
1683         }
1684
1685         /**
1686          * Test the api_conversation_show() function with an ID.
1687          * @return void
1688          */
1689         public function testApiConversationShowWithId()
1690         {
1691                 $this->app->argv[3] = 1;
1692                 $_REQUEST['max_id'] = 10;
1693                 $_REQUEST['page'] = -2;
1694                 $result = api_conversation_show('json');
1695                 $this->assertNotEmpty($result['status']);
1696                 foreach ($result['status'] as $status) {
1697                         $this->assertStatus($status);
1698                 }
1699         }
1700
1701         /**
1702          * Test the api_conversation_show() function with an unallowed user.
1703          * @return void
1704          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1705          */
1706         public function testApiConversationShowWithUnallowedUser()
1707         {
1708                 $_SESSION['allow_api'] = false;
1709                 $_GET['screen_name'] = $this->selfUser['nick'];
1710                 api_conversation_show('json');
1711         }
1712
1713         /**
1714          * Test the api_statuses_repeat() function.
1715          * @return void
1716          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1717          */
1718         public function testApiStatusesRepeat()
1719         {
1720                 api_statuses_repeat('json');
1721         }
1722
1723         /**
1724          * Test the api_statuses_repeat() function without an authenticated user.
1725          * @return void
1726          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1727          */
1728         public function testApiStatusesRepeatWithoutAuthenticatedUser()
1729         {
1730                 $_SESSION['authenticated'] = false;
1731                 api_statuses_repeat('json');
1732         }
1733
1734         /**
1735          * Test the api_statuses_repeat() function with an ID.
1736          * @return void
1737          */
1738         public function testApiStatusesRepeatWithId()
1739         {
1740                 $this->app->argv[3] = 1;
1741                 $result = api_statuses_repeat('json');
1742                 $this->assertStatus($result['status']);
1743
1744                 // Also test with a shared status
1745                 $this->app->argv[3] = 5;
1746                 $result = api_statuses_repeat('json');
1747                 $this->assertStatus($result['status']);
1748         }
1749
1750         /**
1751          * Test the api_statuses_destroy() function.
1752          * @return void
1753          * @expectedException Friendica\Network\HTTPException\BadRequestException
1754          */
1755         public function testApiStatusesDestroy()
1756         {
1757                 api_statuses_destroy('json');
1758         }
1759
1760         /**
1761          * Test the api_statuses_destroy() function without an authenticated user.
1762          * @return void
1763          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1764          */
1765         public function testApiStatusesDestroyWithoutAuthenticatedUser()
1766         {
1767                 $_SESSION['authenticated'] = false;
1768                 api_statuses_destroy('json');
1769         }
1770
1771         /**
1772          * Test the api_statuses_destroy() function with an ID.
1773          * @return void
1774          */
1775         public function testApiStatusesDestroyWithId()
1776         {
1777                 $this->app->argv[3] = 1;
1778                 $result = api_statuses_destroy('json');
1779                 $this->assertStatus($result['status']);
1780         }
1781
1782         /**
1783          * Test the api_statuses_mentions() function.
1784          * @return void
1785          */
1786         public function testApiStatusesMentions()
1787         {
1788                 $this->app->user = ['nickname' => $this->selfUser['nick']];
1789                 $_REQUEST['max_id'] = 10;
1790                 $result = api_statuses_mentions('json');
1791                 $this->assertEmpty($result['status']);
1792                 // We should test with mentions in the database.
1793         }
1794
1795         /**
1796          * Test the api_statuses_mentions() function with a negative page parameter.
1797          * @return void
1798          */
1799         public function testApiStatusesMentionsWithNegativePage()
1800         {
1801                 $_REQUEST['page'] = -2;
1802                 $result = api_statuses_mentions('json');
1803                 $this->assertEmpty($result['status']);
1804         }
1805
1806         /**
1807          * Test the api_statuses_mentions() function with an unallowed user.
1808          * @return void
1809          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1810          */
1811         public function testApiStatusesMentionsWithUnallowedUser()
1812         {
1813                 $_SESSION['allow_api'] = false;
1814                 $_GET['screen_name'] = $this->selfUser['nick'];
1815                 api_statuses_mentions('json');
1816         }
1817
1818         /**
1819          * Test the api_statuses_mentions() function with an RSS result.
1820          * @return void
1821          */
1822         public function testApiStatusesMentionsWithRss()
1823         {
1824                 $result = api_statuses_mentions('rss');
1825                 $this->assertXml($result, 'statuses');
1826         }
1827
1828         /**
1829          * Test the api_statuses_user_timeline() function.
1830          * @return void
1831          */
1832         public function testApiStatusesUserTimeline()
1833         {
1834                 $_REQUEST['max_id'] = 10;
1835                 $_REQUEST['exclude_replies'] = true;
1836                 $_REQUEST['conversation_id'] = 1;
1837                 $result = api_statuses_user_timeline('json');
1838                 $this->assertNotEmpty($result['status']);
1839                 foreach ($result['status'] as $status) {
1840                         $this->assertStatus($status);
1841                 }
1842         }
1843
1844         /**
1845          * Test the api_statuses_user_timeline() function with a negative page parameter.
1846          * @return void
1847          */
1848         public function testApiStatusesUserTimelineWithNegativePage()
1849         {
1850                 $_REQUEST['page'] = -2;
1851                 $result = api_statuses_user_timeline('json');
1852                 $this->assertNotEmpty($result['status']);
1853                 foreach ($result['status'] as $status) {
1854                         $this->assertStatus($status);
1855                 }
1856         }
1857
1858         /**
1859          * Test the api_statuses_user_timeline() function with an RSS result.
1860          * @return void
1861          */
1862         public function testApiStatusesUserTimelineWithRss()
1863         {
1864                 $result = api_statuses_user_timeline('rss');
1865                 $this->assertXml($result, 'statuses');
1866         }
1867
1868         /**
1869          * Test the api_statuses_user_timeline() function with an unallowed user.
1870          * @return void
1871          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1872          */
1873         public function testApiStatusesUserTimelineWithUnallowedUser()
1874         {
1875                 $_SESSION['allow_api'] = false;
1876                 $_GET['screen_name'] = $this->selfUser['nick'];
1877                 api_statuses_user_timeline('json');
1878         }
1879
1880         /**
1881          * Test the api_favorites_create_destroy() function.
1882          * @return void
1883          * @expectedException Friendica\Network\HTTPException\BadRequestException
1884          */
1885         public function testApiFavoritesCreateDestroy()
1886         {
1887                 $this->app->argv = ['api', '1.1', 'favorites', 'create'];
1888                 $this->app->argc = count($this->app->argv);
1889                 api_favorites_create_destroy('json');
1890         }
1891
1892         /**
1893          * Test the api_favorites_create_destroy() function with an invalid ID.
1894          * @return void
1895          * @expectedException Friendica\Network\HTTPException\BadRequestException
1896          */
1897         public function testApiFavoritesCreateDestroyWithInvalidId()
1898         {
1899                 $this->app->argv = ['api', '1.1', 'favorites', 'create', '12.json'];
1900                 $this->app->argc = count($this->app->argv);
1901                 api_favorites_create_destroy('json');
1902         }
1903
1904         /**
1905          * Test the api_favorites_create_destroy() function with an invalid action.
1906          * @return void
1907          * @expectedException Friendica\Network\HTTPException\BadRequestException
1908          */
1909         public function testApiFavoritesCreateDestroyWithInvalidAction()
1910         {
1911                 $this->app->argv = ['api', '1.1', 'favorites', 'change.json'];
1912                 $this->app->argc = count($this->app->argv);
1913                 $_REQUEST['id'] = 1;
1914                 api_favorites_create_destroy('json');
1915         }
1916
1917         /**
1918          * Test the api_favorites_create_destroy() function with the create action.
1919          * @return void
1920          */
1921         public function testApiFavoritesCreateDestroyWithCreateAction()
1922         {
1923                 $this->app->argv = ['api', '1.1', 'favorites', 'create.json'];
1924                 $this->app->argc = count($this->app->argv);
1925                 $_REQUEST['id'] = 3;
1926                 $result = api_favorites_create_destroy('json');
1927                 $this->assertStatus($result['status']);
1928         }
1929
1930         /**
1931          * Test the api_favorites_create_destroy() function with the create action and an RSS result.
1932          * @return void
1933          */
1934         public function testApiFavoritesCreateDestroyWithCreateActionAndRss()
1935         {
1936                 $this->app->argv = ['api', '1.1', 'favorites', 'create.rss'];
1937                 $this->app->argc = count($this->app->argv);
1938                 $_REQUEST['id'] = 3;
1939                 $result = api_favorites_create_destroy('rss');
1940                 $this->assertXml($result, 'status');
1941         }
1942
1943         /**
1944          * Test the api_favorites_create_destroy() function with the destroy action.
1945          * @return void
1946          */
1947         public function testApiFavoritesCreateDestroyWithDestroyAction()
1948         {
1949                 $this->app->argv = ['api', '1.1', 'favorites', 'destroy.json'];
1950                 $this->app->argc = count($this->app->argv);
1951                 $_REQUEST['id'] = 3;
1952                 $result = api_favorites_create_destroy('json');
1953                 $this->assertStatus($result['status']);
1954         }
1955
1956         /**
1957          * Test the api_favorites_create_destroy() function without an authenticated user.
1958          * @return void
1959          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1960          */
1961         public function testApiFavoritesCreateDestroyWithoutAuthenticatedUser()
1962         {
1963                 $this->app->argv = ['api', '1.1', 'favorites', 'create.json'];
1964                 $this->app->argc = count($this->app->argv);
1965                 $_SESSION['authenticated'] = false;
1966                 api_favorites_create_destroy('json');
1967         }
1968
1969         /**
1970          * Test the api_favorites() function.
1971          * @return void
1972          */
1973         public function testApiFavorites()
1974         {
1975                 $_REQUEST['page'] = -1;
1976                 $_REQUEST['max_id'] = 10;
1977                 $result = api_favorites('json');
1978                 foreach ($result['status'] as $status) {
1979                         $this->assertStatus($status);
1980                 }
1981         }
1982
1983         /**
1984          * Test the api_favorites() function with an RSS result.
1985          * @return void
1986          */
1987         public function testApiFavoritesWithRss()
1988         {
1989                 $result = api_favorites('rss');
1990                 $this->assertXml($result, 'statuses');
1991         }
1992
1993         /**
1994          * Test the api_favorites() function with an unallowed user.
1995          * @return void
1996          * @expectedException Friendica\Network\HTTPException\ForbiddenException
1997          */
1998         public function testApiFavoritesWithUnallowedUser()
1999         {
2000                 $_SESSION['allow_api'] = false;
2001                 $_GET['screen_name'] = $this->selfUser['nick'];
2002                 api_favorites('json');
2003         }
2004
2005         /**
2006          * Test the api_format_messages() function.
2007          * @return void
2008          */
2009         public function testApiFormatMessages()
2010         {
2011                 $result = api_format_messages(
2012                         ['id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
2013                         ['id' => 2, 'screen_name' => 'recipient_name'],
2014                         ['id' => 3, 'screen_name' => 'sender_name']
2015                 );
2016                 $this->assertEquals('item_title'."\n".'item_body', $result['text']);
2017                 $this->assertEquals(1, $result['id']);
2018                 $this->assertEquals(2, $result['recipient_id']);
2019                 $this->assertEquals(3, $result['sender_id']);
2020                 $this->assertEquals('recipient_name', $result['recipient_screen_name']);
2021                 $this->assertEquals('sender_name', $result['sender_screen_name']);
2022         }
2023
2024         /**
2025          * Test the api_format_messages() function with HTML.
2026          * @return void
2027          */
2028         public function testApiFormatMessagesWithHtmlText()
2029         {
2030                 $_GET['getText'] = 'html';
2031                 $result = api_format_messages(
2032                         ['id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
2033                         ['id' => 2, 'screen_name' => 'recipient_name'],
2034                         ['id' => 3, 'screen_name' => 'sender_name']
2035                 );
2036                 $this->assertEquals('item_title', $result['title']);
2037                 $this->assertEquals('<strong>item_body</strong>', $result['text']);
2038         }
2039
2040         /**
2041          * Test the api_format_messages() function with plain text.
2042          * @return void
2043          */
2044         public function testApiFormatMessagesWithPlainText()
2045         {
2046                 $_GET['getText'] = 'plain';
2047                 $result = api_format_messages(
2048                         ['id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
2049                         ['id' => 2, 'screen_name' => 'recipient_name'],
2050                         ['id' => 3, 'screen_name' => 'sender_name']
2051                 );
2052                 $this->assertEquals('item_title', $result['title']);
2053                 $this->assertEquals('item_body', $result['text']);
2054         }
2055
2056         /**
2057          * Test the api_format_messages() function with the getUserObjects GET parameter set to false.
2058          * @return void
2059          */
2060         public function testApiFormatMessagesWithoutUserObjects()
2061         {
2062                 $_GET['getUserObjects'] = 'false';
2063                 $result = api_format_messages(
2064                         ['id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
2065                         ['id' => 2, 'screen_name' => 'recipient_name'],
2066                         ['id' => 3, 'screen_name' => 'sender_name']
2067                 );
2068                 $this->assertTrue(!isset($result['sender']));
2069                 $this->assertTrue(!isset($result['recipient']));
2070         }
2071
2072         /**
2073          * Test the api_convert_item() function.
2074          * @return void
2075          */
2076         public function testApiConvertItem()
2077         {
2078                 $result = api_convert_item(
2079                         [
2080                                 'network' => 'feed',
2081                                 'title' => 'item_title',
2082                                 // We need a long string to test that it is correctly cut
2083                                 'body' => 'perspiciatis impedit voluptatem quis molestiae ea qui '.
2084                                 'reiciendis dolorum aut ducimus sunt consequatur inventore dolor '.
2085                                 'officiis pariatur doloremque nemo culpa aut quidem qui dolore '.
2086                                 'laudantium atque commodi alias voluptatem non possimus aperiam '.
2087                                 'ipsum rerum consequuntur aut amet fugit quia aliquid praesentium '.
2088                                 'repellendus quibusdam et et inventore mollitia rerum sit autem '.
2089                                 'pariatur maiores ipsum accusantium perferendis vel sit possimus '.
2090                                 'veritatis nihil distinctio qui eum repellat officia illum quos '.
2091                                 'impedit quam iste esse unde qui suscipit aut facilis ut inventore '.
2092                                 'omnis exercitationem quo magnam consequatur maxime aut illum '.
2093                                 'soluta quaerat natus unde aspernatur et sed beatae nihil ullam '.
2094                                 'temporibus corporis ratione blanditiis perspiciatis impedit '.
2095                                 'voluptatem quis molestiae ea qui reiciendis dolorum aut ducimus '.
2096                                 'sunt consequatur inventore dolor officiis pariatur doloremque '.
2097                                 'nemo culpa aut quidem qui dolore laudantium atque commodi alias '.
2098                                 'voluptatem non possimus aperiam ipsum rerum consequuntur aut '.
2099                                 'amet fugit quia aliquid praesentium repellendus quibusdam et et '.
2100                                 'inventore mollitia rerum sit autem pariatur maiores ipsum accusantium '.
2101                                 'perferendis vel sit possimus veritatis nihil distinctio qui eum '.
2102                                 'repellat officia illum quos impedit quam iste esse unde qui '.
2103                                 'suscipit aut facilis ut inventore omnis exercitationem quo magnam '.
2104                                 'consequatur maxime aut illum soluta quaerat natus unde aspernatur '.
2105                                 'et sed beatae nihil ullam temporibus corporis ratione blanditiis',
2106                                 'plink' => 'item_plink'
2107                         ]
2108                 );
2109                 $this->assertStringStartsWith('item_title', $result['text']);
2110                 $this->assertStringStartsWith('<h4>item_title</h4><br>perspiciatis impedit voluptatem', $result['html']);
2111         }
2112
2113         /**
2114          * Test the api_convert_item() function with an empty item body.
2115          * @return void
2116          */
2117         public function testApiConvertItemWithoutBody()
2118         {
2119                 $result = api_convert_item(
2120                         [
2121                                 'network' => 'feed',
2122                                 'title' => 'item_title',
2123                                 'body' => '',
2124                                 'plink' => 'item_plink'
2125                         ]
2126                 );
2127                 $this->assertEquals('item_title', $result['text']);
2128                 $this->assertEquals('<h4>item_title</h4><br>item_plink', $result['html']);
2129         }
2130
2131         /**
2132          * Test the api_convert_item() function with the title in the body.
2133          * @return void
2134          */
2135         public function testApiConvertItemWithTitleInBody()
2136         {
2137                 $result = api_convert_item(
2138                         [
2139                                 'title' => 'item_title',
2140                                 'body' => 'item_title item_body'
2141                         ]
2142                 );
2143                 $this->assertEquals('item_title item_body', $result['text']);
2144                 $this->assertEquals('<h4>item_title</h4><br>item_title item_body', $result['html']);
2145         }
2146
2147         /**
2148          * Test the api_get_attachments() function.
2149          * @return void
2150          */
2151         public function testApiGetAttachments()
2152         {
2153                 $body = 'body';
2154                 $this->assertEmpty(api_get_attachments($body));
2155         }
2156
2157         /**
2158          * Test the api_get_attachments() function with an img tag.
2159          * @return void
2160          */
2161         public function testApiGetAttachmentsWithImage()
2162         {
2163                 $body = '[img]http://via.placeholder.com/1x1.png[/img]';
2164                 $this->assertInternalType('array', api_get_attachments($body));
2165         }
2166
2167         /**
2168          * Test the api_get_attachments() function with an img tag and an AndStatus user agent.
2169          * @return void
2170          */
2171         public function testApiGetAttachmentsWithImageAndAndStatus()
2172         {
2173                 $_SERVER['HTTP_USER_AGENT'] = 'AndStatus';
2174                 $body = '[img]http://via.placeholder.com/1x1.png[/img]';
2175                 $this->assertInternalType('array', api_get_attachments($body));
2176         }
2177
2178         /**
2179          * Test the api_get_entitities() function.
2180          * @return void
2181          */
2182         public function testApiGetEntitities()
2183         {
2184                 $text = 'text';
2185                 $this->assertInternalType('array', api_get_entitities($text, 'bbcode'));
2186         }
2187
2188         /**
2189          * Test the api_get_entitities() function with the include_entities parameter.
2190          * @return void
2191          */
2192         public function testApiGetEntititiesWithIncludeEntities()
2193         {
2194                 $_REQUEST['include_entities'] = 'true';
2195                 $text = 'text';
2196                 $result = api_get_entitities($text, 'bbcode');
2197                 $this->assertInternalType('array', $result['hashtags']);
2198                 $this->assertInternalType('array', $result['symbols']);
2199                 $this->assertInternalType('array', $result['urls']);
2200                 $this->assertInternalType('array', $result['user_mentions']);
2201         }
2202
2203         /**
2204          * Test the api_format_items_embeded_images() function.
2205          * @return void
2206          */
2207         public function testApiFormatItemsEmbededImages()
2208         {
2209                 $this->assertEquals(
2210                         'text ' . System::baseUrl() . '/display/item_guid',
2211                         api_format_items_embeded_images(['guid' => 'item_guid'], 'text data:image/foo')
2212                 );
2213         }
2214
2215         /**
2216          * Test the api_contactlink_to_array() function.
2217          * @return void
2218          */
2219         public function testApiContactlinkToArray()
2220         {
2221                 $this->assertEquals(
2222                         [
2223                                 'name' => 'text',
2224                                 'url' => '',
2225                         ],
2226                         api_contactlink_to_array('text')
2227                 );
2228         }
2229
2230         /**
2231          * Test the api_contactlink_to_array() function with an URL.
2232          * @return void
2233          */
2234         public function testApiContactlinkToArrayWithUrl()
2235         {
2236                 $this->assertEquals(
2237                         [
2238                                 'name' => ['link_text'],
2239                                 'url' => ['url'],
2240                         ],
2241                         api_contactlink_to_array('text <a href="url">link_text</a>')
2242                 );
2243         }
2244
2245         /**
2246          * Test the api_format_items_activities() function.
2247          * @return void
2248          */
2249         public function testApiFormatItemsActivities()
2250         {
2251                 $item = ['uid' => 0, 'uri' => ''];
2252                 $result = api_format_items_activities($item);
2253                 $this->assertArrayHasKey('like', $result);
2254                 $this->assertArrayHasKey('dislike', $result);
2255                 $this->assertArrayHasKey('attendyes', $result);
2256                 $this->assertArrayHasKey('attendno', $result);
2257                 $this->assertArrayHasKey('attendmaybe', $result);
2258         }
2259
2260         /**
2261          * Test the api_format_items_activities() function with an XML result.
2262          * @return void
2263          */
2264         public function testApiFormatItemsActivitiesWithXml()
2265         {
2266                 $item = ['uid' => 0, 'uri' => ''];
2267                 $result = api_format_items_activities($item, 'xml');
2268                 $this->assertArrayHasKey('friendica:like', $result);
2269                 $this->assertArrayHasKey('friendica:dislike', $result);
2270                 $this->assertArrayHasKey('friendica:attendyes', $result);
2271                 $this->assertArrayHasKey('friendica:attendno', $result);
2272                 $this->assertArrayHasKey('friendica:attendmaybe', $result);
2273         }
2274
2275         /**
2276          * Test the api_format_items_profiles() function.
2277          * @return void
2278          */
2279         public function testApiFormatItemsProfiles()
2280         {
2281                 $profile_row = [
2282                         'id' => 'profile_id',
2283                         'profile-name' => 'profile_name',
2284                         'is-default' => true,
2285                         'hide-friends' => true,
2286                         'photo' => 'profile_photo',
2287                         'thumb' => 'profile_thumb',
2288                         'publish' => true,
2289                         'net-publish' => true,
2290                         'pdesc' => 'description',
2291                         'dob' => 'date_of_birth',
2292                         'address' => 'address',
2293                         'locality' => 'city',
2294                         'region' => 'region',
2295                         'postal-code' => 'postal_code',
2296                         'country-name' => 'country',
2297                         'hometown' => 'hometown',
2298                         'gender' => 'gender',
2299                         'marital' => 'marital',
2300                         'with' => 'marital_with',
2301                         'howlong' => 'marital_since',
2302                         'sexual' => 'sexual',
2303                         'politic' => 'politic',
2304                         'religion' => 'religion',
2305                         'pub_keywords' => 'public_keywords',
2306                         'prv_keywords' => 'private_keywords',
2307
2308                         'likes' => 'likes',
2309                         'dislikes' => 'dislikes',
2310                         'about' => 'about',
2311                         'music' => 'music',
2312                         'book' => 'book',
2313                         'tv' => 'tv',
2314                         'film' => 'film',
2315                         'interest' => 'interest',
2316                         'romance' => 'romance',
2317                         'work' => 'work',
2318                         'education' => 'education',
2319                         'contact' => 'social_networks',
2320                         'homepage' => 'homepage'
2321                 ];
2322                 $result = api_format_items_profiles($profile_row);
2323                 $this->assertEquals(
2324                         [
2325                                 'profile_id' => 'profile_id',
2326                                 'profile_name' => 'profile_name',
2327                                 'is_default' => true,
2328                                 'hide_friends' => true,
2329                                 'profile_photo' => 'profile_photo',
2330                                 'profile_thumb' => 'profile_thumb',
2331                                 'publish' => true,
2332                                 'net_publish' => true,
2333                                 'description' => 'description',
2334                                 'date_of_birth' => 'date_of_birth',
2335                                 'address' => 'address',
2336                                 'city' => 'city',
2337                                 'region' => 'region',
2338                                 'postal_code' => 'postal_code',
2339                                 'country' => 'country',
2340                                 'hometown' => 'hometown',
2341                                 'gender' => 'gender',
2342                                 'marital' => 'marital',
2343                                 'marital_with' => 'marital_with',
2344                                 'marital_since' => 'marital_since',
2345                                 'sexual' => 'sexual',
2346                                 'politic' => 'politic',
2347                                 'religion' => 'religion',
2348                                 'public_keywords' => 'public_keywords',
2349                                 'private_keywords' => 'private_keywords',
2350
2351                                 'likes' => 'likes',
2352                                 'dislikes' => 'dislikes',
2353                                 'about' => 'about',
2354                                 'music' => 'music',
2355                                 'book' => 'book',
2356                                 'tv' => 'tv',
2357                                 'film' => 'film',
2358                                 'interest' => 'interest',
2359                                 'romance' => 'romance',
2360                                 'work' => 'work',
2361                                 'education' => 'education',
2362                                 'social_networks' => 'social_networks',
2363                                 'homepage' => 'homepage',
2364                                 'users' => null
2365                         ],
2366                         $result
2367                 );
2368         }
2369
2370         /**
2371          * Test the api_format_items() function.
2372          * @return void
2373          */
2374         public function testApiFormatItems()
2375         {
2376                 $items = [
2377                         [
2378                                 'item_network' => 'item_network',
2379                                 'source' => 'web',
2380                                 'coord' => '5 7',
2381                                 'body' => '',
2382                                 'verb' => '',
2383                                 'author-id' => 43,
2384                                 'author-network' => Protocol::DFRN,
2385                                 'author-link' => 'http://localhost/profile/othercontact',
2386                                 'plink' => '',
2387                         ]
2388                 ];
2389                 $result = api_format_items($items, ['id' => 0], true);
2390                 foreach ($result as $status) {
2391                         $this->assertStatus($status);
2392                 }
2393         }
2394
2395         /**
2396          * Test the api_format_items() function with an XML result.
2397          * @return void
2398          */
2399         public function testApiFormatItemsWithXml()
2400         {
2401                 $items = [
2402                         [
2403                                 'coord' => '5 7',
2404                                 'body' => '',
2405                                 'verb' => '',
2406                                 'author-id' => 43,
2407                                 'author-network' => Protocol::DFRN,
2408                                 'author-link' => 'http://localhost/profile/othercontact',
2409                                 'plink' => '',
2410                         ]
2411                 ];
2412                 $result = api_format_items($items, ['id' => 0], true, 'xml');
2413                 foreach ($result as $status) {
2414                         $this->assertStatus($status);
2415                 }
2416         }
2417
2418         /**
2419          * Test the api_format_items() function.
2420          * @return void
2421          */
2422         public function testApiAccountRateLimitStatus()
2423         {
2424                 $result = api_account_rate_limit_status('json');
2425                 $this->assertEquals(150, $result['hash']['remaining_hits']);
2426                 $this->assertEquals(150, $result['hash']['hourly_limit']);
2427                 $this->assertInternalType('int', $result['hash']['reset_time_in_seconds']);
2428         }
2429
2430         /**
2431          * Test the api_format_items() function with an XML result.
2432          * @return void
2433          */
2434         public function testApiAccountRateLimitStatusWithXml()
2435         {
2436                 $result = api_account_rate_limit_status('xml');
2437                 $this->assertXml($result, 'hash');
2438         }
2439
2440         /**
2441          * Test the api_help_test() function.
2442          * @return void
2443          */
2444         public function testApiHelpTest()
2445         {
2446                 $result = api_help_test('json');
2447                 $this->assertEquals(['ok' => 'ok'], $result);
2448         }
2449
2450         /**
2451          * Test the api_help_test() function with an XML result.
2452          * @return void
2453          */
2454         public function testApiHelpTestWithXml()
2455         {
2456                 $result = api_help_test('xml');
2457                 $this->assertXml($result, 'ok');
2458         }
2459
2460         /**
2461          * Test the api_lists_list() function.
2462          * @return void
2463          */
2464         public function testApiListsList()
2465         {
2466                 $result = api_lists_list('json');
2467                 $this->assertEquals(['lists_list' => []], $result);
2468         }
2469
2470         /**
2471          * Test the api_lists_ownerships() function.
2472          * @return void
2473          */
2474         public function testApiListsOwnerships()
2475         {
2476                 $result = api_lists_ownerships('json');
2477                 foreach ($result['lists']['lists'] as $list) {
2478                         $this->assertList($list);
2479                 }
2480         }
2481
2482         /**
2483          * Test the api_lists_ownerships() function without an authenticated user.
2484          * @return void
2485          * @expectedException Friendica\Network\HTTPException\ForbiddenException
2486          */
2487         public function testApiListsOwnershipsWithoutAuthenticatedUser()
2488         {
2489                 $_SESSION['authenticated'] = false;
2490                 api_lists_ownerships('json');
2491         }
2492
2493         /**
2494          * Test the api_lists_statuses() function.
2495          * @expectedException Friendica\Network\HTTPException\BadRequestException
2496          * @return void
2497          */
2498         public function testApiListsStatuses()
2499         {
2500                 api_lists_statuses('json');
2501         }
2502
2503         /**
2504          * Test the api_lists_statuses() function with a list ID.
2505          * @return void
2506          */
2507         public function testApiListsStatusesWithListId()
2508         {
2509                 $_REQUEST['list_id'] = 1;
2510                 $_REQUEST['page'] = -1;
2511                 $_REQUEST['max_id'] = 10;
2512                 $result = api_lists_statuses('json');
2513                 foreach ($result['status'] as $status) {
2514                         $this->assertStatus($status);
2515                 }
2516         }
2517
2518         /**
2519          * Test the api_lists_statuses() function with a list ID and a RSS result.
2520          * @return void
2521          */
2522         public function testApiListsStatusesWithListIdAndRss()
2523         {
2524                 $_REQUEST['list_id'] = 1;
2525                 $result = api_lists_statuses('rss');
2526                 $this->assertXml($result, 'statuses');
2527         }
2528
2529         /**
2530          * Test the api_lists_statuses() function with an unallowed user.
2531          * @return void
2532          * @expectedException Friendica\Network\HTTPException\ForbiddenException
2533          */
2534         public function testApiListsStatusesWithUnallowedUser()
2535         {
2536                 $_SESSION['allow_api'] = false;
2537                 $_GET['screen_name'] = $this->selfUser['nick'];
2538                 api_lists_statuses('json');
2539         }
2540
2541         /**
2542          * Test the api_statuses_f() function.
2543          * @return void
2544          */
2545         public function testApiStatusesFWithFriends()
2546         {
2547                 $_GET['page'] = -1;
2548                 $result = api_statuses_f('friends');
2549                 $this->assertArrayHasKey('user', $result);
2550         }
2551
2552         /**
2553          * Test the api_statuses_f() function.
2554          * @return void
2555          */
2556         public function testApiStatusesFWithFollowers()
2557         {
2558                 $result = api_statuses_f('followers');
2559                 $this->assertArrayHasKey('user', $result);
2560         }
2561
2562         /**
2563          * Test the api_statuses_f() function.
2564          * @return void
2565          */
2566         public function testApiStatusesFWithBlocks()
2567         {
2568                 $result = api_statuses_f('blocks');
2569                 $this->assertArrayHasKey('user', $result);
2570         }
2571
2572         /**
2573          * Test the api_statuses_f() function.
2574          * @return void
2575          */
2576         public function testApiStatusesFWithIncoming()
2577         {
2578                 $result = api_statuses_f('incoming');
2579                 $this->assertArrayHasKey('user', $result);
2580         }
2581
2582         /**
2583          * Test the api_statuses_f() function an undefined cursor GET variable.
2584          * @return void
2585          */
2586         public function testApiStatusesFWithUndefinedCursor()
2587         {
2588                 $_GET['cursor'] = 'undefined';
2589                 $this->assertFalse(api_statuses_f('friends'));
2590         }
2591
2592         /**
2593          * Test the api_statuses_friends() function.
2594          * @return void
2595          */
2596         public function testApiStatusesFriends()
2597         {
2598                 $result = api_statuses_friends('json');
2599                 $this->assertArrayHasKey('user', $result);
2600         }
2601
2602         /**
2603          * Test the api_statuses_friends() function an undefined cursor GET variable.
2604          * @return void
2605          */
2606         public function testApiStatusesFriendsWithUndefinedCursor()
2607         {
2608                 $_GET['cursor'] = 'undefined';
2609                 $this->assertFalse(api_statuses_friends('json'));
2610         }
2611
2612         /**
2613          * Test the api_statuses_followers() function.
2614          * @return void
2615          */
2616         public function testApiStatusesFollowers()
2617         {
2618                 $result = api_statuses_followers('json');
2619                 $this->assertArrayHasKey('user', $result);
2620         }
2621
2622         /**
2623          * Test the api_statuses_followers() function an undefined cursor GET variable.
2624          * @return void
2625          */
2626         public function testApiStatusesFollowersWithUndefinedCursor()
2627         {
2628                 $_GET['cursor'] = 'undefined';
2629                 $this->assertFalse(api_statuses_followers('json'));
2630         }
2631
2632         /**
2633          * Test the api_blocks_list() function.
2634          * @return void
2635          */
2636         public function testApiBlocksList()
2637         {
2638                 $result = api_blocks_list('json');
2639                 $this->assertArrayHasKey('user', $result);
2640         }
2641
2642         /**
2643          * Test the api_blocks_list() function an undefined cursor GET variable.
2644          * @return void
2645          */
2646         public function testApiBlocksListWithUndefinedCursor()
2647         {
2648                 $_GET['cursor'] = 'undefined';
2649                 $this->assertFalse(api_blocks_list('json'));
2650         }
2651
2652         /**
2653          * Test the api_friendships_incoming() function.
2654          * @return void
2655          */
2656         public function testApiFriendshipsIncoming()
2657         {
2658                 $result = api_friendships_incoming('json');
2659                 $this->assertArrayHasKey('id', $result);
2660         }
2661
2662         /**
2663          * Test the api_friendships_incoming() function an undefined cursor GET variable.
2664          * @return void
2665          */
2666         public function testApiFriendshipsIncomingWithUndefinedCursor()
2667         {
2668                 $_GET['cursor'] = 'undefined';
2669                 $this->assertFalse(api_friendships_incoming('json'));
2670         }
2671
2672         /**
2673          * Test the api_statusnet_config() function.
2674          * @return void
2675          */
2676         public function testApiStatusnetConfig()
2677         {
2678                 $result = api_statusnet_config('json');
2679                 $this->assertEquals('localhost', $result['config']['site']['server']);
2680                 $this->assertEquals('default', $result['config']['site']['theme']);
2681                 $this->assertEquals(System::baseUrl() . '/images/friendica-64.png', $result['config']['site']['logo']);
2682                 $this->assertTrue($result['config']['site']['fancy']);
2683                 $this->assertEquals('en', $result['config']['site']['language']);
2684                 $this->assertEquals('UTC', $result['config']['site']['timezone']);
2685                 $this->assertEquals(200000, $result['config']['site']['textlimit']);
2686                 $this->assertEquals('false', $result['config']['site']['private']);
2687                 $this->assertEquals('false', $result['config']['site']['ssl']);
2688                 $this->assertEquals(30, $result['config']['site']['shorturllength']);
2689         }
2690
2691         /**
2692          * Test the api_statusnet_version() function.
2693          * @return void
2694          */
2695         public function testApiStatusnetVersion()
2696         {
2697                 $result = api_statusnet_version('json');
2698                 $this->assertEquals('0.9.7', $result['version']);
2699         }
2700
2701         /**
2702          * Test the api_ff_ids() function.
2703          * @return void
2704          */
2705         public function testApiFfIds()
2706         {
2707                 $result = api_ff_ids('json');
2708                 $this->assertNull($result);
2709         }
2710
2711         /**
2712          * Test the api_ff_ids() function with a result.
2713          * @return void
2714          */
2715         public function testApiFfIdsWithResult()
2716         {
2717                 $this->markTestIncomplete();
2718         }
2719
2720         /**
2721          * Test the api_ff_ids() function without an authenticated user.
2722          * @return void
2723          * @expectedException Friendica\Network\HTTPException\ForbiddenException
2724          */
2725         public function testApiFfIdsWithoutAuthenticatedUser()
2726         {
2727                 $_SESSION['authenticated'] = false;
2728                 api_ff_ids('json');
2729         }
2730
2731         /**
2732          * Test the api_friends_ids() function.
2733          * @return void
2734          */
2735         public function testApiFriendsIds()
2736         {
2737                 $result = api_friends_ids('json');
2738                 $this->assertNull($result);
2739         }
2740
2741         /**
2742          * Test the api_followers_ids() function.
2743          * @return void
2744          */
2745         public function testApiFollowersIds()
2746         {
2747                 $result = api_followers_ids('json');
2748                 $this->assertNull($result);
2749         }
2750
2751         /**
2752          * Test the api_direct_messages_new() function.
2753          * @return void
2754          */
2755         public function testApiDirectMessagesNew()
2756         {
2757                 $result = api_direct_messages_new('json');
2758                 $this->assertNull($result);
2759         }
2760
2761         /**
2762          * Test the api_direct_messages_new() function without an authenticated user.
2763          * @return void
2764          * @expectedException Friendica\Network\HTTPException\ForbiddenException
2765          */
2766         public function testApiDirectMessagesNewWithoutAuthenticatedUser()
2767         {
2768                 $_SESSION['authenticated'] = false;
2769                 api_direct_messages_new('json');
2770         }
2771
2772         /**
2773          * Test the api_direct_messages_new() function with an user ID.
2774          * @return void
2775          */
2776         public function testApiDirectMessagesNewWithUserId()
2777         {
2778                 $_POST['text'] = 'message_text';
2779                 $_POST['user_id'] = $this->otherUser['id'];
2780                 $result = api_direct_messages_new('json');
2781                 $this->assertEquals(['direct_message' => ['error' => -1]], $result);
2782         }
2783
2784         /**
2785          * Test the api_direct_messages_new() function with a screen name.
2786          * @return void
2787          */
2788         public function testApiDirectMessagesNewWithScreenName()
2789         {
2790                 $_POST['text'] = 'message_text';
2791                 $_POST['screen_name'] = $this->friendUser['nick'];
2792                 $result = api_direct_messages_new('json');
2793                 $this->assertEquals(1, $result['direct_message']['id']);
2794                 $this->assertContains('message_text', $result['direct_message']['text']);
2795                 $this->assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
2796                 $this->assertEquals(1, $result['direct_message']['friendica_seen']);
2797         }
2798
2799         /**
2800          * Test the api_direct_messages_new() function with a title.
2801          * @return void
2802          */
2803         public function testApiDirectMessagesNewWithTitle()
2804         {
2805                 $_POST['text'] = 'message_text';
2806                 $_POST['screen_name'] = $this->friendUser['nick'];
2807                 $_REQUEST['title'] = 'message_title';
2808                 $result = api_direct_messages_new('json');
2809                 $this->assertEquals(1, $result['direct_message']['id']);
2810                 $this->assertContains('message_text', $result['direct_message']['text']);
2811                 $this->assertContains('message_title', $result['direct_message']['text']);
2812                 $this->assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
2813                 $this->assertEquals(1, $result['direct_message']['friendica_seen']);
2814         }
2815
2816         /**
2817          * Test the api_direct_messages_new() function with an RSS result.
2818          * @return void
2819          */
2820         public function testApiDirectMessagesNewWithRss()
2821         {
2822                 $_POST['text'] = 'message_text';
2823                 $_POST['screen_name'] = $this->friendUser['nick'];
2824                 $result = api_direct_messages_new('rss');
2825                 $this->assertXml($result, 'direct-messages');
2826         }
2827
2828         /**
2829          * Test the api_direct_messages_destroy() function.
2830          * @return void
2831          * @expectedException Friendica\Network\HTTPException\BadRequestException
2832          */
2833         public function testApiDirectMessagesDestroy()
2834         {
2835                 api_direct_messages_destroy('json');
2836         }
2837
2838         /**
2839          * Test the api_direct_messages_destroy() function with the friendica_verbose GET param.
2840          * @return void
2841          */
2842         public function testApiDirectMessagesDestroyWithVerbose()
2843         {
2844                 $_GET['friendica_verbose'] = 'true';
2845                 $result = api_direct_messages_destroy('json');
2846                 $this->assertEquals(
2847                         [
2848                                 '$result' => [
2849                                         'result' => 'error',
2850                                         'message' => 'message id or parenturi not specified'
2851                                 ]
2852                         ],
2853                         $result
2854                 );
2855         }
2856
2857         /**
2858          * Test the api_direct_messages_destroy() function without an authenticated user.
2859          * @return void
2860          * @expectedException Friendica\Network\HTTPException\ForbiddenException
2861          */
2862         public function testApiDirectMessagesDestroyWithoutAuthenticatedUser()
2863         {
2864                 $_SESSION['authenticated'] = false;
2865                 api_direct_messages_destroy('json');
2866         }
2867
2868         /**
2869          * Test the api_direct_messages_destroy() function with a non-zero ID.
2870          * @return void
2871          * @expectedException Friendica\Network\HTTPException\BadRequestException
2872          */
2873         public function testApiDirectMessagesDestroyWithId()
2874         {
2875                 $_REQUEST['id'] = 1;
2876                 api_direct_messages_destroy('json');
2877         }
2878
2879         /**
2880          * Test the api_direct_messages_destroy() with a non-zero ID and the friendica_verbose GET param.
2881          * @return void
2882          */
2883         public function testApiDirectMessagesDestroyWithIdAndVerbose()
2884         {
2885                 $_REQUEST['id'] = 1;
2886                 $_REQUEST['friendica_parenturi'] = 'parent_uri';
2887                 $_GET['friendica_verbose'] = 'true';
2888                 $result = api_direct_messages_destroy('json');
2889                 $this->assertEquals(
2890                         [
2891                                 '$result' => [
2892                                         'result' => 'error',
2893                                         'message' => 'message id not in database'
2894                                 ]
2895                         ],
2896                         $result
2897                 );
2898         }
2899
2900         /**
2901          * Test the api_direct_messages_destroy() function with a non-zero ID.
2902          * @return void
2903          */
2904         public function testApiDirectMessagesDestroyWithCorrectId()
2905         {
2906                 $this->markTestIncomplete('We need to add a dataset for this.');
2907         }
2908
2909         /**
2910          * Test the api_direct_messages_box() function.
2911          * @return void
2912          */
2913         public function testApiDirectMessagesBoxWithSentbox()
2914         {
2915                 $_REQUEST['page'] = -1;
2916                 $_REQUEST['max_id'] = 10;
2917                 $result = api_direct_messages_box('json', 'sentbox', 'false');
2918                 $this->assertArrayHasKey('direct_message', $result);
2919         }
2920
2921         /**
2922          * Test the api_direct_messages_box() function.
2923          * @return void
2924          */
2925         public function testApiDirectMessagesBoxWithConversation()
2926         {
2927                 $result = api_direct_messages_box('json', 'conversation', 'false');
2928                 $this->assertArrayHasKey('direct_message', $result);
2929         }
2930
2931         /**
2932          * Test the api_direct_messages_box() function.
2933          * @return void
2934          */
2935         public function testApiDirectMessagesBoxWithAll()
2936         {
2937                 $result = api_direct_messages_box('json', 'all', 'false');
2938                 $this->assertArrayHasKey('direct_message', $result);
2939         }
2940
2941         /**
2942          * Test the api_direct_messages_box() function.
2943          * @return void
2944          */
2945         public function testApiDirectMessagesBoxWithInbox()
2946         {
2947                 $result = api_direct_messages_box('json', 'inbox', 'false');
2948                 $this->assertArrayHasKey('direct_message', $result);
2949         }
2950
2951         /**
2952          * Test the api_direct_messages_box() function.
2953          * @return void
2954          */
2955         public function testApiDirectMessagesBoxWithVerbose()
2956         {
2957                 $result = api_direct_messages_box('json', 'sentbox', 'true');
2958                 $this->assertEquals(
2959                         [
2960                                 '$result' => [
2961                                         'result' => 'error',
2962                                         'message' => 'no mails available'
2963                                 ]
2964                         ],
2965                         $result
2966                 );
2967         }
2968
2969         /**
2970          * Test the api_direct_messages_box() function with a RSS result.
2971          * @return void
2972          */
2973         public function testApiDirectMessagesBoxWithRss()
2974         {
2975                 $result = api_direct_messages_box('rss', 'sentbox', 'false');
2976                 $this->assertXml($result, 'direct-messages');
2977         }
2978
2979         /**
2980          * Test the api_direct_messages_box() function without an authenticated user.
2981          * @return void
2982          * @expectedException Friendica\Network\HTTPException\ForbiddenException
2983          */
2984         public function testApiDirectMessagesBoxWithUnallowedUser()
2985         {
2986                 $_SESSION['allow_api'] = false;
2987                 $_GET['screen_name'] = $this->selfUser['nick'];
2988                 api_direct_messages_box('json', 'sentbox', 'false');
2989         }
2990
2991         /**
2992          * Test the api_direct_messages_sentbox() function.
2993          * @return void
2994          */
2995         public function testApiDirectMessagesSentbox()
2996         {
2997                 $result = api_direct_messages_sentbox('json');
2998                 $this->assertArrayHasKey('direct_message', $result);
2999         }
3000
3001         /**
3002          * Test the api_direct_messages_inbox() function.
3003          * @return void
3004          */
3005         public function testApiDirectMessagesInbox()
3006         {
3007                 $result = api_direct_messages_inbox('json');
3008                 $this->assertArrayHasKey('direct_message', $result);
3009         }
3010
3011         /**
3012          * Test the api_direct_messages_all() function.
3013          * @return void
3014          */
3015         public function testApiDirectMessagesAll()
3016         {
3017                 $result = api_direct_messages_all('json');
3018                 $this->assertArrayHasKey('direct_message', $result);
3019         }
3020
3021         /**
3022          * Test the api_direct_messages_conversation() function.
3023          * @return void
3024          */
3025         public function testApiDirectMessagesConversation()
3026         {
3027                 $result = api_direct_messages_conversation('json');
3028                 $this->assertArrayHasKey('direct_message', $result);
3029         }
3030
3031         /**
3032          * Test the api_oauth_request_token() function.
3033          * @return void
3034          */
3035         public function testApiOauthRequestToken()
3036         {
3037                 $this->markTestIncomplete('killme() kills phpunit as well');
3038         }
3039
3040         /**
3041          * Test the api_oauth_access_token() function.
3042          * @return void
3043          */
3044         public function testApiOauthAccessToken()
3045         {
3046                 $this->markTestIncomplete('killme() kills phpunit as well');
3047         }
3048
3049         /**
3050          * Test the api_fr_photoalbum_delete() function.
3051          * @return void
3052          * @expectedException Friendica\Network\HTTPException\BadRequestException
3053          */
3054         public function testApiFrPhotoalbumDelete()
3055         {
3056                 api_fr_photoalbum_delete('json');
3057         }
3058
3059         /**
3060          * Test the api_fr_photoalbum_delete() function with an album name.
3061          * @return void
3062          * @expectedException Friendica\Network\HTTPException\BadRequestException
3063          */
3064         public function testApiFrPhotoalbumDeleteWithAlbum()
3065         {
3066                 $_REQUEST['album'] = 'album_name';
3067                 api_fr_photoalbum_delete('json');
3068         }
3069
3070         /**
3071          * Test the api_fr_photoalbum_delete() function with an album name.
3072          * @return void
3073          */
3074         public function testApiFrPhotoalbumDeleteWithValidAlbum()
3075         {
3076                 $this->markTestIncomplete('We need to add a dataset for this.');
3077         }
3078
3079         /**
3080          * Test the api_fr_photoalbum_delete() function.
3081          * @return void
3082          * @expectedException Friendica\Network\HTTPException\BadRequestException
3083          */
3084         public function testApiFrPhotoalbumUpdate()
3085         {
3086                 api_fr_photoalbum_update('json');
3087         }
3088
3089         /**
3090          * Test the api_fr_photoalbum_delete() function with an album name.
3091          * @return void
3092          * @expectedException Friendica\Network\HTTPException\BadRequestException
3093          */
3094         public function testApiFrPhotoalbumUpdateWithAlbum()
3095         {
3096                 $_REQUEST['album'] = 'album_name';
3097                 api_fr_photoalbum_update('json');
3098         }
3099
3100         /**
3101          * Test the api_fr_photoalbum_delete() function with an album name.
3102          * @return void
3103          * @expectedException Friendica\Network\HTTPException\BadRequestException
3104          */
3105         public function testApiFrPhotoalbumUpdateWithAlbumAndNewAlbum()
3106         {
3107                 $_REQUEST['album'] = 'album_name';
3108                 $_REQUEST['album_new'] = 'album_name';
3109                 api_fr_photoalbum_update('json');
3110         }
3111
3112         /**
3113          * Test the api_fr_photoalbum_update() function without an authenticated user.
3114          * @return void
3115          * @expectedException Friendica\Network\HTTPException\ForbiddenException
3116          */
3117         public function testApiFrPhotoalbumUpdateWithoutAuthenticatedUser()
3118         {
3119                 $_SESSION['authenticated'] = false;
3120                 api_fr_photoalbum_update('json');
3121         }
3122
3123         /**
3124          * Test the api_fr_photoalbum_delete() function with an album name.
3125          * @return void
3126          */
3127         public function testApiFrPhotoalbumUpdateWithValidAlbum()
3128         {
3129                 $this->markTestIncomplete('We need to add a dataset for this.');
3130         }
3131
3132         /**
3133          * Test the api_fr_photos_list() function.
3134          * @return void
3135          */
3136         public function testApiFrPhotosList()
3137         {
3138                 $result = api_fr_photos_list('json');
3139                 $this->assertArrayHasKey('photo', $result);
3140         }
3141
3142         /**
3143          * Test the api_fr_photos_list() function without an authenticated user.
3144          * @return void
3145          * @expectedException Friendica\Network\HTTPException\ForbiddenException
3146          */
3147         public function testApiFrPhotosListWithoutAuthenticatedUser()
3148         {
3149                 $_SESSION['authenticated'] = false;
3150                 api_fr_photos_list('json');
3151         }
3152
3153         /**
3154          * Test the api_fr_photo_create_update() function.
3155          * @return void
3156          * @expectedException Friendica\Network\HTTPException\BadRequestException
3157          */
3158         public function testApiFrPhotoCreateUpdate()
3159         {
3160                 api_fr_photo_create_update('json');
3161         }
3162
3163         /**
3164          * Test the api_fr_photo_create_update() function without an authenticated user.
3165          * @return void
3166          * @expectedException Friendica\Network\HTTPException\ForbiddenException
3167          */
3168         public function testApiFrPhotoCreateUpdateWithoutAuthenticatedUser()
3169         {
3170                 $_SESSION['authenticated'] = false;
3171                 api_fr_photo_create_update('json');
3172         }
3173
3174         /**
3175          * Test the api_fr_photo_create_update() function with an album name.
3176          * @return void
3177          * @expectedException Friendica\Network\HTTPException\BadRequestException
3178          */
3179         public function testApiFrPhotoCreateUpdateWithAlbum()
3180         {
3181                 $_REQUEST['album'] = 'album_name';
3182                 api_fr_photo_create_update('json');
3183         }
3184
3185         /**
3186          * Test the api_fr_photo_create_update() function with the update mode.
3187          * @return void
3188          */
3189         public function testApiFrPhotoCreateUpdateWithUpdate()
3190         {
3191                 $this->markTestIncomplete('We need to create a dataset for this');
3192         }
3193
3194         /**
3195          * Test the api_fr_photo_create_update() function with an uploaded file.
3196          * @return void
3197          */
3198         public function testApiFrPhotoCreateUpdateWithFile()
3199         {
3200                 $this->markTestIncomplete();
3201         }
3202
3203         /**
3204          * Test the api_fr_photo_delete() function.
3205          * @return void
3206          * @expectedException Friendica\Network\HTTPException\BadRequestException
3207          */
3208         public function testApiFrPhotoDelete()
3209         {
3210                 api_fr_photo_delete('json');
3211         }
3212
3213         /**
3214          * Test the api_fr_photo_delete() function without an authenticated user.
3215          * @return void
3216          * @expectedException Friendica\Network\HTTPException\ForbiddenException
3217          */
3218         public function testApiFrPhotoDeleteWithoutAuthenticatedUser()
3219         {
3220                 $_SESSION['authenticated'] = false;
3221                 api_fr_photo_delete('json');
3222         }
3223
3224         /**
3225          * Test the api_fr_photo_delete() function with a photo ID.
3226          * @return void
3227          * @expectedException Friendica\Network\HTTPException\BadRequestException
3228          */
3229         public function testApiFrPhotoDeleteWithPhotoId()
3230         {
3231                 $_REQUEST['photo_id'] = 1;
3232                 api_fr_photo_delete('json');
3233         }
3234
3235         /**
3236          * Test the api_fr_photo_delete() function with a correct photo ID.
3237          * @return void
3238          */
3239         public function testApiFrPhotoDeleteWithCorrectPhotoId()
3240         {
3241                 $this->markTestIncomplete('We need to create a dataset for this.');
3242         }
3243
3244         /**
3245          * Test the api_fr_photo_detail() function.
3246          * @return void
3247          * @expectedException Friendica\Network\HTTPException\BadRequestException
3248          */
3249         public function testApiFrPhotoDetail()
3250         {
3251                 api_fr_photo_detail('json');
3252         }
3253
3254         /**
3255          * Test the api_fr_photo_detail() function without an authenticated user.
3256          * @return void
3257          * @expectedException Friendica\Network\HTTPException\ForbiddenException
3258          */
3259         public function testApiFrPhotoDetailWithoutAuthenticatedUser()
3260         {
3261                 $_SESSION['authenticated'] = false;
3262                 api_fr_photo_detail('json');
3263         }
3264
3265         /**
3266          * Test the api_fr_photo_detail() function with a photo ID.
3267          * @return void
3268          * @expectedException Friendica\Network\HTTPException\NotFoundException
3269          */
3270         public function testApiFrPhotoDetailWithPhotoId()
3271         {
3272                 $_REQUEST['photo_id'] = 1;
3273                 api_fr_photo_detail('json');
3274         }
3275
3276         /**
3277          * Test the api_fr_photo_detail() function with a correct photo ID.
3278          * @return void
3279          */
3280         public function testApiFrPhotoDetailCorrectPhotoId()
3281         {
3282                 $this->markTestIncomplete('We need to create a dataset for this.');
3283         }
3284
3285         /**
3286          * Test the api_account_update_profile_image() function.
3287          * @return void
3288          * @expectedException Friendica\Network\HTTPException\BadRequestException
3289          */
3290         public function testApiAccountUpdateProfileImage()
3291         {
3292                 api_account_update_profile_image('json');
3293         }
3294
3295         /**
3296          * Test the api_account_update_profile_image() function without an authenticated user.
3297          * @return void
3298          * @expectedException Friendica\Network\HTTPException\ForbiddenException
3299          */
3300         public function testApiAccountUpdateProfileImageWithoutAuthenticatedUser()
3301         {
3302                 $_SESSION['authenticated'] = false;
3303                 api_account_update_profile_image('json');
3304         }
3305
3306         /**
3307          * Test the api_account_update_profile_image() function with an uploaded file.
3308          * @return void
3309          * @expectedException Friendica\Network\HTTPException\BadRequestException
3310          */
3311         public function testApiAccountUpdateProfileImageWithUpload()
3312         {
3313                 $this->markTestIncomplete();
3314         }
3315
3316
3317         /**
3318          * Test the api_account_update_profile() function.
3319          * @return void
3320          */
3321         public function testApiAccountUpdateProfile()
3322         {
3323                 $_POST['name'] = 'new_name';
3324                 $_POST['description'] = 'new_description';
3325                 $result = api_account_update_profile('json');
3326                 // We can't use assertSelfUser() here because the user object is missing some properties.
3327                 $this->assertEquals($this->selfUser['id'], $result['user']['cid']);
3328                 $this->assertEquals('DFRN', $result['user']['location']);
3329                 $this->assertEquals($this->selfUser['nick'], $result['user']['screen_name']);
3330                 $this->assertEquals('dfrn', $result['user']['network']);
3331                 $this->assertEquals('new_name', $result['user']['name']);
3332                 $this->assertEquals('new_description', $result['user']['description']);
3333         }
3334
3335         /**
3336          * Test the check_acl_input() function.
3337          * @return void
3338          */
3339         public function testCheckAclInput()
3340         {
3341                 $result = check_acl_input('<aclstring>');
3342                 // Where does this result come from?
3343                 $this->assertEquals(1, $result);
3344         }
3345
3346         /**
3347          * Test the check_acl_input() function with an empty ACL string.
3348          * @return void
3349          */
3350         public function testCheckAclInputWithEmptyAclString()
3351         {
3352                 $result = check_acl_input(' ');
3353                 $this->assertFalse($result);
3354         }
3355
3356         /**
3357          * Test the save_media_to_database() function.
3358          * @return void
3359          */
3360         public function testSaveMediaToDatabase()
3361         {
3362                 $this->markTestIncomplete();
3363         }
3364
3365         /**
3366          * Test the post_photo_item() function.
3367          * @return void
3368          */
3369         public function testPostPhotoItem()
3370         {
3371                 $this->markTestIncomplete();
3372         }
3373
3374         /**
3375          * Test the prepare_photo_data() function.
3376          * @return void
3377          */
3378         public function testPreparePhotoData()
3379         {
3380                 $this->markTestIncomplete();
3381         }
3382
3383         /**
3384          * Test the api_friendica_remoteauth() function.
3385          * @return void
3386          * @expectedException Friendica\Network\HTTPException\BadRequestException
3387          */
3388         public function testApiFriendicaRemoteauth()
3389         {
3390                 api_friendica_remoteauth();
3391         }
3392
3393         /**
3394          * Test the api_friendica_remoteauth() function with an URL.
3395          * @return void
3396          * @expectedException Friendica\Network\HTTPException\BadRequestException
3397          */
3398         public function testApiFriendicaRemoteauthWithUrl()
3399         {
3400                 $_GET['url'] = 'url';
3401                 $_GET['c_url'] = 'url';
3402                 api_friendica_remoteauth();
3403         }
3404
3405         /**
3406          * Test the api_friendica_remoteauth() function with a correct URL.
3407          * @return void
3408          */
3409         public function testApiFriendicaRemoteauthWithCorrectUrl()
3410         {
3411                 $this->markTestIncomplete("We can't use an assertion here because of App->redirect().");
3412                 $_GET['url'] = 'url';
3413                 $_GET['c_url'] = $this->selfUser['nurl'];
3414                 api_friendica_remoteauth();
3415         }
3416
3417         /**
3418          * Test the api_share_as_retweet() function.
3419          * @return void
3420          */
3421         public function testApiShareAsRetweet()
3422         {
3423                 $item = ['body' => '', 'author-id' => 1, 'owner-id' => 1];
3424                 $result = api_share_as_retweet($item);
3425                 $this->assertFalse($result);
3426         }
3427
3428         /**
3429          * Test the api_share_as_retweet() function with a valid item.
3430          * @return void
3431          */
3432         public function testApiShareAsRetweetWithValidItem()
3433         {
3434                 $this->markTestIncomplete();
3435         }
3436
3437         /**
3438          * Test the api_get_nick() function.
3439          * @return void
3440          */
3441         public function testApiGetNick()
3442         {
3443                 $result = api_get_nick($this->otherUser['nurl']);
3444                 $this->assertEquals('othercontact', $result);
3445         }
3446
3447         /**
3448          * Test the api_get_nick() function with a wrong URL.
3449          * @return void
3450          */
3451         public function testApiGetNickWithWrongUrl()
3452         {
3453                 $result = api_get_nick('wrong_url');
3454                 $this->assertFalse($result);
3455         }
3456
3457         /**
3458          * Test the api_in_reply_to() function.
3459          * @return void
3460          */
3461         public function testApiInReplyTo()
3462         {
3463                 $result = api_in_reply_to(['id' => 0, 'parent' => 0, 'uri' => '', 'thr-parent' => '']);
3464                 $this->assertArrayHasKey('status_id', $result);
3465                 $this->assertArrayHasKey('user_id', $result);
3466                 $this->assertArrayHasKey('status_id_str', $result);
3467                 $this->assertArrayHasKey('user_id_str', $result);
3468                 $this->assertArrayHasKey('screen_name', $result);
3469         }
3470
3471         /**
3472          * Test the api_in_reply_to() function with a valid item.
3473          * @return void
3474          */
3475         public function testApiInReplyToWithValidItem()
3476         {
3477                 $this->markTestIncomplete();
3478         }
3479
3480         /**
3481          * Test the api_clean_plain_items() function.
3482          * @return void
3483          */
3484         public function testApiCleanPlainItems()
3485         {
3486                 $_REQUEST['include_entities'] = 'true';
3487                 $result = api_clean_plain_items('some_text [url="some_url"]some_text[/url]');
3488                 $this->assertEquals('some_text [url="some_url"]"some_url"[/url]', $result);
3489         }
3490
3491         /**
3492          * Test the api_clean_attachments() function.
3493          * @return void
3494          */
3495         public function testApiCleanAttachments()
3496         {
3497                 $this->markTestIncomplete();
3498         }
3499
3500         /**
3501          * Test the api_best_nickname() function.
3502          * @return void
3503          */
3504         public function testApiBestNickname()
3505         {
3506                 $contacts = [];
3507                 $result = api_best_nickname($contacts);
3508                 $this->assertNull($result);
3509         }
3510
3511         /**
3512          * Test the api_best_nickname() function with contacts.
3513          * @return void
3514          */
3515         public function testApiBestNicknameWithContacts()
3516         {
3517                 $this->markTestIncomplete();
3518         }
3519
3520         /**
3521          * Test the api_friendica_group_show() function.
3522          * @return void
3523          */
3524         public function testApiFriendicaGroupShow()
3525         {
3526                 $this->markTestIncomplete();
3527         }
3528
3529         /**
3530          * Test the api_friendica_group_delete() function.
3531          * @return void
3532          */
3533         public function testApiFriendicaGroupDelete()
3534         {
3535                 $this->markTestIncomplete();
3536         }
3537
3538         /**
3539          * Test the api_lists_destroy() function.
3540          * @return void
3541          */
3542         public function testApiListsDestroy()
3543         {
3544                 $this->markTestIncomplete();
3545         }
3546
3547         /**
3548          * Test the group_create() function.
3549          * @return void
3550          */
3551         public function testGroupCreate()
3552         {
3553                 $this->markTestIncomplete();
3554         }
3555
3556         /**
3557          * Test the api_friendica_group_create() function.
3558          * @return void
3559          */
3560         public function testApiFriendicaGroupCreate()
3561         {
3562                 $this->markTestIncomplete();
3563         }
3564
3565         /**
3566          * Test the api_lists_create() function.
3567          * @return void
3568          */
3569         public function testApiListsCreate()
3570         {
3571                 $this->markTestIncomplete();
3572         }
3573
3574         /**
3575          * Test the api_friendica_group_update() function.
3576          * @return void
3577          */
3578         public function testApiFriendicaGroupUpdate()
3579         {
3580                 $this->markTestIncomplete();
3581         }
3582
3583         /**
3584          * Test the api_lists_update() function.
3585          * @return void
3586          */
3587         public function testApiListsUpdate()
3588         {
3589                 $this->markTestIncomplete();
3590         }
3591
3592         /**
3593          * Test the api_friendica_activity() function.
3594          * @return void
3595          */
3596         public function testApiFriendicaActivity()
3597         {
3598                 $this->markTestIncomplete();
3599         }
3600
3601         /**
3602          * Test the api_friendica_notification() function.
3603          * @return void
3604          * @expectedException Friendica\Network\HTTPException\BadRequestException
3605          */
3606         public function testApiFriendicaNotification()
3607         {
3608                 api_friendica_notification('json');
3609         }
3610
3611         /**
3612          * Test the api_friendica_notification() function without an authenticated user.
3613          * @return void
3614          * @expectedException Friendica\Network\HTTPException\ForbiddenException
3615          */
3616         public function testApiFriendicaNotificationWithoutAuthenticatedUser()
3617         {
3618                 $_SESSION['authenticated'] = false;
3619                 api_friendica_notification('json');
3620         }
3621
3622         /**
3623          * Test the api_friendica_notification() function with an argument count.
3624          * @return void
3625          */
3626         public function testApiFriendicaNotificationWithArgumentCount()
3627         {
3628                 $this->app->argv = ['api', 'friendica', 'notification'];
3629                 $this->app->argc = count($this->app->argv);
3630                 $result = api_friendica_notification('json');
3631                 $this->assertEquals(['note' => false], $result);
3632         }
3633
3634         /**
3635          * Test the api_friendica_notification() function with an XML result.
3636          * @return void
3637          */
3638         public function testApiFriendicaNotificationWithXmlResult()
3639         {
3640                 $this->app->argv = ['api', 'friendica', 'notification'];
3641                 $this->app->argc = count($this->app->argv);
3642                 $result = api_friendica_notification('xml');
3643                 $this->assertXml($result, 'notes');
3644         }
3645
3646         /**
3647          * Test the api_friendica_notification_seen() function.
3648          * @return void
3649          */
3650         public function testApiFriendicaNotificationSeen()
3651         {
3652                 $this->markTestIncomplete();
3653         }
3654
3655         /**
3656          * Test the api_friendica_direct_messages_setseen() function.
3657          * @return void
3658          */
3659         public function testApiFriendicaDirectMessagesSetseen()
3660         {
3661                 $this->markTestIncomplete();
3662         }
3663
3664         /**
3665          * Test the api_friendica_direct_messages_search() function.
3666          * @return void
3667          */
3668         public function testApiFriendicaDirectMessagesSearch()
3669         {
3670                 $this->markTestIncomplete();
3671         }
3672
3673         /**
3674          * Test the api_friendica_profile_show() function.
3675          * @return void
3676          */
3677         public function testApiFriendicaProfileShow()
3678         {
3679                 $result = api_friendica_profile_show('json');
3680                 // We can't use assertSelfUser() here because the user object is missing some properties.
3681                 $this->assertEquals($this->selfUser['id'], $result['$result']['friendica_owner']['cid']);
3682                 $this->assertEquals('DFRN', $result['$result']['friendica_owner']['location']);
3683                 $this->assertEquals($this->selfUser['name'], $result['$result']['friendica_owner']['name']);
3684                 $this->assertEquals($this->selfUser['nick'], $result['$result']['friendica_owner']['screen_name']);
3685                 $this->assertEquals('dfrn', $result['$result']['friendica_owner']['network']);
3686                 $this->assertTrue($result['$result']['friendica_owner']['verified']);
3687                 $this->assertFalse($result['$result']['multi_profiles']);
3688         }
3689
3690         /**
3691          * Test the api_friendica_profile_show() function with a profile ID.
3692          * @return void
3693          */
3694         public function testApiFriendicaProfileShowWithProfileId()
3695         {
3696                 $this->markTestIncomplete('We need to add a dataset for this.');
3697         }
3698
3699         /**
3700          * Test the api_friendica_profile_show() function with a wrong profile ID.
3701          * @return void
3702          * @expectedException Friendica\Network\HTTPException\BadRequestException
3703          */
3704         public function testApiFriendicaProfileShowWithWrongProfileId()
3705         {
3706                 $_REQUEST['profile_id'] = 666;
3707                 api_friendica_profile_show('json');
3708         }
3709
3710         /**
3711          * Test the api_friendica_profile_show() function without an authenticated user.
3712          * @return void
3713          * @expectedException Friendica\Network\HTTPException\ForbiddenException
3714          */
3715         public function testApiFriendicaProfileShowWithoutAuthenticatedUser()
3716         {
3717                 $_SESSION['authenticated'] = false;
3718                 api_friendica_profile_show('json');
3719         }
3720
3721         /**
3722          * Test the api_saved_searches_list() function.
3723          * @return void
3724          */
3725         public function testApiSavedSearchesList()
3726         {
3727                 $result = api_saved_searches_list('json');
3728                 $this->assertEquals(1, $result['terms'][0]['id']);
3729                 $this->assertEquals(1, $result['terms'][0]['id_str']);
3730                 $this->assertEquals('Saved search', $result['terms'][0]['name']);
3731                 $this->assertEquals('Saved search', $result['terms'][0]['query']);
3732         }
3733 }