tests/src/Core/StorageManagerTest.php

   1 <?php
   2
   3 namespace Friendica\Test\src\Core;
   4
   5 use Dice\Dice;
   6 use Friendica\Core\Config\IConfiguration;
   7 use Friendica\Core\Config\PreloadConfiguration;
   8 use Friendica\Core\Hook;
   9 use Friendica\Core\L10n\L10n;
  10 use Friendica\Core\Session\ISession;
  11 use Friendica\Core\StorageManager;
  12 use Friendica\Database\Database;
  13 use Friendica\DI;
  14 use Friendica\Factory\ConfigFactory;
  15 use Friendica\Model\Config\Config;
  16 use Friendica\Model\Storage;
  17 use Friendica\Core\Session;
  18 use Friendica\Test\DatabaseTest;
  19 use Friendica\Test\Util\Database\StaticDatabase;
  20 use Friendica\Test\Util\VFSTrait;
  21 use Friendica\Util\ConfigFileLoader;
  22 use Friendica\Util\Profiler;
  23 use Psr\Log\LoggerInterface;
  24 use Psr\Log\NullLogger;
  25 use Friendica\Test\Util\SampleStorageBackend;
  26
  27 /**
  28  * @todo Rework Hook:: methods to dynamic to remove the separated process annotation
  29  *
  30  * @runTestsInSeparateProcesses
  31  */
  32 class StorageManagerTest extends DatabaseTest
  33 {
  34         /** @var Database */
  35         private $dba;
  36         /** @var IConfiguration */
  37         private $config;
  38         /** @var LoggerInterface */
  39         private $logger;
  40         /** @var L10n */
  41         private $l10n;
  42
  43         use VFSTrait;
  44
  45         public function setUp()
  46         {
  47                 parent::setUp();
  48
  49                 $this->setUpVfsDir();
  50
  51                 $this->logger = new NullLogger();
  52
  53                 $profiler = \Mockery::mock(Profiler::class);
  54                 $profiler->shouldReceive('saveTimestamp')->withAnyArgs()->andReturn(true);
  55
  56                 // load real config to avoid mocking every config-entry which is related to the Database class
  57                 $configFactory = new ConfigFactory();
  58                 $loader        = new ConfigFileLoader($this->root->url());
  59                 $configCache   = $configFactory->createCache($loader);
  60
  61                 $this->dba = new StaticDatabase($configCache, $profiler, $this->logger);
  62
  63                 $configModel  = new Config($this->dba);
  64                 $this->config = new PreloadConfiguration($configCache, $configModel);
  65
  66                 $this->l10n = \Mockery::mock(L10n::class);
  67         }
  68
  69         /**
  70          * Test plain instancing first
  71          */
  72         public function testInstance()
  73         {
  74                 $storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
  75
  76                 $this->assertInstanceOf(StorageManager::class, $storageManager);
  77         }
  78
  79         public function dataStorages()
  80         {
  81                 return [
  82                         'empty'          => [
  83                                 'name'        => '',
  84                                 'assert'      => null,
  85                                 'assertName'  => '',
  86                                 'userBackend' => false,
  87                         ],
  88                         'database'       => [
  89                                 'name'        => Storage\Database::NAME,
  90                                 'assert'      => Storage\Database::class,
  91                                 'assertName'  => Storage\Database::NAME,
  92                                 'userBackend' => true,
  93                         ],
  94                         'filesystem'     => [
  95                                 'name'        => Storage\Filesystem::NAME,
  96                                 'assert'      => Storage\Filesystem::class,
  97                                 'assertName'  => Storage\Filesystem::NAME,
  98                                 'userBackend' => true,
  99                         ],
 100                         'systemresource' => [
 101                                 'name'        => Storage\SystemResource::NAME,
 102                                 'assert'      => Storage\SystemResource::class,
 103                                 'assertName'  => Storage\SystemResource::NAME,
 104                                 // false here, because SystemResource isn't meant to be a user backend,
 105                                 // it's for system resources only
 106                                 'userBackend' => false,
 107                         ],
 108                         'invalid'        => [
 109                                 'name'        => 'invalid',
 110                                 'assert'      => null,
 111                                 'assertName'  => '',
 112                                 'userBackend' => false,
 113                         ],
 114                 ];
 115         }
 116
 117         /**
 118          * Test the getByName() method
 119          *
 120          * @dataProvider dataStorages
 121          */
 122         public function testGetByName($name, $assert, $assertName, $userBackend)
 123         {
 124                 $storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
 125
 126                 $storage = $storageManager->getByName($name, $userBackend);
 127
 128                 if (!empty($assert)) {
 129                         $this->assertInstanceOf(Storage\IStorage::class, $storage);
 130                         $this->assertInstanceOf($assert, $storage);
 131                         $this->assertEquals($name, $storage::getName());
 132                 } else {
 133                         $this->assertNull($storage);
 134                 }
 135                 $this->assertEquals($assertName, $storage);
 136         }
 137
 138         /**
 139          * Test the isValidBackend() method
 140          *
 141          * @dataProvider dataStorages
 142          */
 143         public function testIsValidBackend($name, $assert, $assertName, $userBackend)
 144         {
 145                 $storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
 146
 147                 $this->assertEquals($userBackend, $storageManager->isValidBackend($name));
 148         }
 149
 150         /**
 151          * Test the method listBackends() with default setting
 152          */
 153         public function testListBackends()
 154         {
 155                 $storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
 156
 157                 $this->assertEquals(StorageManager::DEFAULT_BACKENDS, $storageManager->listBackends());
 158         }
 159
 160         /**
 161          * Test the method getBackend()
 162          *
 163          * @dataProvider dataStorages
 164          */
 165         public function testGetBackend($name, $assert, $assertName, $userBackend)
 166         {
 167                 $storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
 168
 169                 $this->assertNull($storageManager->getBackend());
 170
 171                 if ($userBackend) {
 172                         $storageManager->setBackend($name);
 173
 174                         $this->assertInstanceOf($assert, $storageManager->getBackend());
 175                 }
 176         }
 177
 178         /**
 179          * Test the method getBackend() with a pre-configured backend
 180          *
 181          * @dataProvider dataStorages
 182          */
 183         public function testPresetBackend($name, $assert, $assertName, $userBackend)
 184         {
 185                 $this->config->set('storage', 'name', $name);
 186
 187                 $storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
 188
 189                 if ($userBackend) {
 190                         $this->assertInstanceOf($assert, $storageManager->getBackend());
 191                 } else {
 192                         $this->assertNull($storageManager->getBackend());
 193                 }
 194         }
 195
 196         /**
 197          * Tests the register and unregister methods for a new backend storage class
 198          *
 199          * Uses a sample storage for testing
 200          *
 201          * @see SampleStorageBackend
 202          */
 203         public function testRegisterUnregisterBackends()
 204         {
 205                 /// @todo Remove dice once "Hook" is dynamic and mockable
 206                 $dice   = (new Dice())
 207                         ->addRules(include __DIR__ . '/../../../static/dependencies.config.php')
 208                         ->addRule(Database::class, ['instanceOf' => StaticDatabase::class, 'shared' => true])
 209                         ->addRule(ISession::class, ['instanceOf' => Session\Memory::class, 'shared' => true, 'call' => null]);
 210                 DI::init($dice);
 211
 212                 $storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
 213
 214                 $this->assertTrue($storageManager->register(SampleStorageBackend::class));
 215
 216                 $this->assertEquals(array_merge(StorageManager::DEFAULT_BACKENDS, [
 217                         SampleStorageBackend::getName() => SampleStorageBackend::class,
 218                 ]), $storageManager->listBackends());
 219                 $this->assertEquals(array_merge(StorageManager::DEFAULT_BACKENDS, [
 220                         SampleStorageBackend::getName() => SampleStorageBackend::class,
 221                 ]), $this->config->get('storage', 'backends'));
 222
 223                 // inline call to register own class as hook (testing purpose only)
 224                 SampleStorageBackend::registerHook();
 225                 Hook::loadHooks();
 226
 227                 $this->assertTrue($storageManager->setBackend(SampleStorageBackend::NAME));
 228                 $this->assertEquals(SampleStorageBackend::NAME, $this->config->get('storage', 'name'));
 229
 230                 $this->assertInstanceOf(SampleStorageBackend::class, $storageManager->getBackend());
 231
 232                 $this->assertTrue($storageManager->unregister(SampleStorageBackend::class));
 233                 $this->assertEquals(StorageManager::DEFAULT_BACKENDS, $this->config->get('storage', 'backends'));
 234                 $this->assertEquals(StorageManager::DEFAULT_BACKENDS, $storageManager->listBackends());
 235
 236                 $this->assertNull($storageManager->getBackend());
 237                 $this->assertNull($this->config->get('storage', 'name'));
 238         }
 239
 240         /**
 241          * Test moving data to a new storage (currently testing db & filesystem)
 242          *
 243          * @dataProvider dataStorages
 244          */
 245         public function testMoveStorage($name, $assert, $assertName, $userBackend)
 246         {
 247                 if (!$userBackend) {
 248                         return;
 249                 }
 250
 251                 $this->loadFixture(__DIR__ . '/../../datasets/storage/database.fixture.php', $this->dba);
 252
 253                 $storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
 254                 $storage = $storageManager->getByName($name);
 255                 $storageManager->move($storage);
 256
 257                 $photos = $this->dba->select('photo', ['backend-ref', 'backend-class', 'id', 'data']);
 258
 259                 while ($photo = $this->dba->fetch($photos)) {
 260
 261                         $this->assertEmpty($photo['data']);
 262
 263                         $storage = $storageManager->getByName($photo['backend-class']);
 264                         $data = $storage->get($photo['backend-ref']);
 265
 266                         $this->assertNotEmpty($data);
 267                 }
 268         }
 269 }