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