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\Api\Twitter\Media\Upload;
  16 use Friendica\Module\BaseApi;
  17 use Friendica\Network\HTTPException;
  18 use Friendica\Security\BasicAuth;
  19 use Friendica\Test\FixtureTest;
  20 use Friendica\Util\Arrays;
  21 use Friendica\Util\DateTimeFormat;
  22 use Friendica\Util\Temporal;
  23 use Monolog\Handler\TestHandler;
  24
  25 require_once __DIR__ . '/../../include/api.php';
  26
  27 /**
  28  * Tests for the API functions.
  29  *
  30  * Functions that use header() need to be tested in a separate process.
  31  * @see https://phpunit.de/manual/5.7/en/appendixes.annotations.html#appendixes.annotations.runTestsInSeparateProcesses
  32  *
  33  * @backupGlobals enabled
  34  */
  35 class ApiTest extends FixtureTest
  36 {
  37         /**
  38          * @var TestHandler Can handle log-outputs
  39          */
  40         protected $logOutput;
  41
  42         /** @var array */
  43         protected $selfUser;
  44         /** @var array */
  45         protected $friendUser;
  46         /** @var array */
  47         protected $otherUser;
  48
  49         protected $wrongUserId;
  50
  51         /** @var App */
  52         protected $app;
  53
  54         /** @var IManageConfigValues */
  55         protected $config;
  56
  57         /**
  58          * Create variables used by tests.
  59          */
  60         protected function setUp() : void
  61         {
  62                 global $API, $called_api;
  63                 $API = [];
  64                 $called_api = [];
  65
  66                 parent::setUp();
  67
  68                 /** @var IManageConfigValues $config */
  69                 $this->config = $this->dice->create(IManageConfigValues::class);
  70
  71                 $this->config->set('system', 'url', 'http://localhost');
  72                 $this->config->set('system', 'hostname', 'localhost');
  73                 $this->config->set('system', 'worker_dont_fork', true);
  74
  75                 // Default config
  76                 $this->config->set('config', 'hostname', 'localhost');
  77                 $this->config->set('system', 'throttle_limit_day', 100);
  78                 $this->config->set('system', 'throttle_limit_week', 100);
  79                 $this->config->set('system', 'throttle_limit_month', 100);
  80                 $this->config->set('system', 'theme', 'system_theme');
  81
  82
  83                 /** @var App app */
  84                 $this->app = DI::app();
  85
  86                 DI::args()->setArgc(1);
  87
  88                 // User data that the test database is populated with
  89                 $this->selfUser   = [
  90                         'id'   => 42,
  91                         'name' => 'Self contact',
  92                         'nick' => 'selfcontact',
  93                         'nurl' => 'http://localhost/profile/selfcontact'
  94                 ];
  95                 $this->friendUser = [
  96                         'id'   => 44,
  97                         'name' => 'Friend contact',
  98                         'nick' => 'friendcontact',
  99                         'nurl' => 'http://localhost/profile/friendcontact'
 100                 ];
 101                 $this->otherUser  = [
 102                         'id'   => 43,
 103                         'name' => 'othercontact',
 104                         'nick' => 'othercontact',
 105                         'nurl' => 'http://localhost/profile/othercontact'
 106                 ];
 107
 108                 // User ID that we know is not in the database
 109                 $this->wrongUserId = 666;
 110
 111                 DI::session()->start();
 112
 113                 // Most API require login so we force the session
 114                 $_SESSION = [
 115                         'authenticated' => true,
 116                         'uid'           => $this->selfUser['id']
 117                 ];
 118                 BasicAuth::setCurrentUserID($this->selfUser['id']);
 119         }
 120
 121         /**
 122          * Assert that an user array contains expected keys.
 123          *
 124          * @param array $user User array
 125          *
 126          * @return void
 127          */
 128         private function assertSelfUser(array $user)
 129         {
 130                 self::assertEquals($this->selfUser['id'], $user['uid']);
 131                 self::assertEquals($this->selfUser['id'], $user['cid']);
 132                 self::assertEquals(1, $user['self']);
 133                 self::assertEquals('DFRN', $user['location']);
 134                 self::assertEquals($this->selfUser['name'], $user['name']);
 135                 self::assertEquals($this->selfUser['nick'], $user['screen_name']);
 136                 self::assertEquals('dfrn', $user['network']);
 137                 self::assertTrue($user['verified']);
 138         }
 139
 140         /**
 141          * Assert that an user array contains expected keys.
 142          *
 143          * @param array $user User array
 144          *
 145          * @return void
 146          */
 147         private function assertOtherUser(array $user = [])
 148         {
 149                 self::assertEquals($this->otherUser['id'], $user['id']);
 150                 self::assertEquals($this->otherUser['id'], $user['id_str']);
 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', BasicAuth::getCurrentApplicationToken()['name']);
 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', BasicAuth::getCurrentApplicationToken()['name']);
 259         }
 260
 261         /**
 262          * Test the api_source() function with a GET parameter.
 263          *
 264          * @return void
 265          */
 266         public function testApiSourceWithGet()
 267         {
 268                 $_REQUEST['source'] = 'source_name';
 269                 self::assertEquals('source_name', BasicAuth::getCurrentApplicationToken()['name']);
 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(is_callable($API['api_path']['func']));
 300         }
 301
 302         /**
 303          * Test the BasicAuth::getCurrentUserID() function without any login.
 304          *
 305          * @runInSeparateProcess
 306          * @preserveGlobalState disabled
 307          * @preserveGlobalState disabled
 308          */
 309         public function testApiLoginWithoutLogin()
 310         {
 311                 BasicAuth::setCurrentUserID();
 312                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 313                 BasicAuth::getCurrentUserID(true);
 314         }
 315
 316         /**
 317          * Test the BasicAuth::getCurrentUserID() function with a bad login.
 318          *
 319          * @runInSeparateProcess
 320          * @preserveGlobalState disabled
 321          * @preserveGlobalState disabled
 322          */
 323         public function testApiLoginWithBadLogin()
 324         {
 325                 BasicAuth::setCurrentUserID();
 326                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 327                 $_SERVER['PHP_AUTH_USER'] = 'user@server';
 328                 BasicAuth::getCurrentUserID(true);
 329         }
 330
 331         /**
 332          * Test the BasicAuth::getCurrentUserID() function with oAuth.
 333          *
 334          * @return void
 335          */
 336         public function testApiLoginWithOauth()
 337         {
 338                 $this->markTestIncomplete('Can we test this easily?');
 339         }
 340
 341         /**
 342          * Test the BasicAuth::getCurrentUserID() function with authentication provided by an addon.
 343          *
 344          * @return void
 345          */
 346         public function testApiLoginWithAddonAuth()
 347         {
 348                 $this->markTestIncomplete('Can we test this easily?');
 349         }
 350
 351         /**
 352          * Test the BasicAuth::getCurrentUserID() function with a correct login.
 353          *
 354          * @runInSeparateProcess
 355          * @preserveGlobalState disabled
 356          * @doesNotPerformAssertions
 357          */
 358         public function testApiLoginWithCorrectLogin()
 359         {
 360                 BasicAuth::setCurrentUserID();
 361                 $_SERVER['PHP_AUTH_USER'] = 'Test user';
 362                 $_SERVER['PHP_AUTH_PW']   = 'password';
 363                 BasicAuth::getCurrentUserID(true);
 364         }
 365
 366         /**
 367          * Test the BasicAuth::getCurrentUserID() function with a remote user.
 368          *
 369          * @runInSeparateProcess
 370          * @preserveGlobalState disabled
 371          */
 372         public function testApiLoginWithRemoteUser()
 373         {
 374                 BasicAuth::setCurrentUserID();
 375                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 376                 $_SERVER['REDIRECT_REMOTE_USER'] = '123456dXNlcjpwYXNzd29yZA==';
 377                 BasicAuth::getCurrentUserID(true);
 378         }
 379
 380         /**
 381          * Test the api_call() function.
 382          *
 383          * @runInSeparateProcess
 384          * @preserveGlobalState disabled
 385          */
 386         public function testApiCall()
 387         {
 388                 global $API;
 389                 $API['api_path']           = [
 390                         'method' => 'method',
 391                         'func'   => function () {
 392                                 return ['data' => ['some_data']];
 393                         }
 394                 ];
 395                 $_SERVER['REQUEST_METHOD'] = 'method';
 396                 $_SERVER['QUERY_STRING'] = 'pagename=api_path';
 397                 $_GET['callback']          = 'callback_name';
 398
 399                 self::assertEquals(
 400                         'callback_name(["some_data"])',
 401                         api_call('api_path', 'json')
 402                 );
 403         }
 404
 405         /**
 406          * Test the api_call() function with the profiled enabled.
 407          *
 408          * @runInSeparateProcess
 409          * @preserveGlobalState disabled
 410          */
 411         public function testApiCallWithProfiler()
 412         {
 413                 global $API;
 414                 $API['api_path']           = [
 415                         'method' => 'method',
 416                         'func'   => function () {
 417                                 return ['data' => ['some_data']];
 418                         }
 419                 ];
 420
 421                 $_SERVER['REQUEST_METHOD'] = 'method';
 422                 $_SERVER['QUERY_STRING'] = 'pagename=api_path';
 423
 424                 $this->config->set('system', 'profiler', true);
 425                 $this->config->set('rendertime', 'callstack', true);
 426                 $this->app->callstack = [
 427                         'database'       => ['some_function' => 200],
 428                         'database_write' => ['some_function' => 200],
 429                         'cache'          => ['some_function' => 200],
 430                         'cache_write'    => ['some_function' => 200],
 431                         'network'        => ['some_function' => 200]
 432                 ];
 433
 434                 self::assertEquals(
 435                         '["some_data"]',
 436                         api_call('api_path', 'json')
 437                 );
 438         }
 439
 440         /**
 441          * Test the api_call() function with a JSON result.
 442          *
 443          * @runInSeparateProcess
 444          * @preserveGlobalState disabled
 445          */
 446         public function testApiCallWithJson()
 447         {
 448                 global $API;
 449                 $API['api_path']           = [
 450                         'method' => 'method',
 451                         'func'   => function () {
 452                                 return ['data' => ['some_data']];
 453                         }
 454                 ];
 455                 $_SERVER['REQUEST_METHOD'] = 'method';
 456                 $_SERVER['QUERY_STRING'] = 'pagename=api_path.json';
 457
 458                 self::assertEquals(
 459                         '["some_data"]',
 460                         api_call('api_path.json', 'json')
 461                 );
 462         }
 463
 464         /**
 465          * Test the api_call() function with an XML result.
 466          *
 467          * @runInSeparateProcess
 468          * @preserveGlobalState disabled
 469          */
 470         public function testApiCallWithXml()
 471         {
 472                 global $API;
 473                 $API['api_path']           = [
 474                         'method' => 'method',
 475                         'func'   => function () {
 476                                 return 'some_data';
 477                         }
 478                 ];
 479                 $_SERVER['REQUEST_METHOD'] = 'method';
 480                 $_SERVER['QUERY_STRING'] = 'pagename=api_path.xml';
 481
 482                 $args = DI::args()->determine($_SERVER, $_GET);
 483
 484                 self::assertEquals(
 485                         'some_data',
 486                         api_call('api_path.xml', 'xml')
 487                 );
 488         }
 489
 490         /**
 491          * Test the api_call() function with an RSS result.
 492          *
 493          * @runInSeparateProcess
 494          * @preserveGlobalState disabled
 495          */
 496         public function testApiCallWithRss()
 497         {
 498                 global $API;
 499                 $API['api_path']           = [
 500                         'method' => 'method',
 501                         'func'   => function () {
 502                                 return 'some_data';
 503                         }
 504                 ];
 505                 $_SERVER['REQUEST_METHOD'] = 'method';
 506                 $_SERVER['QUERY_STRING'] = 'pagename=api_path.rss';
 507
 508                 self::assertEquals(
 509                         '<?xml version="1.0" encoding="UTF-8"?>' . "\n" .
 510                         'some_data',
 511                         api_call('api_path.rss', 'rss')
 512                 );
 513         }
 514
 515         /**
 516          * Test the api_call() function with an Atom result.
 517          *
 518          * @runInSeparateProcess
 519          * @preserveGlobalState disabled
 520          */
 521         public function testApiCallWithAtom()
 522         {
 523                 global $API;
 524                 $API['api_path']           = [
 525                         'method' => 'method',
 526                         'func'   => function () {
 527                                 return 'some_data';
 528                         }
 529                 ];
 530                 $_SERVER['REQUEST_METHOD'] = 'method';
 531                 $_SERVER['QUERY_STRING'] = 'pagename=api_path.atom';
 532
 533                 self::assertEquals(
 534                         '<?xml version="1.0" encoding="UTF-8"?>' . "\n" .
 535                         'some_data',
 536                         api_call('api_path.atom', 'atom')
 537                 );
 538         }
 539
 540         /**
 541          * Test the api_rss_extra() function.
 542          *
 543          * @return void
 544          */
 545         public function testApiRssExtra()
 546         {
 547                 /*
 548                 $user_info = ['url' => 'user_url', 'lang' => 'en'];
 549                 $result    = api_rss_extra([], $user_info);
 550                 self::assertEquals($user_info, $result['$user']);
 551                 self::assertEquals($user_info['url'], $result['$rss']['alternate']);
 552                 self::assertArrayHasKey('self', $result['$rss']);
 553                 self::assertArrayHasKey('base', $result['$rss']);
 554                 self::assertArrayHasKey('updated', $result['$rss']);
 555                 self::assertArrayHasKey('atom_updated', $result['$rss']);
 556                 self::assertArrayHasKey('language', $result['$rss']);
 557                 self::assertArrayHasKey('logo', $result['$rss']);
 558                 */
 559         }
 560
 561         /**
 562          * Test the api_rss_extra() function without any user info.
 563          *
 564          * @return void
 565          */
 566         public function testApiRssExtraWithoutUserInfo()
 567         {
 568                 /*
 569                 $result = api_rss_extra([], null);
 570                 self::assertIsArray($result['$user']);
 571                 self::assertArrayHasKey('alternate', $result['$rss']);
 572                 self::assertArrayHasKey('self', $result['$rss']);
 573                 self::assertArrayHasKey('base', $result['$rss']);
 574                 self::assertArrayHasKey('updated', $result['$rss']);
 575                 self::assertArrayHasKey('atom_updated', $result['$rss']);
 576                 self::assertArrayHasKey('language', $result['$rss']);
 577                 self::assertArrayHasKey('logo', $result['$rss']);
 578                 */
 579         }
 580
 581         /**
 582          * Test the api_get_user() function.
 583          *
 584          * @return void
 585          */
 586         public function testApiGetUser()
 587         {
 588                 // $user = api_get_user();
 589                 // self::assertSelfUser($user);
 590                 // self::assertEquals('708fa0', $user['profile_sidebar_fill_color']);
 591                 // self::assertEquals('6fdbe8', $user['profile_link_color']);
 592                 // self::assertEquals('ededed', $user['profile_background_color']);
 593         }
 594
 595         /**
 596          * Test the api_get_user() function with a Frio schema.
 597          *
 598          * @return void
 599          */
 600         public function testApiGetUserWithFrioSchema()
 601         {
 602                 // $pConfig = $this->dice->create(IManagePersonalConfigValues::class);
 603                 // $pConfig->set($this->selfUser['id'], 'frio', 'schema', 'red');
 604                 // $user = api_get_user();
 605                 // self::assertSelfUser($user);
 606                 // self::assertEquals('708fa0', $user['profile_sidebar_fill_color']);
 607                 // self::assertEquals('6fdbe8', $user['profile_link_color']);
 608                 // self::assertEquals('ededed', $user['profile_background_color']);
 609         }
 610
 611         /**
 612          * Test the api_get_user() function with an empty Frio schema.
 613          *
 614          * @return void
 615          */
 616         public function testApiGetUserWithEmptyFrioSchema()
 617         {
 618                 // $pConfig = $this->dice->create(IManagePersonalConfigValues::class);
 619                 // $pConfig->set($this->selfUser['id'], 'frio', 'schema', '---');
 620                 // $user = api_get_user();
 621                 // self::assertSelfUser($user);
 622                 // self::assertEquals('708fa0', $user['profile_sidebar_fill_color']);
 623                 // self::assertEquals('6fdbe8', $user['profile_link_color']);
 624                 // self::assertEquals('ededed', $user['profile_background_color']);
 625         }
 626
 627         /**
 628          * Test the api_get_user() function with a custom Frio schema.
 629          *
 630          * @return void
 631          */
 632         public function testApiGetUserWithCustomFrioSchema()
 633         {
 634                 // $pConfig = $this->dice->create(IManagePersonalConfigValues::class);
 635                 // $pConfig->set($this->selfUser['id'], 'frio', 'schema', '---');
 636                 // $pConfig->set($this->selfUser['id'], 'frio', 'nav_bg', '#123456');
 637                 // $pConfig->set($this->selfUser['id'], 'frio', 'link_color', '#123456');
 638                 // $pConfig->set($this->selfUser['id'], 'frio', 'background_color', '#123456');
 639                 // $user = api_get_user();
 640                 // self::assertSelfUser($user);
 641                 // self::assertEquals('123456', $user['profile_sidebar_fill_color']);
 642                 // self::assertEquals('123456', $user['profile_link_color']);
 643                 // self::assertEquals('123456', $user['profile_background_color']);
 644         }
 645
 646         /**
 647          * Test the api_get_user() function with an user that is not allowed to use the API.
 648          *
 649          * @runInSeparateProcess
 650          * @preserveGlobalState disabled
 651          */
 652         public function testApiGetUserWithoutApiUser()
 653         {
 654                 // api_get_user() with empty parameters is not used anymore
 655                 /*
 656                 $_SERVER['PHP_AUTH_USER'] = 'Test user';
 657                 $_SERVER['PHP_AUTH_PW']   = 'password';
 658                 BasicAuth::setCurrentUserID();
 659                 self::assertFalse(api_get_user());
 660                 */
 661         }
 662
 663         /**
 664          * Test the api_get_user() function with an user ID in a GET parameter.
 665          *
 666          * @return void
 667          */
 668         public function testApiGetUserWithGetId()
 669         {
 670                 // self::assertOtherUser(api_get_user());
 671         }
 672
 673         /**
 674          * Test the api_get_user() function with a wrong user ID in a GET parameter.
 675          *
 676          * @return void
 677          */
 678         public function testApiGetUserWithWrongGetId()
 679         {
 680                 // $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
 681                 // self::assertOtherUser(api_get_user());
 682         }
 683
 684         /**
 685          * Test the api_get_user() function with an user name in a GET parameter.
 686          *
 687          * @return void
 688          */
 689         public function testApiGetUserWithGetName()
 690         {
 691                 // self::assertSelfUser(api_get_user());
 692         }
 693
 694         /**
 695          * Test the api_get_user() function with a profile URL in a GET parameter.
 696          *
 697          * @return void
 698          */
 699         public function testApiGetUserWithGetUrl()
 700         {
 701                 // self::assertSelfUser(api_get_user());
 702         }
 703
 704         /**
 705          * Test the api_get_user() function with an user ID in the API path.
 706          *
 707          * @return void
 708          */
 709         public function testApiGetUserWithNumericCalledApi()
 710         {
 711                 // global $called_api;
 712                 // $called_api         = ['api_path'];
 713                 // DI::args()->setArgv(['', $this->otherUser['id'] . '.json']);
 714                 // self::assertOtherUser(api_get_user());
 715         }
 716
 717         /**
 718          * Test the api_get_user() function with the $called_api global variable.
 719          *
 720          * @return void
 721          */
 722         public function testApiGetUserWithCalledApi()
 723         {
 724                 // global $called_api;
 725                 // $called_api = ['api', 'api_path'];
 726                 // self::assertSelfUser(api_get_user());
 727         }
 728
 729         /**
 730          * Test the Arrays::walkRecursive() function.
 731          *
 732          * @return void
 733          */
 734         public function testApiWalkRecursive()
 735         {
 736                 $array = ['item1'];
 737                 self::assertEquals(
 738                         $array,
 739                         Arrays::walkRecursive(
 740                                 $array,
 741                                 function () {
 742                                         // Should we test this with a callback that actually does something?
 743                                         return true;
 744                                 }
 745                         )
 746                 );
 747         }
 748
 749         /**
 750          * Test the Arrays::walkRecursive() function with an array.
 751          *
 752          * @return void
 753          */
 754         public function testApiWalkRecursiveWithArray()
 755         {
 756                 $array = [['item1'], ['item2']];
 757                 self::assertEquals(
 758                         $array,
 759                         Arrays::walkRecursive(
 760                                 $array,
 761                                 function () {
 762                                         // Should we test this with a callback that actually does something?
 763                                         return true;
 764                                 }
 765                         )
 766                 );
 767         }
 768
 769         /**
 770          * Test the BaseApi::reformatXML() function.
 771          *
 772          * @return void
 773          */
 774         public function testApiReformatXml()
 775         {
 776                 $item = true;
 777                 $key  = '';
 778                 self::assertTrue(ApiResponse::reformatXML($item, $key));
 779                 self::assertEquals('true', $item);
 780         }
 781
 782         /**
 783          * Test the BaseApi::reformatXML() function with a statusnet_api key.
 784          *
 785          * @return void
 786          */
 787         public function testApiReformatXmlWithStatusnetKey()
 788         {
 789                 $item = '';
 790                 $key  = 'statusnet_api';
 791                 self::assertTrue(ApiResponse::reformatXML($item, $key));
 792                 self::assertEquals('statusnet:api', $key);
 793         }
 794
 795         /**
 796          * Test the BaseApi::reformatXML() function with a friendica_api key.
 797          *
 798          * @return void
 799          */
 800         public function testApiReformatXmlWithFriendicaKey()
 801         {
 802                 $item = '';
 803                 $key  = 'friendica_api';
 804                 self::assertTrue(ApiResponse::reformatXML($item, $key));
 805                 self::assertEquals('friendica:api', $key);
 806         }
 807
 808         /**
 809          * Test the BaseApi::createXML() function.
 810          *
 811          * @return void
 812          */
 813         public function testApiCreateXml()
 814         {
 815                 self::assertEquals(
 816                         '<?xml version="1.0"?>' . "\n" .
 817                         '<root_element xmlns="http://api.twitter.com" xmlns:statusnet="http://status.net/schema/api/1/" ' .
 818                         'xmlns:friendica="http://friendi.ca/schema/api/1/" ' .
 819                         'xmlns:georss="http://www.georss.org/georss">' . "\n" .
 820                         '  <data>some_data</data>' . "\n" .
 821                         '</root_element>' . "\n",
 822                         DI::apiResponse()->createXML(['data' => ['some_data']], 'root_element')
 823                 );
 824         }
 825
 826         /**
 827          * Test the BaseApi::createXML() function without any XML namespace.
 828          *
 829          * @return void
 830          */
 831         public function testApiCreateXmlWithoutNamespaces()
 832         {
 833                 self::assertEquals(
 834                         '<?xml version="1.0"?>' . "\n" .
 835                         '<ok>' . "\n" .
 836                         '  <data>some_data</data>' . "\n" .
 837                         '</ok>' . "\n",
 838                         DI::apiResponse()->createXML(['data' => ['some_data']], 'ok')
 839                 );
 840         }
 841
 842         /**
 843          * Test the BaseApi::formatData() function.
 844          *
 845          * @return void
 846          */
 847         public function testApiFormatData()
 848         {
 849                 $data = ['some_data'];
 850                 self::assertEquals($data, DI::apiResponse()->formatData('root_element', 'json', $data));
 851         }
 852
 853         /**
 854          * Test the BaseApi::formatData() function with an XML result.
 855          *
 856          * @return void
 857          */
 858         public function testApiFormatDataWithXml()
 859         {
 860                 self::assertEquals(
 861                         '<?xml version="1.0"?>' . "\n" .
 862                         '<root_element xmlns="http://api.twitter.com" xmlns:statusnet="http://status.net/schema/api/1/" ' .
 863                         'xmlns:friendica="http://friendi.ca/schema/api/1/" ' .
 864                         'xmlns:georss="http://www.georss.org/georss">' . "\n" .
 865                         '  <data>some_data</data>' . "\n" .
 866                         '</root_element>' . "\n",
 867                         DI::apiResponse()->formatData('root_element', 'xml', ['data' => ['some_data']])
 868                 );
 869         }
 870
 871         /**
 872          * Test the api_statuses_mediap() function.
 873          *
 874          * @return void
 875          */
 876         public function testApiStatusesMediap()
 877         {
 878                 /*
 879                 DI::args()->setArgc(2);
 880
 881                 $_FILES         = [
 882                         'media' => [
 883                                 'id'       => 666,
 884                                 'size'     => 666,
 885                                 'width'    => 666,
 886                                 'height'   => 666,
 887                                 'tmp_name' => $this->getTempImage(),
 888                                 'name'     => 'spacer.png',
 889                                 'type'     => 'image/png'
 890                         ]
 891                 ];
 892                 $_GET['status'] = '<b>Status content</b>';
 893
 894                 $result = api_statuses_mediap('json');
 895                 self::assertStatus($result['status']);
 896                 */
 897         }
 898
 899         /**
 900          * Test the api_statuses_mediap() function without an authenticated user.
 901          *
 902          * @return void
 903          */
 904         public function testApiStatusesMediapWithoutAuthenticatedUser()
 905         {
 906                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 907                 // BasicAuth::setCurrentUserID();
 908                 // $_SESSION['authenticated'] = false;
 909                 // api_statuses_mediap('json');
 910         }
 911
 912         /**
 913          * Test the api_statuses_update() function.
 914          *
 915          * @return void
 916          */
 917         public function testApiStatusesUpdate()
 918         {
 919                 $_REQUEST['status']                = 'Status content #friendica';
 920                 $_REQUEST['in_reply_to_status_id'] = -1;
 921                 $_REQUEST['lat']                   = 48;
 922                 $_REQUEST['long']                  = 7;
 923                 $_FILES                            = [
 924                         'media' => [
 925                                 'id'       => 666,
 926                                 'size'     => 666,
 927                                 'width'    => 666,
 928                                 'height'   => 666,
 929                                 'tmp_name' => $this->getTempImage(),
 930                                 'name'     => 'spacer.png',
 931                                 'type'     => 'image/png'
 932                         ]
 933                 ];
 934
 935                 $result = api_statuses_update('json');
 936                 self::assertStatus($result['status']);
 937         }
 938
 939         /**
 940          * Test the api_statuses_update() function with an HTML status.
 941          *
 942          * @return void
 943          */
 944         public function testApiStatusesUpdateWithHtml()
 945         {
 946                 $_REQUEST['htmlstatus'] = '<b>Status content</b>';
 947
 948                 $result = api_statuses_update('json');
 949                 self::assertStatus($result['status']);
 950         }
 951
 952         /**
 953          * Test the api_statuses_update() function without an authenticated user.
 954          *
 955          * @return void
 956          */
 957         public function testApiStatusesUpdateWithoutAuthenticatedUser()
 958         {
 959                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 960                 BasicAuth::setCurrentUserID();
 961                 $_SESSION['authenticated'] = false;
 962                 api_statuses_update('json');
 963         }
 964
 965         /**
 966          * Test the api_statuses_update() function with a parent status.
 967          *
 968          * @return void
 969          */
 970         public function testApiStatusesUpdateWithParent()
 971         {
 972                 $this->markTestIncomplete('This triggers an exit() somewhere and kills PHPUnit.');
 973         }
 974
 975         /**
 976          * Test the api_statuses_update() function with a media_ids parameter.
 977          *
 978          * @return void
 979          */
 980         public function testApiStatusesUpdateWithMediaIds()
 981         {
 982                 $this->markTestIncomplete();
 983         }
 984
 985         /**
 986          * Test the api_statuses_update() function with the throttle limit reached.
 987          *
 988          * @return void
 989          */
 990         public function testApiStatusesUpdateWithDayThrottleReached()
 991         {
 992                 $this->markTestIncomplete();
 993         }
 994
 995         /**
 996          * Test the \Friendica\Module\Api\Twitter\Media\Upload module.
 997          * @runInSeparateProcess
 998          * @preserveGlobalState disabled
 999          */
1000         public function testApiMediaUpload()
1001         {
1002                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1003                 (new Upload(DI::app(), DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), $_SERVER))->run();
1004         }
1005
1006         /**
1007          * Test the \Friendica\Module\Api\Twitter\Media\Upload module without an authenticated user.
1008          *
1009          * @return void
1010          */
1011         public function testApiMediaUploadWithoutAuthenticatedUser()
1012         {
1013                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1014                 BasicAuth::setCurrentUserID();
1015                 $_SESSION['authenticated'] = false;
1016                 (new Upload(DI::app(), DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), $_SERVER))->run();
1017         }
1018
1019         /**
1020          * Test the \Friendica\Module\Api\Twitter\Media\Upload module with an invalid uploaded media.
1021          *
1022          * @return void
1023          */
1024         public function testApiMediaUploadWithMedia()
1025         {
1026                 $this->expectException(\Friendica\Network\HTTPException\InternalServerErrorException::class);
1027                 $_FILES = [
1028                         'media' => [
1029                                 'id'       => 666,
1030                                 'tmp_name' => 'tmp_name'
1031                         ]
1032                 ];
1033                 (new Upload(DI::app(), DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), $_SERVER))->run();
1034         }
1035
1036         /**
1037          * Test the \Friendica\Module\Api\Twitter\Media\Upload module with an valid uploaded media.
1038          *
1039          * @return void
1040          */
1041         public function testApiMediaUploadWithValidMedia()
1042         {
1043                 $_FILES    = [
1044                         'media' => [
1045                                 'id'       => 666,
1046                                 'size'     => 666,
1047                                 'width'    => 666,
1048                                 'height'   => 666,
1049                                 'tmp_name' => $this->getTempImage(),
1050                                 'name'     => 'spacer.png',
1051                                 'type'     => 'image/png'
1052                         ]
1053                 ];
1054
1055                 $response = (new Upload(DI::app(), DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), $_SERVER))->run();
1056                 $media = json_decode($response->getBody(), true);
1057
1058                 self::assertEquals('image/png', $media['image']['image_type']);
1059                 self::assertEquals(1, $media['image']['w']);
1060                 self::assertEquals(1, $media['image']['h']);
1061                 self::assertNotEmpty($media['image']['friendica_preview_url']);
1062         }
1063
1064         /**
1065          * Test the api_statuses_repeat() function.
1066          *
1067          * @return void
1068          */
1069         public function testApiStatusesRepeat()
1070         {
1071                 $this->expectException(\Friendica\Network\HTTPException\ForbiddenException::class);
1072                 api_statuses_repeat('json');
1073         }
1074
1075         /**
1076          * Test the api_statuses_repeat() function without an authenticated user.
1077          *
1078          * @return void
1079          */
1080         public function testApiStatusesRepeatWithoutAuthenticatedUser()
1081         {
1082                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1083                 BasicAuth::setCurrentUserID();
1084                 $_SESSION['authenticated'] = false;
1085                 api_statuses_repeat('json');
1086         }
1087
1088         /**
1089          * Test the api_statuses_repeat() function with an ID.
1090          *
1091          * @return void
1092          */
1093         public function testApiStatusesRepeatWithId()
1094         {
1095                 DI::args()->setArgv(['', '', '', 1]);
1096                 $result = api_statuses_repeat('json');
1097                 self::assertStatus($result['status']);
1098
1099                 // Also test with a shared status
1100                 DI::args()->setArgv(['', '', '', 5]);
1101                 $result = api_statuses_repeat('json');
1102                 self::assertStatus($result['status']);
1103         }
1104
1105         /**
1106          * Test the api_favorites_create_destroy() function.
1107          *
1108          * @return void
1109          */
1110         public function testApiFavoritesCreateDestroy()
1111         {
1112                 // $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1113                 // DI::args()->setArgv(['api', '1.1', 'favorites', 'create']);
1114                 // api_favorites_create_destroy('json');
1115         }
1116
1117         /**
1118          * Test the api_favorites_create_destroy() function with an invalid ID.
1119          *
1120          * @return void
1121          */
1122         public function testApiFavoritesCreateDestroyWithInvalidId()
1123         {
1124                 // $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1125                 // DI::args()->setArgv(['api', '1.1', 'favorites', 'create', '12.json']);
1126                 // api_favorites_create_destroy('json');
1127         }
1128
1129         /**
1130          * Test the api_favorites_create_destroy() function with an invalid action.
1131          *
1132          * @return void
1133          */
1134         public function testApiFavoritesCreateDestroyWithInvalidAction()
1135         {
1136                 // $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1137                 // DI::args()->setArgv(['api', '1.1', 'favorites', 'change.json']);
1138                 // $_REQUEST['id'] = 1;
1139                 // api_favorites_create_destroy('json');
1140         }
1141
1142         /**
1143          * Test the api_favorites_create_destroy() function with the create action.
1144          *
1145          * @return void
1146          */
1147         public function testApiFavoritesCreateDestroyWithCreateAction()
1148         {
1149                 // DI::args()->setArgv(['api', '1.1', 'favorites', 'create.json']);
1150                 // $_REQUEST['id'] = 3;
1151                 // $result         = api_favorites_create_destroy('json');
1152                 // self::assertStatus($result['status']);
1153         }
1154
1155         /**
1156          * Test the api_favorites_create_destroy() function with the create action and an RSS result.
1157          *
1158          * @return void
1159          */
1160         public function testApiFavoritesCreateDestroyWithCreateActionAndRss()
1161         {
1162                 // DI::args()->setArgv(['api', '1.1', 'favorites', 'create.rss']);
1163                 // $_REQUEST['id'] = 3;
1164                 // $result         = api_favorites_create_destroy('rss');
1165                 // self::assertXml($result, 'status');
1166         }
1167
1168         /**
1169          * Test the api_favorites_create_destroy() function with the destroy action.
1170          *
1171          * @return void
1172          */
1173         public function testApiFavoritesCreateDestroyWithDestroyAction()
1174         {
1175                 // DI::args()->setArgv(['api', '1.1', 'favorites', 'destroy.json']);
1176                 // $_REQUEST['id'] = 3;
1177                 // $result         = api_favorites_create_destroy('json');
1178                 // self::assertStatus($result['status']);
1179         }
1180
1181         /**
1182          * Test the api_favorites_create_destroy() function without an authenticated user.
1183          *
1184          * @return void
1185          */
1186         public function testApiFavoritesCreateDestroyWithoutAuthenticatedUser()
1187         {
1188                 /*
1189                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1190                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.json']);
1191                 BasicAuth::setCurrentUserID();
1192                 $_SESSION['authenticated'] = false;
1193                 api_favorites_create_destroy('json');
1194                 */
1195         }
1196
1197
1198
1199         /**
1200          * Test the api_format_messages() function.
1201          *
1202          * @return void
1203          */
1204         public function testApiFormatMessages()
1205         {
1206                 $result = api_format_messages(
1207                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1208                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1209                         ['id' => 3, 'uri-id' => 2, 'screen_name' => 'sender_name']
1210                 );
1211                 self::assertEquals('item_title' . "\n" . 'item_body', $result['text']);
1212                 self::assertEquals(1, $result['id']);
1213                 self::assertEquals(2, $result['recipient_id']);
1214                 self::assertEquals(3, $result['sender_id']);
1215                 self::assertEquals('recipient_name', $result['recipient_screen_name']);
1216                 self::assertEquals('sender_name', $result['sender_screen_name']);
1217         }
1218
1219         /**
1220          * Test the api_format_messages() function with HTML.
1221          *
1222          * @return void
1223          */
1224         public function testApiFormatMessagesWithHtmlText()
1225         {
1226                 $_GET['getText'] = 'html';
1227                 $result          = api_format_messages(
1228                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1229                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1230                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1231                 );
1232                 self::assertEquals('item_title', $result['title']);
1233                 self::assertEquals('<strong>item_body</strong>', $result['text']);
1234         }
1235
1236         /**
1237          * Test the api_format_messages() function with plain text.
1238          *
1239          * @return void
1240          */
1241         public function testApiFormatMessagesWithPlainText()
1242         {
1243                 $_GET['getText'] = 'plain';
1244                 $result          = api_format_messages(
1245                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1246                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1247                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1248                 );
1249                 self::assertEquals('item_title', $result['title']);
1250                 self::assertEquals('item_body', $result['text']);
1251         }
1252
1253         /**
1254          * Test the api_format_messages() function with the getUserObjects GET parameter set to false.
1255          *
1256          * @return void
1257          */
1258         public function testApiFormatMessagesWithoutUserObjects()
1259         {
1260                 $_GET['getUserObjects'] = 'false';
1261                 $result                 = api_format_messages(
1262                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1263                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1264                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1265                 );
1266                 self::assertTrue(!isset($result['sender']));
1267                 self::assertTrue(!isset($result['recipient']));
1268         }
1269
1270         /**
1271          * Test the api_convert_item() function.
1272          *
1273          * @return void
1274          */
1275         public function testApiConvertItem()
1276         {
1277                 /*
1278                 $result = api_convert_item(
1279                         [
1280                                 'network' => 'feed',
1281                                 'title'   => 'item_title',
1282                                 'uri-id'  => 1,
1283                                 // We need a long string to test that it is correctly cut
1284                                 'body'    => 'perspiciatis impedit voluptatem quis molestiae ea qui ' .
1285                                                          'reiciendis dolorum aut ducimus sunt consequatur inventore dolor ' .
1286                                                          'officiis pariatur doloremque nemo culpa aut quidem qui dolore ' .
1287                                                          'laudantium atque commodi alias voluptatem non possimus aperiam ' .
1288                                                          'ipsum rerum consequuntur aut amet fugit quia aliquid praesentium ' .
1289                                                          'repellendus quibusdam et et inventore mollitia rerum sit autem ' .
1290                                                          'pariatur maiores ipsum accusantium perferendis vel sit possimus ' .
1291                                                          'veritatis nihil distinctio qui eum repellat officia illum quos ' .
1292                                                          'impedit quam iste esse unde qui suscipit aut facilis ut inventore ' .
1293                                                          'omnis exercitationem quo magnam consequatur maxime aut illum ' .
1294                                                          'soluta quaerat natus unde aspernatur et sed beatae nihil ullam ' .
1295                                                          'temporibus corporis ratione blanditiis perspiciatis impedit ' .
1296                                                          'voluptatem quis molestiae ea qui reiciendis dolorum aut ducimus ' .
1297                                                          'sunt consequatur inventore dolor officiis pariatur doloremque ' .
1298                                                          'nemo culpa aut quidem qui dolore laudantium atque commodi alias ' .
1299                                                          'voluptatem non possimus aperiam ipsum rerum consequuntur aut ' .
1300                                                          'amet fugit quia aliquid praesentium repellendus quibusdam et et ' .
1301                                                          'inventore mollitia rerum sit autem pariatur maiores ipsum accusantium ' .
1302                                                          'perferendis vel sit possimus veritatis nihil distinctio qui eum ' .
1303                                                          'repellat officia illum quos impedit quam iste esse unde qui ' .
1304                                                          'suscipit aut facilis ut inventore omnis exercitationem quo magnam ' .
1305                                                          'consequatur maxime aut illum soluta quaerat natus unde aspernatur ' .
1306                                                          'et sed beatae nihil ullam temporibus corporis ratione blanditiis',
1307                                 'plink'   => 'item_plink'
1308                         ]
1309                 );
1310                 self::assertStringStartsWith('item_title', $result['text']);
1311                 self::assertStringStartsWith('<h4>item_title</h4><br>perspiciatis impedit voluptatem', $result['html']);
1312                 */
1313         }
1314
1315         /**
1316          * Test the api_convert_item() function with an empty item body.
1317          *
1318          * @return void
1319          */
1320         public function testApiConvertItemWithoutBody()
1321         {
1322                 /*
1323                 $result = api_convert_item(
1324                         [
1325                                 'network' => 'feed',
1326                                 'title'   => 'item_title',
1327                                 'uri-id'  => -1,
1328                                 'body'    => '',
1329                                 'plink'   => 'item_plink'
1330                         ]
1331                 );
1332                 self::assertEquals("item_title", $result['text']);
1333                 self::assertEquals('<h4>item_title</h4><br>item_plink', $result['html']);
1334                 */
1335         }
1336
1337         /**
1338          * Test the api_convert_item() function with the title in the body.
1339          *
1340          * @return void
1341          */
1342         public function testApiConvertItemWithTitleInBody()
1343         {
1344                 /*
1345                 $result = api_convert_item(
1346                         [
1347                                 'title'  => 'item_title',
1348                                 'body'   => 'item_title item_body',
1349                                 'uri-id' => 1,
1350                         ]
1351                 );
1352                 self::assertEquals('item_title item_body', $result['text']);
1353                 self::assertEquals('<h4>item_title</h4><br>item_title item_body', $result['html']);
1354                 */
1355         }
1356
1357         /**
1358          * Test the api_get_attachments() function.
1359          *
1360          * @return void
1361          */
1362         public function testApiGetAttachments()
1363         {
1364                 // $body = 'body';
1365                 // self::assertEmpty(api_get_attachments($body, 0));
1366         }
1367
1368         /**
1369          * Test the api_get_attachments() function with an img tag.
1370          *
1371          * @return void
1372          */
1373         public function testApiGetAttachmentsWithImage()
1374         {
1375                 // $body = '[img]http://via.placeholder.com/1x1.png[/img]';
1376                 // self::assertIsArray(api_get_attachments($body, 0));
1377         }
1378
1379         /**
1380          * Test the api_get_attachments() function with an img tag and an AndStatus user agent.
1381          *
1382          * @return void
1383          */
1384         public function testApiGetAttachmentsWithImageAndAndStatus()
1385         {
1386                 // $_SERVER['HTTP_USER_AGENT'] = 'AndStatus';
1387                 // $body                       = '[img]http://via.placeholder.com/1x1.png[/img]';
1388                 // self::assertIsArray(api_get_attachments($body, 0));
1389         }
1390
1391         /**
1392          * Test the api_get_entitities() function.
1393          *
1394          * @return void
1395          */
1396         public function testApiGetEntitities()
1397         {
1398                 // $text = 'text';
1399                 // self::assertIsArray(api_get_entitities($text, 'bbcode', 0));
1400         }
1401
1402         /**
1403          * Test the api_get_entitities() function with the include_entities parameter.
1404          *
1405          * @return void
1406          */
1407         public function testApiGetEntititiesWithIncludeEntities()
1408         {
1409                 /*
1410                 $_REQUEST['include_entities'] = 'true';
1411                 $text                         = 'text';
1412                 $result                       = api_get_entitities($text, 'bbcode', 0);
1413                 self::assertIsArray($result['hashtags']);
1414                 self::assertIsArray($result['symbols']);
1415                 self::assertIsArray($result['urls']);
1416                 self::assertIsArray($result['user_mentions']);
1417                 */
1418         }
1419
1420         /**
1421          * Test the api_format_items_embeded_images() function.
1422          *
1423          * @return void
1424          */
1425         public function testApiFormatItemsEmbededImages()
1426         {
1427                 /*
1428                 self::assertEquals(
1429                         'text ' . DI::baseUrl() . '/display/item_guid',
1430                         api_format_items_embeded_images(['guid' => 'item_guid'], 'text data:image/foo')
1431                 );
1432                 */
1433         }
1434
1435         /**
1436          * Test the api_format_items_activities() function.
1437          *
1438          * @return void
1439          */
1440         public function testApiFormatItemsActivities()
1441         {
1442                 $item   = ['uid' => 0, 'uri-id' => 1];
1443                 $result = DI::friendicaActivities()->createFromUriId($item['uri-id'], $item['uid']);
1444                 self::assertArrayHasKey('like', $result);
1445                 self::assertArrayHasKey('dislike', $result);
1446                 self::assertArrayHasKey('attendyes', $result);
1447                 self::assertArrayHasKey('attendno', $result);
1448                 self::assertArrayHasKey('attendmaybe', $result);
1449         }
1450
1451         /**
1452          * Test the api_format_items_activities() function with an XML result.
1453          *
1454          * @return void
1455          */
1456         public function testApiFormatItemsActivitiesWithXml()
1457         {
1458                 $item   = ['uid' => 0, 'uri-id' => 1];
1459                 $result = DI::friendicaActivities()->createFromUriId($item['uri-id'], $item['uid'], 'xml');
1460                 self::assertArrayHasKey('friendica:like', $result);
1461                 self::assertArrayHasKey('friendica:dislike', $result);
1462                 self::assertArrayHasKey('friendica:attendyes', $result);
1463                 self::assertArrayHasKey('friendica:attendno', $result);
1464                 self::assertArrayHasKey('friendica:attendmaybe', $result);
1465         }
1466
1467         /**
1468          * Test the api_format_items() function.
1469          * @doesNotPerformAssertions
1470          */
1471         public function testApiFormatItems()
1472         {
1473                 /*
1474                 $items = Post::selectToArray([], ['uid' => 42]);
1475                 foreach ($items as $item) {
1476                         $status = api_format_item($item);
1477                         self::assertStatus($status);
1478                 }
1479                 */
1480         }
1481
1482         /**
1483          * Test the api_format_items() function with an XML result.
1484          * @doesNotPerformAssertions
1485          */
1486         public function testApiFormatItemsWithXml()
1487         {
1488                 /*
1489                 $items = Post::selectToArray([], ['uid' => 42]);
1490                 foreach ($items as $item) {
1491                         $status = api_format_item($item, 'xml');
1492                         self::assertStatus($status);
1493                 }
1494                 */
1495         }
1496
1497         /**
1498          * Test the api_lists_list() function.
1499          *
1500          * @return void
1501          */
1502         public function testApiListsList()
1503         {
1504                 $result = api_lists_list('json');
1505                 self::assertEquals(['lists_list' => []], $result);
1506         }
1507
1508         /**
1509          * Test the api_lists_ownerships() function.
1510          *
1511          * @return void
1512          */
1513         public function testApiListsOwnerships()
1514         {
1515                 $result = api_lists_ownerships('json');
1516                 foreach ($result['lists']['lists'] as $list) {
1517                         self::assertList($list);
1518                 }
1519         }
1520
1521         /**
1522          * Test the api_lists_ownerships() function without an authenticated user.
1523          *
1524          * @return void
1525          */
1526         public function testApiListsOwnershipsWithoutAuthenticatedUser()
1527         {
1528                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1529                 BasicAuth::setCurrentUserID();
1530                 $_SESSION['authenticated'] = false;
1531                 api_lists_ownerships('json');
1532         }
1533
1534         /**
1535          * Test the api_statuses_f() function.
1536          *
1537          * @return void
1538          */
1539         public function testApiStatusesFWithIncoming()
1540         {
1541                 // $result = api_statuses_f('incoming');
1542                 // self::assertArrayHasKey('user', $result);
1543         }
1544
1545
1546         /**
1547          * Test the api_direct_messages_new() function.
1548          *
1549          * @return void
1550          */
1551         public function testApiDirectMessagesNew()
1552         {
1553                 $result = api_direct_messages_new('json');
1554                 self::assertNull($result);
1555         }
1556
1557         /**
1558          * Test the api_direct_messages_new() function without an authenticated user.
1559          *
1560          * @return void
1561          */
1562         public function testApiDirectMessagesNewWithoutAuthenticatedUser()
1563         {
1564                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1565                 BasicAuth::setCurrentUserID();
1566                 $_SESSION['authenticated'] = false;
1567                 api_direct_messages_new('json');
1568         }
1569
1570         /**
1571          * Test the api_direct_messages_new() function with an user ID.
1572          *
1573          * @return void
1574          */
1575         public function testApiDirectMessagesNewWithUserId()
1576         {
1577                 $_POST['text']       = 'message_text';
1578                 $_REQUEST['user_id'] = $this->otherUser['id'];
1579                 $result           = api_direct_messages_new('json');
1580                 self::assertEquals(['direct_message' => ['error' => -1]], $result);
1581         }
1582
1583         /**
1584          * Test the api_direct_messages_new() function with a screen name.
1585          *
1586          * @return void
1587          */
1588         public function testApiDirectMessagesNewWithScreenName()
1589         {
1590                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1591                 $_POST['text']       = 'message_text';
1592                 $_REQUEST['user_id'] = $this->friendUser['id'];
1593                 $result              = api_direct_messages_new('json');
1594                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
1595                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
1596                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
1597         }
1598
1599         /**
1600          * Test the api_direct_messages_new() function with a title.
1601          *
1602          * @return void
1603          */
1604         public function testApiDirectMessagesNewWithTitle()
1605         {
1606                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1607                 $_POST['text']        = 'message_text';
1608                 $_REQUEST['user_id']  = $this->friendUser['id'];
1609                 $_REQUEST['title']    = 'message_title';
1610                 $result            = api_direct_messages_new('json');
1611                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
1612                 self::assertStringContainsString('message_title', $result['direct_message']['text']);
1613                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
1614                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
1615         }
1616
1617         /**
1618          * Test the api_direct_messages_new() function with an RSS result.
1619          *
1620          * @return void
1621          */
1622         public function testApiDirectMessagesNewWithRss()
1623         {
1624                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1625                 $_POST['text']       = 'message_text';
1626                 $_REQUEST['user_id'] = $this->friendUser['id'];
1627                 $result              = api_direct_messages_new('rss');
1628                 self::assertXml($result, 'direct-messages');
1629         }
1630
1631         /**
1632          * Test the api_direct_messages_destroy() function.
1633          *
1634          * @return void
1635          */
1636         public function testApiDirectMessagesDestroy()
1637         {
1638                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1639                 api_direct_messages_destroy('json');
1640         }
1641
1642         /**
1643          * Test the api_direct_messages_destroy() function with the friendica_verbose GET param.
1644          *
1645          * @return void
1646          */
1647         public function testApiDirectMessagesDestroyWithVerbose()
1648         {
1649                 $_GET['friendica_verbose'] = 'true';
1650                 $result                    = api_direct_messages_destroy('json');
1651                 self::assertEquals(
1652                         [
1653                                 '$result' => [
1654                                         'result'  => 'error',
1655                                         'message' => 'message id or parenturi not specified'
1656                                 ]
1657                         ],
1658                         $result
1659                 );
1660         }
1661
1662         /**
1663          * Test the api_direct_messages_destroy() function without an authenticated user.
1664          *
1665          * @return void
1666          */
1667         public function testApiDirectMessagesDestroyWithoutAuthenticatedUser()
1668         {
1669                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1670                 BasicAuth::setCurrentUserID();
1671                 $_SESSION['authenticated'] = false;
1672                 api_direct_messages_destroy('json');
1673         }
1674
1675         /**
1676          * Test the api_direct_messages_destroy() function with a non-zero ID.
1677          *
1678          * @return void
1679          */
1680         public function testApiDirectMessagesDestroyWithId()
1681         {
1682                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1683                 $_REQUEST['id'] = 1;
1684                 api_direct_messages_destroy('json');
1685         }
1686
1687         /**
1688          * Test the api_direct_messages_destroy() with a non-zero ID and the friendica_verbose GET param.
1689          *
1690          * @return void
1691          */
1692         public function testApiDirectMessagesDestroyWithIdAndVerbose()
1693         {
1694                 $_REQUEST['id']                  = 1;
1695                 $_REQUEST['friendica_parenturi'] = 'parent_uri';
1696                 $_GET['friendica_verbose']       = 'true';
1697                 $result                          = api_direct_messages_destroy('json');
1698                 self::assertEquals(
1699                         [
1700                                 '$result' => [
1701                                         'result'  => 'error',
1702                                         'message' => 'message id not in database'
1703                                 ]
1704                         ],
1705                         $result
1706                 );
1707         }
1708
1709         /**
1710          * Test the api_direct_messages_destroy() function with a non-zero ID.
1711          *
1712          * @return void
1713          */
1714         public function testApiDirectMessagesDestroyWithCorrectId()
1715         {
1716                 $this->markTestIncomplete('We need to add a dataset for this.');
1717         }
1718
1719         /**
1720          * Test the api_direct_messages_box() function.
1721          *
1722          * @return void
1723          */
1724         public function testApiDirectMessagesBoxWithSentbox()
1725         {
1726                 $_REQUEST['page']   = -1;
1727                 $_REQUEST['max_id'] = 10;
1728                 $result             = api_direct_messages_box('json', 'sentbox', 'false');
1729                 self::assertArrayHasKey('direct_message', $result);
1730         }
1731
1732         /**
1733          * Test the api_direct_messages_box() function.
1734          *
1735          * @return void
1736          */
1737         public function testApiDirectMessagesBoxWithConversation()
1738         {
1739                 $result = api_direct_messages_box('json', 'conversation', 'false');
1740                 self::assertArrayHasKey('direct_message', $result);
1741         }
1742
1743         /**
1744          * Test the api_direct_messages_box() function.
1745          *
1746          * @return void
1747          */
1748         public function testApiDirectMessagesBoxWithAll()
1749         {
1750                 $result = api_direct_messages_box('json', 'all', 'false');
1751                 self::assertArrayHasKey('direct_message', $result);
1752         }
1753
1754         /**
1755          * Test the api_direct_messages_box() function.
1756          *
1757          * @return void
1758          */
1759         public function testApiDirectMessagesBoxWithInbox()
1760         {
1761                 $result = api_direct_messages_box('json', 'inbox', 'false');
1762                 self::assertArrayHasKey('direct_message', $result);
1763         }
1764
1765         /**
1766          * Test the api_direct_messages_box() function.
1767          *
1768          * @return void
1769          */
1770         public function testApiDirectMessagesBoxWithVerbose()
1771         {
1772                 $result = api_direct_messages_box('json', 'sentbox', 'true');
1773                 self::assertEquals(
1774                         [
1775                                 '$result' => [
1776                                         'result'  => 'error',
1777                                         'message' => 'no mails available'
1778                                 ]
1779                         ],
1780                         $result
1781                 );
1782         }
1783
1784         /**
1785          * Test the api_direct_messages_box() function with a RSS result.
1786          *
1787          * @return void
1788          */
1789         public function testApiDirectMessagesBoxWithRss()
1790         {
1791                 $result = api_direct_messages_box('rss', 'sentbox', 'false');
1792                 self::assertXml($result, 'direct-messages');
1793         }
1794
1795         /**
1796          * Test the api_direct_messages_box() function without an authenticated user.
1797          *
1798          * @return void
1799          */
1800         public function testApiDirectMessagesBoxWithUnallowedUser()
1801         {
1802                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1803                 BasicAuth::setCurrentUserID();
1804                 api_direct_messages_box('json', 'sentbox', 'false');
1805         }
1806
1807         /**
1808          * Test the api_direct_messages_sentbox() function.
1809          *
1810          * @return void
1811          */
1812         public function testApiDirectMessagesSentbox()
1813         {
1814                 $result = api_direct_messages_sentbox('json');
1815                 self::assertArrayHasKey('direct_message', $result);
1816         }
1817
1818         /**
1819          * Test the api_direct_messages_inbox() function.
1820          *
1821          * @return void
1822          */
1823         public function testApiDirectMessagesInbox()
1824         {
1825                 $result = api_direct_messages_inbox('json');
1826                 self::assertArrayHasKey('direct_message', $result);
1827         }
1828
1829         /**
1830          * Test the api_direct_messages_all() function.
1831          *
1832          * @return void
1833          */
1834         public function testApiDirectMessagesAll()
1835         {
1836                 $result = api_direct_messages_all('json');
1837                 self::assertArrayHasKey('direct_message', $result);
1838         }
1839
1840         /**
1841          * Test the api_direct_messages_conversation() function.
1842          *
1843          * @return void
1844          */
1845         public function testApiDirectMessagesConversation()
1846         {
1847                 $result = api_direct_messages_conversation('json');
1848                 self::assertArrayHasKey('direct_message', $result);
1849         }
1850
1851         /**
1852          * Test the api_oauth_request_token() function.
1853          *
1854          * @return void
1855          */
1856         public function testApiOauthRequestToken()
1857         {
1858                 $this->markTestIncomplete('exit() kills phpunit as well');
1859         }
1860
1861         /**
1862          * Test the api_oauth_access_token() function.
1863          *
1864          * @return void
1865          */
1866         public function testApiOauthAccessToken()
1867         {
1868                 $this->markTestIncomplete('exit() kills phpunit as well');
1869         }
1870
1871         /**
1872          * Test the api_fr_photos_list() function.
1873          *
1874          * @return void
1875          */
1876         public function testApiFrPhotosList()
1877         {
1878                 $result = api_fr_photos_list('json');
1879                 self::assertArrayHasKey('photo', $result);
1880         }
1881
1882         /**
1883          * Test the api_fr_photos_list() function without an authenticated user.
1884          *
1885          * @return void
1886          */
1887         public function testApiFrPhotosListWithoutAuthenticatedUser()
1888         {
1889                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1890                 BasicAuth::setCurrentUserID();
1891                 $_SESSION['authenticated'] = false;
1892                 api_fr_photos_list('json');
1893         }
1894
1895         /**
1896          * Test the api_fr_photo_create_update() function.
1897          */
1898         public function testApiFrPhotoCreateUpdate()
1899         {
1900                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1901                 api_fr_photo_create_update('json');
1902         }
1903
1904         /**
1905          * Test the api_fr_photo_create_update() function without an authenticated user.
1906          *
1907          * @return void
1908          */
1909         public function testApiFrPhotoCreateUpdateWithoutAuthenticatedUser()
1910         {
1911                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1912                 BasicAuth::setCurrentUserID();
1913                 $_SESSION['authenticated'] = false;
1914                 api_fr_photo_create_update('json');
1915         }
1916
1917         /**
1918          * Test the api_fr_photo_create_update() function with an album name.
1919          *
1920          * @return void
1921          */
1922         public function testApiFrPhotoCreateUpdateWithAlbum()
1923         {
1924                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1925                 $_REQUEST['album'] = 'album_name';
1926                 api_fr_photo_create_update('json');
1927         }
1928
1929         /**
1930          * Test the api_fr_photo_create_update() function with the update mode.
1931          *
1932          * @return void
1933          */
1934         public function testApiFrPhotoCreateUpdateWithUpdate()
1935         {
1936                 $this->markTestIncomplete('We need to create a dataset for this');
1937         }
1938
1939         /**
1940          * Test the api_fr_photo_create_update() function with an uploaded file.
1941          *
1942          * @return void
1943          */
1944         public function testApiFrPhotoCreateUpdateWithFile()
1945         {
1946                 $this->markTestIncomplete();
1947         }
1948
1949         /**
1950          * Test the api_fr_photo_detail() function.
1951          *
1952          * @return void
1953          */
1954         public function testApiFrPhotoDetail()
1955         {
1956                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1957                 api_fr_photo_detail('json');
1958         }
1959
1960         /**
1961          * Test the api_fr_photo_detail() function without an authenticated user.
1962          *
1963          * @return void
1964          */
1965         public function testApiFrPhotoDetailWithoutAuthenticatedUser()
1966         {
1967                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1968                 BasicAuth::setCurrentUserID();
1969                 $_SESSION['authenticated'] = false;
1970                 api_fr_photo_detail('json');
1971         }
1972
1973         /**
1974          * Test the api_fr_photo_detail() function with a photo ID.
1975          *
1976          * @return void
1977          */
1978         public function testApiFrPhotoDetailWithPhotoId()
1979         {
1980                 $this->expectException(\Friendica\Network\HTTPException\NotFoundException::class);
1981                 $_REQUEST['photo_id'] = 1;
1982                 api_fr_photo_detail('json');
1983         }
1984
1985         /**
1986          * Test the api_fr_photo_detail() function with a correct photo ID.
1987          *
1988          * @return void
1989          */
1990         public function testApiFrPhotoDetailCorrectPhotoId()
1991         {
1992                 $this->markTestIncomplete('We need to create a dataset for this.');
1993         }
1994
1995         /**
1996          * Test the api_account_update_profile_image() function.
1997          *
1998          * @return void
1999          */
2000         public function testApiAccountUpdateProfileImage()
2001         {
2002                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2003                 api_account_update_profile_image('json');
2004         }
2005
2006         /**
2007          * Test the api_account_update_profile_image() function without an authenticated user.
2008          *
2009          * @return void
2010          */
2011         public function testApiAccountUpdateProfileImageWithoutAuthenticatedUser()
2012         {
2013                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2014                 BasicAuth::setCurrentUserID();
2015                 $_SESSION['authenticated'] = false;
2016                 api_account_update_profile_image('json');
2017         }
2018
2019         /**
2020          * Test the api_account_update_profile_image() function with an uploaded file.
2021          *
2022          * @return void
2023          */
2024         public function testApiAccountUpdateProfileImageWithUpload()
2025         {
2026                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2027                 $this->markTestIncomplete();
2028         }
2029
2030         /**
2031          * Test the check_acl_input() function.
2032          *
2033          * @return void
2034          */
2035         public function testCheckAclInput()
2036         {
2037                 $result = check_acl_input('<aclstring>', BaseApi::getCurrentUserID());
2038                 // Where does this result come from?
2039                 self::assertEquals(1, $result);
2040         }
2041
2042         /**
2043          * Test the check_acl_input() function with an empty ACL string.
2044          *
2045          * @return void
2046          */
2047         public function testCheckAclInputWithEmptyAclString()
2048         {
2049                 $result = check_acl_input(' ', BaseApi::getCurrentUserID());
2050                 self::assertFalse($result);
2051         }
2052
2053         /**
2054          * Test the save_media_to_database() function.
2055          *
2056          * @return void
2057          */
2058         public function testSaveMediaToDatabase()
2059         {
2060                 $this->markTestIncomplete();
2061         }
2062
2063         /**
2064          * Test the post_photo_item() function.
2065          *
2066          * @return void
2067          */
2068         public function testPostPhotoItem()
2069         {
2070                 $this->markTestIncomplete();
2071         }
2072
2073         /**
2074          * Test the prepare_photo_data() function.
2075          *
2076          * @return void
2077          */
2078         public function testPreparePhotoData()
2079         {
2080                 $this->markTestIncomplete();
2081         }
2082
2083         /**
2084          * Test the api_share_as_retweet() function with a valid item.
2085          *
2086          * @return void
2087          */
2088         public function testApiShareAsRetweetWithValidItem()
2089         {
2090                 $this->markTestIncomplete();
2091         }
2092
2093         /**
2094          * Test the api_in_reply_to() function with a valid item.
2095          *
2096          * @return void
2097          */
2098         public function testApiInReplyToWithValidItem()
2099         {
2100                 $this->markTestIncomplete();
2101         }
2102
2103         /**
2104          * Test the api_clean_plain_items() function.
2105          *
2106          * @return void
2107          */
2108         public function testApiCleanPlainItems()
2109         {
2110                 $_REQUEST['include_entities'] = 'true';
2111                 $result                       = api_clean_plain_items('some_text [url="some_url"]some_text[/url]');
2112                 self::assertEquals('some_text [url="some_url"]"some_url"[/url]', $result);
2113         }
2114
2115         /**
2116          * Test the api_best_nickname() function with contacts.
2117          *
2118          * @return void
2119          */
2120         public function testApiBestNicknameWithContacts()
2121         {
2122                 $this->markTestIncomplete();
2123         }
2124
2125         /**
2126          * Test the api_friendica_group_show() function.
2127          *
2128          * @return void
2129          */
2130         public function testApiFriendicaGroupShow()
2131         {
2132                 $this->markTestIncomplete();
2133         }
2134
2135         /**
2136          * Test the api_friendica_group_delete() function.
2137          *
2138          * @return void
2139          */
2140         public function testApiFriendicaGroupDelete()
2141         {
2142                 $this->markTestIncomplete();
2143         }
2144
2145         /**
2146          * Test the api_lists_destroy() function.
2147          *
2148          * @return void
2149          */
2150         public function testApiListsDestroy()
2151         {
2152                 $this->markTestIncomplete();
2153         }
2154
2155         /**
2156          * Test the group_create() function.
2157          *
2158          * @return void
2159          */
2160         public function testGroupCreate()
2161         {
2162                 $this->markTestIncomplete();
2163         }
2164
2165         /**
2166          * Test the api_friendica_group_create() function.
2167          *
2168          * @return void
2169          */
2170         public function testApiFriendicaGroupCreate()
2171         {
2172                 $this->markTestIncomplete();
2173         }
2174
2175         /**
2176          * Test the api_lists_create() function.
2177          *
2178          * @return void
2179          */
2180         public function testApiListsCreate()
2181         {
2182                 $this->markTestIncomplete();
2183         }
2184
2185         /**
2186          * Test the api_friendica_group_update() function.
2187          *
2188          * @return void
2189          */
2190         public function testApiFriendicaGroupUpdate()
2191         {
2192                 $this->markTestIncomplete();
2193         }
2194
2195         /**
2196          * Test the api_lists_update() function.
2197          *
2198          * @return void
2199          */
2200         public function testApiListsUpdate()
2201         {
2202                 $this->markTestIncomplete();
2203         }
2204
2205         /**
2206          * Test the api_friendica_activity() function.
2207          *
2208          * @return void
2209          */
2210         public function testApiFriendicaActivity()
2211         {
2212                 $this->markTestIncomplete();
2213         }
2214
2215         /**
2216          * Test the api_friendica_notification_seen() function.
2217          *
2218          * @return void
2219          */
2220         public function testApiFriendicaNotificationSeen()
2221         {
2222                 $this->markTestIncomplete();
2223         }
2224
2225         /**
2226          * Test the api_friendica_direct_messages_setseen() function.
2227          *
2228          * @return void
2229          */
2230         public function testApiFriendicaDirectMessagesSetseen()
2231         {
2232                 $this->markTestIncomplete();
2233         }
2234
2235         /**
2236          * Test the api_friendica_direct_messages_search() function.
2237          *
2238          * @return void
2239          */
2240         public function testApiFriendicaDirectMessagesSearch()
2241         {
2242                 $this->markTestIncomplete();
2243         }
2244 }