nextcloud / server

tests/lib/Files/AppData/AppDataTest.php

Indentation +55 added lines, -55 removed lines

@@ -16,79 +16,79 @@
 use OCP\Files\SimpleFS\ISimpleFolder;
 
 class AppDataTest extends \Test\TestCase {
-	/** @var IRootFolder|\PHPUnit\Framework\MockObject\MockObject */
-	private $rootFolder;
+    /** @var IRootFolder|\PHPUnit\Framework\MockObject\MockObject */
+    private $rootFolder;
 
-	/** @var SystemConfig|\PHPUnit\Framework\MockObject\MockObject */
-	private $systemConfig;
+    /** @var SystemConfig|\PHPUnit\Framework\MockObject\MockObject */
+    private $systemConfig;
 
-	/** @var IAppData */
-	private $appData;
+    /** @var IAppData */
+    private $appData;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->rootFolder = $this->createMock(IRootFolder::class);
-		$this->systemConfig = $this->createMock(SystemConfig::class);
-		$this->appData = new AppData($this->rootFolder, $this->systemConfig, 'myApp');
+        $this->rootFolder = $this->createMock(IRootFolder::class);
+        $this->systemConfig = $this->createMock(SystemConfig::class);
+        $this->appData = new AppData($this->rootFolder, $this->systemConfig, 'myApp');
 
-		$this->systemConfig->expects($this->any())
-			->method('getValue')
-			->with('instanceid', null)
-			->willReturn('iid');
-	}
+        $this->systemConfig->expects($this->any())
+            ->method('getValue')
+            ->with('instanceid', null)
+            ->willReturn('iid');
+    }
 
-	private function setupAppFolder() {
-		$appFolder = $this->createMock(Folder::class);
+    private function setupAppFolder() {
+        $appFolder = $this->createMock(Folder::class);
 
-		$this->rootFolder->expects($this->any())
-			->method('get')
-			->with($this->equalTo('appdata_iid/myApp'))
-			->willReturn($appFolder);
+        $this->rootFolder->expects($this->any())
+            ->method('get')
+            ->with($this->equalTo('appdata_iid/myApp'))
+            ->willReturn($appFolder);
 
-		return $appFolder;
-	}
+        return $appFolder;
+    }
 
-	public function testGetFolder(): void {
-		$folder = $this->createMock(Folder::class);
+    public function testGetFolder(): void {
+        $folder = $this->createMock(Folder::class);
 
-		$this->rootFolder->expects($this->once())
-			->method('get')
-			->with($this->equalTo('appdata_iid/myApp/folder'))
-			->willReturn($folder);
+        $this->rootFolder->expects($this->once())
+            ->method('get')
+            ->with($this->equalTo('appdata_iid/myApp/folder'))
+            ->willReturn($folder);
 
-		$result = $this->appData->getFolder('folder');
-		$this->assertInstanceOf(ISimpleFolder::class, $result);
-	}
+        $result = $this->appData->getFolder('folder');
+        $this->assertInstanceOf(ISimpleFolder::class, $result);
+    }
 
-	public function testNewFolder(): void {
-		$appFolder = $this->setupAppFolder();
+    public function testNewFolder(): void {
+        $appFolder = $this->setupAppFolder();
 
-		$folder = $this->createMock(Folder::class);
+        $folder = $this->createMock(Folder::class);
 
-		$appFolder->expects($this->once())
-			->method('newFolder')
-			->with($this->equalTo('folder'))
-			->willReturn($folder);
+        $appFolder->expects($this->once())
+            ->method('newFolder')
+            ->with($this->equalTo('folder'))
+            ->willReturn($folder);
 
-		$result = $this->appData->newFolder('folder');
-		$this->assertInstanceOf(ISimpleFolder::class, $result);
-	}
+        $result = $this->appData->newFolder('folder');
+        $this->assertInstanceOf(ISimpleFolder::class, $result);
+    }
 
-	public function testGetDirectoryListing(): void {
-		$appFolder = $this->setupAppFolder();
+    public function testGetDirectoryListing(): void {
+        $appFolder = $this->setupAppFolder();
 
-		$file = $this->createMock(File::class);
-		$folder = $this->createMock(Folder::class);
-		$node = $this->createMock(Node::class);
+        $file = $this->createMock(File::class);
+        $folder = $this->createMock(Folder::class);
+        $node = $this->createMock(Node::class);
 
-		$appFolder->expects($this->once())
-			->method('getDirectoryListing')
-			->willReturn([$file, $folder, $node]);
+        $appFolder->expects($this->once())
+            ->method('getDirectoryListing')
+            ->willReturn([$file, $folder, $node]);
 
-		$result = $this->appData->getDirectoryListing();
+        $result = $this->appData->getDirectoryListing();
 
-		$this->assertCount(1, $result);
-		$this->assertInstanceOf(ISimpleFolder::class, $result[0]);
-	}
+        $this->assertCount(1, $result);
+        $this->assertInstanceOf(ISimpleFolder::class, $result[0]);
+    }
 }

