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                 DI::args()->setArgc(2);
 879
 880                 $_FILES         = [
 881                         'media' => [
 882                                 'id'       => 666,
 883                                 'size'     => 666,
 884                                 'width'    => 666,
 885                                 'height'   => 666,
 886                                 'tmp_name' => $this->getTempImage(),
 887                                 'name'     => 'spacer.png',
 888                                 'type'     => 'image/png'
 889                         ]
 890                 ];
 891                 $_GET['status'] = '<b>Status content</b>';
 892
 893                 $result = api_statuses_mediap('json');
 894                 self::assertStatus($result['status']);
 895         }
 896
 897         /**
 898          * Test the api_statuses_mediap() function without an authenticated user.
 899          *
 900          * @return void
 901          */
 902         public function testApiStatusesMediapWithoutAuthenticatedUser()
 903         {
 904                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 905                 BasicAuth::setCurrentUserID();
 906                 $_SESSION['authenticated'] = false;
 907                 api_statuses_mediap('json');
 908         }
 909
 910         /**
 911          * Test the api_statuses_update() function.
 912          *
 913          * @return void
 914          */
 915         public function testApiStatusesUpdate()
 916         {
 917                 $_REQUEST['status']                = 'Status content #friendica';
 918                 $_REQUEST['in_reply_to_status_id'] = -1;
 919                 $_REQUEST['lat']                   = 48;
 920                 $_REQUEST['long']                  = 7;
 921                 $_FILES                            = [
 922                         'media' => [
 923                                 'id'       => 666,
 924                                 'size'     => 666,
 925                                 'width'    => 666,
 926                                 'height'   => 666,
 927                                 'tmp_name' => $this->getTempImage(),
 928                                 'name'     => 'spacer.png',
 929                                 'type'     => 'image/png'
 930                         ]
 931                 ];
 932
 933                 $result = api_statuses_update('json');
 934                 self::assertStatus($result['status']);
 935         }
 936
 937         /**
 938          * Test the api_statuses_update() function with an HTML status.
 939          *
 940          * @return void
 941          */
 942         public function testApiStatusesUpdateWithHtml()
 943         {
 944                 $_REQUEST['htmlstatus'] = '<b>Status content</b>';
 945
 946                 $result = api_statuses_update('json');
 947                 self::assertStatus($result['status']);
 948         }
 949
 950         /**
 951          * Test the api_statuses_update() function without an authenticated user.
 952          *
 953          * @return void
 954          */
 955         public function testApiStatusesUpdateWithoutAuthenticatedUser()
 956         {
 957                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 958                 BasicAuth::setCurrentUserID();
 959                 $_SESSION['authenticated'] = false;
 960                 api_statuses_update('json');
 961         }
 962
 963         /**
 964          * Test the api_statuses_update() function with a parent status.
 965          *
 966          * @return void
 967          */
 968         public function testApiStatusesUpdateWithParent()
 969         {
 970                 $this->markTestIncomplete('This triggers an exit() somewhere and kills PHPUnit.');
 971         }
 972
 973         /**
 974          * Test the api_statuses_update() function with a media_ids parameter.
 975          *
 976          * @return void
 977          */
 978         public function testApiStatusesUpdateWithMediaIds()
 979         {
 980                 $this->markTestIncomplete();
 981         }
 982
 983         /**
 984          * Test the api_statuses_update() function with the throttle limit reached.
 985          *
 986          * @return void
 987          */
 988         public function testApiStatusesUpdateWithDayThrottleReached()
 989         {
 990                 $this->markTestIncomplete();
 991         }
 992
 993         /**
 994          * Test the \Friendica\Module\Api\Twitter\Media\Upload module.
 995          * @runInSeparateProcess
 996          * @preserveGlobalState disabled
 997          */
 998         public function testApiMediaUpload()
 999         {
1000                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1001                 (new Upload(DI::app(), DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), $_SERVER))->run();
1002         }
1003
1004         /**
1005          * Test the \Friendica\Module\Api\Twitter\Media\Upload module without an authenticated user.
1006          *
1007          * @return void
1008          */
1009         public function testApiMediaUploadWithoutAuthenticatedUser()
1010         {
1011                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1012                 BasicAuth::setCurrentUserID();
1013                 $_SESSION['authenticated'] = false;
1014                 (new Upload(DI::app(), DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), $_SERVER))->run();
1015         }
1016
1017         /**
1018          * Test the \Friendica\Module\Api\Twitter\Media\Upload module with an invalid uploaded media.
1019          *
1020          * @return void
1021          */
1022         public function testApiMediaUploadWithMedia()
1023         {
1024                 $this->expectException(\Friendica\Network\HTTPException\InternalServerErrorException::class);
1025                 $_FILES = [
1026                         'media' => [
1027                                 'id'       => 666,
1028                                 'tmp_name' => 'tmp_name'
1029                         ]
1030                 ];
1031                 (new Upload(DI::app(), DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), $_SERVER))->run();
1032         }
1033
1034         /**
1035          * Test the \Friendica\Module\Api\Twitter\Media\Upload module with an valid uploaded media.
1036          *
1037          * @return void
1038          */
1039         public function testApiMediaUploadWithValidMedia()
1040         {
1041                 $_FILES    = [
1042                         'media' => [
1043                                 'id'       => 666,
1044                                 'size'     => 666,
1045                                 'width'    => 666,
1046                                 'height'   => 666,
1047                                 'tmp_name' => $this->getTempImage(),
1048                                 'name'     => 'spacer.png',
1049                                 'type'     => 'image/png'
1050                         ]
1051                 ];
1052
1053                 $response = (new Upload(DI::app(), DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), $_SERVER))->run();
1054                 $media = json_decode($response->getBody(), true);
1055
1056                 self::assertEquals('image/png', $media['image']['image_type']);
1057                 self::assertEquals(1, $media['image']['w']);
1058                 self::assertEquals(1, $media['image']['h']);
1059                 self::assertNotEmpty($media['image']['friendica_preview_url']);
1060         }
1061
1062         /**
1063          * Test the api_statuses_repeat() function.
1064          *
1065          * @return void
1066          */
1067         public function testApiStatusesRepeat()
1068         {
1069                 $this->expectException(\Friendica\Network\HTTPException\ForbiddenException::class);
1070                 api_statuses_repeat('json');
1071         }
1072
1073         /**
1074          * Test the api_statuses_repeat() function without an authenticated user.
1075          *
1076          * @return void
1077          */
1078         public function testApiStatusesRepeatWithoutAuthenticatedUser()
1079         {
1080                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1081                 BasicAuth::setCurrentUserID();
1082                 $_SESSION['authenticated'] = false;
1083                 api_statuses_repeat('json');
1084         }
1085
1086         /**
1087          * Test the api_statuses_repeat() function with an ID.
1088          *
1089          * @return void
1090          */
1091         public function testApiStatusesRepeatWithId()
1092         {
1093                 DI::args()->setArgv(['', '', '', 1]);
1094                 $result = api_statuses_repeat('json');
1095                 self::assertStatus($result['status']);
1096
1097                 // Also test with a shared status
1098                 DI::args()->setArgv(['', '', '', 5]);
1099                 $result = api_statuses_repeat('json');
1100                 self::assertStatus($result['status']);
1101         }
1102
1103         /**
1104          * Test the api_favorites_create_destroy() function.
1105          *
1106          * @return void
1107          */
1108         public function testApiFavoritesCreateDestroy()
1109         {
1110                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1111                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create']);
1112                 api_favorites_create_destroy('json');
1113         }
1114
1115         /**
1116          * Test the api_favorites_create_destroy() function with an invalid ID.
1117          *
1118          * @return void
1119          */
1120         public function testApiFavoritesCreateDestroyWithInvalidId()
1121         {
1122                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1123                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create', '12.json']);
1124                 api_favorites_create_destroy('json');
1125         }
1126
1127         /**
1128          * Test the api_favorites_create_destroy() function with an invalid action.
1129          *
1130          * @return void
1131          */
1132         public function testApiFavoritesCreateDestroyWithInvalidAction()
1133         {
1134                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1135                 DI::args()->setArgv(['api', '1.1', 'favorites', 'change.json']);
1136                 $_REQUEST['id'] = 1;
1137                 api_favorites_create_destroy('json');
1138         }
1139
1140         /**
1141          * Test the api_favorites_create_destroy() function with the create action.
1142          *
1143          * @return void
1144          */
1145         public function testApiFavoritesCreateDestroyWithCreateAction()
1146         {
1147                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.json']);
1148                 $_REQUEST['id'] = 3;
1149                 $result         = api_favorites_create_destroy('json');
1150                 self::assertStatus($result['status']);
1151         }
1152
1153         /**
1154          * Test the api_favorites_create_destroy() function with the create action and an RSS result.
1155          *
1156          * @return void
1157          */
1158         public function testApiFavoritesCreateDestroyWithCreateActionAndRss()
1159         {
1160                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.rss']);
1161                 $_REQUEST['id'] = 3;
1162                 $result         = api_favorites_create_destroy('rss');
1163                 self::assertXml($result, 'status');
1164         }
1165
1166         /**
1167          * Test the api_favorites_create_destroy() function with the destroy action.
1168          *
1169          * @return void
1170          */
1171         public function testApiFavoritesCreateDestroyWithDestroyAction()
1172         {
1173                 DI::args()->setArgv(['api', '1.1', 'favorites', 'destroy.json']);
1174                 $_REQUEST['id'] = 3;
1175                 $result         = api_favorites_create_destroy('json');
1176                 self::assertStatus($result['status']);
1177         }
1178
1179         /**
1180          * Test the api_favorites_create_destroy() function without an authenticated user.
1181          *
1182          * @return void
1183          */
1184         public function testApiFavoritesCreateDestroyWithoutAuthenticatedUser()
1185         {
1186                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1187                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.json']);
1188                 BasicAuth::setCurrentUserID();
1189                 $_SESSION['authenticated'] = false;
1190                 api_favorites_create_destroy('json');
1191         }
1192
1193
1194
1195         /**
1196          * Test the api_format_messages() function.
1197          *
1198          * @return void
1199          */
1200         public function testApiFormatMessages()
1201         {
1202                 $result = api_format_messages(
1203                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1204                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1205                         ['id' => 3, 'uri-id' => 2, 'screen_name' => 'sender_name']
1206                 );
1207                 self::assertEquals('item_title' . "\n" . 'item_body', $result['text']);
1208                 self::assertEquals(1, $result['id']);
1209                 self::assertEquals(2, $result['recipient_id']);
1210                 self::assertEquals(3, $result['sender_id']);
1211                 self::assertEquals('recipient_name', $result['recipient_screen_name']);
1212                 self::assertEquals('sender_name', $result['sender_screen_name']);
1213         }
1214
1215         /**
1216          * Test the api_format_messages() function with HTML.
1217          *
1218          * @return void
1219          */
1220         public function testApiFormatMessagesWithHtmlText()
1221         {
1222                 $_GET['getText'] = 'html';
1223                 $result          = api_format_messages(
1224                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1225                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1226                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1227                 );
1228                 self::assertEquals('item_title', $result['title']);
1229                 self::assertEquals('<strong>item_body</strong>', $result['text']);
1230         }
1231
1232         /**
1233          * Test the api_format_messages() function with plain text.
1234          *
1235          * @return void
1236          */
1237         public function testApiFormatMessagesWithPlainText()
1238         {
1239                 $_GET['getText'] = 'plain';
1240                 $result          = api_format_messages(
1241                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1242                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1243                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1244                 );
1245                 self::assertEquals('item_title', $result['title']);
1246                 self::assertEquals('item_body', $result['text']);
1247         }
1248
1249         /**
1250          * Test the api_format_messages() function with the getUserObjects GET parameter set to false.
1251          *
1252          * @return void
1253          */
1254         public function testApiFormatMessagesWithoutUserObjects()
1255         {
1256                 $_GET['getUserObjects'] = 'false';
1257                 $result                 = api_format_messages(
1258                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1259                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1260                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1261                 );
1262                 self::assertTrue(!isset($result['sender']));
1263                 self::assertTrue(!isset($result['recipient']));
1264         }
1265
1266         /**
1267          * Test the api_convert_item() function.
1268          *
1269          * @return void
1270          */
1271         public function testApiConvertItem()
1272         {
1273                 /*
1274                 $result = api_convert_item(
1275                         [
1276                                 'network' => 'feed',
1277                                 'title'   => 'item_title',
1278                                 'uri-id'  => 1,
1279                                 // We need a long string to test that it is correctly cut
1280                                 'body'    => 'perspiciatis impedit voluptatem quis molestiae ea qui ' .
1281                                                          'reiciendis dolorum aut ducimus sunt consequatur inventore dolor ' .
1282                                                          'officiis pariatur doloremque nemo culpa aut quidem qui dolore ' .
1283                                                          'laudantium atque commodi alias voluptatem non possimus aperiam ' .
1284                                                          'ipsum rerum consequuntur aut amet fugit quia aliquid praesentium ' .
1285                                                          'repellendus quibusdam et et inventore mollitia rerum sit autem ' .
1286                                                          'pariatur maiores ipsum accusantium perferendis vel sit possimus ' .
1287                                                          'veritatis nihil distinctio qui eum repellat officia illum quos ' .
1288                                                          'impedit quam iste esse unde qui suscipit aut facilis ut inventore ' .
1289                                                          'omnis exercitationem quo magnam consequatur maxime aut illum ' .
1290                                                          'soluta quaerat natus unde aspernatur et sed beatae nihil ullam ' .
1291                                                          'temporibus corporis ratione blanditiis perspiciatis impedit ' .
1292                                                          'voluptatem quis molestiae ea qui reiciendis dolorum aut ducimus ' .
1293                                                          'sunt consequatur inventore dolor officiis pariatur doloremque ' .
1294                                                          'nemo culpa aut quidem qui dolore laudantium atque commodi alias ' .
1295                                                          'voluptatem non possimus aperiam ipsum rerum consequuntur aut ' .
1296                                                          'amet fugit quia aliquid praesentium repellendus quibusdam et et ' .
1297                                                          'inventore mollitia rerum sit autem pariatur maiores ipsum accusantium ' .
1298                                                          'perferendis vel sit possimus veritatis nihil distinctio qui eum ' .
1299                                                          'repellat officia illum quos impedit quam iste esse unde qui ' .
1300                                                          'suscipit aut facilis ut inventore omnis exercitationem quo magnam ' .
1301                                                          'consequatur maxime aut illum soluta quaerat natus unde aspernatur ' .
1302                                                          'et sed beatae nihil ullam temporibus corporis ratione blanditiis',
1303                                 'plink'   => 'item_plink'
1304                         ]
1305                 );
1306                 self::assertStringStartsWith('item_title', $result['text']);
1307                 self::assertStringStartsWith('<h4>item_title</h4><br>perspiciatis impedit voluptatem', $result['html']);
1308                 */
1309         }
1310
1311         /**
1312          * Test the api_convert_item() function with an empty item body.
1313          *
1314          * @return void
1315          */
1316         public function testApiConvertItemWithoutBody()
1317         {
1318                 /*
1319                 $result = api_convert_item(
1320                         [
1321                                 'network' => 'feed',
1322                                 'title'   => 'item_title',
1323                                 'uri-id'  => -1,
1324                                 'body'    => '',
1325                                 'plink'   => 'item_plink'
1326                         ]
1327                 );
1328                 self::assertEquals("item_title", $result['text']);
1329                 self::assertEquals('<h4>item_title</h4><br>item_plink', $result['html']);
1330                 */
1331         }
1332
1333         /**
1334          * Test the api_convert_item() function with the title in the body.
1335          *
1336          * @return void
1337          */
1338         public function testApiConvertItemWithTitleInBody()
1339         {
1340                 /*
1341                 $result = api_convert_item(
1342                         [
1343                                 'title'  => 'item_title',
1344                                 'body'   => 'item_title item_body',
1345                                 'uri-id' => 1,
1346                         ]
1347                 );
1348                 self::assertEquals('item_title item_body', $result['text']);
1349                 self::assertEquals('<h4>item_title</h4><br>item_title item_body', $result['html']);
1350                 */
1351         }
1352
1353         /**
1354          * Test the api_get_attachments() function.
1355          *
1356          * @return void
1357          */
1358         public function testApiGetAttachments()
1359         {
1360                 // $body = 'body';
1361                 // self::assertEmpty(api_get_attachments($body, 0));
1362         }
1363
1364         /**
1365          * Test the api_get_attachments() function with an img tag.
1366          *
1367          * @return void
1368          */
1369         public function testApiGetAttachmentsWithImage()
1370         {
1371                 // $body = '[img]http://via.placeholder.com/1x1.png[/img]';
1372                 // self::assertIsArray(api_get_attachments($body, 0));
1373         }
1374
1375         /**
1376          * Test the api_get_attachments() function with an img tag and an AndStatus user agent.
1377          *
1378          * @return void
1379          */
1380         public function testApiGetAttachmentsWithImageAndAndStatus()
1381         {
1382                 // $_SERVER['HTTP_USER_AGENT'] = 'AndStatus';
1383                 // $body                       = '[img]http://via.placeholder.com/1x1.png[/img]';
1384                 // self::assertIsArray(api_get_attachments($body, 0));
1385         }
1386
1387         /**
1388          * Test the api_get_entitities() function.
1389          *
1390          * @return void
1391          */
1392         public function testApiGetEntitities()
1393         {
1394                 // $text = 'text';
1395                 // self::assertIsArray(api_get_entitities($text, 'bbcode', 0));
1396         }
1397
1398         /**
1399          * Test the api_get_entitities() function with the include_entities parameter.
1400          *
1401          * @return void
1402          */
1403         public function testApiGetEntititiesWithIncludeEntities()
1404         {
1405                 /*
1406                 $_REQUEST['include_entities'] = 'true';
1407                 $text                         = 'text';
1408                 $result                       = api_get_entitities($text, 'bbcode', 0);
1409                 self::assertIsArray($result['hashtags']);
1410                 self::assertIsArray($result['symbols']);
1411                 self::assertIsArray($result['urls']);
1412                 self::assertIsArray($result['user_mentions']);
1413                 */
1414         }
1415
1416         /**
1417          * Test the api_format_items_embeded_images() function.
1418          *
1419          * @return void
1420          */
1421         public function testApiFormatItemsEmbededImages()
1422         {
1423                 /*
1424                 self::assertEquals(
1425                         'text ' . DI::baseUrl() . '/display/item_guid',
1426                         api_format_items_embeded_images(['guid' => 'item_guid'], 'text data:image/foo')
1427                 );
1428                 */
1429         }
1430
1431         /**
1432          * Test the api_format_items_activities() function.
1433          *
1434          * @return void
1435          */
1436         public function testApiFormatItemsActivities()
1437         {
1438                 $item   = ['uid' => 0, 'uri-id' => 1];
1439                 $result = DI::friendicaActivities()->createFromUriId($item['uri-id'], $item['uid']);
1440                 self::assertArrayHasKey('like', $result);
1441                 self::assertArrayHasKey('dislike', $result);
1442                 self::assertArrayHasKey('attendyes', $result);
1443                 self::assertArrayHasKey('attendno', $result);
1444                 self::assertArrayHasKey('attendmaybe', $result);
1445         }
1446
1447         /**
1448          * Test the api_format_items_activities() function with an XML result.
1449          *
1450          * @return void
1451          */
1452         public function testApiFormatItemsActivitiesWithXml()
1453         {
1454                 $item   = ['uid' => 0, 'uri-id' => 1];
1455                 $result = DI::friendicaActivities()->createFromUriId($item['uri-id'], $item['uid'], 'xml');
1456                 self::assertArrayHasKey('friendica:like', $result);
1457                 self::assertArrayHasKey('friendica:dislike', $result);
1458                 self::assertArrayHasKey('friendica:attendyes', $result);
1459                 self::assertArrayHasKey('friendica:attendno', $result);
1460                 self::assertArrayHasKey('friendica:attendmaybe', $result);
1461         }
1462
1463         /**
1464          * Test the api_format_items() function.
1465          * @doesNotPerformAssertions
1466          */
1467         public function testApiFormatItems()
1468         {
1469                 /*
1470                 $items = Post::selectToArray([], ['uid' => 42]);
1471                 foreach ($items as $item) {
1472                         $status = api_format_item($item);
1473                         self::assertStatus($status);
1474                 }
1475                 */
1476         }
1477
1478         /**
1479          * Test the api_format_items() function with an XML result.
1480          * @doesNotPerformAssertions
1481          */
1482         public function testApiFormatItemsWithXml()
1483         {
1484                 /*
1485                 $items = Post::selectToArray([], ['uid' => 42]);
1486                 foreach ($items as $item) {
1487                         $status = api_format_item($item, 'xml');
1488                         self::assertStatus($status);
1489                 }
1490                 */
1491         }
1492
1493         /**
1494          * Test the api_lists_list() function.
1495          *
1496          * @return void
1497          */
1498         public function testApiListsList()
1499         {
1500                 $result = api_lists_list('json');
1501                 self::assertEquals(['lists_list' => []], $result);
1502         }
1503
1504         /**
1505          * Test the api_lists_ownerships() function.
1506          *
1507          * @return void
1508          */
1509         public function testApiListsOwnerships()
1510         {
1511                 $result = api_lists_ownerships('json');
1512                 foreach ($result['lists']['lists'] as $list) {
1513                         self::assertList($list);
1514                 }
1515         }
1516
1517         /**
1518          * Test the api_lists_ownerships() function without an authenticated user.
1519          *
1520          * @return void
1521          */
1522         public function testApiListsOwnershipsWithoutAuthenticatedUser()
1523         {
1524                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1525                 BasicAuth::setCurrentUserID();
1526                 $_SESSION['authenticated'] = false;
1527                 api_lists_ownerships('json');
1528         }
1529
1530         /**
1531          * Test the api_statuses_f() function.
1532          *
1533          * @return void
1534          */
1535         public function testApiStatusesFWithIncoming()
1536         {
1537                 // $result = api_statuses_f('incoming');
1538                 // self::assertArrayHasKey('user', $result);
1539         }
1540
1541
1542         /**
1543          * Test the api_direct_messages_new() function.
1544          *
1545          * @return void
1546          */
1547         public function testApiDirectMessagesNew()
1548         {
1549                 $result = api_direct_messages_new('json');
1550                 self::assertNull($result);
1551         }
1552
1553         /**
1554          * Test the api_direct_messages_new() function without an authenticated user.
1555          *
1556          * @return void
1557          */
1558         public function testApiDirectMessagesNewWithoutAuthenticatedUser()
1559         {
1560                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1561                 BasicAuth::setCurrentUserID();
1562                 $_SESSION['authenticated'] = false;
1563                 api_direct_messages_new('json');
1564         }
1565
1566         /**
1567          * Test the api_direct_messages_new() function with an user ID.
1568          *
1569          * @return void
1570          */
1571         public function testApiDirectMessagesNewWithUserId()
1572         {
1573                 $_POST['text']       = 'message_text';
1574                 $_REQUEST['user_id'] = $this->otherUser['id'];
1575                 $result           = api_direct_messages_new('json');
1576                 self::assertEquals(['direct_message' => ['error' => -1]], $result);
1577         }
1578
1579         /**
1580          * Test the api_direct_messages_new() function with a screen name.
1581          *
1582          * @return void
1583          */
1584         public function testApiDirectMessagesNewWithScreenName()
1585         {
1586                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1587                 $_POST['text']       = 'message_text';
1588                 $_REQUEST['user_id'] = $this->friendUser['id'];
1589                 $result              = api_direct_messages_new('json');
1590                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
1591                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
1592                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
1593         }
1594
1595         /**
1596          * Test the api_direct_messages_new() function with a title.
1597          *
1598          * @return void
1599          */
1600         public function testApiDirectMessagesNewWithTitle()
1601         {
1602                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1603                 $_POST['text']        = 'message_text';
1604                 $_REQUEST['user_id']  = $this->friendUser['id'];
1605                 $_REQUEST['title']    = 'message_title';
1606                 $result            = api_direct_messages_new('json');
1607                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
1608                 self::assertStringContainsString('message_title', $result['direct_message']['text']);
1609                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
1610                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
1611         }
1612
1613         /**
1614          * Test the api_direct_messages_new() function with an RSS result.
1615          *
1616          * @return void
1617          */
1618         public function testApiDirectMessagesNewWithRss()
1619         {
1620                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1621                 $_POST['text']       = 'message_text';
1622                 $_REQUEST['user_id'] = $this->friendUser['id'];
1623                 $result              = api_direct_messages_new('rss');
1624                 self::assertXml($result, 'direct-messages');
1625         }
1626
1627         /**
1628          * Test the api_direct_messages_destroy() function.
1629          *
1630          * @return void
1631          */
1632         public function testApiDirectMessagesDestroy()
1633         {
1634                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1635                 api_direct_messages_destroy('json');
1636         }
1637
1638         /**
1639          * Test the api_direct_messages_destroy() function with the friendica_verbose GET param.
1640          *
1641          * @return void
1642          */
1643         public function testApiDirectMessagesDestroyWithVerbose()
1644         {
1645                 $_GET['friendica_verbose'] = 'true';
1646                 $result                    = api_direct_messages_destroy('json');
1647                 self::assertEquals(
1648                         [
1649                                 '$result' => [
1650                                         'result'  => 'error',
1651                                         'message' => 'message id or parenturi not specified'
1652                                 ]
1653                         ],
1654                         $result
1655                 );
1656         }
1657
1658         /**
1659          * Test the api_direct_messages_destroy() function without an authenticated user.
1660          *
1661          * @return void
1662          */
1663         public function testApiDirectMessagesDestroyWithoutAuthenticatedUser()
1664         {
1665                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1666                 BasicAuth::setCurrentUserID();
1667                 $_SESSION['authenticated'] = false;
1668                 api_direct_messages_destroy('json');
1669         }
1670
1671         /**
1672          * Test the api_direct_messages_destroy() function with a non-zero ID.
1673          *
1674          * @return void
1675          */
1676         public function testApiDirectMessagesDestroyWithId()
1677         {
1678                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1679                 $_REQUEST['id'] = 1;
1680                 api_direct_messages_destroy('json');
1681         }
1682
1683         /**
1684          * Test the api_direct_messages_destroy() with a non-zero ID and the friendica_verbose GET param.
1685          *
1686          * @return void
1687          */
1688         public function testApiDirectMessagesDestroyWithIdAndVerbose()
1689         {
1690                 $_REQUEST['id']                  = 1;
1691                 $_REQUEST['friendica_parenturi'] = 'parent_uri';
1692                 $_GET['friendica_verbose']       = 'true';
1693                 $result                          = api_direct_messages_destroy('json');
1694                 self::assertEquals(
1695                         [
1696                                 '$result' => [
1697                                         'result'  => 'error',
1698                                         'message' => 'message id not in database'
1699                                 ]
1700                         ],
1701                         $result
1702                 );
1703         }
1704
1705         /**
1706          * Test the api_direct_messages_destroy() function with a non-zero ID.
1707          *
1708          * @return void
1709          */
1710         public function testApiDirectMessagesDestroyWithCorrectId()
1711         {
1712                 $this->markTestIncomplete('We need to add a dataset for this.');
1713         }
1714
1715         /**
1716          * Test the api_direct_messages_box() function.
1717          *
1718          * @return void
1719          */
1720         public function testApiDirectMessagesBoxWithSentbox()
1721         {
1722                 $_REQUEST['page']   = -1;
1723                 $_REQUEST['max_id'] = 10;
1724                 $result             = api_direct_messages_box('json', 'sentbox', 'false');
1725                 self::assertArrayHasKey('direct_message', $result);
1726         }
1727
1728         /**
1729          * Test the api_direct_messages_box() function.
1730          *
1731          * @return void
1732          */
1733         public function testApiDirectMessagesBoxWithConversation()
1734         {
1735                 $result = api_direct_messages_box('json', 'conversation', 'false');
1736                 self::assertArrayHasKey('direct_message', $result);
1737         }
1738
1739         /**
1740          * Test the api_direct_messages_box() function.
1741          *
1742          * @return void
1743          */
1744         public function testApiDirectMessagesBoxWithAll()
1745         {
1746                 $result = api_direct_messages_box('json', 'all', 'false');
1747                 self::assertArrayHasKey('direct_message', $result);
1748         }
1749
1750         /**
1751          * Test the api_direct_messages_box() function.
1752          *
1753          * @return void
1754          */
1755         public function testApiDirectMessagesBoxWithInbox()
1756         {
1757                 $result = api_direct_messages_box('json', 'inbox', 'false');
1758                 self::assertArrayHasKey('direct_message', $result);
1759         }
1760
1761         /**
1762          * Test the api_direct_messages_box() function.
1763          *
1764          * @return void
1765          */
1766         public function testApiDirectMessagesBoxWithVerbose()
1767         {
1768                 $result = api_direct_messages_box('json', 'sentbox', 'true');
1769                 self::assertEquals(
1770                         [
1771                                 '$result' => [
1772                                         'result'  => 'error',
1773                                         'message' => 'no mails available'
1774                                 ]
1775                         ],
1776                         $result
1777                 );
1778         }
1779
1780         /**
1781          * Test the api_direct_messages_box() function with a RSS result.
1782          *
1783          * @return void
1784          */
1785         public function testApiDirectMessagesBoxWithRss()
1786         {
1787                 $result = api_direct_messages_box('rss', 'sentbox', 'false');
1788                 self::assertXml($result, 'direct-messages');
1789         }
1790
1791         /**
1792          * Test the api_direct_messages_box() function without an authenticated user.
1793          *
1794          * @return void
1795          */
1796         public function testApiDirectMessagesBoxWithUnallowedUser()
1797         {
1798                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1799                 BasicAuth::setCurrentUserID();
1800                 api_direct_messages_box('json', 'sentbox', 'false');
1801         }
1802
1803         /**
1804          * Test the api_direct_messages_sentbox() function.
1805          *
1806          * @return void
1807          */
1808         public function testApiDirectMessagesSentbox()
1809         {
1810                 $result = api_direct_messages_sentbox('json');
1811                 self::assertArrayHasKey('direct_message', $result);
1812         }
1813
1814         /**
1815          * Test the api_direct_messages_inbox() function.
1816          *
1817          * @return void
1818          */
1819         public function testApiDirectMessagesInbox()
1820         {
1821                 $result = api_direct_messages_inbox('json');
1822                 self::assertArrayHasKey('direct_message', $result);
1823         }
1824
1825         /**
1826          * Test the api_direct_messages_all() function.
1827          *
1828          * @return void
1829          */
1830         public function testApiDirectMessagesAll()
1831         {
1832                 $result = api_direct_messages_all('json');
1833                 self::assertArrayHasKey('direct_message', $result);
1834         }
1835
1836         /**
1837          * Test the api_direct_messages_conversation() function.
1838          *
1839          * @return void
1840          */
1841         public function testApiDirectMessagesConversation()
1842         {
1843                 $result = api_direct_messages_conversation('json');
1844                 self::assertArrayHasKey('direct_message', $result);
1845         }
1846
1847         /**
1848          * Test the api_oauth_request_token() function.
1849          *
1850          * @return void
1851          */
1852         public function testApiOauthRequestToken()
1853         {
1854                 $this->markTestIncomplete('exit() kills phpunit as well');
1855         }
1856
1857         /**
1858          * Test the api_oauth_access_token() function.
1859          *
1860          * @return void
1861          */
1862         public function testApiOauthAccessToken()
1863         {
1864                 $this->markTestIncomplete('exit() kills phpunit as well');
1865         }
1866
1867         /**
1868          * Test the api_fr_photos_list() function.
1869          *
1870          * @return void
1871          */
1872         public function testApiFrPhotosList()
1873         {
1874                 $result = api_fr_photos_list('json');
1875                 self::assertArrayHasKey('photo', $result);
1876         }
1877
1878         /**
1879          * Test the api_fr_photos_list() function without an authenticated user.
1880          *
1881          * @return void
1882          */
1883         public function testApiFrPhotosListWithoutAuthenticatedUser()
1884         {
1885                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1886                 BasicAuth::setCurrentUserID();
1887                 $_SESSION['authenticated'] = false;
1888                 api_fr_photos_list('json');
1889         }
1890
1891         /**
1892          * Test the api_fr_photo_create_update() function.
1893          */
1894         public function testApiFrPhotoCreateUpdate()
1895         {
1896                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1897                 api_fr_photo_create_update('json');
1898         }
1899
1900         /**
1901          * Test the api_fr_photo_create_update() function without an authenticated user.
1902          *
1903          * @return void
1904          */
1905         public function testApiFrPhotoCreateUpdateWithoutAuthenticatedUser()
1906         {
1907                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1908                 BasicAuth::setCurrentUserID();
1909                 $_SESSION['authenticated'] = false;
1910                 api_fr_photo_create_update('json');
1911         }
1912
1913         /**
1914          * Test the api_fr_photo_create_update() function with an album name.
1915          *
1916          * @return void
1917          */
1918         public function testApiFrPhotoCreateUpdateWithAlbum()
1919         {
1920                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1921                 $_REQUEST['album'] = 'album_name';
1922                 api_fr_photo_create_update('json');
1923         }
1924
1925         /**
1926          * Test the api_fr_photo_create_update() function with the update mode.
1927          *
1928          * @return void
1929          */
1930         public function testApiFrPhotoCreateUpdateWithUpdate()
1931         {
1932                 $this->markTestIncomplete('We need to create a dataset for this');
1933         }
1934
1935         /**
1936          * Test the api_fr_photo_create_update() function with an uploaded file.
1937          *
1938          * @return void
1939          */
1940         public function testApiFrPhotoCreateUpdateWithFile()
1941         {
1942                 $this->markTestIncomplete();
1943         }
1944
1945         /**
1946          * Test the api_fr_photo_detail() function.
1947          *
1948          * @return void
1949          */
1950         public function testApiFrPhotoDetail()
1951         {
1952                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1953                 api_fr_photo_detail('json');
1954         }
1955
1956         /**
1957          * Test the api_fr_photo_detail() function without an authenticated user.
1958          *
1959          * @return void
1960          */
1961         public function testApiFrPhotoDetailWithoutAuthenticatedUser()
1962         {
1963                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1964                 BasicAuth::setCurrentUserID();
1965                 $_SESSION['authenticated'] = false;
1966                 api_fr_photo_detail('json');
1967         }
1968
1969         /**
1970          * Test the api_fr_photo_detail() function with a photo ID.
1971          *
1972          * @return void
1973          */
1974         public function testApiFrPhotoDetailWithPhotoId()
1975         {
1976                 $this->expectException(\Friendica\Network\HTTPException\NotFoundException::class);
1977                 $_REQUEST['photo_id'] = 1;
1978                 api_fr_photo_detail('json');
1979         }
1980
1981         /**
1982          * Test the api_fr_photo_detail() function with a correct photo ID.
1983          *
1984          * @return void
1985          */
1986         public function testApiFrPhotoDetailCorrectPhotoId()
1987         {
1988                 $this->markTestIncomplete('We need to create a dataset for this.');
1989         }
1990
1991         /**
1992          * Test the api_account_update_profile_image() function.
1993          *
1994          * @return void
1995          */
1996         public function testApiAccountUpdateProfileImage()
1997         {
1998                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1999                 api_account_update_profile_image('json');
2000         }
2001
2002         /**
2003          * Test the api_account_update_profile_image() function without an authenticated user.
2004          *
2005          * @return void
2006          */
2007         public function testApiAccountUpdateProfileImageWithoutAuthenticatedUser()
2008         {
2009                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2010                 BasicAuth::setCurrentUserID();
2011                 $_SESSION['authenticated'] = false;
2012                 api_account_update_profile_image('json');
2013         }
2014
2015         /**
2016          * Test the api_account_update_profile_image() function with an uploaded file.
2017          *
2018          * @return void
2019          */
2020         public function testApiAccountUpdateProfileImageWithUpload()
2021         {
2022                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2023                 $this->markTestIncomplete();
2024         }
2025
2026         /**
2027          * Test the check_acl_input() function.
2028          *
2029          * @return void
2030          */
2031         public function testCheckAclInput()
2032         {
2033                 $result = check_acl_input('<aclstring>', BaseApi::getCurrentUserID());
2034                 // Where does this result come from?
2035                 self::assertEquals(1, $result);
2036         }
2037
2038         /**
2039          * Test the check_acl_input() function with an empty ACL string.
2040          *
2041          * @return void
2042          */
2043         public function testCheckAclInputWithEmptyAclString()
2044         {
2045                 $result = check_acl_input(' ', BaseApi::getCurrentUserID());
2046                 self::assertFalse($result);
2047         }
2048
2049         /**
2050          * Test the save_media_to_database() function.
2051          *
2052          * @return void
2053          */
2054         public function testSaveMediaToDatabase()
2055         {
2056                 $this->markTestIncomplete();
2057         }
2058
2059         /**
2060          * Test the post_photo_item() function.
2061          *
2062          * @return void
2063          */
2064         public function testPostPhotoItem()
2065         {
2066                 $this->markTestIncomplete();
2067         }
2068
2069         /**
2070          * Test the prepare_photo_data() function.
2071          *
2072          * @return void
2073          */
2074         public function testPreparePhotoData()
2075         {
2076                 $this->markTestIncomplete();
2077         }
2078
2079         /**
2080          * Test the api_share_as_retweet() function with a valid item.
2081          *
2082          * @return void
2083          */
2084         public function testApiShareAsRetweetWithValidItem()
2085         {
2086                 $this->markTestIncomplete();
2087         }
2088
2089         /**
2090          * Test the api_in_reply_to() function with a valid item.
2091          *
2092          * @return void
2093          */
2094         public function testApiInReplyToWithValidItem()
2095         {
2096                 $this->markTestIncomplete();
2097         }
2098
2099         /**
2100          * Test the api_clean_plain_items() function.
2101          *
2102          * @return void
2103          */
2104         public function testApiCleanPlainItems()
2105         {
2106                 $_REQUEST['include_entities'] = 'true';
2107                 $result                       = api_clean_plain_items('some_text [url="some_url"]some_text[/url]');
2108                 self::assertEquals('some_text [url="some_url"]"some_url"[/url]', $result);
2109         }
2110
2111         /**
2112          * Test the api_best_nickname() function with contacts.
2113          *
2114          * @return void
2115          */
2116         public function testApiBestNicknameWithContacts()
2117         {
2118                 $this->markTestIncomplete();
2119         }
2120
2121         /**
2122          * Test the api_friendica_group_show() function.
2123          *
2124          * @return void
2125          */
2126         public function testApiFriendicaGroupShow()
2127         {
2128                 $this->markTestIncomplete();
2129         }
2130
2131         /**
2132          * Test the api_friendica_group_delete() function.
2133          *
2134          * @return void
2135          */
2136         public function testApiFriendicaGroupDelete()
2137         {
2138                 $this->markTestIncomplete();
2139         }
2140
2141         /**
2142          * Test the api_lists_destroy() function.
2143          *
2144          * @return void
2145          */
2146         public function testApiListsDestroy()
2147         {
2148                 $this->markTestIncomplete();
2149         }
2150
2151         /**
2152          * Test the group_create() function.
2153          *
2154          * @return void
2155          */
2156         public function testGroupCreate()
2157         {
2158                 $this->markTestIncomplete();
2159         }
2160
2161         /**
2162          * Test the api_friendica_group_create() function.
2163          *
2164          * @return void
2165          */
2166         public function testApiFriendicaGroupCreate()
2167         {
2168                 $this->markTestIncomplete();
2169         }
2170
2171         /**
2172          * Test the api_lists_create() function.
2173          *
2174          * @return void
2175          */
2176         public function testApiListsCreate()
2177         {
2178                 $this->markTestIncomplete();
2179         }
2180
2181         /**
2182          * Test the api_friendica_group_update() function.
2183          *
2184          * @return void
2185          */
2186         public function testApiFriendicaGroupUpdate()
2187         {
2188                 $this->markTestIncomplete();
2189         }
2190
2191         /**
2192          * Test the api_lists_update() function.
2193          *
2194          * @return void
2195          */
2196         public function testApiListsUpdate()
2197         {
2198                 $this->markTestIncomplete();
2199         }
2200
2201         /**
2202          * Test the api_friendica_activity() function.
2203          *
2204          * @return void
2205          */
2206         public function testApiFriendicaActivity()
2207         {
2208                 $this->markTestIncomplete();
2209         }
2210
2211         /**
2212          * Test the api_friendica_notification_seen() function.
2213          *
2214          * @return void
2215          */
2216         public function testApiFriendicaNotificationSeen()
2217         {
2218                 $this->markTestIncomplete();
2219         }
2220
2221         /**
2222          * Test the api_friendica_direct_messages_setseen() function.
2223          *
2224          * @return void
2225          */
2226         public function testApiFriendicaDirectMessagesSetseen()
2227         {
2228                 $this->markTestIncomplete();
2229         }
2230
2231         /**
2232          * Test the api_friendica_direct_messages_search() function.
2233          *
2234          * @return void
2235          */
2236         public function testApiFriendicaDirectMessagesSearch()
2237         {
2238                 $this->markTestIncomplete();
2239         }
2240 }