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_format_messages() function.
 840          *
 841          * @return void
 842          */
 843         public function testApiFormatMessages()
 844         {
 845                 $result = api_format_messages(
 846                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
 847                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
 848                         ['id' => 3, 'uri-id' => 2, 'screen_name' => 'sender_name']
 849                 );
 850                 self::assertEquals('item_title' . "\n" . 'item_body', $result['text']);
 851                 self::assertEquals(1, $result['id']);
 852                 self::assertEquals(2, $result['recipient_id']);
 853                 self::assertEquals(3, $result['sender_id']);
 854                 self::assertEquals('recipient_name', $result['recipient_screen_name']);
 855                 self::assertEquals('sender_name', $result['sender_screen_name']);
 856         }
 857
 858         /**
 859          * Test the api_format_messages() function with HTML.
 860          *
 861          * @return void
 862          */
 863         public function testApiFormatMessagesWithHtmlText()
 864         {
 865                 $_GET['getText'] = 'html';
 866                 $result          = api_format_messages(
 867                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
 868                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
 869                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
 870                 );
 871                 self::assertEquals('item_title', $result['title']);
 872                 self::assertEquals('<strong>item_body</strong>', $result['text']);
 873         }
 874
 875         /**
 876          * Test the api_format_messages() function with plain text.
 877          *
 878          * @return void
 879          */
 880         public function testApiFormatMessagesWithPlainText()
 881         {
 882                 $_GET['getText'] = 'plain';
 883                 $result          = api_format_messages(
 884                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
 885                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
 886                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
 887                 );
 888                 self::assertEquals('item_title', $result['title']);
 889                 self::assertEquals('item_body', $result['text']);
 890         }
 891
 892         /**
 893          * Test the api_format_messages() function with the getUserObjects GET parameter set to false.
 894          *
 895          * @return void
 896          */
 897         public function testApiFormatMessagesWithoutUserObjects()
 898         {
 899                 $_GET['getUserObjects'] = 'false';
 900                 $result                 = api_format_messages(
 901                         ['id' => 1, 'uri-id' => 1, 'title' => 'item_title', 'body' => '[b]item_body[/b]'],
 902                         ['id' => 2, 'uri-id' => 2, 'screen_name' => 'recipient_name'],
 903                         ['id' => 3, 'uri-id' => 3, 'screen_name' => 'sender_name']
 904                 );
 905                 self::assertTrue(!isset($result['sender']));
 906                 self::assertTrue(!isset($result['recipient']));
 907         }
 908
 909         /**
 910          * Test the api_convert_item() function.
 911          *
 912          * @return void
 913          */
 914         public function testApiConvertItem()
 915         {
 916                 /*
 917                 $result = api_convert_item(
 918                         [
 919                                 'network' => 'feed',
 920                                 'title'   => 'item_title',
 921                                 'uri-id'  => 1,
 922                                 // We need a long string to test that it is correctly cut
 923                                 'body'    => 'perspiciatis impedit voluptatem quis molestiae ea qui ' .
 924                                                          'reiciendis dolorum aut ducimus sunt consequatur inventore dolor ' .
 925                                                          'officiis pariatur doloremque nemo culpa aut quidem qui dolore ' .
 926                                                          'laudantium atque commodi alias voluptatem non possimus aperiam ' .
 927                                                          'ipsum rerum consequuntur aut amet fugit quia aliquid praesentium ' .
 928                                                          'repellendus quibusdam et et inventore mollitia rerum sit autem ' .
 929                                                          'pariatur maiores ipsum accusantium perferendis vel sit possimus ' .
 930                                                          'veritatis nihil distinctio qui eum repellat officia illum quos ' .
 931                                                          'impedit quam iste esse unde qui suscipit aut facilis ut inventore ' .
 932                                                          'omnis exercitationem quo magnam consequatur maxime aut illum ' .
 933                                                          'soluta quaerat natus unde aspernatur et sed beatae nihil ullam ' .
 934                                                          'temporibus corporis ratione blanditiis perspiciatis impedit ' .
 935                                                          'voluptatem quis molestiae ea qui reiciendis dolorum aut ducimus ' .
 936                                                          'sunt consequatur inventore dolor officiis pariatur doloremque ' .
 937                                                          'nemo culpa aut quidem qui dolore laudantium atque commodi alias ' .
 938                                                          'voluptatem non possimus aperiam ipsum rerum consequuntur aut ' .
 939                                                          'amet fugit quia aliquid praesentium repellendus quibusdam et et ' .
 940                                                          'inventore mollitia rerum sit autem pariatur maiores ipsum accusantium ' .
 941                                                          'perferendis vel sit possimus veritatis nihil distinctio qui eum ' .
 942                                                          'repellat officia illum quos impedit quam iste esse unde qui ' .
 943                                                          'suscipit aut facilis ut inventore omnis exercitationem quo magnam ' .
 944                                                          'consequatur maxime aut illum soluta quaerat natus unde aspernatur ' .
 945                                                          'et sed beatae nihil ullam temporibus corporis ratione blanditiis',
 946                                 'plink'   => 'item_plink'
 947                         ]
 948                 );
 949                 self::assertStringStartsWith('item_title', $result['text']);
 950                 self::assertStringStartsWith('<h4>item_title</h4><br>perspiciatis impedit voluptatem', $result['html']);
 951                 */
 952         }
 953
 954         /**
 955          * Test the api_convert_item() function with an empty item body.
 956          *
 957          * @return void
 958          */
 959         public function testApiConvertItemWithoutBody()
 960         {
 961                 /*
 962                 $result = api_convert_item(
 963                         [
 964                                 'network' => 'feed',
 965                                 'title'   => 'item_title',
 966                                 'uri-id'  => -1,
 967                                 'body'    => '',
 968                                 'plink'   => 'item_plink'
 969                         ]
 970                 );
 971                 self::assertEquals("item_title", $result['text']);
 972                 self::assertEquals('<h4>item_title</h4><br>item_plink', $result['html']);
 973                 */
 974         }
 975
 976         /**
 977          * Test the api_convert_item() function with the title in the body.
 978          *
 979          * @return void
 980          */
 981         public function testApiConvertItemWithTitleInBody()
 982         {
 983                 /*
 984                 $result = api_convert_item(
 985                         [
 986                                 'title'  => 'item_title',
 987                                 'body'   => 'item_title item_body',
 988                                 'uri-id' => 1,
 989                         ]
 990                 );
 991                 self::assertEquals('item_title item_body', $result['text']);
 992                 self::assertEquals('<h4>item_title</h4><br>item_title item_body', $result['html']);
 993                 */
 994         }
 995
 996         /**
 997          * Test the api_get_attachments() function.
 998          *
 999          * @return void
1000          */
1001         public function testApiGetAttachments()
1002         {
1003                 // $body = 'body';
1004                 // self::assertEmpty(api_get_attachments($body, 0));
1005         }
1006
1007         /**
1008          * Test the api_get_attachments() function with an img tag.
1009          *
1010          * @return void
1011          */
1012         public function testApiGetAttachmentsWithImage()
1013         {
1014                 // $body = '[img]http://via.placeholder.com/1x1.png[/img]';
1015                 // self::assertIsArray(api_get_attachments($body, 0));
1016         }
1017
1018         /**
1019          * Test the api_get_attachments() function with an img tag and an AndStatus user agent.
1020          *
1021          * @return void
1022          */
1023         public function testApiGetAttachmentsWithImageAndAndStatus()
1024         {
1025                 // $_SERVER['HTTP_USER_AGENT'] = 'AndStatus';
1026                 // $body                       = '[img]http://via.placeholder.com/1x1.png[/img]';
1027                 // self::assertIsArray(api_get_attachments($body, 0));
1028         }
1029
1030         /**
1031          * Test the api_get_entitities() function.
1032          *
1033          * @return void
1034          */
1035         public function testApiGetEntitities()
1036         {
1037                 // $text = 'text';
1038                 // self::assertIsArray(api_get_entitities($text, 'bbcode', 0));
1039         }
1040
1041         /**
1042          * Test the api_get_entitities() function with the include_entities parameter.
1043          *
1044          * @return void
1045          */
1046         public function testApiGetEntititiesWithIncludeEntities()
1047         {
1048                 /*
1049                 $_REQUEST['include_entities'] = 'true';
1050                 $text                         = 'text';
1051                 $result                       = api_get_entitities($text, 'bbcode', 0);
1052                 self::assertIsArray($result['hashtags']);
1053                 self::assertIsArray($result['symbols']);
1054                 self::assertIsArray($result['urls']);
1055                 self::assertIsArray($result['user_mentions']);
1056                 */
1057         }
1058
1059         /**
1060          * Test the api_format_items_embeded_images() function.
1061          *
1062          * @return void
1063          */
1064         public function testApiFormatItemsEmbededImages()
1065         {
1066                 /*
1067                 self::assertEquals(
1068                         'text ' . DI::baseUrl() . '/display/item_guid',
1069                         api_format_items_embeded_images(['guid' => 'item_guid'], 'text data:image/foo')
1070                 );
1071                 */
1072         }
1073
1074         /**
1075          * Test the api_format_items_activities() function.
1076          *
1077          * @return void
1078          */
1079         public function testApiFormatItemsActivities()
1080         {
1081                 $item   = ['uid' => 0, 'uri-id' => 1];
1082                 $result = DI::friendicaActivities()->createFromUriId($item['uri-id'], $item['uid']);
1083                 self::assertArrayHasKey('like', $result);
1084                 self::assertArrayHasKey('dislike', $result);
1085                 self::assertArrayHasKey('attendyes', $result);
1086                 self::assertArrayHasKey('attendno', $result);
1087                 self::assertArrayHasKey('attendmaybe', $result);
1088         }
1089
1090         /**
1091          * Test the api_format_items_activities() function with an XML result.
1092          *
1093          * @return void
1094          */
1095         public function testApiFormatItemsActivitiesWithXml()
1096         {
1097                 $item   = ['uid' => 0, 'uri-id' => 1];
1098                 $result = DI::friendicaActivities()->createFromUriId($item['uri-id'], $item['uid'], 'xml');
1099                 self::assertArrayHasKey('friendica:like', $result);
1100                 self::assertArrayHasKey('friendica:dislike', $result);
1101                 self::assertArrayHasKey('friendica:attendyes', $result);
1102                 self::assertArrayHasKey('friendica:attendno', $result);
1103                 self::assertArrayHasKey('friendica:attendmaybe', $result);
1104         }
1105
1106         /**
1107          * Test the api_format_items() function.
1108          * @doesNotPerformAssertions
1109          */
1110         public function testApiFormatItems()
1111         {
1112                 /*
1113                 $items = Post::selectToArray([], ['uid' => 42]);
1114                 foreach ($items as $item) {
1115                         $status = api_format_item($item);
1116                         self::assertStatus($status);
1117                 }
1118                 */
1119         }
1120
1121         /**
1122          * Test the api_format_items() function with an XML result.
1123          * @doesNotPerformAssertions
1124          */
1125         public function testApiFormatItemsWithXml()
1126         {
1127                 /*
1128                 $items = Post::selectToArray([], ['uid' => 42]);
1129                 foreach ($items as $item) {
1130                         $status = api_format_item($item, 'xml');
1131                         self::assertStatus($status);
1132                 }
1133                 */
1134         }
1135
1136         /**
1137          * Test the api_lists_list() function.
1138          *
1139          * @return void
1140          */
1141         public function testApiListsList()
1142         {
1143                 $result = api_lists_list('json');
1144                 self::assertEquals(['lists_list' => []], $result);
1145         }
1146
1147         /**
1148          * Test the api_lists_ownerships() function.
1149          *
1150          * @return void
1151          */
1152         public function testApiListsOwnerships()
1153         {
1154                 $result = api_lists_ownerships('json');
1155                 foreach ($result['lists']['lists'] as $list) {
1156                         self::assertList($list);
1157                 }
1158         }
1159
1160         /**
1161          * Test the api_lists_ownerships() function without an authenticated user.
1162          *
1163          * @return void
1164          */
1165         public function testApiListsOwnershipsWithoutAuthenticatedUser()
1166         {
1167                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1168                 BasicAuth::setCurrentUserID();
1169                 $_SESSION['authenticated'] = false;
1170                 api_lists_ownerships('json');
1171         }
1172
1173         /**
1174          * Test the api_statuses_f() function.
1175          *
1176          * @return void
1177          */
1178         public function testApiStatusesFWithIncoming()
1179         {
1180                 // $result = api_statuses_f('incoming');
1181                 // self::assertArrayHasKey('user', $result);
1182         }
1183
1184
1185         /**
1186          * Test the api_direct_messages_new() function.
1187          *
1188          * @return void
1189          */
1190         public function testApiDirectMessagesNew()
1191         {
1192                 $result = api_direct_messages_new('json');
1193                 self::assertNull($result);
1194         }
1195
1196         /**
1197          * Test the api_direct_messages_new() function without an authenticated user.
1198          *
1199          * @return void
1200          */
1201         public function testApiDirectMessagesNewWithoutAuthenticatedUser()
1202         {
1203                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1204                 BasicAuth::setCurrentUserID();
1205                 $_SESSION['authenticated'] = false;
1206                 api_direct_messages_new('json');
1207         }
1208
1209         /**
1210          * Test the api_direct_messages_new() function with an user ID.
1211          *
1212          * @return void
1213          */
1214         public function testApiDirectMessagesNewWithUserId()
1215         {
1216                 $_POST['text']       = 'message_text';
1217                 $_REQUEST['user_id'] = $this->otherUser['id'];
1218                 $result           = api_direct_messages_new('json');
1219                 self::assertEquals(['direct_message' => ['error' => -1]], $result);
1220         }
1221
1222         /**
1223          * Test the api_direct_messages_new() function with a screen name.
1224          *
1225          * @return void
1226          */
1227         public function testApiDirectMessagesNewWithScreenName()
1228         {
1229                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1230                 $_POST['text']       = 'message_text';
1231                 $_REQUEST['user_id'] = $this->friendUser['id'];
1232                 $result              = api_direct_messages_new('json');
1233                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
1234                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
1235                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
1236         }
1237
1238         /**
1239          * Test the api_direct_messages_new() function with a title.
1240          *
1241          * @return void
1242          */
1243         public function testApiDirectMessagesNewWithTitle()
1244         {
1245                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1246                 $_POST['text']        = 'message_text';
1247                 $_REQUEST['user_id']  = $this->friendUser['id'];
1248                 $_REQUEST['title']    = 'message_title';
1249                 $result            = api_direct_messages_new('json');
1250                 self::assertStringContainsString('message_text', $result['direct_message']['text']);
1251                 self::assertStringContainsString('message_title', $result['direct_message']['text']);
1252                 self::assertEquals('selfcontact', $result['direct_message']['sender_screen_name']);
1253                 self::assertEquals(1, $result['direct_message']['friendica_seen']);
1254         }
1255
1256         /**
1257          * Test the api_direct_messages_new() function with an RSS result.
1258          *
1259          * @return void
1260          */
1261         public function testApiDirectMessagesNewWithRss()
1262         {
1263                 $this->app->setLoggedInUserNickname($this->selfUser['nick']);
1264                 $_POST['text']       = 'message_text';
1265                 $_REQUEST['user_id'] = $this->friendUser['id'];
1266                 $result              = api_direct_messages_new('rss');
1267                 self::assertXml($result, 'direct-messages');
1268         }
1269
1270         /**
1271          * Test the api_direct_messages_destroy() function.
1272          *
1273          * @return void
1274          */
1275         public function testApiDirectMessagesDestroy()
1276         {
1277                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1278                 api_direct_messages_destroy('json');
1279         }
1280
1281         /**
1282          * Test the api_direct_messages_destroy() function with the friendica_verbose GET param.
1283          *
1284          * @return void
1285          */
1286         public function testApiDirectMessagesDestroyWithVerbose()
1287         {
1288                 $_GET['friendica_verbose'] = 'true';
1289                 $result                    = api_direct_messages_destroy('json');
1290                 self::assertEquals(
1291                         [
1292                                 '$result' => [
1293                                         'result'  => 'error',
1294                                         'message' => 'message id or parenturi not specified'
1295                                 ]
1296                         ],
1297                         $result
1298                 );
1299         }
1300
1301         /**
1302          * Test the api_direct_messages_destroy() function without an authenticated user.
1303          *
1304          * @return void
1305          */
1306         public function testApiDirectMessagesDestroyWithoutAuthenticatedUser()
1307         {
1308                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1309                 BasicAuth::setCurrentUserID();
1310                 $_SESSION['authenticated'] = false;
1311                 api_direct_messages_destroy('json');
1312         }
1313
1314         /**
1315          * Test the api_direct_messages_destroy() function with a non-zero ID.
1316          *
1317          * @return void
1318          */
1319         public function testApiDirectMessagesDestroyWithId()
1320         {
1321                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1322                 $_REQUEST['id'] = 1;
1323                 api_direct_messages_destroy('json');
1324         }
1325
1326         /**
1327          * Test the api_direct_messages_destroy() with a non-zero ID and the friendica_verbose GET param.
1328          *
1329          * @return void
1330          */
1331         public function testApiDirectMessagesDestroyWithIdAndVerbose()
1332         {
1333                 $_REQUEST['id']                  = 1;
1334                 $_REQUEST['friendica_parenturi'] = 'parent_uri';
1335                 $_GET['friendica_verbose']       = 'true';
1336                 $result                          = api_direct_messages_destroy('json');
1337                 self::assertEquals(
1338                         [
1339                                 '$result' => [
1340                                         'result'  => 'error',
1341                                         'message' => 'message id not in database'
1342                                 ]
1343                         ],
1344                         $result
1345                 );
1346         }
1347
1348         /**
1349          * Test the api_direct_messages_destroy() function with a non-zero ID.
1350          *
1351          * @return void
1352          */
1353         public function testApiDirectMessagesDestroyWithCorrectId()
1354         {
1355                 $this->markTestIncomplete('We need to add a dataset for this.');
1356         }
1357
1358         /**
1359          * Test the api_direct_messages_box() function.
1360          *
1361          * @return void
1362          */
1363         public function testApiDirectMessagesBoxWithSentbox()
1364         {
1365                 $_REQUEST['page']   = -1;
1366                 $_REQUEST['max_id'] = 10;
1367                 $result             = api_direct_messages_box('json', 'sentbox', 'false');
1368                 self::assertArrayHasKey('direct_message', $result);
1369         }
1370
1371         /**
1372          * Test the api_direct_messages_box() function.
1373          *
1374          * @return void
1375          */
1376         public function testApiDirectMessagesBoxWithConversation()
1377         {
1378                 $result = api_direct_messages_box('json', 'conversation', 'false');
1379                 self::assertArrayHasKey('direct_message', $result);
1380         }
1381
1382         /**
1383          * Test the api_direct_messages_box() function.
1384          *
1385          * @return void
1386          */
1387         public function testApiDirectMessagesBoxWithAll()
1388         {
1389                 $result = api_direct_messages_box('json', 'all', 'false');
1390                 self::assertArrayHasKey('direct_message', $result);
1391         }
1392
1393         /**
1394          * Test the api_direct_messages_box() function.
1395          *
1396          * @return void
1397          */
1398         public function testApiDirectMessagesBoxWithInbox()
1399         {
1400                 $result = api_direct_messages_box('json', 'inbox', 'false');
1401                 self::assertArrayHasKey('direct_message', $result);
1402         }
1403
1404         /**
1405          * Test the api_direct_messages_box() function.
1406          *
1407          * @return void
1408          */
1409         public function testApiDirectMessagesBoxWithVerbose()
1410         {
1411                 $result = api_direct_messages_box('json', 'sentbox', 'true');
1412                 self::assertEquals(
1413                         [
1414                                 '$result' => [
1415                                         'result'  => 'error',
1416                                         'message' => 'no mails available'
1417                                 ]
1418                         ],
1419                         $result
1420                 );
1421         }
1422
1423         /**
1424          * Test the api_direct_messages_box() function with a RSS result.
1425          *
1426          * @return void
1427          */
1428         public function testApiDirectMessagesBoxWithRss()
1429         {
1430                 $result = api_direct_messages_box('rss', 'sentbox', 'false');
1431                 self::assertXml($result, 'direct-messages');
1432         }
1433
1434         /**
1435          * Test the api_direct_messages_box() function without an authenticated user.
1436          *
1437          * @return void
1438          */
1439         public function testApiDirectMessagesBoxWithUnallowedUser()
1440         {
1441                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1442                 BasicAuth::setCurrentUserID();
1443                 api_direct_messages_box('json', 'sentbox', 'false');
1444         }
1445
1446         /**
1447          * Test the api_direct_messages_sentbox() function.
1448          *
1449          * @return void
1450          */
1451         public function testApiDirectMessagesSentbox()
1452         {
1453                 $result = api_direct_messages_sentbox('json');
1454                 self::assertArrayHasKey('direct_message', $result);
1455         }
1456
1457         /**
1458          * Test the api_direct_messages_inbox() function.
1459          *
1460          * @return void
1461          */
1462         public function testApiDirectMessagesInbox()
1463         {
1464                 $result = api_direct_messages_inbox('json');
1465                 self::assertArrayHasKey('direct_message', $result);
1466         }
1467
1468         /**
1469          * Test the api_direct_messages_all() function.
1470          *
1471          * @return void
1472          */
1473         public function testApiDirectMessagesAll()
1474         {
1475                 $result = api_direct_messages_all('json');
1476                 self::assertArrayHasKey('direct_message', $result);
1477         }
1478
1479         /**
1480          * Test the api_direct_messages_conversation() function.
1481          *
1482          * @return void
1483          */
1484         public function testApiDirectMessagesConversation()
1485         {
1486                 $result = api_direct_messages_conversation('json');
1487                 self::assertArrayHasKey('direct_message', $result);
1488         }
1489
1490         /**
1491          * Test the api_oauth_request_token() function.
1492          *
1493          * @return void
1494          */
1495         public function testApiOauthRequestToken()
1496         {
1497                 $this->markTestIncomplete('exit() kills phpunit as well');
1498         }
1499
1500         /**
1501          * Test the api_oauth_access_token() function.
1502          *
1503          * @return void
1504          */
1505         public function testApiOauthAccessToken()
1506         {
1507                 $this->markTestIncomplete('exit() kills phpunit as well');
1508         }
1509
1510         /**
1511          * Test the api_fr_photos_list() function.
1512          *
1513          * @return void
1514          */
1515         public function testApiFrPhotosList()
1516         {
1517                 $result = api_fr_photos_list('json');
1518                 self::assertArrayHasKey('photo', $result);
1519         }
1520
1521         /**
1522          * Test the api_fr_photos_list() function without an authenticated user.
1523          *
1524          * @return void
1525          */
1526         public function testApiFrPhotosListWithoutAuthenticatedUser()
1527         {
1528                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1529                 BasicAuth::setCurrentUserID();
1530                 $_SESSION['authenticated'] = false;
1531                 api_fr_photos_list('json');
1532         }
1533
1534         /**
1535          * Test the api_fr_photo_create_update() function.
1536          */
1537         public function testApiFrPhotoCreateUpdate()
1538         {
1539                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1540                 api_fr_photo_create_update('json');
1541         }
1542
1543         /**
1544          * Test the api_fr_photo_create_update() function without an authenticated user.
1545          *
1546          * @return void
1547          */
1548         public function testApiFrPhotoCreateUpdateWithoutAuthenticatedUser()
1549         {
1550                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1551                 BasicAuth::setCurrentUserID();
1552                 $_SESSION['authenticated'] = false;
1553                 api_fr_photo_create_update('json');
1554         }
1555
1556         /**
1557          * Test the api_fr_photo_create_update() function with an album name.
1558          *
1559          * @return void
1560          */
1561         public function testApiFrPhotoCreateUpdateWithAlbum()
1562         {
1563                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1564                 $_REQUEST['album'] = 'album_name';
1565                 api_fr_photo_create_update('json');
1566         }
1567
1568         /**
1569          * Test the api_fr_photo_create_update() function with the update mode.
1570          *
1571          * @return void
1572          */
1573         public function testApiFrPhotoCreateUpdateWithUpdate()
1574         {
1575                 $this->markTestIncomplete('We need to create a dataset for this');
1576         }
1577
1578         /**
1579          * Test the api_fr_photo_create_update() function with an uploaded file.
1580          *
1581          * @return void
1582          */
1583         public function testApiFrPhotoCreateUpdateWithFile()
1584         {
1585                 $this->markTestIncomplete();
1586         }
1587
1588         /**
1589          * Test the api_fr_photo_detail() function.
1590          *
1591          * @return void
1592          */
1593         public function testApiFrPhotoDetail()
1594         {
1595                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1596                 api_fr_photo_detail('json');
1597         }
1598
1599         /**
1600          * Test the api_fr_photo_detail() function without an authenticated user.
1601          *
1602          * @return void
1603          */
1604         public function testApiFrPhotoDetailWithoutAuthenticatedUser()
1605         {
1606                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1607                 BasicAuth::setCurrentUserID();
1608                 $_SESSION['authenticated'] = false;
1609                 api_fr_photo_detail('json');
1610         }
1611
1612         /**
1613          * Test the api_fr_photo_detail() function with a photo ID.
1614          *
1615          * @return void
1616          */
1617         public function testApiFrPhotoDetailWithPhotoId()
1618         {
1619                 $this->expectException(\Friendica\Network\HTTPException\NotFoundException::class);
1620                 $_REQUEST['photo_id'] = 1;
1621                 api_fr_photo_detail('json');
1622         }
1623
1624         /**
1625          * Test the api_fr_photo_detail() function with a correct photo ID.
1626          *
1627          * @return void
1628          */
1629         public function testApiFrPhotoDetailCorrectPhotoId()
1630         {
1631                 $this->markTestIncomplete('We need to create a dataset for this.');
1632         }
1633
1634         /**
1635          * Test the api_account_update_profile_image() function.
1636          *
1637          * @return void
1638          */
1639         public function testApiAccountUpdateProfileImage()
1640         {
1641                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1642                 api_account_update_profile_image('json');
1643         }
1644
1645         /**
1646          * Test the api_account_update_profile_image() function without an authenticated user.
1647          *
1648          * @return void
1649          */
1650         public function testApiAccountUpdateProfileImageWithoutAuthenticatedUser()
1651         {
1652                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
1653                 BasicAuth::setCurrentUserID();
1654                 $_SESSION['authenticated'] = false;
1655                 api_account_update_profile_image('json');
1656         }
1657
1658         /**
1659          * Test the api_account_update_profile_image() function with an uploaded file.
1660          *
1661          * @return void
1662          */
1663         public function testApiAccountUpdateProfileImageWithUpload()
1664         {
1665                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
1666                 $this->markTestIncomplete();
1667         }
1668
1669         /**
1670          * Test the check_acl_input() function.
1671          *
1672          * @return void
1673          */
1674         public function testCheckAclInput()
1675         {
1676                 $result = check_acl_input('<aclstring>', BaseApi::getCurrentUserID());
1677                 // Where does this result come from?
1678                 self::assertEquals(1, $result);
1679         }
1680
1681         /**
1682          * Test the check_acl_input() function with an empty ACL string.
1683          *
1684          * @return void
1685          */
1686         public function testCheckAclInputWithEmptyAclString()
1687         {
1688                 $result = check_acl_input(' ', BaseApi::getCurrentUserID());
1689                 self::assertFalse($result);
1690         }
1691
1692         /**
1693          * Test the save_media_to_database() function.
1694          *
1695          * @return void
1696          */
1697         public function testSaveMediaToDatabase()
1698         {
1699                 $this->markTestIncomplete();
1700         }
1701
1702         /**
1703          * Test the post_photo_item() function.
1704          *
1705          * @return void
1706          */
1707         public function testPostPhotoItem()
1708         {
1709                 $this->markTestIncomplete();
1710         }
1711
1712         /**
1713          * Test the prepare_photo_data() function.
1714          *
1715          * @return void
1716          */
1717         public function testPreparePhotoData()
1718         {
1719                 $this->markTestIncomplete();
1720         }
1721
1722         /**
1723          * Test the api_share_as_retweet() function with a valid item.
1724          *
1725          * @return void
1726          */
1727         public function testApiShareAsRetweetWithValidItem()
1728         {
1729                 $this->markTestIncomplete();
1730         }
1731
1732         /**
1733          * Test the api_in_reply_to() function with a valid item.
1734          *
1735          * @return void
1736          */
1737         public function testApiInReplyToWithValidItem()
1738         {
1739                 $this->markTestIncomplete();
1740         }
1741
1742         /**
1743          * Test the api_clean_plain_items() function.
1744          *
1745          * @return void
1746          */
1747         public function testApiCleanPlainItems()
1748         {
1749                 $_REQUEST['include_entities'] = 'true';
1750                 $result                       = api_clean_plain_items('some_text [url="some_url"]some_text[/url]');
1751                 self::assertEquals('some_text [url="some_url"]"some_url"[/url]', $result);
1752         }
1753
1754         /**
1755          * Test the api_best_nickname() function with contacts.
1756          *
1757          * @return void
1758          */
1759         public function testApiBestNicknameWithContacts()
1760         {
1761                 $this->markTestIncomplete();
1762         }
1763
1764         /**
1765          * Test the api_friendica_group_show() function.
1766          *
1767          * @return void
1768          */
1769         public function testApiFriendicaGroupShow()
1770         {
1771                 $this->markTestIncomplete();
1772         }
1773
1774         /**
1775          * Test the api_friendica_group_delete() function.
1776          *
1777          * @return void
1778          */
1779         public function testApiFriendicaGroupDelete()
1780         {
1781                 $this->markTestIncomplete();
1782         }
1783
1784         /**
1785          * Test the api_lists_destroy() function.
1786          *
1787          * @return void
1788          */
1789         public function testApiListsDestroy()
1790         {
1791                 $this->markTestIncomplete();
1792         }
1793
1794         /**
1795          * Test the group_create() function.
1796          *
1797          * @return void
1798          */
1799         public function testGroupCreate()
1800         {
1801                 $this->markTestIncomplete();
1802         }
1803
1804         /**
1805          * Test the api_friendica_group_create() function.
1806          *
1807          * @return void
1808          */
1809         public function testApiFriendicaGroupCreate()
1810         {
1811                 $this->markTestIncomplete();
1812         }
1813
1814         /**
1815          * Test the api_lists_create() function.
1816          *
1817          * @return void
1818          */
1819         public function testApiListsCreate()
1820         {
1821                 $this->markTestIncomplete();
1822         }
1823
1824         /**
1825          * Test the api_friendica_group_update() function.
1826          *
1827          * @return void
1828          */
1829         public function testApiFriendicaGroupUpdate()
1830         {
1831                 $this->markTestIncomplete();
1832         }
1833
1834         /**
1835          * Test the api_lists_update() function.
1836          *
1837          * @return void
1838          */
1839         public function testApiListsUpdate()
1840         {
1841                 $this->markTestIncomplete();
1842         }
1843
1844         /**
1845          * Test the api_friendica_activity() function.
1846          *
1847          * @return void
1848          */
1849         public function testApiFriendicaActivity()
1850         {
1851                 $this->markTestIncomplete();
1852         }
1853
1854         /**
1855          * Test the api_friendica_notification_seen() function.
1856          *
1857          * @return void
1858          */
1859         public function testApiFriendicaNotificationSeen()
1860         {
1861                 $this->markTestIncomplete();
1862         }
1863
1864         /**
1865          * Test the api_friendica_direct_messages_setseen() function.
1866          *
1867          * @return void
1868          */
1869         public function testApiFriendicaDirectMessagesSetseen()
1870         {
1871                 $this->markTestIncomplete();
1872         }
1873
1874         /**
1875          * Test the api_friendica_direct_messages_search() function.
1876          *
1877          * @return void
1878          */
1879         public function testApiFriendicaDirectMessagesSearch()
1880         {
1881                 $this->markTestIncomplete();
1882         }
1883 }