tests/lib/Files/Mount/ObjectStorePreviewCacheMountProviderTest.php

Indentation +59 added lines, -59 removed lines

@@ -22,74 +22,74 @@
  * The DB permission is needed for the fake root storage initialization
  */
 class ObjectStorePreviewCacheMountProviderTest extends \Test\TestCase {
-	/** @var ObjectStorePreviewCacheMountProvider */
-	protected $provider;
+    /** @var ObjectStorePreviewCacheMountProvider */
+    protected $provider;
 
-	/** @var LoggerInterface|MockObject */
-	protected $logger;
-	/** @var IConfig|MockObject */
-	protected $config;
-	/** @var IStorageFactory|MockObject */
-	protected $loader;
+    /** @var LoggerInterface|MockObject */
+    protected $logger;
+    /** @var IConfig|MockObject */
+    protected $config;
+    /** @var IStorageFactory|MockObject */
+    protected $loader;
 
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->config = $this->createMock(IConfig::class);
-		$this->loader = $this->createMock(StorageFactory::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->config = $this->createMock(IConfig::class);
+        $this->loader = $this->createMock(StorageFactory::class);
 
-		$this->provider = new ObjectStorePreviewCacheMountProvider($this->logger, $this->config);
-	}
+        $this->provider = new ObjectStorePreviewCacheMountProvider($this->logger, $this->config);
+    }
 
-	public function testNoMultibucketObjectStorage(): void {
-		$this->config->expects($this->once())
-			->method('getSystemValue')
-			->with('objectstore_multibucket')
-			->willReturn(null);
+    public function testNoMultibucketObjectStorage(): void {
+        $this->config->expects($this->once())
+            ->method('getSystemValue')
+            ->with('objectstore_multibucket')
+            ->willReturn(null);
 
-		$this->assertEquals([], $this->provider->getRootMounts($this->loader));
-	}
+        $this->assertEquals([], $this->provider->getRootMounts($this->loader));
+    }
 
-	public function testMultibucketObjectStorage(): void {
-		$objectstoreConfig = [
-			'class' => S3::class,
-			'arguments' => [
-				'bucket' => 'abc',
-				'num_buckets' => 64,
-				'key' => 'KEY',
-				'secret' => 'SECRET',
-				'hostname' => 'IP',
-				'port' => 'PORT',
-				'use_ssl' => false,
-				'use_path_style' => true,
-			],
-		];
-		$this->config->expects($this->any())
-			->method('getSystemValue')
-			->willReturnCallback(function ($config) use ($objectstoreConfig) {
-				if ($config === 'objectstore_multibucket') {
-					return $objectstoreConfig;
-				} elseif ($config === 'objectstore.multibucket.preview-distribution') {
-					return true;
-				}
-				return null;
-			});
-		$this->config->expects($this->once())
-			->method('getSystemValueString')
-			->with('instanceid')
-			->willReturn('INSTANCEID');
+    public function testMultibucketObjectStorage(): void {
+        $objectstoreConfig = [
+            'class' => S3::class,
+            'arguments' => [
+                'bucket' => 'abc',
+                'num_buckets' => 64,
+                'key' => 'KEY',
+                'secret' => 'SECRET',
+                'hostname' => 'IP',
+                'port' => 'PORT',
+                'use_ssl' => false,
+                'use_path_style' => true,
+            ],
+        ];
+        $this->config->expects($this->any())
+            ->method('getSystemValue')
+            ->willReturnCallback(function ($config) use ($objectstoreConfig) {
+                if ($config === 'objectstore_multibucket') {
+                    return $objectstoreConfig;
+                } elseif ($config === 'objectstore.multibucket.preview-distribution') {
+                    return true;
+                }
+                return null;
+            });
+        $this->config->expects($this->once())
+            ->method('getSystemValueString')
+            ->with('instanceid')
+            ->willReturn('INSTANCEID');
 
-		$mounts = $this->provider->getRootMounts($this->loader);
+        $mounts = $this->provider->getRootMounts($this->loader);
 
-		// 256 mounts for the subfolders and 1 for the fake root
-		$this->assertCount(257, $mounts);
+        // 256 mounts for the subfolders and 1 for the fake root
+        $this->assertCount(257, $mounts);
 
-		// do some sanity checks if they have correct mount point paths
-		$this->assertEquals('/appdata_INSTANCEID/preview/0/0/', $mounts[0]->getMountPoint());
-		$this->assertEquals('/appdata_INSTANCEID/preview/2/5/', $mounts[37]->getMountPoint());
-		// also test the path of the fake bucket
-		$this->assertEquals('/appdata_INSTANCEID/preview/old-multibucket/', $mounts[256]->getMountPoint());
-	}
+        // do some sanity checks if they have correct mount point paths
+        $this->assertEquals('/appdata_INSTANCEID/preview/0/0/', $mounts[0]->getMountPoint());
+        $this->assertEquals('/appdata_INSTANCEID/preview/2/5/', $mounts[37]->getMountPoint());
+        // also test the path of the fake bucket
+        $this->assertEquals('/appdata_INSTANCEID/preview/old-multibucket/', $mounts[256]->getMountPoint());
+    }
 }

