tests/legacy/ApiTest.php

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