/**
* @inheritDoc
*/
public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
{
$filters = array();
$config = $container->get('config');
if (!empty($config['asset_manager']['filters'])) {
$filters = $config['asset_manager']['filters'];
}
$assetFilterManager = new AssetFilterManager($filters);
$assetFilterManager->setServiceLocator($container);
$assetFilterManager->setMimeResolver($container->get(MimeResolver::class));
return $assetFilterManager;
}
/**
* {@inheritDoc}
*
* @return AssetFilterManager
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$filters = array();
$config = $serviceLocator->get('Config');
if (!empty($config['asset_manager']['filters'])) {
$filters = $config['asset_manager']['filters'];
}
$assetFilterManager = new AssetFilterManager($filters);
$assetFilterManager->setServiceLocator($serviceLocator);
$assetFilterManager->setMimeResolver($serviceLocator->get('AssetManager\\Service\\MimeResolver'));
return $assetFilterManager;
}
public function testFiltersAreInstantiatedOnce()
{
$assetFilterManager = new AssetFilterManager(array('test/path.test' => array(array('filter' => 'CustomFilter'))));
$filterInstance = null;
$asset = $this->getMock(AssetInterface::class);
$asset->expects($this->any())->method('ensureFilter')->with($this->callback(function (FilterInterface $filter) use(&$filterInstance) {
if ($filterInstance === null) {
$filterInstance = $filter;
}
return $filter === $filterInstance;
}));
$assetFilterManager->setFilters('test/path.test', $asset);
$assetFilterManager->setFilters('test/path.test', $asset);
}
public function testResolveAssetSuccess()
{
$resolver = new ConcatResolver();
$asset1 = array('bacon' => array(__FILE__, __FILE__));
$callback = function ($file) {
$asset = new \Assetic\Asset\FileAsset($file);
return $asset;
};
$aggregateResolver = $this->getMock(ResolverInterface::class);
$aggregateResolver->expects($this->exactly(2))->method('resolve')->will($this->returnCallback($callback));
$resolver->setAggregateResolver($aggregateResolver);
$assetFilterManager = new AssetFilterManager();
$mimeResolver = new MimeResolver();
$assetFilterManager->setMimeResolver($mimeResolver);
$resolver->setMimeResolver($mimeResolver);
$resolver->setAssetFilterManager($assetFilterManager);
$resolver->setConcats($asset1);
$asset = $resolver->resolve('bacon');
$this->assertTrue($asset instanceof AggregateAsset);
$this->assertEquals($asset->dump(), file_get_contents(__FILE__) . file_get_contents(__FILE__));
}
public function testSuccessResolve()
{
$callbackInvocationCount = 0;
$callback = function () use(&$callbackInvocationCount) {
$asset1 = new Asset\StringAsset('bacon');
$asset2 = new Asset\StringAsset('eggs');
$asset3 = new Asset\StringAsset('Mud');
$asset1->mimetype = 'text/plain';
$asset2->mimetype = 'text/plain';
$asset3->mimetype = 'text/plain';
$callbackInvocationCount += 1;
$assetName = "asset{$callbackInvocationCount}";
return ${$assetName};
};
$aggregateResolver = $this->getMock('AssetManager\\Resolver\\ResolverInterface');
$aggregateResolver->expects($this->exactly(3))->method('resolve')->will($this->returnCallback($callback));
$resolver = new CollectionResolver(array('myCollection' => array('bacon', 'eggs', 'mud')));
$mimeResolver = new MimeResolver();
$assetFilterManager = new AssetFilterManager();
$assetFilterManager->setMimeResolver($mimeResolver);
$resolver->setAggregateResolver($aggregateResolver);
$resolver->setAssetFilterManager($assetFilterManager);
$collectionResolved = $resolver->resolve('myCollection');
$this->assertEquals($collectionResolved->mimetype, 'text/plain');
$this->assertTrue($collectionResolved instanceof Asset\AssetCollection);
}
public function testTwoCollectionsHasDifferentCacheKey()
{
$aggregateResolver = $this->getMock('AssetManager\\Resolver\\ResolverInterface');
//assets with same 'last modifled time'.
$now = time();
$bacon = new Asset\StringAsset('bacon');
$bacon->setLastModified($now);
$bacon->mimetype = 'text/plain';
$eggs = new Asset\StringAsset('eggs');
$eggs->setLastModified($now);
$eggs->mimetype = 'text/plain';
$assets = array(array('bacon', $bacon), array('eggs', $eggs));
$aggregateResolver->expects($this->any())->method('resolve')->will($this->returnValueMap($assets));
$resolver = new CollectionResolver(array('collection1' => array('bacon'), 'collection2' => array('eggs')));
$mimeResolver = new MimeResolver();
$assetFilterManager = new \AssetManager\Service\AssetFilterManager();
$assetFilterManager->setMimeResolver($mimeResolver);
$resolver->setAggregateResolver($aggregateResolver);
$resolver->setAssetFilterManager($assetFilterManager);
$collection1 = $resolver->resolve('collection1');
$collection2 = $resolver->resolve('collection2');
$cacheInterface = $this->getMock('Assetic\\Cache\\CacheInterface');
$cacheKeys = new \ArrayObject();
$callback = function ($key) use($cacheKeys) {
$cacheKeys[] = $key;
return true;
};
$cacheInterface->expects($this->exactly(2))->method('has')->will($this->returnCallback($callback));
$cacheInterface->expects($this->exactly(2))->method('get')->will($this->returnValue('cached content'));
$cache1 = new AssetCache($collection1, $cacheInterface);
$cache1->load();
$cache2 = new AssetCache($collection2, $cacheInterface);
$cache2->load();
$this->assertCount(2, $cacheKeys);
$this->assertNotEquals($cacheKeys[0], $cacheKeys[1]);
}
public function testClearOutputBufferInSetAssetOnResponse()
{
$this->expectOutputString(file_get_contents(__FILE__));
echo "This string would definately break any image source.\n";
echo "This one would make it even worse.\n";
echo "They all should be gone soon...\n";
$assetFilterManager = new AssetFilterManager();
$assetCacheManager = $this->getAssetCacheManagerMock();
$mimeResolver = new MimeResolver();
$assetManager = new AssetManager($this->getResolver(), array('clear_output_buffer' => true));
$assetFilterManager->setMimeResolver($mimeResolver);
$assetManager->setAssetFilterManager($assetFilterManager);
$assetManager->setAssetCacheManager($assetCacheManager);
$assetManager->resolvesToAsset($this->getRequest());
$response = $assetManager->setAssetOnResponse(new Response());
echo $response->getContent();
}
public function testResponseHeadersForAsset()
{
$mimeResolver = new MimeResolver();
$assetFilterManager = new AssetFilterManager();
$assetCacheManager = $this->getAssetCacheManagerMock();
$assetManager = new AssetManager($this->getResolver());
$assetFilterManager->setMimeResolver($mimeResolver);
$assetManager->setAssetFilterManager($assetFilterManager);
$assetManager->setAssetCacheManager($assetCacheManager);
$request = $this->getRequest();
$assetManager->resolvesToAsset($request);
$response = $assetManager->setAssetOnResponse(new Response());
$thisFile = file_get_contents(__FILE__);
if (function_exists('mb_strlen')) {
$fileSize = mb_strlen($thisFile, '8bit');
} else {
$fileSize = strlen($thisFile);
}
$mimeType = $mimeResolver->getMimeType(__FILE__);
$headers = 'Content-Transfer-Encoding: binary' . "\r\n";
$headers .= 'Content-Type: ' . $mimeType . "\r\n";
$headers .= 'Content-Length: ' . $fileSize . "\r\n";
$this->assertSame($headers, $response->getHeaders()->toString());
}
/**
* @expectedException \RuntimeException
*/
public function testensureByInvalid()
{
$assetFilterManager = new AssetFilterManager(array('test/path.test' => array(array())));
$asset = new StringAsset('Herp derp');
$assetFilterManager->setFilters('test/path.test', $asset);
}