tests/lib/Files/Mount/CacheMountProviderTest.php

Indentation +53 added lines, -53 removed lines

@@ -17,76 +17,76 @@
 use Test\TestCase;
 
 class CacheMountProviderTestStream {
-	public static $statCounter = 0;
-	public static $mkdirCounter = 0;
+    public static $statCounter = 0;
+    public static $mkdirCounter = 0;
 
-	public $context;
+    public $context;
 
-	public function mkdir(string $path, int $mode, int $options): bool {
-		self::$mkdirCounter++;
-		return true;
-	}
+    public function mkdir(string $path, int $mode, int $options): bool {
+        self::$mkdirCounter++;
+        return true;
+    }
 
-	public function url_stat(string $path, int $flags): array|false {
-		self::$statCounter++;
-		return false;
-	}
+    public function url_stat(string $path, int $flags): array|false {
+        self::$statCounter++;
+        return false;
+    }
 }
 
 class CacheMountProviderTest extends TestCase {
-	private IConfig $config;
-	private IUser $user;
-	private IStorageFactory $storageFactory;
+    private IConfig $config;
+    private IUser $user;
+    private IStorageFactory $storageFactory;
 
-	protected function setUp(): void {
-		$this->config = $this->createMock(IConfig::class);
-		$this->user = $this->createMock(IUser::class);
-		$this->storageFactory = new StorageFactory();
-		stream_wrapper_register('cachemountprovidertest', CacheMountProviderTestStream::class);
-	}
+    protected function setUp(): void {
+        $this->config = $this->createMock(IConfig::class);
+        $this->user = $this->createMock(IUser::class);
+        $this->storageFactory = new StorageFactory();
+        stream_wrapper_register('cachemountprovidertest', CacheMountProviderTestStream::class);
+    }
 
-	protected function tearDown(): void {
-		stream_wrapper_unregister('cachemountprovidertest');
-	}
+    protected function tearDown(): void {
+        stream_wrapper_unregister('cachemountprovidertest');
+    }
 
-	public function testGetMountsForUser(): void {
-		$provider = new CacheMountProvider($this->config);
+    public function testGetMountsForUser(): void {
+        $provider = new CacheMountProvider($this->config);
 
-		$this->assertCount(0, $provider->getMountsForUser($this->user, $this->storageFactory));
-	}
+        $this->assertCount(0, $provider->getMountsForUser($this->user, $this->storageFactory));
+    }
 
-	public function testGetMountsForUserCacheDir(): void {
-		$this->config->expects($this->exactly(1))
-			->method('getSystemValueString')
-			->willReturnMap([
-				['cache_path', '', 'cachemountprovidertest:////cache_path'],
-			]);
-		$this->user->method('getUID')
-			->willReturn('bob');
+    public function testGetMountsForUserCacheDir(): void {
+        $this->config->expects($this->exactly(1))
+            ->method('getSystemValueString')
+            ->willReturnMap([
+                ['cache_path', '', 'cachemountprovidertest:////cache_path'],
+            ]);
+        $this->user->method('getUID')
+            ->willReturn('bob');
 
-		$provider = new CacheMountProvider($this->config);
-		$mounts = $provider->getMountsForUser($this->user, $this->storageFactory);
+        $provider = new CacheMountProvider($this->config);
+        $mounts = $provider->getMountsForUser($this->user, $this->storageFactory);
 
-		$this->assertCount(2, $mounts);
-		$this->assertEquals(1, CacheMountProviderTestStream::$statCounter);
-		$this->assertEquals(2, CacheMountProviderTestStream::$mkdirCounter);
+        $this->assertCount(2, $mounts);
+        $this->assertEquals(1, CacheMountProviderTestStream::$statCounter);
+        $this->assertEquals(2, CacheMountProviderTestStream::$mkdirCounter);
 
-		$cacheMountProvider = $mounts[0];
-		$this->assertEquals('/bob/cache/', $cacheMountProvider->getMountPoint());
+        $cacheMountProvider = $mounts[0];
+        $this->assertEquals('/bob/cache/', $cacheMountProvider->getMountPoint());
 
-		$cacheStorage = $cacheMountProvider->getStorage();
-		$this->assertEquals('local::cachemountprovidertest://cache_path/bob/', $cacheStorage->getId());
+        $cacheStorage = $cacheMountProvider->getStorage();
+        $this->assertEquals('local::cachemountprovidertest://cache_path/bob/', $cacheStorage->getId());
 
-		$uploadsMountProvider = $mounts[1];
-		$this->assertEquals('/bob/uploads/', $uploadsMountProvider->getMountPoint());
+        $uploadsMountProvider = $mounts[1];
+        $this->assertEquals('/bob/uploads/', $uploadsMountProvider->getMountPoint());
 
-		$uploadsStorage = $uploadsMountProvider->getStorage();
-		$this->assertEquals('local::cachemountprovidertest://cache_path/bob/uploads/', $uploadsStorage->getId());
+        $uploadsStorage = $uploadsMountProvider->getStorage();
+        $this->assertEquals('local::cachemountprovidertest://cache_path/bob/uploads/', $uploadsStorage->getId());
 
-		$cacheStorage->mkdir('foobar');
-		$this->assertEquals(3, CacheMountProviderTestStream::$mkdirCounter);
+        $cacheStorage->mkdir('foobar');
+        $this->assertEquals(3, CacheMountProviderTestStream::$mkdirCounter);
 
-		$uploadsStorage->mkdir('foobar');
-		$this->assertEquals(4, CacheMountProviderTestStream::$mkdirCounter);
-	}
+        $uploadsStorage->mkdir('foobar');
+        $this->assertEquals(4, CacheMountProviderTestStream::$mkdirCounter);
+    }
 }

