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                 $_REQUEST['status']                = 'Status content #friendica';
 952                 $_REQUEST['in_reply_to_status_id'] = -1;
 953                 $_REQUEST['lat']                   = 48;
 954                 $_REQUEST['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                 $_REQUEST['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                 /*
1131                 $result = api_users_show('json');
1132                 // We can't use assertSelfUser() here because the user object is missing some properties.
1133                 self::assertEquals($this->selfUser['id'], $result['user']['cid']);
1134                 self::assertEquals('DFRN', $result['user']['location']);
1135                 self::assertEquals($this->selfUser['name'], $result['user']['name']);
1136                 self::assertEquals($this->selfUser['nick'], $result['user']['screen_name']);
1137                 self::assertTrue($result['user']['verified']);
1138                 */
1139         }
1140
1141         /**
1142          * Test the api_users_show() function with an XML result.
1143          *
1144          * @return void
1145          */
1146         public function testApiUsersShowWithXml()
1147         {
1148                 // $result = api_users_show('xml');
1149                 // self::assertXml($result, 'statuses');
1150         }
1151
1152         /**
1153          * Test the api_users_search() function.
1154          *
1155          * @return void
1156          */
1157         public function testApiUsersSearch()
1158         {
1159                 // $_GET['q'] = 'othercontact';
1160                 // $result    = api_users_search('json');
1161                 // self::assertOtherUser($result['users'][0]);
1162         }
1163
1164         /**
1165          * Test the api_users_search() function with an XML result.
1166          *
1167          * @return void
1168          */
1169         public function testApiUsersSearchWithXml()
1170         {
1171                 // $_GET['q'] = 'othercontact';
1172                 // $result    = api_users_search('xml');
1173                 // self::assertXml($result, 'users');
1174         }
1175
1176         /**
1177          * Test the api_users_search() function without a GET q parameter.
1178          *
1179          * @return void
1180          */
1181         public function testApiUsersSearchWithoutQuery()
1182         {
1183                 // $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1184                 // api_users_search('json');
1185         }
1186
1187         /**
1188          * Test the api_users_lookup() function.
1189          *
1190          * @return void
1191          */
1192         public function testApiUsersLookup()
1193         {
1194                 // $this->expectException(\Friendica\Network\HTTPException\NotFoundException::class);
1195                 // api_users_lookup('json');
1196         }
1197
1198         /**
1199          * Test the api_users_lookup() function with an user ID.
1200          *
1201          * @return void
1202          */
1203         public function testApiUsersLookupWithUserId()
1204         {
1205                 // $_REQUEST['user_id'] = $this->otherUser['id'];
1206                 // $result              = api_users_lookup('json');
1207                 // self::assertOtherUser($result['users'][0]);
1208         }
1209
1210         /**
1211          * Test the api_search() function.
1212          *
1213          * @return void
1214          */
1215         public function testApiSearch()
1216         {
1217                 $_REQUEST['q']      = 'reply';
1218                 $_REQUEST['max_id'] = 10;
1219                 $result             = api_search('json');
1220                 foreach ($result['status'] as $status) {
1221                         self::assertStatus($status);
1222                         self::assertStringContainsStringIgnoringCase('reply', $status['text'], '', true);
1223                 }
1224         }
1225
1226         /**
1227          * Test the api_search() function a count parameter.
1228          *
1229          * @return void
1230          */
1231         public function testApiSearchWithCount()
1232         {
1233                 $_REQUEST['q']     = 'reply';
1234                 $_REQUEST['count'] = 20;
1235                 $result            = api_search('json');
1236                 foreach ($result['status'] as $status) {
1237                         self::assertStatus($status);
1238                         self::assertStringContainsStringIgnoringCase('reply', $status['text'], '', true);
1239                 }
1240         }
1241
1242         /**
1243          * Test the api_search() function with an rpp parameter.
1244          *
1245          * @return void
1246          */
1247         public function testApiSearchWithRpp()
1248         {
1249                 $_REQUEST['q']   = 'reply';
1250                 $_REQUEST['rpp'] = 20;
1251                 $result          = api_search('json');
1252                 foreach ($result['status'] as $status) {
1253                         self::assertStatus($status);
1254                         self::assertStringContainsStringIgnoringCase('reply', $status['text'], '', true);
1255                 }
1256         }
1257
1258         /**
1259          * Test the api_search() function with an q parameter contains hashtag.
1260          * @doesNotPerformAssertions
1261          */
1262         public function testApiSearchWithHashtag()
1263         {
1264                 $_REQUEST['q'] = '%23friendica';
1265                 $result        = api_search('json');
1266                 foreach ($result['status'] as $status) {
1267                         self::assertStatus($status);
1268                         self::assertStringContainsStringIgnoringCase('#friendica', $status['text'], '', true);
1269                 }
1270         }
1271
1272         /**
1273          * Test the api_search() function with an exclude_replies parameter.
1274          * @doesNotPerformAssertions
1275          */
1276         public function testApiSearchWithExcludeReplies()
1277         {
1278                 $_REQUEST['max_id']          = 10;
1279                 $_REQUEST['exclude_replies'] = true;
1280                 $_REQUEST['q']               = 'friendica';
1281                 $result                      = api_search('json');
1282                 foreach ($result['status'] as $status) {
1283                         self::assertStatus($status);
1284                 }
1285         }
1286
1287         /**
1288          * Test the api_search() function without an authenticated user.
1289          *
1290          * @return void
1291          */
1292         public function testApiSearchWithUnallowedUser()
1293         {
1294                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1295                 BasicAuth::setCurrentUserID();
1296                 api_search('json');
1297         }
1298
1299         /**
1300          * Test the api_search() function without any GET query parameter.
1301          *
1302          * @return void
1303          */
1304         public function testApiSearchWithoutQuery()
1305         {
1306                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1307                 api_search('json');
1308         }
1309
1310         /**
1311          * Test the api_statuses_home_timeline() function.
1312          *
1313          * @return void
1314          */
1315         public function testApiStatusesHomeTimeline()
1316         {
1317                 /*
1318                 $_REQUEST['max_id']          = 10;
1319                 $_REQUEST['exclude_replies'] = true;
1320                 $_REQUEST['conversation_id'] = 1;
1321                 $result                      = api_statuses_home_timeline('json');
1322                 self::assertNotEmpty($result['status']);
1323                 foreach ($result['status'] as $status) {
1324                         self::assertStatus($status);
1325                 }
1326                 */
1327         }
1328
1329         /**
1330          * Test the api_statuses_home_timeline() function with a negative page parameter.
1331          *
1332          * @return void
1333          */
1334         public function testApiStatusesHomeTimelineWithNegativePage()
1335         {
1336                 /*
1337                 $_REQUEST['page'] = -2;
1338                 $result           = api_statuses_home_timeline('json');
1339                 self::assertNotEmpty($result['status']);
1340                 foreach ($result['status'] as $status) {
1341                         self::assertStatus($status);
1342                 }
1343                 */
1344         }
1345
1346         /**
1347          * Test the api_statuses_home_timeline() with an unallowed user.
1348          *
1349          * @return void
1350          */
1351         public function testApiStatusesHomeTimelineWithUnallowedUser()
1352         {
1353                 /*
1354                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1355                 BasicAuth::setCurrentUserID();
1356                 api_statuses_home_timeline('json');
1357                 */
1358         }
1359
1360         /**
1361          * Test the api_statuses_home_timeline() function with an RSS result.
1362          *
1363          * @return void
1364          */
1365         public function testApiStatusesHomeTimelineWithRss()
1366         {
1367                 // $result = api_statuses_home_timeline('rss');
1368                 // self::assertXml($result, 'statuses');
1369         }
1370
1371         /**
1372          * Test the api_statuses_public_timeline() function.
1373          *
1374          * @return void
1375          */
1376         public function testApiStatusesPublicTimeline()
1377         {
1378                 /*
1379                 $_REQUEST['max_id']          = 10;
1380                 $_REQUEST['conversation_id'] = 1;
1381                 $result                      = api_statuses_public_timeline('json');
1382                 self::assertNotEmpty($result['status']);
1383                 foreach ($result['status'] as $status) {
1384                         self::assertStatus($status);
1385                 }
1386                 */
1387         }
1388
1389         /**
1390          * Test the api_statuses_public_timeline() function with the exclude_replies parameter.
1391          *
1392          * @return void
1393          */
1394         public function testApiStatusesPublicTimelineWithExcludeReplies()
1395         {
1396                 /*
1397                 $_REQUEST['max_id']          = 10;
1398                 $_REQUEST['exclude_replies'] = true;
1399                 $result                      = api_statuses_public_timeline('json');
1400                 self::assertNotEmpty($result['status']);
1401                 foreach ($result['status'] as $status) {
1402                         self::assertStatus($status);
1403                 }
1404                 */
1405         }
1406
1407         /**
1408          * Test the api_statuses_public_timeline() function with a negative page parameter.
1409          *
1410          * @return void
1411          */
1412         public function testApiStatusesPublicTimelineWithNegativePage()
1413         {
1414                 /*
1415                 $_REQUEST['page'] = -2;
1416                 $result           = api_statuses_public_timeline('json');
1417                 self::assertNotEmpty($result['status']);
1418                 foreach ($result['status'] as $status) {
1419                         self::assertStatus($status);
1420                 }
1421                 */
1422         }
1423
1424         /**
1425          * Test the api_statuses_public_timeline() function with an unallowed user.
1426          *
1427          * @return void
1428          */
1429         public function testApiStatusesPublicTimelineWithUnallowedUser()
1430         {
1431                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1432                 // BasicAuth::setCurrentUserID();
1433                 // api_statuses_public_timeline('json');
1434         }
1435
1436         /**
1437          * Test the api_statuses_public_timeline() function with an RSS result.
1438          *
1439          * @return void
1440          */
1441         public function testApiStatusesPublicTimelineWithRss()
1442         {
1443                 // $result = api_statuses_public_timeline('rss');
1444                 // self::assertXml($result, 'statuses');
1445         }
1446
1447         /**
1448          * Test the api_statuses_networkpublic_timeline() function.
1449          *
1450          * @return void
1451          */
1452         public function testApiStatusesNetworkpublicTimeline()
1453         {
1454                 /*
1455                 $_REQUEST['max_id'] = 10;
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         /**
1465          * Test the api_statuses_networkpublic_timeline() function with a negative page parameter.
1466          *
1467          * @return void
1468          */
1469         public function testApiStatusesNetworkpublicTimelineWithNegativePage()
1470         {
1471                 /*
1472                 $_REQUEST['page'] = -2;
1473                 $result           = api_statuses_networkpublic_timeline('json');
1474                 self::assertNotEmpty($result['status']);
1475                 foreach ($result['status'] as $status) {
1476                         self::assertStatus($status);
1477                 }
1478                 */
1479         }
1480
1481         /**
1482          * Test the api_statuses_networkpublic_timeline() function with an unallowed user.
1483          *
1484          * @return void
1485          */
1486         public function testApiStatusesNetworkpublicTimelineWithUnallowedUser()
1487         {
1488                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1489                 // BasicAuth::setCurrentUserID();
1490                 // api_statuses_networkpublic_timeline('json');
1491         }
1492
1493         /**
1494          * Test the api_statuses_networkpublic_timeline() function with an RSS result.
1495          *
1496          * @return void
1497          */
1498         public function testApiStatusesNetworkpublicTimelineWithRss()
1499         {
1500                 // $result = api_statuses_networkpublic_timeline('rss');
1501                 // self::assertXml($result, 'statuses');
1502         }
1503
1504         /**
1505          * Test the api_statuses_show() function.
1506          *
1507          * @return void
1508          */
1509         public function testApiStatusesShow()
1510         {
1511                 // $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1512                 // api_statuses_show('json');
1513         }
1514
1515         /**
1516          * Test the api_statuses_show() function with an ID.
1517          *
1518          * @return void
1519          */
1520         public function testApiStatusesShowWithId()
1521         {
1522                 // DI::args()->setArgv(['', '', '', 1]);
1523                 // $result = api_statuses_show('json');
1524                 // self::assertStatus($result['status']);
1525         }
1526
1527         /**
1528          * Test the api_statuses_show() function with the conversation parameter.
1529          *
1530          * @return void
1531          */
1532         public function testApiStatusesShowWithConversation()
1533         {
1534                 /*
1535                 DI::args()->setArgv(['', '', '', 1]);
1536                 $_REQUEST['conversation'] = 1;
1537                 $result                   = api_statuses_show('json');
1538                 self::assertNotEmpty($result['status']);
1539                 foreach ($result['status'] as $status) {
1540                         self::assertStatus($status);
1541                 }
1542                 */
1543         }
1544
1545         /**
1546          * Test the api_statuses_show() function with an unallowed user.
1547          *
1548          * @return void
1549          */
1550         public function testApiStatusesShowWithUnallowedUser()
1551         {
1552                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1553                 // BasicAuth::setCurrentUserID();
1554                 // api_statuses_show('json');
1555         }
1556
1557         /**
1558          * Test the api_conversation_show() function.
1559          *
1560          * @return void
1561          */
1562         public function testApiConversationShow()
1563         {
1564                 // $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1565                 // api_conversation_show('json');
1566         }
1567
1568         /**
1569          * Test the api_conversation_show() function with an ID.
1570          *
1571          * @return void
1572          */
1573         public function testApiConversationShowWithId()
1574         {
1575                 /*
1576                 DI::args()->setArgv(['', '', '', 1]);
1577                 $_REQUEST['max_id'] = 10;
1578                 $_REQUEST['page']   = -2;
1579                 $result             = api_conversation_show('json');
1580                 self::assertNotEmpty($result['status']);
1581                 foreach ($result['status'] as $status) {
1582                         self::assertStatus($status);
1583                 }
1584                 */
1585         }
1586
1587         /**
1588          * Test the api_conversation_show() function with an unallowed user.
1589          *
1590          * @return void
1591          */
1592         public function testApiConversationShowWithUnallowedUser()
1593         {
1594                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1595                 // BasicAuth::setCurrentUserID();
1596                 // api_conversation_show('json');
1597         }
1598
1599         /**
1600          * Test the api_statuses_repeat() function.
1601          *
1602          * @return void
1603          */
1604         public function testApiStatusesRepeat()
1605         {
1606                 $this->expectException(\Friendica\Network\HTTPException\ForbiddenException::class);
1607                 api_statuses_repeat('json');
1608         }
1609
1610         /**
1611          * Test the api_statuses_repeat() function without an authenticated user.
1612          *
1613          * @return void
1614          */
1615         public function testApiStatusesRepeatWithoutAuthenticatedUser()
1616         {
1617                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1618                 BasicAuth::setCurrentUserID();
1619                 $_SESSION['authenticated'] = false;
1620                 api_statuses_repeat('json');
1621         }
1622
1623         /**
1624          * Test the api_statuses_repeat() function with an ID.
1625          *
1626          * @return void
1627          */
1628         public function testApiStatusesRepeatWithId()
1629         {
1630                 DI::args()->setArgv(['', '', '', 1]);
1631                 $result = api_statuses_repeat('json');
1632                 self::assertStatus($result['status']);
1633
1634                 // Also test with a shared status
1635                 DI::args()->setArgv(['', '', '', 5]);
1636                 $result = api_statuses_repeat('json');
1637                 self::assertStatus($result['status']);
1638         }
1639
1640         /**
1641          * Test the api_statuses_destroy() function.
1642          *
1643          * @return void
1644          */
1645         public function testApiStatusesDestroy()
1646         {
1647                 // $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1648                 // api_statuses_destroy('json');
1649         }
1650
1651         /**
1652          * Test the api_statuses_destroy() function without an authenticated user.
1653          *
1654          * @return void
1655          */
1656         public function testApiStatusesDestroyWithoutAuthenticatedUser()
1657         {
1658                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1659                 // BasicAuth::setCurrentUserID();
1660                 // $_SESSION['authenticated'] = false;
1661                 // api_statuses_destroy('json');
1662         }
1663
1664         /**
1665          * Test the api_statuses_destroy() function with an ID.
1666          *
1667          * @return void
1668          */
1669         public function testApiStatusesDestroyWithId()
1670         {
1671                 // DI::args()->setArgv(['', '', '', 1]);
1672                 // $result = api_statuses_destroy('json');
1673                 // self::assertStatus($result['status']);
1674         }
1675
1676         /**
1677          * Test the api_statuses_mentions() function.
1678          *
1679          * @return void
1680          */
1681         public function testApiStatusesMentions()
1682         {
1683                 /*
1684                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1685                 $_REQUEST['max_id'] = 10;
1686                 $result             = api_statuses_mentions('json');
1687                 self::assertEmpty($result['status']);
1688                 // We should test with mentions in the database.
1689                 */
1690         }
1691
1692         /**
1693          * Test the api_statuses_mentions() function with a negative page parameter.
1694          *
1695          * @return void
1696          */
1697         public function testApiStatusesMentionsWithNegativePage()
1698         {
1699                 // $_REQUEST['page'] = -2;
1700                 // $result           = api_statuses_mentions('json');
1701                 // self::assertEmpty($result['status']);
1702         }
1703
1704         /**
1705          * Test the api_statuses_mentions() function with an unallowed user.
1706          *
1707          * @return void
1708          */
1709         public function testApiStatusesMentionsWithUnallowedUser()
1710         {
1711                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1712                 // BasicAuth::setCurrentUserID();
1713                 // api_statuses_mentions('json');
1714         }
1715
1716         /**
1717          * Test the api_statuses_mentions() function with an RSS result.
1718          *
1719          * @return void
1720          */
1721         public function testApiStatusesMentionsWithRss()
1722         {
1723                 // $result = api_statuses_mentions('rss');
1724                 // self::assertXml($result, 'statuses');
1725         }
1726
1727         /**
1728          * Test the api_statuses_user_timeline() function.
1729          *
1730          * @return void
1731          */
1732         public function testApiStatusesUserTimeline()
1733         {
1734         /*
1735                 $_REQUEST['user_id']         = 42;
1736                 $_REQUEST['max_id']          = 10;
1737                 $_REQUEST['exclude_replies'] = true;
1738                 $_REQUEST['conversation_id'] = 7;
1739
1740                 $result = api_statuses_user_timeline('json');
1741                 self::assertNotEmpty($result['status']);
1742                 foreach ($result['status'] as $status) {
1743                         self::assertStatus($status);
1744                 }
1745                 */
1746         }
1747
1748         /**
1749          * Test the api_statuses_user_timeline() function with a negative page parameter.
1750          *
1751          * @return void
1752          */
1753         public function testApiStatusesUserTimelineWithNegativePage()
1754         {
1755                 /*
1756                 $_REQUEST['user_id'] = 42;
1757                 $_REQUEST['page']    = -2;
1758
1759                 $result = api_statuses_user_timeline('json');
1760                 self::assertNotEmpty($result['status']);
1761                 foreach ($result['status'] as $status) {
1762                         self::assertStatus($status);
1763                 }
1764                 */
1765         }
1766
1767         /**
1768          * Test the api_statuses_user_timeline() function with an RSS result.
1769          *
1770          * @return void
1771          */
1772         public function testApiStatusesUserTimelineWithRss()
1773         {
1774                 // $result = api_statuses_user_timeline('rss');
1775                 // self::assertXml($result, 'statuses');
1776         }
1777
1778         /**
1779          * Test the api_statuses_user_timeline() function with an unallowed user.
1780          *
1781          * @return void
1782          */
1783         public function testApiStatusesUserTimelineWithUnallowedUser()
1784         {
1785                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1786                 // BasicAuth::setCurrentUserID();
1787                 // api_statuses_user_timeline('json');
1788         }
1789
1790         /**
1791          * Test the api_favorites_create_destroy() function.
1792          *
1793          * @return void
1794          */
1795         public function testApiFavoritesCreateDestroy()
1796         {
1797                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1798                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create']);
1799                 api_favorites_create_destroy('json');
1800         }
1801
1802         /**
1803          * Test the api_favorites_create_destroy() function with an invalid ID.
1804          *
1805          * @return void
1806          */
1807         public function testApiFavoritesCreateDestroyWithInvalidId()
1808         {
1809                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1810                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create', '12.json']);
1811                 api_favorites_create_destroy('json');
1812         }
1813
1814         /**
1815          * Test the api_favorites_create_destroy() function with an invalid action.
1816          *
1817          * @return void
1818          */
1819         public function testApiFavoritesCreateDestroyWithInvalidAction()
1820         {
1821                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1822                 DI::args()->setArgv(['api', '1.1', 'favorites', 'change.json']);
1823                 $_REQUEST['id'] = 1;
1824                 api_favorites_create_destroy('json');
1825         }
1826
1827         /**
1828          * Test the api_favorites_create_destroy() function with the create action.
1829          *
1830          * @return void
1831          */
1832         public function testApiFavoritesCreateDestroyWithCreateAction()
1833         {
1834                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.json']);
1835                 $_REQUEST['id'] = 3;
1836                 $result         = api_favorites_create_destroy('json');
1837                 self::assertStatus($result['status']);
1838         }
1839
1840         /**
1841          * Test the api_favorites_create_destroy() function with the create action and an RSS result.
1842          *
1843          * @return void
1844          */
1845         public function testApiFavoritesCreateDestroyWithCreateActionAndRss()
1846         {
1847                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.rss']);
1848                 $_REQUEST['id'] = 3;
1849                 $result         = api_favorites_create_destroy('rss');
1850                 self::assertXml($result, 'status');
1851         }
1852
1853         /**
1854          * Test the api_favorites_create_destroy() function with the destroy action.
1855          *
1856          * @return void
1857          */
1858         public function testApiFavoritesCreateDestroyWithDestroyAction()
1859         {
1860                 DI::args()->setArgv(['api', '1.1', 'favorites', 'destroy.json']);
1861                 $_REQUEST['id'] = 3;
1862                 $result         = api_favorites_create_destroy('json');
1863                 self::assertStatus($result['status']);
1864         }
1865
1866         /**
1867          * Test the api_favorites_create_destroy() function without an authenticated user.
1868          *
1869          * @return void
1870          */
1871         public function testApiFavoritesCreateDestroyWithoutAuthenticatedUser()
1872         {
1873                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1874                 DI::args()->setArgv(['api', '1.1', 'favorites', 'create.json']);
1875                 BasicAuth::setCurrentUserID();
1876                 $_SESSION['authenticated'] = false;
1877                 api_favorites_create_destroy('json');
1878         }
1879
1880         /**
1881          * Test the api_favorites() function.
1882          *
1883          * @return void
1884          */
1885         public function testApiFavorites()
1886         {
1887                 /*
1888                 $_REQUEST['page']   = -1;
1889                 $_REQUEST['max_id'] = 10;
1890                 $result             = api_favorites('json');
1891                 foreach ($result['status'] as $status) {
1892                         self::assertStatus($status);
1893                 }
1894                 */
1895         }
1896
1897         /**
1898          * Test the api_favorites() function with an RSS result.
1899          *
1900          * @return void
1901          */
1902         public function testApiFavoritesWithRss()
1903         {
1904                 // $result = api_favorites('rss');
1905                 // self::assertXml($result, 'statuses');
1906         }
1907
1908         /**
1909          * Test the api_favorites() function with an unallowed user.
1910          *
1911          * @return void
1912          */
1913         public function testApiFavoritesWithUnallowedUser()
1914         {
1915                 // $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1916                 // BasicAuth::setCurrentUserID();
1917                 // api_favorites('json');
1918         }
1919
1920         /**
1921          * Test the api_format_messages() function.
1922          *
1923          * @return void
1924          */
1925         public function testApiFormatMessages()
1926         {
1927                 $result = api_format_messages(
1928                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1929                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1930                         ['id' => 3, 'uri-id' => 2, 'screen_name' => 'sender_name']
1931                 );
1932                 self::assertEquals('item_title' . "\n" . 'item_body', $result['text']);
1933                 self::assertEquals(1, $result['id']);
1934                 self::assertEquals(2, $result['recipient_id']);
1935                 self::assertEquals(3, $result['sender_id']);
1936                 self::assertEquals('recipient_name', $result['recipient_screen_name']);
1937                 self::assertEquals('sender_name', $result['sender_screen_name']);
1938         }
1939
1940         /**
1941          * Test the api_format_messages() function with HTML.
1942          *
1943          * @return void
1944          */
1945         public function testApiFormatMessagesWithHtmlText()
1946         {
1947                 $_GET['getText'] = 'html';
1948                 $result          = api_format_messages(
1949                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1950                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1951                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1952                 );
1953                 self::assertEquals('item_title', $result['title']);
1954                 self::assertEquals('<strong>item_body</strong>', $result['text']);
1955         }
1956
1957         /**
1958          * Test the api_format_messages() function with plain text.
1959          *
1960          * @return void
1961          */
1962         public function testApiFormatMessagesWithPlainText()
1963         {
1964                 $_GET['getText'] = 'plain';
1965                 $result          = api_format_messages(
1966                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1967                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1968                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1969                 );
1970                 self::assertEquals('item_title', $result['title']);
1971                 self::assertEquals('item_body', $result['text']);
1972         }
1973
1974         /**
1975          * Test the api_format_messages() function with the getUserObjects GET parameter set to false.
1976          *
1977          * @return void
1978          */
1979         public function testApiFormatMessagesWithoutUserObjects()
1980         {
1981                 $_GET['getUserObjects'] = 'false';
1982                 $result                 = api_format_messages(
1983                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
1984                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
1985                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
1986                 );
1987                 self::assertTrue(!isset($result['sender']));
1988                 self::assertTrue(!isset($result['recipient']));
1989         }
1990
1991         /**
1992          * Test the api_convert_item() function.
1993          *
1994          * @return void
1995          */
1996         public function testApiConvertItem()
1997         {
1998                 /*
1999                 $result = api_convert_item(
2000                         [
2001                                 'network' => 'feed',
2002                                 'title'   => 'item_title',
2003                                 'uri-id'  => 1,
2004                                 // We need a long string to test that it is correctly cut
2005                                 'body'    => 'perspiciatis impedit voluptatem quis molestiae ea qui ' .
2006                                                          'reiciendis dolorum aut ducimus sunt consequatur inventore dolor ' .
2007                                                          'officiis pariatur doloremque nemo culpa aut quidem qui dolore ' .
2008                                                          'laudantium atque commodi alias voluptatem non possimus aperiam ' .
2009                                                          'ipsum rerum consequuntur aut amet fugit quia aliquid praesentium ' .
2010                                                          'repellendus quibusdam et et inventore mollitia rerum sit autem ' .
2011                                                          'pariatur maiores ipsum accusantium perferendis vel sit possimus ' .
2012                                                          'veritatis nihil distinctio qui eum repellat officia illum quos ' .
2013                                                          'impedit quam iste esse unde qui suscipit aut facilis ut inventore ' .
2014                                                          'omnis exercitationem quo magnam consequatur maxime aut illum ' .
2015                                                          'soluta quaerat natus unde aspernatur et sed beatae nihil ullam ' .
2016                                                          'temporibus corporis ratione blanditiis perspiciatis impedit ' .
2017                                                          'voluptatem quis molestiae ea qui reiciendis dolorum aut ducimus ' .
2018                                                          'sunt consequatur inventore dolor officiis pariatur doloremque ' .
2019                                                          'nemo culpa aut quidem qui dolore laudantium atque commodi alias ' .
2020                                                          'voluptatem non possimus aperiam ipsum rerum consequuntur aut ' .
2021                                                          'amet fugit quia aliquid praesentium repellendus quibusdam et et ' .
2022                                                          'inventore mollitia rerum sit autem pariatur maiores ipsum accusantium ' .
2023                                                          'perferendis vel sit possimus veritatis nihil distinctio qui eum ' .
2024                                                          'repellat officia illum quos impedit quam iste esse unde qui ' .
2025                                                          'suscipit aut facilis ut inventore omnis exercitationem quo magnam ' .
2026                                                          'consequatur maxime aut illum soluta quaerat natus unde aspernatur ' .
2027                                                          'et sed beatae nihil ullam temporibus corporis ratione blanditiis',
2028                                 'plink'   => 'item_plink'
2029                         ]
2030                 );
2031                 self::assertStringStartsWith('item_title', $result['text']);
2032                 self::assertStringStartsWith('<h4>item_title</h4><br>perspiciatis impedit voluptatem', $result['html']);
2033                 */
2034         }
2035
2036         /**
2037          * Test the api_convert_item() function with an empty item body.
2038          *
2039          * @return void
2040          */
2041         public function testApiConvertItemWithoutBody()
2042         {
2043                 /*
2044                 $result = api_convert_item(
2045                         [
2046                                 'network' => 'feed',
2047                                 'title'   => 'item_title',
2048                                 'uri-id'  => -1,
2049                                 'body'    => '',
2050                                 'plink'   => 'item_plink'
2051                         ]
2052                 );
2053                 self::assertEquals("item_title", $result['text']);
2054                 self::assertEquals('<h4>item_title</h4><br>item_plink', $result['html']);
2055                 */
2056         }
2057
2058         /**
2059          * Test the api_convert_item() function with the title in the body.
2060          *
2061          * @return void
2062          */
2063         public function testApiConvertItemWithTitleInBody()
2064         {
2065                 /*
2066                 $result = api_convert_item(
2067                         [
2068                                 'title'  => 'item_title',
2069                                 'body'   => 'item_title item_body',
2070                                 'uri-id' => 1,
2071                         ]
2072                 );
2073                 self::assertEquals('item_title item_body', $result['text']);
2074                 self::assertEquals('<h4>item_title</h4><br>item_title item_body', $result['html']);
2075                 */
2076         }
2077
2078         /**
2079          * Test the api_get_attachments() function.
2080          *
2081          * @return void
2082          */
2083         public function testApiGetAttachments()
2084         {
2085                 // $body = 'body';
2086                 // self::assertEmpty(api_get_attachments($body, 0));
2087         }
2088
2089         /**
2090          * Test the api_get_attachments() function with an img tag.
2091          *
2092          * @return void
2093          */
2094         public function testApiGetAttachmentsWithImage()
2095         {
2096                 // $body = '[img]http://via.placeholder.com/1x1.png[/img]';
2097                 // self::assertIsArray(api_get_attachments($body, 0));
2098         }
2099
2100         /**
2101          * Test the api_get_attachments() function with an img tag and an AndStatus user agent.
2102          *
2103          * @return void
2104          */
2105         public function testApiGetAttachmentsWithImageAndAndStatus()
2106         {
2107                 // $_SERVER['HTTP_USER_AGENT'] = 'AndStatus';
2108                 // $body                       = '[img]http://via.placeholder.com/1x1.png[/img]';
2109                 // self::assertIsArray(api_get_attachments($body, 0));
2110         }
2111
2112         /**
2113          * Test the api_get_entitities() function.
2114          *
2115          * @return void
2116          */
2117         public function testApiGetEntitities()
2118         {
2119                 // $text = 'text';
2120                 // self::assertIsArray(api_get_entitities($text, 'bbcode', 0));
2121         }
2122
2123         /**
2124          * Test the api_get_entitities() function with the include_entities parameter.
2125          *
2126          * @return void
2127          */
2128         public function testApiGetEntititiesWithIncludeEntities()
2129         {
2130                 /*
2131                 $_REQUEST['include_entities'] = 'true';
2132                 $text                         = 'text';
2133                 $result                       = api_get_entitities($text, 'bbcode', 0);
2134                 self::assertIsArray($result['hashtags']);
2135                 self::assertIsArray($result['symbols']);
2136                 self::assertIsArray($result['urls']);
2137                 self::assertIsArray($result['user_mentions']);
2138                 */
2139         }
2140
2141         /**
2142          * Test the api_format_items_embeded_images() function.
2143          *
2144          * @return void
2145          */
2146         public function testApiFormatItemsEmbededImages()
2147         {
2148                 /*
2149                 self::assertEquals(
2150                         'text ' . DI::baseUrl() . '/display/item_guid',
2151                         api_format_items_embeded_images(['guid' => 'item_guid'], 'text data:image/foo')
2152                 );
2153                 */
2154         }
2155
2156         /**
2157          * Test the api_format_items_activities() function.
2158          *
2159          * @return void
2160          */
2161         public function testApiFormatItemsActivities()
2162         {
2163                 $item   = ['uid' => 0, 'uri-id' => 1];
2164                 $result = DI::friendicaActivities()->createFromUriId($item['uri-id'], $item['uid']);
2165                 self::assertArrayHasKey('like', $result);
2166                 self::assertArrayHasKey('dislike', $result);
2167                 self::assertArrayHasKey('attendyes', $result);
2168                 self::assertArrayHasKey('attendno', $result);
2169                 self::assertArrayHasKey('attendmaybe', $result);
2170         }
2171
2172         /**
2173          * Test the api_format_items_activities() function with an XML result.
2174          *
2175          * @return void
2176          */
2177         public function testApiFormatItemsActivitiesWithXml()
2178         {
2179                 $item   = ['uid' => 0, 'uri-id' => 1];
2180                 $result = DI::friendicaActivities()->createFromUriId($item['uri-id'], $item['uid'], 'xml');
2181                 self::assertArrayHasKey('friendica:like', $result);
2182                 self::assertArrayHasKey('friendica:dislike', $result);
2183                 self::assertArrayHasKey('friendica:attendyes', $result);
2184                 self::assertArrayHasKey('friendica:attendno', $result);
2185                 self::assertArrayHasKey('friendica:attendmaybe', $result);
2186         }
2187
2188         /**
2189          * Test the api_format_items() function.
2190          * @doesNotPerformAssertions
2191          */
2192         public function testApiFormatItems()
2193         {
2194                 /*
2195                 $items = Post::selectToArray([], ['uid' => 42]);
2196                 foreach ($items as $item) {
2197                         $status = api_format_item($item);
2198                         self::assertStatus($status);
2199                 }
2200                 */
2201         }
2202
2203         /**
2204          * Test the api_format_items() function with an XML result.
2205          * @doesNotPerformAssertions
2206          */
2207         public function testApiFormatItemsWithXml()
2208         {
2209                 /*
2210                 $items = Post::selectToArray([], ['uid' => 42]);
2211                 foreach ($items as $item) {
2212                         $status = api_format_item($item, 'xml');
2213                         self::assertStatus($status);
2214                 }
2215                 */
2216         }
2217
2218         /**
2219          * Test the api_lists_list() function.
2220          *
2221          * @return void
2222          */
2223         public function testApiListsList()
2224         {
2225                 $result = api_lists_list('json');
2226                 self::assertEquals(['lists_list' => []], $result);
2227         }
2228
2229         /**
2230          * Test the api_lists_ownerships() function.
2231          *
2232          * @return void
2233          */
2234         public function testApiListsOwnerships()
2235         {
2236                 $result = api_lists_ownerships('json');
2237                 foreach ($result['lists']['lists'] as $list) {
2238                         self::assertList($list);
2239                 }
2240         }
2241
2242         /**
2243          * Test the api_lists_ownerships() function without an authenticated user.
2244          *
2245          * @return void
2246          */
2247         public function testApiListsOwnershipsWithoutAuthenticatedUser()
2248         {
2249                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2250                 BasicAuth::setCurrentUserID();
2251                 $_SESSION['authenticated'] = false;
2252                 api_lists_ownerships('json');
2253         }
2254
2255         /**
2256          * Test the api_lists_statuses() function.
2257          *
2258          * @return void
2259          */
2260         public function testApiListsStatuses()
2261         {
2262                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2263                 api_lists_statuses('json');
2264         }
2265
2266         /**
2267          * Test the api_lists_statuses() function with a list ID.
2268          * @doesNotPerformAssertions
2269          */
2270         public function testApiListsStatusesWithListId()
2271         {
2272                 $_REQUEST['list_id'] = 1;
2273                 $_REQUEST['page']    = -1;
2274                 $_REQUEST['max_id']  = 10;
2275                 $result              = api_lists_statuses('json');
2276                 foreach ($result['status'] as $status) {
2277                         self::assertStatus($status);
2278                 }
2279         }
2280
2281         /**
2282          * Test the api_lists_statuses() function with a list ID and a RSS result.
2283          *
2284          * @return void
2285          */
2286         public function testApiListsStatusesWithListIdAndRss()
2287         {
2288                 $_REQUEST['list_id'] = 1;
2289                 $result              = api_lists_statuses('rss');
2290                 self::assertXml($result, 'statuses');
2291         }
2292
2293         /**
2294          * Test the api_lists_statuses() function with an unallowed user.
2295          *
2296          * @return void
2297          */
2298         public function testApiListsStatusesWithUnallowedUser()
2299         {
2300                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2301                 BasicAuth::setCurrentUserID();
2302                 api_lists_statuses('json');
2303         }
2304
2305         /**
2306          * Test the api_statuses_f() function.
2307          *
2308          * @return void
2309          */
2310         public function testApiStatusesFWithFriends()
2311         {
2312                 $_GET['page'] = -1;
2313                 $result       = api_statuses_f('friends');
2314                 self::assertArrayHasKey('user', $result);
2315         }
2316
2317         /**
2318          * Test the api_statuses_f() function.
2319          *
2320          * @return void
2321          */
2322         public function testApiStatusesFWithFollowers()
2323         {
2324                 $result = api_statuses_f('followers');
2325                 self::assertArrayHasKey('user', $result);
2326         }
2327
2328         /**
2329          * Test the api_statuses_f() function.
2330          *
2331          * @return void
2332          */
2333         public function testApiStatusesFWithBlocks()
2334         {
2335                 $result = api_statuses_f('blocks');
2336                 self::assertArrayHasKey('user', $result);
2337         }
2338
2339         /**
2340          * Test the api_statuses_f() function.
2341          *
2342          * @return void
2343          */
2344         public function testApiStatusesFWithIncoming()
2345         {
2346                 $result = api_statuses_f('incoming');
2347                 self::assertArrayHasKey('user', $result);
2348         }
2349
2350         /**
2351          * Test the api_statuses_f() function an undefined cursor GET variable.
2352          *
2353          * @return void
2354          */
2355         public function testApiStatusesFWithUndefinedCursor()
2356         {
2357                 $_GET['cursor'] = 'undefined';
2358                 self::assertFalse(api_statuses_f('friends'));
2359         }
2360
2361         /**
2362          * Test the api_statuses_friends() function.
2363          *
2364          * @return void
2365          */
2366         public function testApiStatusesFriends()
2367         {
2368                 $result = api_statuses_friends('json');
2369                 self::assertArrayHasKey('user', $result);
2370         }
2371
2372         /**
2373          * Test the api_statuses_friends() function an undefined cursor GET variable.
2374          *
2375          * @return void
2376          */
2377         public function testApiStatusesFriendsWithUndefinedCursor()
2378         {
2379                 $_GET['cursor'] = 'undefined';
2380                 self::assertFalse(api_statuses_friends('json'));
2381         }
2382
2383         /**
2384          * Test the api_statuses_followers() function.
2385          *
2386          * @return void
2387          */
2388         public function testApiStatusesFollowers()
2389         {
2390                 $result = api_statuses_followers('json');
2391                 self::assertArrayHasKey('user', $result);
2392         }
2393
2394         /**
2395          * Test the api_statuses_followers() function an undefined cursor GET variable.
2396          *
2397          * @return void
2398          */
2399         public function testApiStatusesFollowersWithUndefinedCursor()
2400         {
2401                 $_GET['cursor'] = 'undefined';
2402                 self::assertFalse(api_statuses_followers('json'));
2403         }
2404
2405         /**
2406          * Test the api_blocks_list() function.
2407          *
2408          * @return void
2409          */
2410         public function testApiBlocksList()
2411         {
2412                 $result = api_blocks_list('json');
2413                 self::assertArrayHasKey('user', $result);
2414         }
2415
2416         /**
2417          * Test the api_blocks_list() function an undefined cursor GET variable.
2418          *
2419          * @return void
2420          */
2421         public function testApiBlocksListWithUndefinedCursor()
2422         {
2423                 $_GET['cursor'] = 'undefined';
2424                 self::assertFalse(api_blocks_list('json'));
2425         }
2426
2427         /**
2428          * Test the api_friendships_incoming() function.
2429          *
2430          * @return void
2431          */
2432         public function testApiFriendshipsIncoming()
2433         {
2434                 $result = api_friendships_incoming('json');
2435                 self::assertArrayHasKey('id', $result);
2436         }
2437
2438         /**
2439          * Test the api_friendships_incoming() function an undefined cursor GET variable.
2440          *
2441          * @return void
2442          */
2443         public function testApiFriendshipsIncomingWithUndefinedCursor()
2444         {
2445                 $_GET['cursor'] = 'undefined';
2446                 self::assertFalse(api_friendships_incoming('json'));
2447         }
2448
2449         /**
2450          * Test the api_statusnet_config() function.
2451          *
2452          * @return void
2453          */
2454         public function testApiStatusnetConfig()
2455         {
2456                 /*
2457                 $result = api_statusnet_config('json');
2458                 self::assertEquals('localhost', $result['config']['site']['server']);
2459                 self::assertEquals('default', $result['config']['site']['theme']);
2460                 self::assertEquals(DI::baseUrl() . '/images/friendica-64.png', $result['config']['site']['logo']);
2461                 self::assertTrue($result['config']['site']['fancy']);
2462                 self::assertEquals('en', $result['config']['site']['language']);
2463                 self::assertEquals('UTC', $result['config']['site']['timezone']);
2464                 self::assertEquals(200000, $result['config']['site']['textlimit']);
2465                 self::assertEquals('false', $result['config']['site']['private']);
2466                 self::assertEquals('false', $result['config']['site']['ssl']);
2467                 self::assertEquals(30, $result['config']['site']['shorturllength']);
2468                 */
2469         }
2470
2471         /**
2472          * Test the api_direct_messages_new() function.
2473          *
2474          * @return void
2475          */
2476         public function testApiDirectMessagesNew()
2477         {
2478                 $result = api_direct_messages_new('json');
2479                 self::assertNull($result);
2480         }
2481
2482         /**
2483          * Test the api_direct_messages_new() function without an authenticated user.
2484          *
2485          * @return void
2486          */
2487         public function testApiDirectMessagesNewWithoutAuthenticatedUser()
2488         {
2489                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2490                 BasicAuth::setCurrentUserID();
2491                 $_SESSION['authenticated'] = false;
2492                 api_direct_messages_new('json');
2493         }
2494
2495         /**
2496          * Test the api_direct_messages_new() function with an user ID.
2497          *
2498          * @return void
2499          */
2500         public function testApiDirectMessagesNewWithUserId()
2501         {
2502                 $_POST['text']    = 'message_text';
2503                 $_POST['user_id'] = $this->otherUser['id'];
2504                 $result           = api_direct_messages_new('json');
2505                 self::assertEquals(['direct_message' => ['error' => -1]], $result);
2506         }
2507
2508         /**
2509          * Test the api_direct_messages_new() function with a screen name.
2510          *
2511          * @return void
2512          */
2513         public function testApiDirectMessagesNewWithScreenName()
2514         {
2515                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
2516                 $_POST['text']    = 'message_text';
2517                 $_POST['user_id'] = $this->friendUser['id'];
2518                 $result           = api_direct_messages_new('json');
2519                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
2520                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
2521                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
2522         }
2523
2524         /**
2525          * Test the api_direct_messages_new() function with a title.
2526          *
2527          * @return void
2528          */
2529         public function testApiDirectMessagesNewWithTitle()
2530         {
2531                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
2532                 $_POST['text']     = 'message_text';
2533                 $_POST['user_id']  = $this->friendUser['id'];
2534                 $_REQUEST['title'] = 'message_title';
2535                 $result            = api_direct_messages_new('json');
2536                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
2537                 self::assertStringContainsString('message_title', $result['direct_message']['text']);
2538                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
2539                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
2540         }
2541
2542         /**
2543          * Test the api_direct_messages_new() function with an RSS result.
2544          *
2545          * @return void
2546          */
2547         public function testApiDirectMessagesNewWithRss()
2548         {
2549                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
2550                 $_POST['text']    = 'message_text';
2551                 $_POST['user_id'] = $this->friendUser['id'];
2552                 $result           = api_direct_messages_new('rss');
2553                 self::assertXml($result, 'direct-messages');
2554         }
2555
2556         /**
2557          * Test the api_direct_messages_destroy() function.
2558          *
2559          * @return void
2560          */
2561         public function testApiDirectMessagesDestroy()
2562         {
2563                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2564                 api_direct_messages_destroy('json');
2565         }
2566
2567         /**
2568          * Test the api_direct_messages_destroy() function with the friendica_verbose GET param.
2569          *
2570          * @return void
2571          */
2572         public function testApiDirectMessagesDestroyWithVerbose()
2573         {
2574                 $_GET['friendica_verbose'] = 'true';
2575                 $result                    = api_direct_messages_destroy('json');
2576                 self::assertEquals(
2577                         [
2578                                 '$result' => [
2579                                         'result'  => 'error',
2580                                         'message' => 'message id or parenturi not specified'
2581                                 ]
2582                         ],
2583                         $result
2584                 );
2585         }
2586
2587         /**
2588          * Test the api_direct_messages_destroy() function without an authenticated user.
2589          *
2590          * @return void
2591          */
2592         public function testApiDirectMessagesDestroyWithoutAuthenticatedUser()
2593         {
2594                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2595                 BasicAuth::setCurrentUserID();
2596                 $_SESSION['authenticated'] = false;
2597                 api_direct_messages_destroy('json');
2598         }
2599
2600         /**
2601          * Test the api_direct_messages_destroy() function with a non-zero ID.
2602          *
2603          * @return void
2604          */
2605         public function testApiDirectMessagesDestroyWithId()
2606         {
2607                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2608                 $_REQUEST['id'] = 1;
2609                 api_direct_messages_destroy('json');
2610         }
2611
2612         /**
2613          * Test the api_direct_messages_destroy() with a non-zero ID and the friendica_verbose GET param.
2614          *
2615          * @return void
2616          */
2617         public function testApiDirectMessagesDestroyWithIdAndVerbose()
2618         {
2619                 $_REQUEST['id']                  = 1;
2620                 $_REQUEST['friendica_parenturi'] = 'parent_uri';
2621                 $_GET['friendica_verbose']       = 'true';
2622                 $result                          = api_direct_messages_destroy('json');
2623                 self::assertEquals(
2624                         [
2625                                 '$result' => [
2626                                         'result'  => 'error',
2627                                         'message' => 'message id not in database'
2628                                 ]
2629                         ],
2630                         $result
2631                 );
2632         }
2633
2634         /**
2635          * Test the api_direct_messages_destroy() function with a non-zero ID.
2636          *
2637          * @return void
2638          */
2639         public function testApiDirectMessagesDestroyWithCorrectId()
2640         {
2641                 $this->markTestIncomplete('We need to add a dataset for this.');
2642         }
2643
2644         /**
2645          * Test the api_direct_messages_box() function.
2646          *
2647          * @return void
2648          */
2649         public function testApiDirectMessagesBoxWithSentbox()
2650         {
2651                 $_REQUEST['page']   = -1;
2652                 $_REQUEST['max_id'] = 10;
2653                 $result             = api_direct_messages_box('json', 'sentbox', 'false');
2654                 self::assertArrayHasKey('direct_message', $result);
2655         }
2656
2657         /**
2658          * Test the api_direct_messages_box() function.
2659          *
2660          * @return void
2661          */
2662         public function testApiDirectMessagesBoxWithConversation()
2663         {
2664                 $result = api_direct_messages_box('json', 'conversation', 'false');
2665                 self::assertArrayHasKey('direct_message', $result);
2666         }
2667
2668         /**
2669          * Test the api_direct_messages_box() function.
2670          *
2671          * @return void
2672          */
2673         public function testApiDirectMessagesBoxWithAll()
2674         {
2675                 $result = api_direct_messages_box('json', 'all', 'false');
2676                 self::assertArrayHasKey('direct_message', $result);
2677         }
2678
2679         /**
2680          * Test the api_direct_messages_box() function.
2681          *
2682          * @return void
2683          */
2684         public function testApiDirectMessagesBoxWithInbox()
2685         {
2686                 $result = api_direct_messages_box('json', 'inbox', 'false');
2687                 self::assertArrayHasKey('direct_message', $result);
2688         }
2689
2690         /**
2691          * Test the api_direct_messages_box() function.
2692          *
2693          * @return void
2694          */
2695         public function testApiDirectMessagesBoxWithVerbose()
2696         {
2697                 $result = api_direct_messages_box('json', 'sentbox', 'true');
2698                 self::assertEquals(
2699                         [
2700                                 '$result' => [
2701                                         'result'  => 'error',
2702                                         'message' => 'no mails available'
2703                                 ]
2704                         ],
2705                         $result
2706                 );
2707         }
2708
2709         /**
2710          * Test the api_direct_messages_box() function with a RSS result.
2711          *
2712          * @return void
2713          */
2714         public function testApiDirectMessagesBoxWithRss()
2715         {
2716                 $result = api_direct_messages_box('rss', 'sentbox', 'false');
2717                 self::assertXml($result, 'direct-messages');
2718         }
2719
2720         /**
2721          * Test the api_direct_messages_box() function without an authenticated user.
2722          *
2723          * @return void
2724          */
2725         public function testApiDirectMessagesBoxWithUnallowedUser()
2726         {
2727                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2728                 BasicAuth::setCurrentUserID();
2729                 api_direct_messages_box('json', 'sentbox', 'false');
2730         }
2731
2732         /**
2733          * Test the api_direct_messages_sentbox() function.
2734          *
2735          * @return void
2736          */
2737         public function testApiDirectMessagesSentbox()
2738         {
2739                 $result = api_direct_messages_sentbox('json');
2740                 self::assertArrayHasKey('direct_message', $result);
2741         }
2742
2743         /**
2744          * Test the api_direct_messages_inbox() function.
2745          *
2746          * @return void
2747          */
2748         public function testApiDirectMessagesInbox()
2749         {
2750                 $result = api_direct_messages_inbox('json');
2751                 self::assertArrayHasKey('direct_message', $result);
2752         }
2753
2754         /**
2755          * Test the api_direct_messages_all() function.
2756          *
2757          * @return void
2758          */
2759         public function testApiDirectMessagesAll()
2760         {
2761                 $result = api_direct_messages_all('json');
2762                 self::assertArrayHasKey('direct_message', $result);
2763         }
2764
2765         /**
2766          * Test the api_direct_messages_conversation() function.
2767          *
2768          * @return void
2769          */
2770         public function testApiDirectMessagesConversation()
2771         {
2772                 $result = api_direct_messages_conversation('json');
2773                 self::assertArrayHasKey('direct_message', $result);
2774         }
2775
2776         /**
2777          * Test the api_oauth_request_token() function.
2778          *
2779          * @return void
2780          */
2781         public function testApiOauthRequestToken()
2782         {
2783                 $this->markTestIncomplete('exit() kills phpunit as well');
2784         }
2785
2786         /**
2787          * Test the api_oauth_access_token() function.
2788          *
2789          * @return void
2790          */
2791         public function testApiOauthAccessToken()
2792         {
2793                 $this->markTestIncomplete('exit() kills phpunit as well');
2794         }
2795
2796         /**
2797          * Test the api_fr_photos_list() function.
2798          *
2799          * @return void
2800          */
2801         public function testApiFrPhotosList()
2802         {
2803                 $result = api_fr_photos_list('json');
2804                 self::assertArrayHasKey('photo', $result);
2805         }
2806
2807         /**
2808          * Test the api_fr_photos_list() function without an authenticated user.
2809          *
2810          * @return void
2811          */
2812         public function testApiFrPhotosListWithoutAuthenticatedUser()
2813         {
2814                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2815                 BasicAuth::setCurrentUserID();
2816                 $_SESSION['authenticated'] = false;
2817                 api_fr_photos_list('json');
2818         }
2819
2820         /**
2821          * Test the api_fr_photo_create_update() function.
2822          */
2823         public function testApiFrPhotoCreateUpdate()
2824         {
2825                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2826                 api_fr_photo_create_update('json');
2827         }
2828
2829         /**
2830          * Test the api_fr_photo_create_update() function without an authenticated user.
2831          *
2832          * @return void
2833          */
2834         public function testApiFrPhotoCreateUpdateWithoutAuthenticatedUser()
2835         {
2836                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2837                 BasicAuth::setCurrentUserID();
2838                 $_SESSION['authenticated'] = false;
2839                 api_fr_photo_create_update('json');
2840         }
2841
2842         /**
2843          * Test the api_fr_photo_create_update() function with an album name.
2844          *
2845          * @return void
2846          */
2847         public function testApiFrPhotoCreateUpdateWithAlbum()
2848         {
2849                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2850                 $_REQUEST['album'] = 'album_name';
2851                 api_fr_photo_create_update('json');
2852         }
2853
2854         /**
2855          * Test the api_fr_photo_create_update() function with the update mode.
2856          *
2857          * @return void
2858          */
2859         public function testApiFrPhotoCreateUpdateWithUpdate()
2860         {
2861                 $this->markTestIncomplete('We need to create a dataset for this');
2862         }
2863
2864         /**
2865          * Test the api_fr_photo_create_update() function with an uploaded file.
2866          *
2867          * @return void
2868          */
2869         public function testApiFrPhotoCreateUpdateWithFile()
2870         {
2871                 $this->markTestIncomplete();
2872         }
2873
2874         /**
2875          * Test the api_fr_photo_detail() function.
2876          *
2877          * @return void
2878          */
2879         public function testApiFrPhotoDetail()
2880         {
2881                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2882                 api_fr_photo_detail('json');
2883         }
2884
2885         /**
2886          * Test the api_fr_photo_detail() function without an authenticated user.
2887          *
2888          * @return void
2889          */
2890         public function testApiFrPhotoDetailWithoutAuthenticatedUser()
2891         {
2892                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2893                 BasicAuth::setCurrentUserID();
2894                 $_SESSION['authenticated'] = false;
2895                 api_fr_photo_detail('json');
2896         }
2897
2898         /**
2899          * Test the api_fr_photo_detail() function with a photo ID.
2900          *
2901          * @return void
2902          */
2903         public function testApiFrPhotoDetailWithPhotoId()
2904         {
2905                 $this->expectException(\Friendica\Network\HTTPException\NotFoundException::class);
2906                 $_REQUEST['photo_id'] = 1;
2907                 api_fr_photo_detail('json');
2908         }
2909
2910         /**
2911          * Test the api_fr_photo_detail() function with a correct photo ID.
2912          *
2913          * @return void
2914          */
2915         public function testApiFrPhotoDetailCorrectPhotoId()
2916         {
2917                 $this->markTestIncomplete('We need to create a dataset for this.');
2918         }
2919
2920         /**
2921          * Test the api_account_update_profile_image() function.
2922          *
2923          * @return void
2924          */
2925         public function testApiAccountUpdateProfileImage()
2926         {
2927                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2928                 api_account_update_profile_image('json');
2929         }
2930
2931         /**
2932          * Test the api_account_update_profile_image() function without an authenticated user.
2933          *
2934          * @return void
2935          */
2936         public function testApiAccountUpdateProfileImageWithoutAuthenticatedUser()
2937         {
2938                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
2939                 BasicAuth::setCurrentUserID();
2940                 $_SESSION['authenticated'] = false;
2941                 api_account_update_profile_image('json');
2942         }
2943
2944         /**
2945          * Test the api_account_update_profile_image() function with an uploaded file.
2946          *
2947          * @return void
2948          */
2949         public function testApiAccountUpdateProfileImageWithUpload()
2950         {
2951                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
2952                 $this->markTestIncomplete();
2953         }
2954
2955
2956         /**
2957          * Test the api_account_update_profile() function.
2958          *
2959          * @return void
2960          */
2961         public function testApiAccountUpdateProfile()
2962         {
2963                 /*
2964                 $_POST['name']        = 'new_name';
2965                 $_POST['description'] = 'new_description';
2966                 $result               = api_account_update_profile('json');
2967                 // We can't use assertSelfUser() here because the user object is missing some properties.
2968                 self::assertEquals($this->selfUser['id'], $result['user']['cid']);
2969                 self::assertEquals('DFRN', $result['user']['location']);
2970                 self::assertEquals($this->selfUser['nick'], $result['user']['screen_name']);
2971                 self::assertEquals('new_name', $result['user']['name']);
2972                 self::assertEquals('new_description', $result['user']['description']);
2973                 */
2974         }
2975
2976         /**
2977          * Test the check_acl_input() function.
2978          *
2979          * @return void
2980          */
2981         public function testCheckAclInput()
2982         {
2983                 $result = check_acl_input('<aclstring>', BaseApi::getCurrentUserID());
2984                 // Where does this result come from?
2985                 self::assertEquals(1, $result);
2986         }
2987
2988         /**
2989          * Test the check_acl_input() function with an empty ACL string.
2990          *
2991          * @return void
2992          */
2993         public function testCheckAclInputWithEmptyAclString()
2994         {
2995                 $result = check_acl_input(' ', BaseApi::getCurrentUserID());
2996                 self::assertFalse($result);
2997         }
2998
2999         /**
3000          * Test the save_media_to_database() function.
3001          *
3002          * @return void
3003          */
3004         public function testSaveMediaToDatabase()
3005         {
3006                 $this->markTestIncomplete();
3007         }
3008
3009         /**
3010          * Test the post_photo_item() function.
3011          *
3012          * @return void
3013          */
3014         public function testPostPhotoItem()
3015         {
3016                 $this->markTestIncomplete();
3017         }
3018
3019         /**
3020          * Test the prepare_photo_data() function.
3021          *
3022          * @return void
3023          */
3024         public function testPreparePhotoData()
3025         {
3026                 $this->markTestIncomplete();
3027         }
3028
3029         /**
3030          * Test the api_share_as_retweet() function with a valid item.
3031          *
3032          * @return void
3033          */
3034         public function testApiShareAsRetweetWithValidItem()
3035         {
3036                 $this->markTestIncomplete();
3037         }
3038
3039         /**
3040          * Test the api_in_reply_to() function with a valid item.
3041          *
3042          * @return void
3043          */
3044         public function testApiInReplyToWithValidItem()
3045         {
3046                 $this->markTestIncomplete();
3047         }
3048
3049         /**
3050          * Test the api_clean_plain_items() function.
3051          *
3052          * @return void
3053          */
3054         public function testApiCleanPlainItems()
3055         {
3056                 $_REQUEST['include_entities'] = 'true';
3057                 $result                       = api_clean_plain_items('some_text [url="some_url"]some_text[/url]');
3058                 self::assertEquals('some_text [url="some_url"]"some_url"[/url]', $result);
3059         }
3060
3061         /**
3062          * Test the api_best_nickname() function with contacts.
3063          *
3064          * @return void
3065          */
3066         public function testApiBestNicknameWithContacts()
3067         {
3068                 $this->markTestIncomplete();
3069         }
3070
3071         /**
3072          * Test the api_friendica_group_show() function.
3073          *
3074          * @return void
3075          */
3076         public function testApiFriendicaGroupShow()
3077         {
3078                 $this->markTestIncomplete();
3079         }
3080
3081         /**
3082          * Test the api_friendica_group_delete() function.
3083          *
3084          * @return void
3085          */
3086         public function testApiFriendicaGroupDelete()
3087         {
3088                 $this->markTestIncomplete();
3089         }
3090
3091         /**
3092          * Test the api_lists_destroy() function.
3093          *
3094          * @return void
3095          */
3096         public function testApiListsDestroy()
3097         {
3098                 $this->markTestIncomplete();
3099         }
3100
3101         /**
3102          * Test the group_create() function.
3103          *
3104          * @return void
3105          */
3106         public function testGroupCreate()
3107         {
3108                 $this->markTestIncomplete();
3109         }
3110
3111         /**
3112          * Test the api_friendica_group_create() function.
3113          *
3114          * @return void
3115          */
3116         public function testApiFriendicaGroupCreate()
3117         {
3118                 $this->markTestIncomplete();
3119         }
3120
3121         /**
3122          * Test the api_lists_create() function.
3123          *
3124          * @return void
3125          */
3126         public function testApiListsCreate()
3127         {
3128                 $this->markTestIncomplete();
3129         }
3130
3131         /**
3132          * Test the api_friendica_group_update() function.
3133          *
3134          * @return void
3135          */
3136         public function testApiFriendicaGroupUpdate()
3137         {
3138                 $this->markTestIncomplete();
3139         }
3140
3141         /**
3142          * Test the api_lists_update() function.
3143          *
3144          * @return void
3145          */
3146         public function testApiListsUpdate()
3147         {
3148                 $this->markTestIncomplete();
3149         }
3150
3151         /**
3152          * Test the api_friendica_activity() function.
3153          *
3154          * @return void
3155          */
3156         public function testApiFriendicaActivity()
3157         {
3158                 $this->markTestIncomplete();
3159         }
3160
3161         /**
3162          * Test the api_friendica_notification_seen() function.
3163          *
3164          * @return void
3165          */
3166         public function testApiFriendicaNotificationSeen()
3167         {
3168                 $this->markTestIncomplete();
3169         }
3170
3171         /**
3172          * Test the api_friendica_direct_messages_setseen() function.
3173          *
3174          * @return void
3175          */
3176         public function testApiFriendicaDirectMessagesSetseen()
3177         {
3178                 $this->markTestIncomplete();
3179         }
3180
3181         /**
3182          * Test the api_friendica_direct_messages_search() function.
3183          *
3184          * @return void
3185          */
3186         public function testApiFriendicaDirectMessagesSearch()
3187         {
3188                 $this->markTestIncomplete();
3189         }
3190 }