tests/legacy/ApiTest.php

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