tests/lib/Files/ObjectStore/ObjectStoreStorageOverwrite.php

Indentation +9 added lines, -9 removed lines

@@ -15,15 +15,15 @@
  * Allow overwriting the object store instance for test purposes
  */
 class ObjectStoreStorageOverwrite extends ObjectStoreStorage {
-	public function setObjectStore(IObjectStore $objectStore): void {
-		$this->objectStore = $objectStore;
-	}
+    public function setObjectStore(IObjectStore $objectStore): void {
+        $this->objectStore = $objectStore;
+    }
 
-	public function getObjectStore(): IObjectStore {
-		return $this->objectStore;
-	}
+    public function getObjectStore(): IObjectStore {
+        return $this->objectStore;
+    }
 
-	public function setValidateWrites(bool $validate): void {
-		$this->validateWrites = $validate;
-	}
+    public function setValidateWrites(bool $validate): void {
+        $this->validateWrites = $validate;
+    }
 }

tests/lib/Files/ObjectStore/ObjectStoreScannerTest.php

Indentation +44 added lines, -44 removed lines

@@ -17,62 +17,62 @@
  * @group DB
  */
 class ObjectStoreScannerTest extends TestCase {
-	private IStorage $storage;
-	private ICache $cache;
-	private ObjectStoreScanner $scanner;
-	private Scanner $realScanner;
+    private IStorage $storage;
+    private ICache $cache;
+    private ObjectStoreScanner $scanner;
+    private Scanner $realScanner;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->storage = new Temporary([]);
-		$this->cache = $this->storage->getCache();
-		$this->scanner = new ObjectStoreScanner($this->storage);
-		$this->realScanner = new Scanner($this->storage);
-	}
+        $this->storage = new Temporary([]);
+        $this->cache = $this->storage->getCache();
+        $this->scanner = new ObjectStoreScanner($this->storage);
+        $this->realScanner = new Scanner($this->storage);
+    }
 
-	public function testFile(): void {
-		$data = "dummy file data\n";
-		$this->storage->file_put_contents('foo.txt', $data);
+    public function testFile(): void {
+        $data = "dummy file data\n";
+        $this->storage->file_put_contents('foo.txt', $data);
 
-		$this->assertNull($this->scanner->scanFile('foo.txt'),
-			'Asserting that no error occurred while scanFile()'
-		);
-	}
+        $this->assertNull($this->scanner->scanFile('foo.txt'),
+            'Asserting that no error occurred while scanFile()'
+        );
+    }
 
-	private function fillTestFolders() {
-		$textData = "dummy file data\n";
-		$imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo/logo.png');
-		$this->storage->mkdir('folder');
-		$this->storage->file_put_contents('foo.txt', $textData);
-		$this->storage->file_put_contents('foo.png', $imgData);
-		$this->storage->file_put_contents('folder/bar.txt', $textData);
-	}
+    private function fillTestFolders() {
+        $textData = "dummy file data\n";
+        $imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo/logo.png');
+        $this->storage->mkdir('folder');
+        $this->storage->file_put_contents('foo.txt', $textData);
+        $this->storage->file_put_contents('foo.png', $imgData);
+        $this->storage->file_put_contents('folder/bar.txt', $textData);
+    }
 
