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['max_id']          = 10;
1756                 $_REQUEST['exclude_replies'] = true;
1757                 $_REQUEST['conversation_id'] = 1;
1758                 $result                      = api_statuses_user_timeline('json');
1759                 self::assertNotEmpty($result['status']);
1760                 foreach ($result['status'] as $status) {
1761                         self::assertStatus($status);
1762                 }
1763         }
1764
1765         /**
1766          * Test the api_statuses_user_timeline() function with a negative page parameter.
1767          *
1768          * @return void
1769          */
1770         public function testApiStatusesUserTimelineWithNegativePage()
1771         {
1772                 $_REQUEST['page'] = -2;
1773                 $result           = api_statuses_user_timeline('json');
1774                 self::assertNotEmpty($result['status']);
1775                 foreach ($result['status'] as $status) {
1776                         self::assertStatus($status);
1777                 }
1778         }
1779
1780         /**
1781          * Test the api_statuses_user_timeline() function with an RSS result.
1782          *
1783          * @return void
1784          */
1785         public function testApiStatusesUserTimelineWithRss()
1786         {
1787                 $result = api_statuses_user_timeline('rss');
1788                 self::assertXml($result, 'statuses');
1789         }
1790
1791         /**
1792          * Test the api_statuses_user_timeline() function with an unallowed user.
1793          *
1794          * @return void
1795          */
1796         public function testApiStatusesUserTimelineWithUnallowedUser()
1797         {
1798                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1799                 BasicAuth::setCurrentUserID();
1800                 api_statuses_user_timeline('json');
1801         }
1802
1803         /**
1804          * Test the api_favorites_create_destroy() function.
1805          *
1806          * @return void
1807          */
1808         public function testApiFavoritesCreateDestroy()
1809         {
1810                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1811                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create']);
1812                 api_favorites_create_destroy('json');
1813         }
1814
1815         /**
1816          * Test the api_favorites_create_destroy() function with an invalid ID.
1817          *
1818          * @return void
1819          */
1820         public function testApiFavoritesCreateDestroyWithInvalidId()
1821         {
1822                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1823                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create', '12.json']);
1824                 api_favorites_create_destroy('json');
1825         }
1826
1827         /**
1828          * Test the api_favorites_create_destroy() function with an invalid action.
1829          *
1830          * @return void
1831          */
1832         public function testApiFavoritesCreateDestroyWithInvalidAction()
1833         {
1834                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1835                 DI::args()->setArgv(['api', '1.1', 'favorites', 'change.json']);
1836                 $_REQUEST['id'] = 1;
1837                 api_favorites_create_destroy('json');
1838         }
1839
1840         /**
1841          * Test the api_favorites_create_destroy() function with the create action.
1842          *
1843          * @return void
1844          */
1845         public function testApiFavoritesCreateDestroyWithCreateAction()
1846         {
1847                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.json']);
1848                 $_REQUEST['id'] = 3;
1849                 $result         = api_favorites_create_destroy('json');
1850                 self::assertStatus($result['status']);
1851         }
1852
1853         /**
1854          * Test the api_favorites_create_destroy() function with the create action and an RSS result.
1855          *
1856          * @return void
1857          */
1858         public function testApiFavoritesCreateDestroyWithCreateActionAndRss()
1859         {
1860                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.rss']);
1861                 $_REQUEST['id'] = 3;
1862                 $result         = api_favorites_create_destroy('rss');
1863                 self::assertXml($result, 'status');
1864         }
1865
1866         /**
1867          * Test the api_favorites_create_destroy() function with the destroy action.
1868          *
1869          * @return void
1870          */
1871         public function testApiFavoritesCreateDestroyWithDestroyAction()
1872         {
1873                 DI::args()->setArgv(['api', '1.1', 'favorites', 'destroy.json']);
1874                 $_REQUEST['id'] = 3;
1875                 $result         = api_favorites_create_destroy('json');
1876                 self::assertStatus($result['status']);
1877         }
1878
1879         /**
1880          * Test the api_favorites_create_destroy() function without an authenticated user.
1881          *
1882          * @return void
1883          */
1884         public function testApiFavoritesCreateDestroyWithoutAuthenticatedUser()
1885         {
1886                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1887                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.json']);
1888                 BasicAuth::setCurrentUserID();
1889                 $_SESSION['authenticated'] = false;
1890                 api_favorites_create_destroy('json');
1891         }
1892
1893         /**
1894          * Test the api_favorites() function.
1895          *
1896          * @return void
1897          */
1898         public function testApiFavorites()
1899         {
1900                 $_REQUEST['page']   = -1;
1901                 $_REQUEST['max_id'] = 10;
1902                 $result             = api_favorites('json');
1903                 foreach ($result['status'] as $status) {
1904                         self::assertStatus($status);
1905                 }
1906         }
1907
1908         /**
1909          * Test the api_favorites() function with an RSS result.
1910          *
1911          * @return void
1912          */
1913         public function testApiFavoritesWithRss()
1914         {
1915                 $result = api_favorites('rss');
1916                 self::assertXml($result, 'statuses');
1917         }
1918
1919         /**
1920          * Test the api_favorites() function with an unallowed user.
1921          *
1922          * @return void
1923          */
1924         public function testApiFavoritesWithUnallowedUser()
1925         {
1926                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1927                 BasicAuth::setCurrentUserID();
1928                 api_favorites('json');
1929         }
1930
1931         /**
1932          * Test the api_format_messages() function.
1933          *
1934          * @return void
1935          */
1936         public function testApiFormatMessages()
1937         {
1938                 $result = api_format_messages(
1939                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1940                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1941                         ['id' => 3, 'uri-id' => 2, 'screen_name' => 'sender_name']
1942                 );
1943                 self::assertEquals('item_title' . "\n" . 'item_body', $result['text']);
1944                 self::assertEquals(1, $result['id']);
1945                 self::assertEquals(2, $result['recipient_id']);
1946                 self::assertEquals(3, $result['sender_id']);
1947                 self::assertEquals('recipient_name', $result['recipient_screen_name']);
1948                 self::assertEquals('sender_name', $result['sender_screen_name']);
1949         }
1950
1951         /**
1952          * Test the api_format_messages() function with HTML.
1953          *
1954          * @return void
1955          */
1956         public function testApiFormatMessagesWithHtmlText()
1957         {
1958                 $_GET['getText'] = 'html';
1959                 $result          = api_format_messages(
1960                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1961                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1962                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1963                 );
1964                 self::assertEquals('item_title', $result['title']);
1965                 self::assertEquals('<strong>item_body</strong>', $result['text']);
1966         }
1967
1968         /**
1969          * Test the api_format_messages() function with plain text.
1970          *
1971          * @return void
1972          */
1973         public function testApiFormatMessagesWithPlainText()
1974         {
1975                 $_GET['getText'] = 'plain';
1976                 $result          = api_format_messages(
1977                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1978                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1979                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1980                 );
1981                 self::assertEquals('item_title', $result['title']);
1982                 self::assertEquals('item_body', $result['text']);
1983         }
1984
1985         /**
1986          * Test the api_format_messages() function with the getUserObjects GET parameter set to false.
1987          *
1988          * @return void
1989          */
1990         public function testApiFormatMessagesWithoutUserObjects()
1991         {
1992                 $_GET['getUserObjects'] = 'false';
1993                 $result                 = api_format_messages(
1994                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1995                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1996                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1997                 );
1998                 self::assertTrue(!isset($result['sender']));
1999                 self::assertTrue(!isset($result['recipient']));
2000         }
2001
2002         /**
2003          * Test the api_convert_item() function.
2004          *
2005          * @return void
2006          */
2007         public function testApiConvertItem()
2008         {
2009                 $result = api_convert_item(
2010                         [
2011                                 'network' => 'feed',
2012                                 'title'   => 'item_title',
2013                                 'uri-id'  => 1,
2014                                 // We need a long string to test that it is correctly cut
2015                                 'body'    => 'perspiciatis impedit voluptatem quis molestiae ea qui ' .
2016                                                          'reiciendis dolorum aut ducimus sunt consequatur inventore dolor ' .
2017                                                          'officiis pariatur doloremque nemo culpa aut quidem qui dolore ' .
2018                                                          'laudantium atque commodi alias voluptatem non possimus aperiam ' .
2019                                                          'ipsum rerum consequuntur aut amet fugit quia aliquid praesentium ' .
2020                                                          'repellendus quibusdam et et inventore mollitia rerum sit autem ' .
2021                                                          'pariatur maiores ipsum accusantium perferendis vel sit possimus ' .
2022                                                          'veritatis nihil distinctio qui eum repellat officia illum quos ' .
2023                                                          'impedit quam iste esse unde qui suscipit aut facilis ut inventore ' .
2024                                                          'omnis exercitationem quo magnam consequatur maxime aut illum ' .
2025                                                          'soluta quaerat natus unde aspernatur et sed beatae nihil ullam ' .
2026                                                          'temporibus corporis ratione blanditiis perspiciatis impedit ' .
2027                                                          'voluptatem quis molestiae ea qui reiciendis dolorum aut ducimus ' .
2028                                                          'sunt consequatur inventore dolor officiis pariatur doloremque ' .
2029                                                          'nemo culpa aut quidem qui dolore laudantium atque commodi alias ' .
2030                                                          'voluptatem non possimus aperiam ipsum rerum consequuntur aut ' .
2031                                                          'amet fugit quia aliquid praesentium repellendus quibusdam et et ' .
2032                                                          'inventore mollitia rerum sit autem pariatur maiores ipsum accusantium ' .
2033                                                          'perferendis vel sit possimus veritatis nihil distinctio qui eum ' .
2034                                                          'repellat officia illum quos impedit quam iste esse unde qui ' .
2035                                                          'suscipit aut facilis ut inventore omnis exercitationem quo magnam ' .
2036                                                          'consequatur maxime aut illum soluta quaerat natus unde aspernatur ' .
2037                                                          'et sed beatae nihil ullam temporibus corporis ratione blanditiis',
2038                                 'plink'   => 'item_plink'
2039                         ]
2040                 );
2041                 self::assertStringStartsWith('item_title', $result['text']);
2042                 self::assertStringStartsWith('<h4>item_title</h4><br>perspiciatis impedit voluptatem', $result['html']);
2043         }
2044
2045         /**
2046          * Test the api_convert_item() function with an empty item body.
2047          *
2048          * @return void
2049          */
2050         public function testApiConvertItemWithoutBody()
2051         {
2052                 $result = api_convert_item(
2053                         [
2054                                 'network' => 'feed',
2055                                 'title'   => 'item_title',
2056                                 'uri-id'  => -1,
2057                                 'body'    => '',
2058                                 'plink'   => 'item_plink'
2059                         ]
2060                 );
2061                 self::assertEquals("item_title", $result['text']);
2062                 self::assertEquals('<h4>item_title</h4><br>item_plink', $result['html']);
2063         }
2064
2065         /**
2066          * Test the api_convert_item() function with the title in the body.
2067          *
2068          * @return void
2069          */
2070         public function testApiConvertItemWithTitleInBody()
2071         {
2072                 $result = api_convert_item(
2073                         [
2074                                 'title'  => 'item_title',
2075                                 'body'   => 'item_title item_body',
2076                                 'uri-id' => 1,
2077                         ]
2078                 );
2079                 self::assertEquals('item_title item_body', $result['text']);
2080                 self::assertEquals('<h4>item_title</h4><br>item_title item_body', $result['html']);
2081         }
2082
2083         /**
2084          * Test the api_get_attachments() function.
2085          *
2086          * @return void
2087          */
2088         public function testApiGetAttachments()
2089         {
2090                 $body = 'body';
2091                 self::assertEmpty(api_get_attachments($body, 0));
2092         }
2093
2094         /**
2095          * Test the api_get_attachments() function with an img tag.
2096          *
2097          * @return void
2098          */
2099         public function testApiGetAttachmentsWithImage()
2100         {
2101                 $body = '[img]http://via.placeholder.com/1x1.png[/img]';
2102                 self::assertIsArray(api_get_attachments($body, 0));
2103         }
2104
2105         /**
2106          * Test the api_get_attachments() function with an img tag and an AndStatus user agent.
2107          *
2108          * @return void
2109          */
2110         public function testApiGetAttachmentsWithImageAndAndStatus()
2111         {
2112                 $_SERVER['HTTP_USER_AGENT'] = 'AndStatus';
2113                 $body                       = '[img]http://via.placeholder.com/1x1.png[/img]';
2114                 self::assertIsArray(api_get_attachments($body, 0));
2115         }
2116
2117         /**
2118          * Test the api_get_entitities() function.
2119          *
2120          * @return void
2121          */
2122         public function testApiGetEntitities()
2123         {
2124                 $text = 'text';
2125                 self::assertIsArray(api_get_entitities($text, 'bbcode', 0));
2126         }
2127
2128         /**
2129          * Test the api_get_entitities() function with the include_entities parameter.
2130          *
2131          * @return void
2132          */
2133         public function testApiGetEntititiesWithIncludeEntities()
2134         {
2135                 $_REQUEST['include_entities'] = 'true';
2136                 $text                         = 'text';
2137                 $result                       = api_get_entitities($text, 'bbcode', 0);
2138                 self::assertIsArray($result['hashtags']);
2139                 self::assertIsArray($result['symbols']);
2140                 self::assertIsArray($result['urls']);
2141                 self::assertIsArray($result['user_mentions']);
2142         }
2143
2144         /**
2145          * Test the api_format_items_embeded_images() function.
2146          *
2147          * @return void
2148          */
2149         public function testApiFormatItemsEmbededImages()
2150         {
2151                 self::assertEquals(
2152                         'text ' . DI::baseUrl() . '/display/item_guid',
2153                         api_format_items_embeded_images(['guid' => 'item_guid'], 'text data:image/foo')
2154                 );
2155         }
2156
2157         /**
2158          * Test the api_contactlink_to_array() function.
2159          *
2160          * @return void
2161          */
2162         public function testApiContactlinkToArray()
2163         {
2164                 self::assertEquals(
2165                         [
2166                                 'name' => 'text',
2167                                 'url'  => '',
2168                         ],
2169                         api_contactlink_to_array('text')
2170                 );
2171         }
2172
2173         /**
2174          * Test the api_contactlink_to_array() function with an URL.
2175          *
2176          * @return void
2177          */
2178         public function testApiContactlinkToArrayWithUrl()
2179         {
2180                 self::assertEquals(
2181                         [
2182                                 'name' => ['link_text'],
2183                                 'url'  => ['url'],
2184                         ],
2185                         api_contactlink_to_array('text <a href="url">link_text</a>')
2186                 );
2187         }
2188
2189         /**
2190          * Test the api_format_items_activities() function.
2191          *
2192          * @return void
2193          */
2194         public function testApiFormatItemsActivities()
2195         {
2196                 $item   = ['uid' => 0, 'uri' => ''];
2197                 $result = api_format_items_activities($item);
2198                 self::assertArrayHasKey('like', $result);
2199                 self::assertArrayHasKey('dislike', $result);
2200                 self::assertArrayHasKey('attendyes', $result);
2201                 self::assertArrayHasKey('attendno', $result);
2202                 self::assertArrayHasKey('attendmaybe', $result);
2203         }
2204
2205         /**
2206          * Test the api_format_items_activities() function with an XML result.
2207          *
2208          * @return void
2209          */
2210         public function testApiFormatItemsActivitiesWithXml()
2211         {
2212                 $item   = ['uid' => 0, 'uri' => ''];
2213                 $result = api_format_items_activities($item, 'xml');
2214                 self::assertArrayHasKey('friendica:like', $result);
2215                 self::assertArrayHasKey('friendica:dislike', $result);
2216                 self::assertArrayHasKey('friendica:attendyes', $result);
2217                 self::assertArrayHasKey('friendica:attendno', $result);
2218                 self::assertArrayHasKey('friendica:attendmaybe', $result);
2219         }
2220
2221         /**
2222          * Test the api_format_items() function.
2223          * @doesNotPerformAssertions
2224          */
2225         public function testApiFormatItems()
2226         {
2227                 $items = Post::selectToArray([], ['uid' => 42]);
2228                 foreach ($items as $item) {
2229                         $status = api_format_item($item);
2230                         self::assertStatus($status);
2231                 }
2232         }
2233
2234         /**
2235          * Test the api_format_items() function with an XML result.
2236          * @doesNotPerformAssertions
2237          */
2238         public function testApiFormatItemsWithXml()
2239         {
2240                 $items = Post::selectToArray([], ['uid' => 42]);
2241                 foreach ($items as $item) {
2242                         $status = api_format_item($item, 'xml');
2243                         self::assertStatus($status);
2244                 }
2245         }
2246
2247         /**
2248          * Test the api_lists_list() function.
2249          *
2250          * @return void
2251          */
2252         public function testApiListsList()
2253         {
2254                 $result = api_lists_list('json');
2255                 self::assertEquals(['lists_list' => []], $result);
2256         }
2257
2258         /**
2259          * Test the api_lists_ownerships() function.
2260          *
2261          * @return void
2262          */
2263         public function testApiListsOwnerships()
2264         {
2265                 $result = api_lists_ownerships('json');
2266                 foreach ($result['lists']['lists'] as $list) {
2267                         self::assertList($list);
2268                 }
2269         }
2270
2271         /**
2272          * Test the api_lists_ownerships() function without an authenticated user.
2273          *
2274          * @return void
2275          */
2276         public function testApiListsOwnershipsWithoutAuthenticatedUser()
2277         {
2278                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2279                 BasicAuth::setCurrentUserID();
2280                 $_SESSION['authenticated'] = false;
2281                 api_lists_ownerships('json');
2282         }
2283
2284         /**
2285          * Test the api_lists_statuses() function.
2286          *
2287          * @return void
2288          */
2289         public function testApiListsStatuses()
2290         {
2291                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2292                 api_lists_statuses('json');
2293         }
2294
2295         /**
2296          * Test the api_lists_statuses() function with a list ID.
2297          * @doesNotPerformAssertions
2298          */
2299         public function testApiListsStatusesWithListId()
2300         {
2301                 $_REQUEST['list_id'] = 1;
2302                 $_REQUEST['page']    = -1;
2303                 $_REQUEST['max_id']  = 10;
2304                 $result              = api_lists_statuses('json');
2305                 foreach ($result['status'] as $status) {
2306                         self::assertStatus($status);
2307                 }
2308         }
2309
2310         /**
2311          * Test the api_lists_statuses() function with a list ID and a RSS result.
2312          *
2313          * @return void
2314          */
2315         public function testApiListsStatusesWithListIdAndRss()
2316         {
2317                 $_REQUEST['list_id'] = 1;
2318                 $result              = api_lists_statuses('rss');
2319                 self::assertXml($result, 'statuses');
2320         }
2321
2322         /**
2323          * Test the api_lists_statuses() function with an unallowed user.
2324          *
2325          * @return void
2326          */
2327         public function testApiListsStatusesWithUnallowedUser()
2328         {
2329                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2330                 BasicAuth::setCurrentUserID();
2331                 api_lists_statuses('json');
2332         }
2333
2334         /**
2335          * Test the api_statuses_f() function.
2336          *
2337          * @return void
2338          */
2339         public function testApiStatusesFWithFriends()
2340         {
2341                 $_GET['page'] = -1;
2342                 $result       = api_statuses_f('friends');
2343                 self::assertArrayHasKey('user', $result);
2344         }
2345
2346         /**
2347          * Test the api_statuses_f() function.
2348          *
2349          * @return void
2350          */
2351         public function testApiStatusesFWithFollowers()
2352         {
2353                 $result = api_statuses_f('followers');
2354                 self::assertArrayHasKey('user', $result);
2355         }
2356
2357         /**
2358          * Test the api_statuses_f() function.
2359          *
2360          * @return void
2361          */
2362         public function testApiStatusesFWithBlocks()
2363         {
2364                 $result = api_statuses_f('blocks');
2365                 self::assertArrayHasKey('user', $result);
2366         }
2367
2368         /**
2369          * Test the api_statuses_f() function.
2370          *
2371          * @return void
2372          */
2373         public function testApiStatusesFWithIncoming()
2374         {
2375                 $result = api_statuses_f('incoming');
2376                 self::assertArrayHasKey('user', $result);
2377         }
2378
2379         /**
2380          * Test the api_statuses_f() function an undefined cursor GET variable.
2381          *
2382          * @return void
2383          */
2384         public function testApiStatusesFWithUndefinedCursor()
2385         {
2386                 $_GET['cursor'] = 'undefined';
2387                 self::assertFalse(api_statuses_f('friends'));
2388         }
2389
2390         /**
2391          * Test the api_statuses_friends() function.
2392          *
2393          * @return void
2394          */
2395         public function testApiStatusesFriends()
2396         {
2397                 $result = api_statuses_friends('json');
2398                 self::assertArrayHasKey('user', $result);
2399         }
2400
2401         /**
2402          * Test the api_statuses_friends() function an undefined cursor GET variable.
2403          *
2404          * @return void
2405          */
2406         public function testApiStatusesFriendsWithUndefinedCursor()
2407         {
2408                 $_GET['cursor'] = 'undefined';
2409                 self::assertFalse(api_statuses_friends('json'));
2410         }
2411
2412         /**
2413          * Test the api_statuses_followers() function.
2414          *
2415          * @return void
2416          */
2417         public function testApiStatusesFollowers()
2418         {
2419                 $result = api_statuses_followers('json');
2420                 self::assertArrayHasKey('user', $result);
2421         }
2422
2423         /**
2424          * Test the api_statuses_followers() function an undefined cursor GET variable.
2425          *
2426          * @return void
2427          */
2428         public function testApiStatusesFollowersWithUndefinedCursor()
2429         {
2430                 $_GET['cursor'] = 'undefined';
2431                 self::assertFalse(api_statuses_followers('json'));
2432         }
2433
2434         /**
2435          * Test the api_blocks_list() function.
2436          *
2437          * @return void
2438          */
2439         public function testApiBlocksList()
2440         {
2441                 $result = api_blocks_list('json');
2442                 self::assertArrayHasKey('user', $result);
2443         }
2444
2445         /**
2446          * Test the api_blocks_list() function an undefined cursor GET variable.
2447          *
2448          * @return void
2449          */
2450         public function testApiBlocksListWithUndefinedCursor()
2451         {
2452                 $_GET['cursor'] = 'undefined';
2453                 self::assertFalse(api_blocks_list('json'));
2454         }
2455
2456         /**
2457          * Test the api_friendships_incoming() function.
2458          *
2459          * @return void
2460          */
2461         public function testApiFriendshipsIncoming()
2462         {
2463                 $result = api_friendships_incoming('json');
2464                 self::assertArrayHasKey('id', $result);
2465         }
2466
2467         /**
2468          * Test the api_friendships_incoming() function an undefined cursor GET variable.
2469          *
2470          * @return void
2471          */
2472         public function testApiFriendshipsIncomingWithUndefinedCursor()
2473         {
2474                 $_GET['cursor'] = 'undefined';
2475                 self::assertFalse(api_friendships_incoming('json'));
2476         }
2477
2478         /**
2479          * Test the api_statusnet_config() function.
2480          *
2481          * @return void
2482          */
2483         public function testApiStatusnetConfig()
2484         {
2485                 /*
2486                 $result = api_statusnet_config('json');
2487                 self::assertEquals('localhost', $result['config']['site']['server']);
2488                 self::assertEquals('default', $result['config']['site']['theme']);
2489                 self::assertEquals(DI::baseUrl() . '/images/friendica-64.png', $result['config']['site']['logo']);
2490                 self::assertTrue($result['config']['site']['fancy']);
2491                 self::assertEquals('en', $result['config']['site']['language']);
2492                 self::assertEquals('UTC', $result['config']['site']['timezone']);
2493                 self::assertEquals(200000, $result['config']['site']['textlimit']);
2494                 self::assertEquals('false', $result['config']['site']['private']);
2495                 self::assertEquals('false', $result['config']['site']['ssl']);
2496                 self::assertEquals(30, $result['config']['site']['shorturllength']);
2497                 */
2498         }
2499
2500         /**
2501          * Test the api_direct_messages_new() function.
2502          *
2503          * @return void
2504          */
2505         public function testApiDirectMessagesNew()
2506         {
2507                 $result = api_direct_messages_new('json');
2508                 self::assertNull($result);
2509         }
2510
2511         /**
2512          * Test the api_direct_messages_new() function without an authenticated user.
2513          *
2514          * @return void
2515          */
2516         public function testApiDirectMessagesNewWithoutAuthenticatedUser()
2517         {
2518                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2519                 BasicAuth::setCurrentUserID();
2520                 $_SESSION['authenticated'] = false;
2521                 api_direct_messages_new('json');
2522         }
2523
2524         /**
2525          * Test the api_direct_messages_new() function with an user ID.
2526          *
2527          * @return void
2528          */
2529         public function testApiDirectMessagesNewWithUserId()
2530         {
2531                 $_POST['text']    = 'message_text';
2532                 $_POST['user_id'] = $this->otherUser['id'];
2533                 $result           = api_direct_messages_new('json');
2534                 self::assertEquals(['direct_message' => ['error' => -1]], $result);
2535         }
2536
2537         /**
2538          * Test the api_direct_messages_new() function with a screen name.
2539          *
2540          * @return void
2541          */
2542         public function testApiDirectMessagesNewWithScreenName()
2543         {
2544                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
2545                 $_POST['text']    = 'message_text';
2546                 $_POST['user_id'] = $this->friendUser['id'];
2547                 $result           = api_direct_messages_new('json');
2548                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
2549                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
2550                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
2551         }
2552
2553         /**
2554          * Test the api_direct_messages_new() function with a title.
2555          *
2556          * @return void
2557          */
2558         public function testApiDirectMessagesNewWithTitle()
2559         {
2560                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
2561                 $_POST['text']     = 'message_text';
2562                 $_POST['user_id']  = $this->friendUser['id'];
2563                 $_REQUEST['title'] = 'message_title';
2564                 $result            = api_direct_messages_new('json');
2565                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
2566                 self::assertStringContainsString('message_title', $result['direct_message']['text']);
2567                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
2568                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
2569         }
2570
2571         /**
2572          * Test the api_direct_messages_new() function with an RSS result.
2573          *
2574          * @return void
2575          */
2576         public function testApiDirectMessagesNewWithRss()
2577         {
2578                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
2579                 $_POST['text']    = 'message_text';
2580                 $_POST['user_id'] = $this->friendUser['id'];
2581                 $result           = api_direct_messages_new('rss');
2582                 self::assertXml($result, 'direct-messages');
2583         }
2584
2585         /**
2586          * Test the api_direct_messages_destroy() function.
2587          *
2588          * @return void
2589          */
2590         public function testApiDirectMessagesDestroy()
2591         {
2592                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2593                 api_direct_messages_destroy('json');
2594         }
2595
2596         /**
2597          * Test the api_direct_messages_destroy() function with the friendica_verbose GET param.
2598          *
2599          * @return void
2600          */
2601         public function testApiDirectMessagesDestroyWithVerbose()
2602         {
2603                 $_GET['friendica_verbose'] = 'true';
2604                 $result                    = api_direct_messages_destroy('json');
2605                 self::assertEquals(
2606                         [
2607                                 '$result' => [
2608                                         'result'  => 'error',
2609                                         'message' => 'message id or parenturi not specified'
2610                                 ]
2611                         ],
2612                         $result
2613                 );
2614         }
2615
2616         /**
2617          * Test the api_direct_messages_destroy() function without an authenticated user.
2618          *
2619          * @return void
2620          */
2621         public function testApiDirectMessagesDestroyWithoutAuthenticatedUser()
2622         {
2623                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2624                 BasicAuth::setCurrentUserID();
2625                 $_SESSION['authenticated'] = false;
2626                 api_direct_messages_destroy('json');
2627         }
2628
2629         /**
2630          * Test the api_direct_messages_destroy() function with a non-zero ID.
2631          *
2632          * @return void
2633          */
2634         public function testApiDirectMessagesDestroyWithId()
2635         {
2636                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2637                 $_REQUEST['id'] = 1;
2638                 api_direct_messages_destroy('json');
2639         }
2640
2641         /**
2642          * Test the api_direct_messages_destroy() with a non-zero ID and the friendica_verbose GET param.
2643          *
2644          * @return void
2645          */
2646         public function testApiDirectMessagesDestroyWithIdAndVerbose()
2647         {
2648                 $_REQUEST['id']                  = 1;
2649                 $_REQUEST['friendica_parenturi'] = 'parent_uri';
2650                 $_GET['friendica_verbose']       = 'true';
2651                 $result                          = api_direct_messages_destroy('json');
2652                 self::assertEquals(
2653                         [
2654                                 '$result' => [
2655                                         'result'  => 'error',
2656                                         'message' => 'message id not in database'
2657                                 ]
2658                         ],
2659                         $result
2660                 );
2661         }
2662
2663         /**
2664          * Test the api_direct_messages_destroy() function with a non-zero ID.
2665          *
2666          * @return void
2667          */
2668         public function testApiDirectMessagesDestroyWithCorrectId()
2669         {
2670                 $this->markTestIncomplete('We need to add a dataset for this.');
2671         }
2672
2673         /**
2674          * Test the api_direct_messages_box() function.
2675          *
2676          * @return void
2677          */
2678         public function testApiDirectMessagesBoxWithSentbox()
2679         {
2680                 $_REQUEST['page']   = -1;
2681                 $_REQUEST['max_id'] = 10;
2682                 $result             = api_direct_messages_box('json', 'sentbox', 'false');
2683                 self::assertArrayHasKey('direct_message', $result);
2684         }
2685
2686         /**
2687          * Test the api_direct_messages_box() function.
2688          *
2689          * @return void
2690          */
2691         public function testApiDirectMessagesBoxWithConversation()
2692         {
2693                 $result = api_direct_messages_box('json', 'conversation', 'false');
2694                 self::assertArrayHasKey('direct_message', $result);
2695         }
2696
2697         /**
2698          * Test the api_direct_messages_box() function.
2699          *
2700          * @return void
2701          */
2702         public function testApiDirectMessagesBoxWithAll()
2703         {
2704                 $result = api_direct_messages_box('json', 'all', 'false');
2705                 self::assertArrayHasKey('direct_message', $result);
2706         }
2707
2708         /**
2709          * Test the api_direct_messages_box() function.
2710          *
2711          * @return void
2712          */
2713         public function testApiDirectMessagesBoxWithInbox()
2714         {
2715                 $result = api_direct_messages_box('json', 'inbox', 'false');
2716                 self::assertArrayHasKey('direct_message', $result);
2717         }
2718
2719         /**
2720          * Test the api_direct_messages_box() function.
2721          *
2722          * @return void
2723          */
2724         public function testApiDirectMessagesBoxWithVerbose()
2725         {
2726                 $result = api_direct_messages_box('json', 'sentbox', 'true');
2727                 self::assertEquals(
2728                         [
2729                                 '$result' => [
2730                                         'result'  => 'error',
2731                                         'message' => 'no mails available'
2732                                 ]
2733                         ],
2734                         $result
2735                 );
2736         }
2737
2738         /**
2739          * Test the api_direct_messages_box() function with a RSS result.
2740          *
2741          * @return void
2742          */
2743         public function testApiDirectMessagesBoxWithRss()
2744         {
2745                 $result = api_direct_messages_box('rss', 'sentbox', 'false');
2746                 self::assertXml($result, 'direct-messages');
2747         }
2748
2749         /**
2750          * Test the api_direct_messages_box() function without an authenticated user.
2751          *
2752          * @return void
2753          */
2754         public function testApiDirectMessagesBoxWithUnallowedUser()
2755         {
2756                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2757                 BasicAuth::setCurrentUserID();
2758                 api_direct_messages_box('json', 'sentbox', 'false');
2759         }
2760
2761         /**
2762          * Test the api_direct_messages_sentbox() function.
2763          *
2764          * @return void
2765          */
2766         public function testApiDirectMessagesSentbox()
2767         {
2768                 $result = api_direct_messages_sentbox('json');
2769                 self::assertArrayHasKey('direct_message', $result);
2770         }
2771
2772         /**
2773          * Test the api_direct_messages_inbox() function.
2774          *
2775          * @return void
2776          */
2777         public function testApiDirectMessagesInbox()
2778         {
2779                 $result = api_direct_messages_inbox('json');
2780                 self::assertArrayHasKey('direct_message', $result);
2781         }
2782
2783         /**
2784          * Test the api_direct_messages_all() function.
2785          *
2786          * @return void
2787          */
2788         public function testApiDirectMessagesAll()
2789         {
2790                 $result = api_direct_messages_all('json');
2791                 self::assertArrayHasKey('direct_message', $result);
2792         }
2793
2794         /**
2795          * Test the api_direct_messages_conversation() function.
2796          *
2797          * @return void
2798          */
2799         public function testApiDirectMessagesConversation()
2800         {
2801                 $result = api_direct_messages_conversation('json');
2802                 self::assertArrayHasKey('direct_message', $result);
2803         }
2804
2805         /**
2806          * Test the api_oauth_request_token() function.
2807          *
2808          * @return void
2809          */
2810         public function testApiOauthRequestToken()
2811         {
2812                 $this->markTestIncomplete('exit() kills phpunit as well');
2813         }
2814
2815         /**
2816          * Test the api_oauth_access_token() function.
2817          *
2818          * @return void
2819          */
2820         public function testApiOauthAccessToken()
2821         {
2822                 $this->markTestIncomplete('exit() kills phpunit as well');
2823         }
2824
2825         /**
2826          * Test the api_fr_photos_list() function.
2827          *
2828          * @return void
2829          */
2830         public function testApiFrPhotosList()
2831         {
2832                 $result = api_fr_photos_list('json');
2833                 self::assertArrayHasKey('photo', $result);
2834         }
2835
2836         /**
2837          * Test the api_fr_photos_list() function without an authenticated user.
2838          *
2839          * @return void
2840          */
2841         public function testApiFrPhotosListWithoutAuthenticatedUser()
2842         {
2843                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2844                 BasicAuth::setCurrentUserID();
2845                 $_SESSION['authenticated'] = false;
2846                 api_fr_photos_list('json');
2847         }
2848
2849         /**
2850          * Test the api_fr_photo_create_update() function.
2851          */
2852         public function testApiFrPhotoCreateUpdate()
2853         {
2854                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2855                 api_fr_photo_create_update('json');
2856         }
2857
2858         /**
2859          * Test the api_fr_photo_create_update() function without an authenticated user.
2860          *
2861          * @return void
2862          */
2863         public function testApiFrPhotoCreateUpdateWithoutAuthenticatedUser()
2864         {
2865                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2866                 BasicAuth::setCurrentUserID();
2867                 $_SESSION['authenticated'] = false;
2868                 api_fr_photo_create_update('json');
2869         }
2870
2871         /**
2872          * Test the api_fr_photo_create_update() function with an album name.
2873          *
2874          * @return void
2875          */
2876         public function testApiFrPhotoCreateUpdateWithAlbum()
2877         {
2878                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2879                 $_REQUEST['album'] = 'album_name';
2880                 api_fr_photo_create_update('json');
2881         }
2882
2883         /**
2884          * Test the api_fr_photo_create_update() function with the update mode.
2885          *
2886          * @return void
2887          */
2888         public function testApiFrPhotoCreateUpdateWithUpdate()
2889         {
2890                 $this->markTestIncomplete('We need to create a dataset for this');
2891         }
2892
2893         /**
2894          * Test the api_fr_photo_create_update() function with an uploaded file.
2895          *
2896          * @return void
2897          */
2898         public function testApiFrPhotoCreateUpdateWithFile()
2899         {
2900                 $this->markTestIncomplete();
2901         }
2902
2903         /**
2904          * Test the api_fr_photo_detail() function.
2905          *
2906          * @return void
2907          */
2908         public function testApiFrPhotoDetail()
2909         {
2910                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2911                 api_fr_photo_detail('json');
2912         }
2913
2914         /**
2915          * Test the api_fr_photo_detail() function without an authenticated user.
2916          *
2917          * @return void
2918          */
2919         public function testApiFrPhotoDetailWithoutAuthenticatedUser()
2920         {
2921                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2922                 BasicAuth::setCurrentUserID();
2923                 $_SESSION['authenticated'] = false;
2924                 api_fr_photo_detail('json');
2925         }
2926
2927         /**
2928          * Test the api_fr_photo_detail() function with a photo ID.
2929          *
2930          * @return void
2931          */
2932         public function testApiFrPhotoDetailWithPhotoId()
2933         {
2934                 $this->expectException(\Friendica\Network\HTTPException\NotFoundException::class);
2935                 $_REQUEST['photo_id'] = 1;
2936                 api_fr_photo_detail('json');
2937         }
2938
2939         /**
2940          * Test the api_fr_photo_detail() function with a correct photo ID.
2941          *
2942          * @return void
2943          */
2944         public function testApiFrPhotoDetailCorrectPhotoId()
2945         {
2946                 $this->markTestIncomplete('We need to create a dataset for this.');
2947         }
2948
2949         /**
2950          * Test the api_account_update_profile_image() function.
2951          *
2952          * @return void
2953          */
2954         public function testApiAccountUpdateProfileImage()
2955         {
2956                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2957                 api_account_update_profile_image('json');
2958         }
2959
2960         /**
2961          * Test the api_account_update_profile_image() function without an authenticated user.
2962          *
2963          * @return void
2964          */
2965         public function testApiAccountUpdateProfileImageWithoutAuthenticatedUser()
2966         {
2967                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2968                 BasicAuth::setCurrentUserID();
2969                 $_SESSION['authenticated'] = false;
2970                 api_account_update_profile_image('json');
2971         }
2972
2973         /**
2974          * Test the api_account_update_profile_image() function with an uploaded file.
2975          *
2976          * @return void
2977          */
2978         public function testApiAccountUpdateProfileImageWithUpload()
2979         {
2980                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2981                 $this->markTestIncomplete();
2982         }
2983
2984
2985         /**
2986          * Test the api_account_update_profile() function.
2987          *
2988          * @return void
2989          */
2990         public function testApiAccountUpdateProfile()
2991         {
2992                 $_POST['name']        = 'new_name';
2993                 $_POST['description'] = 'new_description';
2994                 $result               = api_account_update_profile('json');
2995                 // We can't use assertSelfUser() here because the user object is missing some properties.
2996                 self::assertEquals($this->selfUser['id'], $result['user']['cid']);
2997                 self::assertEquals('DFRN', $result['user']['location']);
2998                 self::assertEquals($this->selfUser['nick'], $result['user']['screen_name']);
2999                 self::assertEquals('dfrn', $result['user']['network']);
3000                 self::assertEquals('new_name', $result['user']['name']);
3001                 self::assertEquals('new_description', $result['user']['description']);
3002         }
3003
3004         /**
3005          * Test the check_acl_input() function.
3006          *
3007          * @return void
3008          */
3009         public function testCheckAclInput()
3010         {
3011                 $result = check_acl_input('<aclstring>', BaseApi::getCurrentUserID());
3012                 // Where does this result come from?
3013                 self::assertEquals(1, $result);
3014         }
3015
3016         /**
3017          * Test the check_acl_input() function with an empty ACL string.
3018          *
3019          * @return void
3020          */
3021         public function testCheckAclInputWithEmptyAclString()
3022         {
3023                 $result = check_acl_input(' ', BaseApi::getCurrentUserID());
3024                 self::assertFalse($result);
3025         }
3026
3027         /**
3028          * Test the save_media_to_database() function.
3029          *
3030          * @return void
3031          */
3032         public function testSaveMediaToDatabase()
3033         {
3034                 $this->markTestIncomplete();
3035         }
3036
3037         /**
3038          * Test the post_photo_item() function.
3039          *
3040          * @return void
3041          */
3042         public function testPostPhotoItem()
3043         {
3044                 $this->markTestIncomplete();
3045         }
3046
3047         /**
3048          * Test the prepare_photo_data() function.
3049          *
3050          * @return void
3051          */
3052         public function testPreparePhotoData()
3053         {
3054                 $this->markTestIncomplete();
3055         }
3056
3057         /**
3058          * Test the api_share_as_retweet() function with a valid item.
3059          *
3060          * @return void
3061          */
3062         public function testApiShareAsRetweetWithValidItem()
3063         {
3064                 $this->markTestIncomplete();
3065         }
3066
3067         /**
3068          * Test the api_in_reply_to() function.
3069          *
3070          * @return void
3071          */
3072         public function testApiInReplyTo()
3073         {
3074                 $result = api_in_reply_to(['id' => 0, 'parent' => 0, 'uri' => '', 'thr-parent' => '']);
3075                 self::assertArrayHasKey('status_id', $result);
3076                 self::assertArrayHasKey('user_id', $result);
3077                 self::assertArrayHasKey('status_id_str', $result);
3078                 self::assertArrayHasKey('user_id_str', $result);
3079                 self::assertArrayHasKey('screen_name', $result);
3080         }
3081
3082         /**
3083          * Test the api_in_reply_to() function with a valid item.
3084          *
3085          * @return void
3086          */
3087         public function testApiInReplyToWithValidItem()
3088         {
3089                 $this->markTestIncomplete();
3090         }
3091
3092         /**
3093          * Test the api_clean_plain_items() function.
3094          *
3095          * @return void
3096          */
3097         public function testApiCleanPlainItems()
3098         {
3099                 $_REQUEST['include_entities'] = 'true';
3100                 $result                       = api_clean_plain_items('some_text [url="some_url"]some_text[/url]');
3101                 self::assertEquals('some_text [url="some_url"]"some_url"[/url]', $result);
3102         }
3103
3104         /**
3105          * Test the api_best_nickname() function with contacts.
3106          *
3107          * @return void
3108          */
3109         public function testApiBestNicknameWithContacts()
3110         {
3111                 $this->markTestIncomplete();
3112         }
3113
3114         /**
3115          * Test the api_friendica_group_show() function.
3116          *
3117          * @return void
3118          */
3119         public function testApiFriendicaGroupShow()
3120         {
3121                 $this->markTestIncomplete();
3122         }
3123
3124         /**
3125          * Test the api_friendica_group_delete() function.
3126          *
3127          * @return void
3128          */
3129         public function testApiFriendicaGroupDelete()
3130         {
3131                 $this->markTestIncomplete();
3132         }
3133
3134         /**
3135          * Test the api_lists_destroy() function.
3136          *
3137          * @return void
3138          */
3139         public function testApiListsDestroy()
3140         {
3141                 $this->markTestIncomplete();
3142         }
3143
3144         /**
3145          * Test the group_create() function.
3146          *
3147          * @return void
3148          */
3149         public function testGroupCreate()
3150         {
3151                 $this->markTestIncomplete();
3152         }
3153
3154         /**
3155          * Test the api_friendica_group_create() function.
3156          *
3157          * @return void
3158          */
3159         public function testApiFriendicaGroupCreate()
3160         {
3161                 $this->markTestIncomplete();
3162         }
3163
3164         /**
3165          * Test the api_lists_create() function.
3166          *
3167          * @return void
3168          */
3169         public function testApiListsCreate()
3170         {
3171                 $this->markTestIncomplete();
3172         }
3173
3174         /**
3175          * Test the api_friendica_group_update() function.
3176          *
3177          * @return void
3178          */
3179         public function testApiFriendicaGroupUpdate()
3180         {
3181                 $this->markTestIncomplete();
3182         }
3183
3184         /**
3185          * Test the api_lists_update() function.
3186          *
3187          * @return void
3188          */
3189         public function testApiListsUpdate()
3190         {
3191                 $this->markTestIncomplete();
3192         }
3193
3194         /**
3195          * Test the api_friendica_activity() function.
3196          *
3197          * @return void
3198          */
3199         public function testApiFriendicaActivity()
3200         {
3201                 $this->markTestIncomplete();
3202         }
3203
3204         /**
3205          * Test the api_friendica_notification_seen() function.
3206          *
3207          * @return void
3208          */
3209         public function testApiFriendicaNotificationSeen()
3210         {
3211                 $this->markTestIncomplete();
3212         }
3213
3214         /**
3215          * Test the api_friendica_direct_messages_setseen() function.
3216          *
3217          * @return void
3218          */
3219         public function testApiFriendicaDirectMessagesSetseen()
3220         {
3221                 $this->markTestIncomplete();
3222         }
3223
3224         /**
3225          * Test the api_friendica_direct_messages_search() function.
3226          *
3227          * @return void
3228          */
3229         public function testApiFriendicaDirectMessagesSearch()
3230         {
3231                 $this->markTestIncomplete();
3232         }
3233 }