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