-	public function testFolder(): void {
-		$this->fillTestFolders();
+    public function testFolder(): void {
+        $this->fillTestFolders();
 
-		$this->assertNull(
-			$this->scanner->scan(''),
-			'Asserting that no error occurred while scan()'
-		);
-	}
+        $this->assertNull(
+            $this->scanner->scan(''),
+            'Asserting that no error occurred while scan()'
+        );
+    }
 
-	public function testBackgroundScan(): void {
-		$this->fillTestFolders();
-		$this->storage->mkdir('folder2');
-		$this->storage->file_put_contents('folder2/bar.txt', 'foobar');
+    public function testBackgroundScan(): void {
+        $this->fillTestFolders();
+        $this->storage->mkdir('folder2');
+        $this->storage->file_put_contents('folder2/bar.txt', 'foobar');
 
-		$this->realScanner->scan('');
+        $this->realScanner->scan('');
 
-		$this->assertEquals(6, $this->cache->get('folder2')->getSize());
+        $this->assertEquals(6, $this->cache->get('folder2')->getSize());
 
-		$this->cache->put('folder2', ['size' => -1]);
+        $this->cache->put('folder2', ['size' => -1]);
 
-		$this->assertEquals(-1, $this->cache->get('folder2')->getSize());
+        $this->assertEquals(-1, $this->cache->get('folder2')->getSize());
 
-		$this->scanner->backgroundScan();
+        $this->scanner->backgroundScan();
 
-		$this->assertEquals(6, $this->cache->get('folder2')->getSize());
-	}
+        $this->assertEquals(6, $this->cache->get('folder2')->getSize());
+    }
 }

tests/lib/Files/Cache/PropagatorTest.php

Indentation +116 added lines, -116 removed lines

