/**
* Returns link for a version of a file
*
* @param File $file
* @param Version $version Version identifier
* @param string $extension Extension
* @return string Versioned link
*/
public function getLink(File $file, Version $version, $extension)
{
$link = $this->getBaseLink($file);
$pinfo = pathinfo($link);
$link = $pinfo['dirname'] . '/' . $pinfo['filename'] . '-' . $version->toString();
$link .= '.' . $extension;
return $link;
}
/**
* @param Versionable $versionable
* @param Version $version
* @return string
*/
public function getPathVersion(Versionable $versionable, Version $version)
{
list($resource, $file) = $this->extractResourceAndFileFromVersionable($versionable);
$path = $this->getPrefix();
if ($file) {
$path .= 'files/';
} else {
$path .= 'resources/';
}
$path .= $this->directoryCalculator->calculateDirectory($file ?: $resource) . '/' . $version->toString();
$path .= '/' . ($file ? $file->getId() : $resource->getId());
return $path;
}
/**
* @param File $file
* @param string $version
* @param Response $internalResponse
* @param mixed $adaptedResponse
*/
public function __construct(Response $internalResponse, $adaptedResponse, $version, File $file = null)
{
$this->internalResponse = $internalResponse;
$this->adaptedResponse = $adaptedResponse;
$this->version = Version::get($version);
$this->file = $file;
}
/**
* @test
*/
public function hasVersionShouldReturnWhetherResourceHasVersion()
{
$file = $this->getInstance(array('data' => array('versions' => array('tussi', 'watussi'))));
$this->assertTrue($file->hasVersion(Version::get('tussi')));
$this->assertTrue($file->hasVersion(Version::get('watussi')));
$this->assertFalse($file->hasVersion(Version::get('lussi')));
}
/**
* Renders a file to a response
*
* @param mixed $file
* @param mixed $version Version string or object
* @param array $options
* @return mixed
*/
public function render($file, $version, array $options = array())
{
$version = Version::get($version);
$response = new Response();
if (!$file instanceof File) {
$file = $this->fileRepository->find($file);
if (!$file) {
return $this->adaptResponse($response->setStatusCode(404), $version, null);
}
}
// Renderer / authorization evil tag team
try {
$event = new FileEvent($file);
$this->eventDispatcher->dispatch(Events::RENDERER_BEFORE_RENDER, $event);
} catch (AccessDeniedException $e) {
return $this->adaptResponse($response->setStatusCode(403), $version, $file);
}
try {
$provider = $this->profiles->getVersionProvider($file, $version);
$version = $provider->ensureValidVersion($version);
} catch (InvalidVersionException $e) {
return $this->adaptResponse($response->setStatusCode(404), $version, null);
}
if (!$this->versionIsObtainable($file, $version)) {
return $this->adaptResponse($response->setStatusCode(404), $version, $file);
}
$options = $this->mergeOptions($options);
if ($options['download'] == true) {
$response->setHeader('Content-disposition', "attachment; filename={$file->getName()}");
}
$retrieved = new FileObject($this->retrieve($file, $version));
$response->setHeader('Content-Type', $retrieved->getMimetype());
$this->injectContentToResponse($retrieved, $response);
return $this->adaptResponse($response, $version, $file);
}
public function __construct(File $file, array $versions)
{
parent::__construct($file);
$this->versions = array_map(function ($version) {
return Version::get($version);
}, $versions);
}
/**
* @test
* @dataProvider provideAcceleratedOptions
*/
public function shouldSetupAcceleratedResponseCorrectly($download, $enableAcceleration, $canAccelerate, $serverSignature, $expectAccel, $expectedHeader = '', $stripPrefix = '', $addPrefix = '', $expectedPath = null)
{
$this->renderer->enableAcceleration($enableAcceleration);
$this->renderer->stripPrefixFromPath($stripPrefix);
$this->renderer->addPrefixToPath($addPrefix);
$resource = Resource::create()->addVersion(Version::get('xooxer'));
$file = File::create(array('resource' => $resource, 'name' => 'lussuti.pdf'))->addVersion(Version::get('xooxer'));
$this->adapter->expects($this->any())->method('canAccelerate')->will($this->returnValue($canAccelerate));
$this->adapter->expects($this->any())->method('getServerSignature')->will($this->returnValue($serverSignature));
$this->ed->expects($this->at(0))->method('dispatch')->with(Events::RENDERER_BEFORE_RENDER, $this->isInstanceOf('Xi\\Filelib\\Event\\FileEvent'));
$this->storage->expects($this->once())->method('retrieveVersion')->with($resource, Version::get('xooxer'))->will($this->returnValue(ROOT_TESTS . '/data/refcard.pdf'));
$vp = $this->getMockedVersionProvider();
$vp->expects($this->any())->method('getApplicableVersionable')->will($this->returnValue($resource));
$vp->expects($this->any())->method('ensureValidVersion')->with($this->equalTo(Version::get('xooxer')))->will($this->returnArgument(0));
$this->pm->expects($this->any())->method('getVersionProvider')->with($file, Version::get('xooxer'))->will($this->returnValue($vp));
$ret = $this->renderer->render($file, Version::get('xooxer'), array('download' => $download));
$this->assertInstanceOf('Xi\\Filelib\\Renderer\\Response', $ret);
$this->assertEquals(200, $ret->getStatusCode());
$expectedHeaders = array('Content-Type' => 'application/pdf');
if ($download) {
$expectedHeaders['Content-disposition'] = "attachment; filename={$file->getName()}";
}
if (!$expectAccel) {
$this->assertNotEquals('', $ret->getContent());
} else {
$this->assertEquals('', $ret->getContent());
$expectedHeaders[$expectedHeader] = $expectedPath . '/refcard.pdf';
}
$this->assertEquals($expectedHeaders, $ret->getHeaders());
}
/**
* @test
* @dataProvider providePrefixes
*/
public function getPathVersionRespectsPrefixes($prefix)
{
$dc = $this->getMockBuilder(DirectoryCalculator::class)->disableOriginalConstructor()->getMock();
$dc->expects($this->any())->method('calculateDirectory')->will($this->returnValue('1/2/3'));
$pc = new ImprovedPathCalculator($dc, $prefix);
$resource = Resource::create(['id' => 'xooxoo']);
$this->assertEquals(trim($prefix, '/') . '/resources/1/2/3/luslus/xooxoo', $pc->getPathVersion($resource, Version::get('luslus')));
}
public function __construct(VersionProvider $provider, Versionable $versionable, $versions = array())
{
$this->provider = $provider;
$this->versionable = $versionable;
$this->versions = array_map(function ($version) {
return Version::get($version);
}, $versions);
}
/**
* @test
*/
public function linkerShouldExcludeRootProperly()
{
$extension = 'lus';
$file = File::create(array('name' => 'lamantiini.lus', 'folder_id' => 2, 'resource' => Resource::create(array('id' => 1))));
$linker = new BeautifurlLinker();
$linker->attachTo($this->filelib);
$this->assertEquals('lussuttaja/lamantiini-loso.lus', $linker->getLink($file, Version::get('loso'), $extension));
}
/**
* @test
*/
public function storeVersionFailsIfDirectoryNotCreatable()
{
$root = ROOT_TESTS . '/data/files';
$storage = new FilesystemStorageAdapter($root);
chmod($root, 0400);
$resource = Resource::create(['id' => 666, 'uuid' => Uuid::uuid4()]);
$this->setExpectedException('Xi\\Filelib\\Storage\\FileIOException');
$storage->storeVersion($resource, Version::get('puupster'), $this->getSelfLussingManatee());
}
/**
* @test
*/
public function getsPathVersionForFile()
{
$dc = $this->getMockBuilder(DirectoryCalculator::class)->disableOriginalConstructor()->getMock();
$dc->expects($this->exactly(2))->method('calculateDirectory')->will($this->onConsecutiveCalls('1/2/3', '3/2/1'));
$pc = new LegacyPathCalculator($dc);
$resource = Resource::create(['id' => 'xooxoo']);
$file = File::create(['resource' => $resource, 'id' => 'looloo']);
$this->assertEquals('1/2/3/luslus/sub/xooxoo/3/2/1/looloo', $pc->getPathVersion($file, Version::get('luslus')));
}
/**
* @test
*/
public function publishesAndUnpublishes()
{
$this->assertFalse($this->filesystem->has($this->path));
$this->assertTrue($this->adapter->publish($this->file, Version::get('xooxer'), $this->vp, $this->linker));
$this->assertTrue($this->filesystem->has($this->path));
$this->assertFalse($this->adapter->publish($this->file, Version::get('xooxer'), $this->vp, $this->linker));
$this->assertTrue($this->adapter->unpublish($this->file, Version::get('xooxer'), $this->vp, $this->linker));
$this->assertFalse($this->filesystem->has($this->path));
$this->assertFalse($this->adapter->unpublish($this->file, Version::get('xooxer'), $this->vp, $this->linker));
}
/**
* @param string $link
* @return array
*/
public function reverseLink($link)
{
$pinfo = pathinfo($link);
$split = explode('-', $pinfo['filename']);
$version = array_pop($split);
$version = Version::get($version);
$uuid = implode('-', $split);
$file = $this->fileRepository->findByUuid($uuid);
return array($file, $version);
}
/**
* @test
*/
public function eventShouldInitializeCorrectly()
{
$file = File::create();
$versions = array('tussi', 'lussi');
$event = new PublisherEvent($file, $versions);
$this->assertSame($file, $event->getFile());
$versions = $event->getVersions();
$this->assertCount(2, $versions);
$this->assertEquals(array(Version::get('tussi'), Version::get('lussi')), $versions);
}
/**
* @test
*/
public function eventShouldInitializeCorrectly()
{
$vp = $this->getMockedVersionProvider();
$file = File::create();
$versions = array('tussi', 'lussi');
$event = new VersionProviderEvent($vp, $file, $versions);
$this->assertSame($file, $event->getVersionable());
$this->assertSame($vp, $event->getProvider());
$this->assertEquals(array(Version::get('tussi'), Version::get('lussi')), $event->getVersions());
}
/**
* @test
* @dataProvider provideVersionsAndValidities
*/
public function checksVersionValidity($version, $expected)
{
if (!$expected) {
$this->setExpectedException('Xi\\Filelib\\InvalidVersionException');
}
$plugin = new OriginalVersionPlugin('originale');
$version = Version::get($version);
$version2 = $plugin->ensureValidVersion($version);
$this->assertSame($version, $version2);
$this->assertInstanceOf('Xi\\Filelib\\Version', $version2);
}
/**
* @test
*/
public function getVersionProviderShouldDelegateToProfile()
{
$vp = $this->getMockedVersionProvider();
$file = File::create(array('profile' => 'meisterlus'));
$version = Version::get('kloo');
$profile = $this->getMockedFileProfile('meisterlus');
$profile->expects($this->once())->method('getVersionProvider')->with($file, $version)->will($this->returnValue($vp));
$this->manager->addProfile($profile);
$ret = $this->manager->getVersionProvider($file, $version);
$this->assertSame($vp, $ret);
}
/**
* @test
*/
public function unpublishShouldUnpublishFileVersion()
{
$adapter = new CopyFilesystemPublisherAdapter(ROOT_TESTS . '/data/publisher/public', "600", "700", '');
$publisher = new Publisher($adapter, new UniversalSequentialLinker());
$publisher->attachTo($this->filelib);
$file = $this->filelib->uploadFile(ROOT_TESTS . '/data/self-lussing-manatee.jpg');
$publisher->publishVersion($file, Version::get('original'));
$path = ROOT_TESTS . '/data/publisher/public/' . $publisher->getUrl($file, Version::get('original'));
$this->assertFileExists($path);
$this->assertFalse(is_link($path));
$publisher->unpublishVersion($file, Version::get('original'));
$this->assertFileNotExists($path);
}
/**
* @test
*/
public function toArrayShouldWorkAsExpected()
{
$resource = Resource::create();
$resource->setHash('hashisen-kone');
$resource->setUuid('uuid');
$resource->setId(655);
$resource->setDateCreated(new \DateTime('1978-03-21'));
$resource->setMimetype('video/lus');
$resource->setSize(5678);
$resource->setExclusive(true);
$resource->addVersion(Version::get('kraa'));
$resource->addVersion(Version::get('xoo'));
$this->assertEquals(array('id' => 655, 'uuid' => 'uuid', 'hash' => 'hashisen-kone', 'date_created' => new \DateTime('1978-03-21'), 'data' => array('versions' => array('kraa', 'xoo')), 'size' => 5678, 'mimetype' => 'video/lus', 'exclusive' => true), $resource->toArray());
}
/**
* @test
*/
public function eventShouldInitializeCorrectly()
{
$file = $this->getMockedFile();
$response = new Response();
$adaptedResponse = new AdaptedResponse();
$event = new RenderEvent($response, $adaptedResponse, 'gran-tenhunen', $file);
$this->assertSame($file, $event->getFile());
$this->assertEquals(Version::get('gran-tenhunen'), $event->getVersion());
$this->assertSame($response, $event->getInternalResponse());
$this->assertSame($adaptedResponse, $event->getAdaptedResponse());
$replacementResponse = new AdaptedResponse();
$event->setAdaptedResponse($replacementResponse);
$this->assertSame($replacementResponse, $event->getAdaptedResponse());
}
/**
* @test
*/
public function cachesVersions()
{
$id = 'tusso con lusso';
$version = Version::get('tenhunizer');
$versionable = File::create(array('id' => $id));
$versionable2 = Resource::create(array('id' => $id));
$this->assertFalse($this->cache->getVersion($versionable, $version));
$this->cache->setVersion($versionable, $version, $this->retrieved);
$this->cache->setVersion($versionable2, $version, $this->retrieved2);
$this->assertSame($this->retrieved, $this->cache->getVersion($versionable, $version));
$this->assertSame($this->retrieved2, $this->cache->getVersion($versionable2, $version));
$this->assertNotSame($this->cache->getVersion($versionable, $version), $this->cache->getVersion($versionable2, $version));
$this->cache->deleteVersion($versionable, $version);
$this->assertFalse($this->cache->getVersion($versionable, $version));
$this->assertSame($this->retrieved2, $this->cache->getVersion($versionable2, $version));
}
public function setUp()
{
$this->version = Version::get('xoo');
$fo = $this->getMockBuilder('\\Xi\\Filelib\\Folder\\FolderRepository')->disableOriginalConstructor()->getMock();
$fo->expects($this->any())->method('find')->will($this->returnCallback(function ($id) {
if ($id == 1) {
return Folder::create(array('id' => 1, 'name' => 'root', 'parent_id' => null, 'url' => ''));
} elseif ($id == 2) {
return Folder::create(array('id' => 2, 'name' => 'lussuttaja', 'parent_id' => 1, 'url' => '/lussuttaja'));
} elseif ($id == 3) {
return Folder::create(array('id' => 2, 'name' => 'tussin', 'parent_id' => 2, 'url' => '/lussuttaja/tussin'));
} elseif ($id == 4) {
return Folder::create(array('id' => 2, 'name' => 'banaanin', 'parent_id' => 2, 'url' => '/lussuttaja/banaanin'));
}
return null;
}));
$this->fo = $fo;
$vp = $this->getMockedVersionProvider();
$vp->expects($this->any())->method('getExtension')->with($this->isInstanceOf('Xi\\Filelib\\File\\File'), $this->version)->will($this->returnValue('xoo'));
$this->versionProvider = $vp;
}
/**
* @test
*/
public function setsVersion()
{
$version = new Version('tenhunen', array('suuruus' => 'ylistetty'), array('x5', 'x6'));
$this->assertEquals('tenhunen', $version->getVersion());
$ret = $version->setVersion('tenhunizer');
$this->assertNotSame($version, $ret);
$this->assertEquals('tenhunizer', $ret->getVersion());
}
/**
* @test
* @dataProvider provideFiles
*/
public function createsLinks($file, $levels, $fpd, $beautifurl)
{
$linker = new ReversibleSequentialLinker($levels, $fpd);
$linker->attachTo($this->getMockedFilelib());
$this->assertEquals($beautifurl, $linker->getLink($file, Version::get('xoo'), $this->versionProvider->getExtension($file, Version::get('xoo'))));
}
/**
* @param Version $version
* @return Version
* @throws InvalidVersionException
*/
public function ensureValidVersion(Version $version)
{
$version = parent::ensureValidVersion($version);
$unknownParams = array_map(function ($param) {
return '\'' . $param . '\'';
}, array_diff(array_keys($version->getParams()), call_user_func($this->allowedParamsGetter)));
if (count($unknownParams)) {
throw new InvalidVersionException(sprintf("Unknown version parameters: %s", implode(', ', $unknownParams)));
}
$unknownModifiers = array_map(function ($param) {
return '\'' . $param . '\'';
}, array_diff($version->getModifiers(), call_user_func($this->allowedModifiersGetter)));
if (count($unknownModifiers)) {
throw new InvalidVersionException(sprintf("Unknown version modifiers: %s", implode(', ', $unknownModifiers)));
}
$newParams = array_merge(call_user_func($this->defaultParamsGetter), $version->getParams());
$version = new Version($version->getVersion(), $newParams, $version->getModifiers());
$isValid = call_user_func_array($this->versionValidityChecker, array($version));
if (!$isValid) {
throw new InvalidVersionException(sprintf("Invalid version '%s'", $version->toString()));
}
return $version;
}
/**
* @test
*/
public function throwsUpInvalidVersion()
{
$this->plugin->expects($this->once())->method('getProvidedVersions')->will($this->returnValue(array('sooxer')));
$version = Version::get('tooxer');
$this->setExpectedException('Xi\\Filelib\\InvalidVersionException');
$this->plugin->ensureValidVersion($version);
}
/**
* @test
* @dataProvider updateResourceProvider
* @param mixed $resourceId
* @param mixed $versions
*/
public function updateResourceShouldUpdateResource($resourceId, $versions)
{
$this->setUpSimpleDataSet();
$resource = $this->findResource($resourceId);
$this->assertInstanceOf('Xi\\Filelib\\Resource\\Resource', $resource);
$this->assertNotNull($resource->getUuid());
$this->assertEquals($resourceId, $resource->getId());
$this->assertNotEquals($versions, $resource->getVersions());
$this->assertTrue($resource->isExclusive());
$expectedVersions = array_merge($resource->getVersions(), $versions);
foreach ($versions as $version) {
$resource->addVersion(Version::get($version));
}
$resource->setExclusive(false);
$this->assertTrue($this->backend->updateResource($resource));
$resource2 = $this->findResource($resourceId);
$this->assertEquals($expectedVersions, $resource2->getVersions());
$this->assertFalse($resource2->isExclusive());
}
/**
* @test
*/
public function failedProviderFails()
{
$resource = Resource::create();
$file = File::create(array('resource' => $resource, 'name' => 'lussuti.pdf'));
$vp = $this->getMockedVersionProvider(array('xooxer'), true);
$this->pm->expects($this->any())->method('getVersionProvider')->with($file, Version::get('xooxer'))->will($this->returnValue($vp));
$vp->expects($this->atLeastOnce())->method('getApplicableVersionable')->will($this->returnValue($resource));
$vp->expects($this->atLeastOnce())->method('ensureValidVersion')->will($this->returnArgument(0));
$vp->expects($this->once())->method('provideVersion')->with($file, Version::get('xooxer'))->will($this->throwException(new RuntimeException('Oh noes')));
$this->fiop->expects($this->never())->method('update');
$ret = $this->renderer->render($file, 'xooxer');
$this->assertInstanceOf('Xi\\Filelib\\Renderer\\Response', $ret);
$this->assertEquals(404, $ret->getStatusCode());
}
/**
* @param File $file
* @param Version $version
* @param string $extension
* @return string
*/
public function getLink(File $file, Version $version, $extension)
{
$pinfo = pathinfo($this->getFileName($file));
return $file->getDateCreated()->format($this->getFormat()) . '/' . $pinfo['filename'] . '-' . $version->toString() . '.' . $extension;
}
