tests/include/ApiTest.php

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