@@ -16,120 +16,120 @@
  * @group DB
  */
 class PropagatorTest extends TestCase {
-	/** @var IStorage */
-	private $storage;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->storage = new Temporary();
-		$this->storage->mkdir('foo/bar');
-		$this->storage->file_put_contents('foo/bar/file.txt', 'bar');
-		$this->storage->getScanner()->scan('');
-	}
-
-	/**
-	 * @param $paths
-	 * @return ICacheEntry[]
-	 */
-	private function getFileInfos($paths) {
-		$values = array_map(function ($path) {
-			return $this->storage->getCache()->get($path);
-		}, $paths);
-		return array_combine($paths, $values);
-	}
-
-	public function testEtagPropagation(): void {
-		$paths = ['', 'foo', 'foo/bar'];
-		$oldInfos = $this->getFileInfos($paths);
-		$this->storage->getPropagator()->propagateChange('foo/bar/file.txt', time());
-		$newInfos = $this->getFileInfos($paths);
-
-		foreach ($oldInfos as $i => $oldInfo) {
-			$this->assertNotEquals($oldInfo->getEtag(), $newInfos[$i]->getEtag());
-		}
-	}
-
-	public function testTimePropagation(): void {
-		$paths = ['', 'foo', 'foo/bar'];
-		$oldTime = time() - 200;
-		$targetTime = time() - 100;
-		$now = time();
-		$cache = $this->storage->getCache();
-		$cache->put('', ['mtime' => $now]);
-		$cache->put('foo', ['mtime' => $now]);
-		$cache->put('foo/bar', ['mtime' => $oldTime]);
-		$cache->put('foo/bar/file.txt', ['mtime' => $oldTime]);
-		$this->storage->getPropagator()->propagateChange('foo/bar/file.txt', $targetTime);
-		$newInfos = $this->getFileInfos($paths);
-
-		$this->assertEquals($targetTime, $newInfos['foo/bar']->getMTime());
-
-		// dont lower mtimes
-		$this->assertEquals($now, $newInfos['foo']->getMTime());
-		$this->assertEquals($now, $newInfos['']->getMTime());
-	}
-
-	public function testSizePropagation(): void {
-		$paths = ['', 'foo', 'foo/bar'];
-		$oldInfos = $this->getFileInfos($paths);
-		$this->storage->getPropagator()->propagateChange('foo/bar/file.txt', time(), 10);
-		$newInfos = $this->getFileInfos($paths);
-
-		foreach ($oldInfos as $i => $oldInfo) {
-			$this->assertEquals($oldInfo->getSize() + 10, $newInfos[$i]->getSize());
-		}
-	}
-
-	public function testSizePropagationNoNegative(): void {
-		$paths = ['', 'foo', 'foo/bar'];
-		$oldInfos = $this->getFileInfos($paths);
-		$this->storage->getPropagator()->propagateChange('foo/bar/file.txt', time(), -100);
-		$newInfos = $this->getFileInfos($paths);
-
-		foreach ($oldInfos as $i => $oldInfo) {
-			$this->assertEquals(-1, $newInfos[$i]->getSize());
-		}
-	}
-
-	public function testBatchedPropagation(): void {
-		$this->storage->mkdir('foo/baz');
-		$this->storage->mkdir('asd');
-		$this->storage->file_put_contents('asd/file.txt', 'bar');
-		$this->storage->file_put_contents('foo/baz/file.txt', 'bar');
-		$this->storage->getScanner()->scan('');
-
-		$paths = ['', 'foo', 'foo/bar', 'asd', 'foo/baz'];
-
-		$oldInfos = $this->getFileInfos($paths);
-		$propagator = $this->storage->getPropagator();
-
-		$propagator->beginBatch();
-		$propagator->propagateChange('asd/file.txt', time(), 10);
-		$propagator->propagateChange('foo/bar/file.txt', time(), 2);
-
-		$newInfos = $this->getFileInfos($paths);
-
-		// no changes until we finish the batch
-		foreach ($oldInfos as $i => $oldInfo) {
-			$this->assertEquals($oldInfo->getSize(), $newInfos[$i]->getSize());
-			$this->assertEquals($oldInfo->getEtag(), $newInfos[$i]->getEtag());
-			$this->assertEquals($oldInfo->getMTime(), $newInfos[$i]->getMTime());
-		}
-
-		$propagator->commitBatch();
-
-		$newInfos = $this->getFileInfos($paths);
-
-		foreach ($oldInfos as $i => $oldInfo) {
-			if ($oldInfo->getPath() !== 'foo/baz') {
-				$this->assertNotEquals($oldInfo->getEtag(), $newInfos[$i]->getEtag(), "etag for {$oldInfo->getPath()} not updated");
-			}
-		}
-
-		$this->assertEquals($oldInfos['']->getSize() + 12, $newInfos['']->getSize());
-		$this->assertEquals($oldInfos['asd']->getSize() + 10, $newInfos['asd']->getSize());
-		$this->assertEquals($oldInfos['foo']->getSize() + 2, $newInfos['foo']->getSize());
-		$this->assertEquals($oldInfos['foo/bar']->getSize() + 2, $newInfos['foo/bar']->getSize());
-		$this->assertEquals($oldInfos['foo/baz']->getSize(), $newInfos['foo/baz']->getSize());
-	}
+    /** @var IStorage */
+    private $storage;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->storage = new Temporary();
+        $this->storage->mkdir('foo/bar');
+        $this->storage->file_put_contents('foo/bar/file.txt', 'bar');
+        $this->storage->getScanner()->scan('');
+    }
+
+    /**
+     * @param $paths
+     * @return ICacheEntry[]
+     */
+    private function getFileInfos($paths) {
+        $values = array_map(function ($path) {
+            return $this->storage->getCache()->get($path);
+        }, $paths);
+        return array_combine($paths, $values);
+    }
+
+    public function testEtagPropagation(): void {
+        $paths = ['', 'foo', 'foo/bar'];
+        $oldInfos = $this->getFileInfos($paths);
+        $this->storage->getPropagator()->propagateChange('foo/bar/file.txt', time());
+        $newInfos = $this->getFileInfos($paths);
+
+        foreach ($oldInfos as $i => $oldInfo) {
+            $this->assertNotEquals($oldInfo->getEtag(), $newInfos[$i]->getEtag());
+        }
+    }
+
+    public function testTimePropagation(): void {
+        $paths = ['', 'foo', 'foo/bar'];
+        $oldTime = time() - 200;
+        $targetTime = time() - 100;
+        $now = time();
+        $cache = $this->storage->getCache();
+        $cache->put('', ['mtime' => $now]);
+        $cache->put('foo', ['mtime' => $now]);
+        $cache->put('foo/bar', ['mtime' => $oldTime]);
+        $cache->put('foo/bar/file.txt', ['mtime' => $oldTime]);
+        $this->storage->getPropagator()->propagateChange('foo/bar/file.txt', $targetTime);
+        $newInfos = $this->getFileInfos($paths);
+
+        $this->assertEquals($targetTime, $newInfos['foo/bar']->getMTime());
+
+        // dont lower mtimes
+        $this->assertEquals($now, $newInfos['foo']->getMTime());
+        $this->assertEquals($now, $newInfos['']->getMTime());
+    }
+
+    public function testSizePropagation(): void {
+        $paths = ['', 'foo', 'foo/bar'];
+        $oldInfos = $this->getFileInfos($paths);
+        $this->storage->getPropagator()->propagateChange('foo/bar/file.txt', time(), 10);
+        $newInfos = $this->getFileInfos($paths);
+
+        foreach ($oldInfos as $i => $oldInfo) {
+            $this->assertEquals($oldInfo->getSize() + 10, $newInfos[$i]->getSize());
+        }
+    }
+
+    public function testSizePropagationNoNegative(): void {
+        $paths = ['', 'foo', 'foo/bar'];
+        $oldInfos = $this->getFileInfos($paths);
+        $this->storage->getPropagator()->propagateChange('foo/bar/file.txt', time(), -100);
+        $newInfos = $this->getFileInfos($paths);
+
+        foreach ($oldInfos as $i => $oldInfo) {
+            $this->assertEquals(-1, $newInfos[$i]->getSize());
+        }
+    }
+
+    public function testBatchedPropagation(): void {
+        $this->storage->mkdir('foo/baz');
+        $this->storage->mkdir('asd');
+        $this->storage->file_put_contents('asd/file.txt', 'bar');
+        $this->storage->file_put_contents('foo/baz/file.txt', 'bar');
+        $this->storage->getScanner()->scan('');
+
+        $paths = ['', 'foo', 'foo/bar', 'asd', 'foo/baz'];
+
+        $oldInfos = $this->getFileInfos($paths);
+        $propagator = $this->storage->getPropagator();
+
+        $propagator->beginBatch();
+        $propagator->propagateChange('asd/file.txt', time(), 10);
+        $propagator->propagateChange('foo/bar/file.txt', time(), 2);
+
+        $newInfos = $this->getFileInfos($paths);
+
+        // no changes until we finish the batch
+        foreach ($oldInfos as $i => $oldInfo) {
+            $this->assertEquals($oldInfo->getSize(), $newInfos[$i]->getSize());
+            $this->assertEquals($oldInfo->getEtag(), $newInfos[$i]->getEtag());
+            $this->assertEquals($oldInfo->getMTime(), $newInfos[$i]->getMTime());
+        }
+
+        $propagator->commitBatch();
+
+        $newInfos = $this->getFileInfos($paths);
+
+        foreach ($oldInfos as $i => $oldInfo) {
+            if ($oldInfo->getPath() !== 'foo/baz') {
+                $this->assertNotEquals($oldInfo->getEtag(), $newInfos[$i]->getEtag(), "etag for {$oldInfo->getPath()} not updated");
+            }
+        }
+
+        $this->assertEquals($oldInfos['']->getSize() + 12, $newInfos['']->getSize());
+        $this->assertEquals($oldInfos['asd']->getSize() + 10, $newInfos['asd']->getSize());
+        $this->assertEquals($oldInfos['foo']->getSize() + 2, $newInfos['foo']->getSize());
+        $this->assertEquals($oldInfos['foo/bar']->getSize() + 2, $newInfos['foo/bar']->getSize());
+        $this->assertEquals($oldInfos['foo/baz']->getSize(), $newInfos['foo/baz']->getSize());
+    }
 }

