tests/ApiTest.php

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