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\BaseApi;
  12 use Friendica\Security\BasicAuth;
  13 use Friendica\Test\FixtureTest;
  14 use Friendica\Util\Arrays;
  15 use Friendica\Util\DateTimeFormat;
  16 use Monolog\Handler\TestHandler;
  17
  18 require_once __DIR__ . '/../../include/api.php';
  19
  20 /**
  21  * Tests for the API functions.
  22  *
  23  * Functions that use header() need to be tested in a separate process.
  24  * @see https://phpunit.de/manual/5.7/en/appendixes.annotations.html#appendixes.annotations.runTestsInSeparateProcesses
  25  *
  26  * @backupGlobals enabled
  27  */
  28 class ApiTest extends FixtureTest
  29 {
  30         /**
  31          * @var TestHandler Can handle log-outputs
  32          */
  33         protected $logOutput;
  34
  35         /** @var array */
  36         protected $selfUser;
  37         /** @var array */
  38         protected $friendUser;
  39         /** @var array */
  40         protected $otherUser;
  41
  42         protected $wrongUserId;
  43
  44         /** @var App */
  45         protected $app;
  46
  47         /** @var IManageConfigValues */
  48         protected $config;
  49
  50         /**
  51          * Create variables used by tests.
  52          */
  53         protected function setUp() : void
  54         {
  55                 global $API, $called_api;
  56                 $API = [];
  57                 $called_api = [];
  58
  59                 parent::setUp();
  60
  61                 /** @var IManageConfigValues $config */
  62                 $this->config = $this->dice->create(IManageConfigValues::class);
  63
  64                 $this->config->set('system', 'url', 'http://localhost');
  65                 $this->config->set('system', 'hostname', 'localhost');
  66                 $this->config->set('system', 'worker_dont_fork', true);
  67
  68                 // Default config
  69                 $this->config->set('config', 'hostname', 'localhost');
  70                 $this->config->set('system', 'throttle_limit_day', 100);
  71                 $this->config->set('system', 'throttle_limit_week', 100);
  72                 $this->config->set('system', 'throttle_limit_month', 100);
  73                 $this->config->set('system', 'theme', 'system_theme');
  74
  75
  76                 /** @var App app */
  77                 $this->app = DI::app();
  78
  79                 DI::args()->setArgc(1);
  80
  81                 // User data that the test database is populated with
  82                 $this->selfUser   = [
  83                         'id'   => 42,
  84                         'name' => 'Self contact',
  85                         'nick' => 'selfcontact',
  86                         'nurl' => 'http://localhost/profile/selfcontact'
  87                 ];
  88                 $this->friendUser = [
  89                         'id'   => 44,
  90                         'name' => 'Friend contact',
  91                         'nick' => 'friendcontact',
  92                         'nurl' => 'http://localhost/profile/friendcontact'
  93                 ];
  94                 $this->otherUser  = [
  95                         'id'   => 43,
  96                         'name' => 'othercontact',
  97                         'nick' => 'othercontact',
  98                         'nurl' => 'http://localhost/profile/othercontact'
  99                 ];
 100
 101                 // User ID that we know is not in the database
 102                 $this->wrongUserId = 666;
 103
 104                 DI::session()->start();
 105
 106                 // Most API require login so we force the session
 107                 $_SESSION = [
 108                         'authenticated' => true,
 109                         'uid'           => $this->selfUser['id']
 110                 ];
 111                 BasicAuth::setCurrentUserID($this->selfUser['id']);
 112         }
 113
 114         /**
 115          * Assert that a list array contains expected keys.
 116          *
 117          * @param array $list List array
 118          *
 119          * @return void
 120          */
 121         private function assertList(array $list = [])
 122         {
 123                 self::assertIsString($list['name']);
 124                 self::assertIsInt($list['id']);
 125                 self::assertIsString('string', $list['id_str']);
 126                 self::assertContains($list['mode'], ['public', 'private']);
 127                 // We could probably do more checks here.
 128         }
 129
 130         /**
 131          * Assert that the string is XML and contain the root element.
 132          *
 133          * @param string $result       XML string
 134          * @param string $root_element Root element name
 135          *
 136          * @return void
 137          */
 138         private function assertXml($result = '', $root_element = '')
 139         {
 140                 self::assertStringStartsWith('<?xml version="1.0"?>', $result);
 141                 self::assertStringContainsString('<' . $root_element, $result);
 142                 // We could probably do more checks here.
 143         }
 144
 145         /**
 146          * Test the api_user() function.
 147          *
 148          * @return void
 149          */
 150         public function testApiUser()
 151         {
 152                 self::assertEquals($this->selfUser['id'], BaseApi::getCurrentUserID());
 153         }
 154
 155
 156
 157         /**
 158          * Test the api_source() function.
 159          *
 160          * @return void
 161          */
 162         public function testApiSource()
 163         {
 164                 self::assertEquals('api', BasicAuth::getCurrentApplicationToken()['name']);
 165         }
 166
 167         /**
 168          * Test the api_source() function with a Twidere user agent.
 169          *
 170          * @return void
 171          */
 172         public function testApiSourceWithTwidere()
 173         {
 174                 $_SERVER['HTTP_USER_AGENT'] = 'Twidere';
 175                 self::assertEquals('Twidere', BasicAuth::getCurrentApplicationToken()['name']);
 176         }
 177
 178         /**
 179          * Test the api_source() function with a GET parameter.
 180          *
 181          * @return void
 182          */
 183         public function testApiSourceWithGet()
 184         {
 185                 $_REQUEST['source'] = 'source_name';
 186                 self::assertEquals('source_name', BasicAuth::getCurrentApplicationToken()['name']);
 187         }
 188
 189         /**
 190          * Test the api_date() function.
 191          *
 192          * @return void
 193          */
 194         public function testApiDate()
 195         {
 196                 self::assertEquals('Wed Oct 10 00:00:00 +0000 1990', DateTimeFormat::utc('1990-10-10', DateTimeFormat::API));
 197         }
 198
 199         /**
 200          * Test the api_register_func() function.
 201          *
 202          * @return void
 203          */
 204         public function testApiRegisterFunc()
 205         {
 206                 global $API;
 207                 self::assertNull(
 208                         api_register_func(
 209                                 'api_path',
 210                                 function () {
 211                                 },
 212                                 true,
 213                                 'method'
 214                         )
 215                 );
 216                 self::assertTrue(is_callable($API['api_path']['func']));
 217         }
 218
 219         /**
 220          * Test the BasicAuth::getCurrentUserID() function without any login.
 221          *
 222          * @runInSeparateProcess
 223          * @preserveGlobalState disabled
 224          * @preserveGlobalState disabled
 225          */
 226         public function testApiLoginWithoutLogin()
 227         {
 228                 BasicAuth::setCurrentUserID();
 229                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 230                 BasicAuth::getCurrentUserID(true);
 231         }
 232
 233         /**
 234          * Test the BasicAuth::getCurrentUserID() function with a bad login.
 235          *
 236          * @runInSeparateProcess
 237          * @preserveGlobalState disabled
 238          * @preserveGlobalState disabled
 239          */
 240         public function testApiLoginWithBadLogin()
 241         {
 242                 BasicAuth::setCurrentUserID();
 243                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 244                 $_SERVER['PHP_AUTH_USER'] = 'user@server';
 245                 BasicAuth::getCurrentUserID(true);
 246         }
 247
 248         /**
 249          * Test the BasicAuth::getCurrentUserID() function with oAuth.
 250          *
 251          * @return void
 252          */
 253         public function testApiLoginWithOauth()
 254         {
 255                 $this->markTestIncomplete('Can we test this easily?');
 256         }
 257
 258         /**
 259          * Test the BasicAuth::getCurrentUserID() function with authentication provided by an addon.
 260          *
 261          * @return void
 262          */
 263         public function testApiLoginWithAddonAuth()
 264         {
 265                 $this->markTestIncomplete('Can we test this easily?');
 266         }
 267
 268         /**
 269          * Test the BasicAuth::getCurrentUserID() function with a correct login.
 270          *
 271          * @runInSeparateProcess
 272          * @preserveGlobalState disabled
 273          * @doesNotPerformAssertions
 274          */
 275         public function testApiLoginWithCorrectLogin()
 276         {
 277                 BasicAuth::setCurrentUserID();
 278                 $_SERVER['PHP_AUTH_USER'] = 'Test user';
 279                 $_SERVER['PHP_AUTH_PW']   = 'password';
 280                 BasicAuth::getCurrentUserID(true);
 281         }
 282
 283         /**
 284          * Test the BasicAuth::getCurrentUserID() function with a remote user.
 285          *
 286          * @runInSeparateProcess
 287          * @preserveGlobalState disabled
 288          */
 289         public function testApiLoginWithRemoteUser()
 290         {
 291                 BasicAuth::setCurrentUserID();
 292                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 293                 $_SERVER['REDIRECT_REMOTE_USER'] = '123456dXNlcjpwYXNzd29yZA==';
 294                 BasicAuth::getCurrentUserID(true);
 295         }
 296
 297         /**
 298          * Test the api_call() function.
 299          *
 300          * @runInSeparateProcess
 301          * @preserveGlobalState disabled
 302          */
 303         public function testApiCall()
 304         {
 305                 global $API;
 306                 $API['api_path']           = [
 307                         'method' => 'method',
 308                         'func'   => function () {
 309                                 return ['data' => ['some_data']];
 310                         }
 311                 ];
 312                 $_SERVER['REQUEST_METHOD'] = 'method';
 313                 $_SERVER['QUERY_STRING'] = 'pagename=api_path';
 314                 $_GET['callback']          = 'callback_name';
 315
 316                 self::assertEquals(
 317                         'callback_name(["some_data"])',
 318                         api_call('api_path', 'json')
 319                 );
 320         }
 321
 322         /**
 323          * Test the api_call() function with the profiled enabled.
 324          *
 325          * @runInSeparateProcess
 326          * @preserveGlobalState disabled
 327          */
 328         public function testApiCallWithProfiler()
 329         {
 330                 global $API;
 331                 $API['api_path']           = [
 332                         'method' => 'method',
 333                         'func'   => function () {
 334                                 return ['data' => ['some_data']];
 335                         }
 336                 ];
 337
 338                 $_SERVER['REQUEST_METHOD'] = 'method';
 339                 $_SERVER['QUERY_STRING'] = 'pagename=api_path';
 340
 341                 $this->config->set('system', 'profiler', true);
 342                 $this->config->set('rendertime', 'callstack', true);
 343                 $this->app->callstack = [
 344                         'database'       => ['some_function' => 200],
 345                         'database_write' => ['some_function' => 200],
 346                         'cache'          => ['some_function' => 200],
 347                         'cache_write'    => ['some_function' => 200],
 348                         'network'        => ['some_function' => 200]
 349                 ];
 350
 351                 self::assertEquals(
 352                         '["some_data"]',
 353                         api_call('api_path', 'json')
 354                 );
 355         }
 356
 357         /**
 358          * Test the api_call() function with a JSON result.
 359          *
 360          * @runInSeparateProcess
 361          * @preserveGlobalState disabled
 362          */
 363         public function testApiCallWithJson()
 364         {
 365                 global $API;
 366                 $API['api_path']           = [
 367                         'method' => 'method',
 368                         'func'   => function () {
 369                                 return ['data' => ['some_data']];
 370                         }
 371                 ];
 372                 $_SERVER['REQUEST_METHOD'] = 'method';
 373                 $_SERVER['QUERY_STRING'] = 'pagename=api_path.json';
 374
 375                 self::assertEquals(
 376                         '["some_data"]',
 377                         api_call('api_path.json', 'json')
 378                 );
 379         }
 380
 381         /**
 382          * Test the api_call() function with an XML result.
 383          *
 384          * @runInSeparateProcess
 385          * @preserveGlobalState disabled
 386          */
 387         public function testApiCallWithXml()
 388         {
 389                 global $API;
 390                 $API['api_path']           = [
 391                         'method' => 'method',
 392                         'func'   => function () {
 393                                 return 'some_data';
 394                         }
 395                 ];
 396                 $_SERVER['REQUEST_METHOD'] = 'method';
 397                 $_SERVER['QUERY_STRING'] = 'pagename=api_path.xml';
 398
 399                 $args = DI::args()->determine($_SERVER, $_GET);
 400
 401                 self::assertEquals(
 402                         'some_data',
 403                         api_call('api_path.xml', 'xml')
 404                 );
 405         }
 406
 407         /**
 408          * Test the api_call() function with an RSS result.
 409          *
 410          * @runInSeparateProcess
 411          * @preserveGlobalState disabled
 412          */
 413         public function testApiCallWithRss()
 414         {
 415                 global $API;
 416                 $API['api_path']           = [
 417                         'method' => 'method',
 418                         'func'   => function () {
 419                                 return 'some_data';
 420                         }
 421                 ];
 422                 $_SERVER['REQUEST_METHOD'] = 'method';
 423                 $_SERVER['QUERY_STRING'] = 'pagename=api_path.rss';
 424
 425                 self::assertEquals(
 426                         '<?xml version="1.0" encoding="UTF-8"?>' . "\n" .
 427                         'some_data',
 428                         api_call('api_path.rss', 'rss')
 429                 );
 430         }
 431
 432         /**
 433          * Test the api_call() function with an Atom result.
 434          *
 435          * @runInSeparateProcess
 436          * @preserveGlobalState disabled
 437          */
 438         public function testApiCallWithAtom()
 439         {
 440                 global $API;
 441                 $API['api_path']           = [
 442                         'method' => 'method',
 443                         'func'   => function () {
 444                                 return 'some_data';
 445                         }
 446                 ];
 447                 $_SERVER['REQUEST_METHOD'] = 'method';
 448                 $_SERVER['QUERY_STRING'] = 'pagename=api_path.atom';
 449
 450                 self::assertEquals(
 451                         '<?xml version="1.0" encoding="UTF-8"?>' . "\n" .
 452                         'some_data',
 453                         api_call('api_path.atom', 'atom')
 454                 );
 455         }
 456
 457         /**
 458          * Test the api_rss_extra() function.
 459          *
 460          * @return void
 461          */
 462         public function testApiRssExtra()
 463         {
 464                 /*
 465                 $user_info = ['url' => 'user_url', 'lang' => 'en'];
 466                 $result    = api_rss_extra([], $user_info);
 467                 self::assertEquals($user_info, $result['$user']);
 468                 self::assertEquals($user_info['url'], $result['$rss']['alternate']);
 469                 self::assertArrayHasKey('self', $result['$rss']);
 470                 self::assertArrayHasKey('base', $result['$rss']);
 471                 self::assertArrayHasKey('updated', $result['$rss']);
 472                 self::assertArrayHasKey('atom_updated', $result['$rss']);
 473                 self::assertArrayHasKey('language', $result['$rss']);
 474                 self::assertArrayHasKey('logo', $result['$rss']);
 475                 */
 476         }
 477
 478         /**
 479          * Test the api_rss_extra() function without any user info.
 480          *
 481          * @return void
 482          */
 483         public function testApiRssExtraWithoutUserInfo()
 484         {
 485                 /*
 486                 $result = api_rss_extra([], null);
 487                 self::assertIsArray($result['$user']);
 488                 self::assertArrayHasKey('alternate', $result['$rss']);
 489                 self::assertArrayHasKey('self', $result['$rss']);
 490                 self::assertArrayHasKey('base', $result['$rss']);
 491                 self::assertArrayHasKey('updated', $result['$rss']);
 492                 self::assertArrayHasKey('atom_updated', $result['$rss']);
 493                 self::assertArrayHasKey('language', $result['$rss']);
 494                 self::assertArrayHasKey('logo', $result['$rss']);
 495                 */
 496         }
 497
 498         /**
 499          * Test the Arrays::walkRecursive() function.
 500          *
 501          * @return void
 502          */
 503         public function testApiWalkRecursive()
 504         {
 505                 $array = ['item1'];
 506                 self::assertEquals(
 507                         $array,
 508                         Arrays::walkRecursive(
 509                                 $array,
 510                                 function () {
 511                                         // Should we test this with a callback that actually does something?
 512                                         return true;
 513                                 }
 514                         )
 515                 );
 516         }
 517
 518         /**
 519          * Test the Arrays::walkRecursive() function with an array.
 520          *
 521          * @return void
 522          */
 523         public function testApiWalkRecursiveWithArray()
 524         {
 525                 $array = [['item1'], ['item2']];
 526                 self::assertEquals(
 527                         $array,
 528                         Arrays::walkRecursive(
 529                                 $array,
 530                                 function () {
 531                                         // Should we test this with a callback that actually does something?
 532                                         return true;
 533                                 }
 534                         )
 535                 );
 536         }
 537
 538
 539
 540         /**
 541          * Test the api_format_items_embeded_images() function.
 542          *
 543          * @return void
 544          */
 545         public function testApiFormatItemsEmbededImages()
 546         {
 547                 /*
 548                 self::assertEquals(
 549                         'text ' . DI::baseUrl() . '/display/item_guid',
 550                         api_format_items_embeded_images(['guid' => 'item_guid'], 'text data:image/foo')
 551                 );
 552                 */
 553         }
 554
 555         /**
 556          * Test the api_format_items() function.
 557          * @doesNotPerformAssertions
 558          */
 559         public function testApiFormatItems()
 560         {
 561                 /*
 562                 $items = Post::selectToArray([], ['uid' => 42]);
 563                 foreach ($items as $item) {
 564                         $status = api_format_item($item);
 565                         self::assertStatus($status);
 566                 }
 567                 */
 568         }
 569
 570         /**
 571          * Test the api_format_items() function with an XML result.
 572          * @doesNotPerformAssertions
 573          */
 574         public function testApiFormatItemsWithXml()
 575         {
 576                 /*
 577                 $items = Post::selectToArray([], ['uid' => 42]);
 578                 foreach ($items as $item) {
 579                         $status = api_format_item($item, 'xml');
 580                         self::assertStatus($status);
 581                 }
 582                 */
 583         }
 584
 585         /**
 586          * Test the api_lists_list() function.
 587          *
 588          * @return void
 589          */
 590         public function testApiListsList()
 591         {
 592                 $result = api_lists_list('json');
 593                 self::assertEquals(['lists_list' => []], $result);
 594         }
 595
 596         /**
 597          * Test the api_lists_ownerships() function.
 598          *
 599          * @return void
 600          */
 601         public function testApiListsOwnerships()
 602         {
 603                 $result = api_lists_ownerships('json');
 604                 foreach ($result['lists']['lists'] as $list) {
 605                         self::assertList($list);
 606                 }
 607         }
 608
 609         /**
 610          * Test the api_lists_ownerships() function without an authenticated user.
 611          *
 612          * @return void
 613          */
 614         public function testApiListsOwnershipsWithoutAuthenticatedUser()
 615         {
 616                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 617                 BasicAuth::setCurrentUserID();
 618                 $_SESSION['authenticated'] = false;
 619                 api_lists_ownerships('json');
 620         }
 621
 622         /**
 623          * Test the api_statuses_f() function.
 624          *
 625          * @return void
 626          */
 627         public function testApiStatusesFWithIncoming()
 628         {
 629                 // $result = api_statuses_f('incoming');
 630                 // self::assertArrayHasKey('user', $result);
 631         }
 632
 633         /**
 634          * Test the api_fr_photos_list() function.
 635          *
 636          * @return void
 637          */
 638         public function testApiFrPhotosList()
 639         {
 640                 $result = api_fr_photos_list('json');
 641                 self::assertArrayHasKey('photo', $result);
 642         }
 643
 644         /**
 645          * Test the api_fr_photos_list() function without an authenticated user.
 646          *
 647          * @return void
 648          */
 649         public function testApiFrPhotosListWithoutAuthenticatedUser()
 650         {
 651                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 652                 BasicAuth::setCurrentUserID();
 653                 $_SESSION['authenticated'] = false;
 654                 api_fr_photos_list('json');
 655         }
 656
 657         /**
 658          * Test the api_fr_photo_create_update() function.
 659          */
 660         public function testApiFrPhotoCreateUpdate()
 661         {
 662                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
 663                 api_fr_photo_create_update('json');
 664         }
 665
 666         /**
 667          * Test the api_fr_photo_create_update() function without an authenticated user.
 668          *
 669          * @return void
 670          */
 671         public function testApiFrPhotoCreateUpdateWithoutAuthenticatedUser()
 672         {
 673                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 674                 BasicAuth::setCurrentUserID();
 675                 $_SESSION['authenticated'] = false;
 676                 api_fr_photo_create_update('json');
 677         }
 678
 679         /**
 680          * Test the api_fr_photo_create_update() function with an album name.
 681          *
 682          * @return void
 683          */
 684         public function testApiFrPhotoCreateUpdateWithAlbum()
 685         {
 686                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
 687                 $_REQUEST['album'] = 'album_name';
 688                 api_fr_photo_create_update('json');
 689         }
 690
 691         /**
 692          * Test the api_fr_photo_create_update() function with the update mode.
 693          *
 694          * @return void
 695          */
 696         public function testApiFrPhotoCreateUpdateWithUpdate()
 697         {
 698                 $this->markTestIncomplete('We need to create a dataset for this');
 699         }
 700
 701         /**
 702          * Test the api_fr_photo_create_update() function with an uploaded file.
 703          *
 704          * @return void
 705          */
 706         public function testApiFrPhotoCreateUpdateWithFile()
 707         {
 708                 $this->markTestIncomplete();
 709         }
 710
 711         /**
 712          * Test the api_fr_photo_detail() function.
 713          *
 714          * @return void
 715          */
 716         public function testApiFrPhotoDetail()
 717         {
 718                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
 719                 api_fr_photo_detail('json');
 720         }
 721
 722         /**
 723          * Test the api_fr_photo_detail() function without an authenticated user.
 724          *
 725          * @return void
 726          */
 727         public function testApiFrPhotoDetailWithoutAuthenticatedUser()
 728         {
 729                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 730                 BasicAuth::setCurrentUserID();
 731                 $_SESSION['authenticated'] = false;
 732                 api_fr_photo_detail('json');
 733         }
 734
 735         /**
 736          * Test the api_fr_photo_detail() function with a photo ID.
 737          *
 738          * @return void
 739          */
 740         public function testApiFrPhotoDetailWithPhotoId()
 741         {
 742                 $this->expectException(\Friendica\Network\HTTPException\NotFoundException::class);
 743                 $_REQUEST['photo_id'] = 1;
 744                 api_fr_photo_detail('json');
 745         }
 746
 747         /**
 748          * Test the api_fr_photo_detail() function with a correct photo ID.
 749          *
 750          * @return void
 751          */
 752         public function testApiFrPhotoDetailCorrectPhotoId()
 753         {
 754                 $this->markTestIncomplete('We need to create a dataset for this.');
 755         }
 756
 757         /**
 758          * Test the api_account_update_profile_image() function.
 759          *
 760          * @return void
 761          */
 762         public function testApiAccountUpdateProfileImage()
 763         {
 764                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
 765                 api_account_update_profile_image('json');
 766         }
 767
 768         /**
 769          * Test the api_account_update_profile_image() function without an authenticated user.
 770          *
 771          * @return void
 772          */
 773         public function testApiAccountUpdateProfileImageWithoutAuthenticatedUser()
 774         {
 775                 $this->expectException(\Friendica\Network\HTTPException\UnauthorizedException::class);
 776                 BasicAuth::setCurrentUserID();
 777                 $_SESSION['authenticated'] = false;
 778                 api_account_update_profile_image('json');
 779         }
 780
 781         /**
 782          * Test the api_account_update_profile_image() function with an uploaded file.
 783          *
 784          * @return void
 785          */
 786         public function testApiAccountUpdateProfileImageWithUpload()
 787         {
 788                 $this->expectException(\Friendica\Network\HTTPException\BadRequestException::class);
 789                 $this->markTestIncomplete();
 790         }
 791
 792         /**
 793          * Test the check_acl_input() function.
 794          *
 795          * @return void
 796          */
 797         public function testCheckAclInput()
 798         {
 799                 $result = check_acl_input('<aclstring>', BaseApi::getCurrentUserID());
 800                 // Where does this result come from?
 801                 self::assertEquals(1, $result);
 802         }
 803
 804         /**
 805          * Test the check_acl_input() function with an empty ACL string.
 806          *
 807          * @return void
 808          */
 809         public function testCheckAclInputWithEmptyAclString()
 810         {
 811                 $result = check_acl_input(' ', BaseApi::getCurrentUserID());
 812                 self::assertFalse($result);
 813         }
 814
 815         /**
 816          * Test the save_media_to_database() function.
 817          *
 818          * @return void
 819          */
 820         public function testSaveMediaToDatabase()
 821         {
 822                 $this->markTestIncomplete();
 823         }
 824
 825         /**
 826          * Test the post_photo_item() function.
 827          *
 828          * @return void
 829          */
 830         public function testPostPhotoItem()
 831         {
 832                 $this->markTestIncomplete();
 833         }
 834
 835         /**
 836          * Test the prepare_photo_data() function.
 837          *
 838          * @return void
 839          */
 840         public function testPreparePhotoData()
 841         {
 842                 $this->markTestIncomplete();
 843         }
 844
 845         /**
 846          * Test the api_clean_plain_items() function.
 847          *
 848          * @return void
 849          */
 850         public function testApiCleanPlainItems()
 851         {
 852                 //$_REQUEST['include_entities'] = 'true';
 853                 //$result                       = api_clean_plain_items('some_text [url="some_url"]some_text[/url]');
 854                 //self::assertEquals('some_text [url="some_url"]"some_url"[/url]', $result);
 855         }
 856
 857         /**
 858          * Test the api_friendica_group_show() function.
 859          *
 860          * @return void
 861          */
 862         public function testApiFriendicaGroupShow()
 863         {
 864                 $this->markTestIncomplete();
 865         }
 866
 867         /**
 868          * Test the api_lists_destroy() function.
 869          *
 870          * @return void
 871          */
 872         public function testApiListsDestroy()
 873         {
 874                 $this->markTestIncomplete();
 875         }
 876
 877         /**
 878          * Test the group_create() function.
 879          *
 880          * @return void
 881          */
 882         public function testGroupCreate()
 883         {
 884                 $this->markTestIncomplete();
 885         }
 886
 887         /**
 888          * Test the api_friendica_group_create() function.
 889          *
 890          * @return void
 891          */
 892         public function testApiFriendicaGroupCreate()
 893         {
 894                 $this->markTestIncomplete();
 895         }
 896
 897         /**
 898          * Test the api_lists_create() function.
 899          *
 900          * @return void
 901          */
 902         public function testApiListsCreate()
 903         {
 904                 $this->markTestIncomplete();
 905         }
 906
 907         /**
 908          * Test the api_lists_update() function.
 909          *
 910          * @return void
 911          */
 912         public function testApiListsUpdate()
 913         {
 914                 $this->markTestIncomplete();
 915         }
 916 }