tests/lib/Files/FileInfoTest.php

Indentation +39 added lines, -39 removed lines

@@ -17,43 +17,43 @@
 use Test\Traits\UserTrait;
 
 class FileInfoTest extends TestCase {
-	use UserTrait;
-
-	private $config;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->createUser('foo', 'foo');
-		$this->config = $this->getMockBuilder(IConfig::class)->getMock();
-	}
-
-	public function testIsMountedHomeStorage(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')
-			->willReturn('foo');
-		$user->method('getHome')
-			->willReturn('foo');
-		$storage = new Home(['user' => $user]);
-
-		$fileInfo = new FileInfo(
-			'',
-			$storage,
-			'',
-			[],
-			new HomeMountPoint($user, $storage, '/foo/files')
-		);
-		$this->assertFalse($fileInfo->isMounted());
-	}
-
-	public function testIsMountedNonHomeStorage(): void {
-		$storage = new Temporary();
-		$fileInfo = new FileInfo(
-			'',
-			$storage,
-			'',
-			[],
-			new MountPoint($storage, '/foo/files/bar')
-		);
-		$this->assertTrue($fileInfo->isMounted());
-	}
+    use UserTrait;
+
+    private $config;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->createUser('foo', 'foo');
+        $this->config = $this->getMockBuilder(IConfig::class)->getMock();
+    }
+
+    public function testIsMountedHomeStorage(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')
+            ->willReturn('foo');
+        $user->method('getHome')
+            ->willReturn('foo');
+        $storage = new Home(['user' => $user]);
+
+        $fileInfo = new FileInfo(
+            '',
+            $storage,
+            '',
+            [],
+            new HomeMountPoint($user, $storage, '/foo/files')
+        );
+        $this->assertFalse($fileInfo->isMounted());
+    }
+
+    public function testIsMountedNonHomeStorage(): void {
+        $storage = new Temporary();
+        $fileInfo = new FileInfo(
+            '',
+            $storage,
+            '',
+            [],
+            new MountPoint($storage, '/foo/files/bar')
+        );
+        $this->assertTrue($fileInfo->isMounted());
+    }
 }

tests/lib/Files/Storage/Wrapper/KnownMtimeTest.php

Indentation +41 added lines, -41 removed lines

