PHP Cache\Cache类代码示例

 /**
  * @dataProvider maskProvider
  * @param int $mask
  */
 public function testGetMasked($mask)
 {
     $cache = $this->getMaskedCached($mask);
     $data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'text/plain', 'permissions' => Constants::PERMISSION_ALL);
     $this->sourceCache->put('foo', $data);
     $result = $cache->get('foo');
     $this->assertEquals($mask, $result['permissions']);
     $data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'text/plain', 'permissions' => Constants::PERMISSION_ALL - Constants::PERMISSION_DELETE);
     $this->sourceCache->put('bar', $data);
     $result = $cache->get('bar');
     $this->assertEquals($mask & ~Constants::PERMISSION_DELETE, $result['permissions']);
 }

 function tearDown()
 {
     $this->sharedCache->clear();
     self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
     $fileinfo = $this->view->getFileInfo('container/shareddir');
     \OCP\Share::unshare('folder', $fileinfo['fileid'], \OCP\Share::SHARE_TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
     $fileinfo = $this->view->getFileInfo('container/shared single file.txt');
     \OCP\Share::unshare('file', $fileinfo['fileid'], \OCP\Share::SHARE_TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
     $this->view->deleteAll('container');
     $this->ownerCache->clear();
     parent::tearDown();
 }

	public function testTouchWithMountPoints() {
		$storage2 = new \OC\Files\Storage\Temporary(array());
		$cache2 = $storage2->getCache();
		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
		$this->assertTrue($cache2->inCache('foo.txt'));
		$folderCachedData = $this->cache->get('folder');
		$substorageCachedData = $cache2->get('');
		$fooCachedData = $cache2->get('foo.txt');
		$cachedData = $cache2->get('foo.txt');
		$time = 1371006070;
		$this->cache->put('folder', ['mtime' => $time - 100]);
		Filesystem::touch('folder/substorage/foo.txt', $time);
		$cachedData = $cache2->get('foo.txt');
		$this->assertInternalType('string', $fooCachedData['etag']);
		$this->assertInternalType('string', $cachedData['etag']);
		$this->assertNotSame($fooCachedData['etag'], $cachedData['etag']);
		$this->assertEquals($time, $cachedData['mtime']);

		$cachedData = $cache2->get('');
		$this->assertInternalType('string', $substorageCachedData['etag']);
		$this->assertInternalType('string', $cachedData['etag']);
		$this->assertNotSame($substorageCachedData['etag'], $cachedData['etag']);

		$cachedData = $this->cache->get('folder');
		$this->assertInternalType('string', $folderCachedData['etag']);
		$this->assertInternalType('string', $cachedData['etag']);
		$this->assertNotSame($folderCachedData['etag'], $cachedData['etag']);
		$this->assertEquals($time, $cachedData['mtime']);
	}

 private static function checkUpdate($id)
 {
     $cacheItem = Cache::getById($id);
     if (is_null($cacheItem)) {
         return;
     }
     list($storageId, $internalPath) = $cacheItem;
     $mounts = Filesystem::getMountByStorageId($storageId);
     if (count($mounts) === 0) {
         //if the storage we need isn't mounted on default, try to find a user that has access to the storage
         $permissionsCache = new Permissions($storageId);
         $users = $permissionsCache->getUsers($id);
         if (count($users) === 0) {
             return;
         }
         Filesystem::initMountPoints($users[0]);
         $mounts = Filesystem::getMountByStorageId($storageId);
         if (count($mounts) === 0) {
             return;
         }
     }
     $storage = $mounts[0]->getStorage();
     $watcher = new Watcher($storage);
     $watcher->checkUpdate($internalPath);
 }

 public function testTouch()
 {
     $rootCachedData = $this->cache->get('');
     $fooCachedData = $this->cache->get('foo.txt');
     Filesystem::touch('foo.txt');
     $cachedData = $this->cache->get('foo.txt');
     $this->assertInternalType('string', $fooCachedData['etag']);
     $this->assertInternalType('string', $cachedData['etag']);
     $this->assertGreaterThanOrEqual($fooCachedData['mtime'], $cachedData['mtime']);
     $cachedData = $this->cache->get('');
     $this->assertInternalType('string', $rootCachedData['etag']);
     $this->assertInternalType('string', $cachedData['etag']);
     $this->assertNotSame($rootCachedData['etag'], $cachedData['etag']);
     $this->assertGreaterThanOrEqual($rootCachedData['mtime'], $cachedData['mtime']);
     $rootCachedData = $cachedData;
     $time = 1371006070;
     $barCachedData = $this->cache->get('folder/bar.txt');
     $folderCachedData = $this->cache->get('folder');
     $this->cache->put('', ['mtime' => $time - 100]);
     Filesystem::touch('folder/bar.txt', $time);
     $cachedData = $this->cache->get('folder/bar.txt');
     $this->assertInternalType('string', $barCachedData['etag']);
     $this->assertInternalType('string', $cachedData['etag']);
     $this->assertNotSame($barCachedData['etag'], $cachedData['etag']);
     $this->assertEquals($time, $cachedData['mtime']);
     $cachedData = $this->cache->get('folder');
     $this->assertInternalType('string', $folderCachedData['etag']);
     $this->assertInternalType('string', $cachedData['etag']);
     $this->assertNotSame($folderCachedData['etag'], $cachedData['etag']);
     $cachedData = $this->cache->get('');
     $this->assertInternalType('string', $rootCachedData['etag']);
     $this->assertInternalType('string', $cachedData['etag']);
     $this->assertNotSame($rootCachedData['etag'], $cachedData['etag']);
     $this->assertEquals($time, $cachedData['mtime']);
 }

	public function testMoveFolderCrossStorage() {
		$storage2 = new Temporary(array());
		$cache2 = $storage2->getCache();
		Filesystem::mount($storage2, array(), '/bar');
		$this->storage->mkdir('foo');
		$this->storage->mkdir('foo/bar');
		$this->storage->file_put_contents('foo/foo.txt', 'qwerty');
		$this->storage->file_put_contents('foo/bar.txt', 'foo');
		$this->storage->file_put_contents('foo/bar/bar.txt', 'qwertyuiop');

		$this->storage->getScanner()->scan('');

		$this->assertTrue($this->cache->inCache('foo'));
		$this->assertTrue($this->cache->inCache('foo/foo.txt'));
		$this->assertTrue($this->cache->inCache('foo/bar.txt'));
		$this->assertTrue($this->cache->inCache('foo/bar'));
		$this->assertTrue($this->cache->inCache('foo/bar/bar.txt'));
		$cached = [];
		$cached[] = $this->cache->get('foo');
		$cached[] = $this->cache->get('foo/foo.txt');
		$cached[] = $this->cache->get('foo/bar.txt');
		$cached[] = $this->cache->get('foo/bar');
		$cached[] = $this->cache->get('foo/bar/bar.txt');

		// add extension to trigger the possible mimetype change
		$this->view->rename('/foo', '/bar/foo.b');

		$this->assertFalse($this->cache->inCache('foo'));
		$this->assertFalse($this->cache->inCache('foo/foo.txt'));
		$this->assertFalse($this->cache->inCache('foo/bar.txt'));
		$this->assertFalse($this->cache->inCache('foo/bar'));
		$this->assertFalse($this->cache->inCache('foo/bar/bar.txt'));
		$this->assertTrue($cache2->inCache('foo.b'));
		$this->assertTrue($cache2->inCache('foo.b/foo.txt'));
		$this->assertTrue($cache2->inCache('foo.b/bar.txt'));
		$this->assertTrue($cache2->inCache('foo.b/bar'));
		$this->assertTrue($cache2->inCache('foo.b/bar/bar.txt'));

		$cachedTarget = [];
		$cachedTarget[] = $cache2->get('foo.b');
		$cachedTarget[] = $cache2->get('foo.b/foo.txt');
		$cachedTarget[] = $cache2->get('foo.b/bar.txt');
		$cachedTarget[] = $cache2->get('foo.b/bar');
		$cachedTarget[] = $cache2->get('foo.b/bar/bar.txt');

		foreach ($cached as $i => $old) {
			$new = $cachedTarget[$i];
			$this->assertEquals($old['mtime'], $new['mtime']);
			$this->assertEquals($old['size'], $new['size']);
			$this->assertEquals($old['etag'], $new['etag']);
			$this->assertEquals($old['fileid'], $new['fileid']);
			$this->assertEquals($old['mimetype'], $new['mimetype']);
		}
	}

 /**
  * @param string $path
  * @return ICacheEntry
  */
 public function get($path)
 {
     $data = parent::get($path);
     if ($path === '' or $path === '/') {
         // only the size of the "files" dir counts
         $filesData = parent::get('files');
         if (isset($filesData['size'])) {
             $data['size'] = $filesData['size'];
         }
     }
     return $data;
 }

 /**
  * Returns the sizes of the path and its parent dirs in a hash
  * where the key is the path and the value is the size.
  * @param string $path
  */
 function getOwnerDirSizes($path)
 {
     $result = array();
     while ($path != '' && $path != '' && $path != '.') {
         $cachedData = $this->ownerCache->get($path);
         $result[$path] = $cachedData['size'];
         $path = dirname($path);
     }
     $cachedData = $this->ownerCache->get('');
     $result[''] = $cachedData['size'];
     return $result;
 }

 protected function tearDown()
 {
     if ($this->sharedCache) {
         $this->sharedCache->clear();
     }
     self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
     $shares = $this->shareManager->getSharesBy(self::TEST_FILES_SHARING_API_USER1, \OCP\Share::SHARE_TYPE_USER);
     foreach ($shares as $share) {
         $this->shareManager->deleteShare($share);
     }
     $this->view->deleteAll('container');
     $this->ownerCache->clear();
     parent::tearDown();
 }

 public function testMoveDisabled()
 {
     $this->storage->file_put_contents('foo.txt', 'qwerty');
     $this->updater->update('foo.txt');
     $this->assertTrue($this->cache->inCache('foo.txt'));
     $this->assertFalse($this->cache->inCache('bar.txt'));
     $cached = $this->cache->get('foo.txt');
     $this->storage->rename('foo.txt', 'bar.txt');
     $this->assertTrue($this->cache->inCache('foo.txt'));
     $this->assertFalse($this->cache->inCache('bar.txt'));
     $this->updater->disable();
     $this->updater->rename('foo.txt', 'bar.txt');
     $this->assertTrue($this->cache->inCache('foo.txt'));
     $this->assertFalse($this->cache->inCache('bar.txt'));
 }

 /**
  * Test searching by tag for multiple sections of the tree
  */
 function testSearchByTagTree()
 {
     $userId = \OC::$server->getUserSession()->getUser()->getUId();
     $this->sharedStorage->mkdir('subdir/emptydir');
     $this->sharedStorage->mkdir('subdir/emptydir2');
     $this->ownerStorage->getScanner()->scan('');
     $allIds = array($this->sharedCache->get('')['fileid'], $this->sharedCache->get('bar.txt')['fileid'], $this->sharedCache->get('subdir/another too.txt')['fileid'], $this->sharedCache->get('subdir/not a text file.xml')['fileid'], $this->sharedCache->get('subdir/another.txt')['fileid'], $this->sharedCache->get('subdir/emptydir')['fileid'], $this->sharedCache->get('subdir/emptydir2')['fileid']);
     $tagManager = \OC::$server->getTagManager()->load('files', null, null, $userId);
     foreach ($allIds as $id) {
         $tagManager->tagAs($id, 'tag1');
     }
     $results = $this->sharedStorage->getCache()->searchByTag('tag1', $userId);
     $check = array(array('name' => 'shareddir', 'path' => ''), array('name' => 'bar.txt', 'path' => 'bar.txt'), array('name' => 'another.txt', 'path' => 'subdir/another.txt'), array('name' => 'another too.txt', 'path' => 'subdir/another too.txt'), array('name' => 'emptydir', 'path' => 'subdir/emptydir'), array('name' => 'emptydir2', 'path' => 'subdir/emptydir2'), array('name' => 'not a text file.xml', 'path' => 'subdir/not a text file.xml'));
     $this->verifyFiles($check, $results);
     $tagManager->delete(array('tag1'));
 }

 public function testUpdateLegacyAndNewId()
 {
     // add storage ids
     $oldCache = new \OC\Files\Cache\Cache($this->oldId);
     new \OC\Files\Cache\Cache($this->newId);
     // add file to old cache
     $fileId = $oldCache->put('/', array('size' => 0, 'mtime' => time(), 'mimetype' => 'httpd/directory'));
     try {
         $this->instance = new \OC\Files\Storage\AmazonS3($this->params);
     } catch (\Exception $e) {
         //ignore
     }
     $storages = $this->getStorages();
     $this->assertTrue(isset($storages[$this->newId]));
     $this->assertFalse(isset($storages[$this->oldId]));
     $this->assertNull(\OC\Files\Cache\Cache::getById($fileId), 'old filecache has not been cleared');
 }

 private function runBackgroundScanJob(callable $callback, $path)
 {
     try {
         $callback();
         \OC_Hook::emit('Scanner', 'correctFolderSize', array('path' => $path));
         if ($this->cacheActive && $this->cache instanceof Cache) {
             $this->cache->correctFolderSize($path);
         }
     } catch (\OCP\Files\StorageInvalidException $e) {
         // skip unavailable storages
     } catch (\OCP\Files\StorageNotAvailableException $e) {
         // skip unavailable storages
     } catch (\OCP\Files\ForbiddenException $e) {
         // skip forbidden storages
     } catch (\OCP\Lock\LockedException $e) {
         // skip unavailable storages
     }
 }

 protected function tearDown()
 {
     if ($this->cache) {
         $this->cache->clear();
     }
     parent::tearDown();
 }

 public function getFolderContentsById($id)
 {
     $results = parent::getFolderContentsById($id);
     foreach ($results as &$file) {
         $file['displayname_owner'] = $this->remoteUser . '@' . $this->remote;
     }
     return $results;
 }