@@ -16,53 +16,53 @@
  * @group DB
  */
 class KnownMtimeTest extends Storage {
-	/** @var Temporary */
-	private $sourceStorage;
+    /** @var Temporary */
+    private $sourceStorage;
 
-	/** @var ClockInterface|MockObject */
-	private $clock;
-	private int $fakeTime = 0;
+    /** @var ClockInterface|MockObject */
+    private $clock;
+    private int $fakeTime = 0;
 
-	protected function setUp(): void {
-		parent::setUp();
-		$this->fakeTime = 0;
-		$this->sourceStorage = new Temporary([]);
-		$this->clock = $this->createMock(ClockInterface::class);
-		$this->clock->method('now')->willReturnCallback(function () {
-			if ($this->fakeTime) {
-				return new \DateTimeImmutable("@{$this->fakeTime}");
-			} else {
-				return new \DateTimeImmutable();
-			}
-		});
-		$this->instance = $this->getWrappedStorage();
-	}
+    protected function setUp(): void {
+        parent::setUp();
+        $this->fakeTime = 0;
+        $this->sourceStorage = new Temporary([]);
+        $this->clock = $this->createMock(ClockInterface::class);
+        $this->clock->method('now')->willReturnCallback(function () {
+            if ($this->fakeTime) {
+                return new \DateTimeImmutable("@{$this->fakeTime}");
+            } else {
+                return new \DateTimeImmutable();
+            }
+        });
+        $this->instance = $this->getWrappedStorage();
+    }
 
-	protected function tearDown(): void {
-		$this->sourceStorage->cleanUp();
-		parent::tearDown();
-	}
+    protected function tearDown(): void {
+        $this->sourceStorage->cleanUp();
+        parent::tearDown();
+    }
 
-	protected function getWrappedStorage() {
-		return new KnownMtime([
-			'storage' => $this->sourceStorage,
-			'clock' => $this->clock,
-		]);
-	}
+    protected function getWrappedStorage() {
+        return new KnownMtime([
+            'storage' => $this->sourceStorage,
+            'clock' => $this->clock,
+        ]);
+    }
 
-	public function testNewerKnownMtime(): void {
-		$future = time() + 1000;
-		$this->fakeTime = $future;
+    public function testNewerKnownMtime(): void {
+        $future = time() + 1000;
+        $this->fakeTime = $future;
 
-		$this->instance->file_put_contents('foo.txt', 'bar');
+        $this->instance->file_put_contents('foo.txt', 'bar');
 
-		// fuzzy match since the clock might have ticked
-		$this->assertLessThan(2, abs(time() - $this->sourceStorage->filemtime('foo.txt')));
-		$this->assertEquals($this->sourceStorage->filemtime('foo.txt'), $this->sourceStorage->stat('foo.txt')['mtime']);
-		$this->assertEquals($this->sourceStorage->filemtime('foo.txt'), $this->sourceStorage->getMetaData('foo.txt')['mtime']);
+        // fuzzy match since the clock might have ticked
+        $this->assertLessThan(2, abs(time() - $this->sourceStorage->filemtime('foo.txt')));
+        $this->assertEquals($this->sourceStorage->filemtime('foo.txt'), $this->sourceStorage->stat('foo.txt')['mtime']);
+        $this->assertEquals($this->sourceStorage->filemtime('foo.txt'), $this->sourceStorage->getMetaData('foo.txt')['mtime']);
 
-		$this->assertEquals($future, $this->instance->filemtime('foo.txt'));
-		$this->assertEquals($future, $this->instance->stat('foo.txt')['mtime']);
-		$this->assertEquals($future, $this->instance->getMetaData('foo.txt')['mtime']);
-	}
+        $this->assertEquals($future, $this->instance->filemtime('foo.txt'));
+        $this->assertEquals($future, $this->instance->stat('foo.txt')['mtime']);
+        $this->assertEquals($future, $this->instance->getMetaData('foo.txt')['mtime']);
+    }
 }

tests/lib/Settings/SectionTest.php

Indentation +9 added lines, -9 removed lines

@@ -10,13 +10,13 @@
 use Test\TestCase;
 
 class SectionTest extends TestCase {
-	public function testGetID(): void {
-		$this->assertSame('ldap', (new Section('ldap', 'name', 1))->getID());
-	}
-	public function testGetName(): void {
-		$this->assertSame('name', (new Section('ldap', 'name', 1))->getName());
-	}
-	public function testGetPriority(): void {
-		$this->assertSame(1, (new Section('ldap', 'name', 1))->getPriority());
-	}
+    public function testGetID(): void {
+        $this->assertSame('ldap', (new Section('ldap', 'name', 1))->getID());
+    }
+    public function testGetName(): void {
+        $this->assertSame('name', (new Section('ldap', 'name', 1))->getName());
+    }
+    public function testGetPriority(): void {
+        $this->assertSame(1, (new Section('ldap', 'name', 1))->getPriority());
+    }
 }