??????????????
PK ! ϸ# # EsiTest.phpnu
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Tests\HttpCache;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpKernel\HttpCache\Esi;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
class EsiTest extends TestCase
{
public function testHasSurrogateEsiCapability()
{
$esi = new Esi();
$request = Request::create('/');
$request->headers->set('Surrogate-Capability', 'abc="ESI/1.0"');
$this->assertTrue($esi->hasSurrogateCapability($request));
$request = Request::create('/');
$request->headers->set('Surrogate-Capability', 'foobar');
$this->assertFalse($esi->hasSurrogateCapability($request));
$request = Request::create('/');
$this->assertFalse($esi->hasSurrogateCapability($request));
}
public function testAddSurrogateEsiCapability()
{
$esi = new Esi();
$request = Request::create('/');
$esi->addSurrogateCapability($request);
$this->assertEquals('symfony="ESI/1.0"', $request->headers->get('Surrogate-Capability'));
$esi->addSurrogateCapability($request);
$this->assertEquals('symfony="ESI/1.0", symfony="ESI/1.0"', $request->headers->get('Surrogate-Capability'));
}
public function testAddSurrogateControl()
{
$esi = new Esi();
$response = new Response('foo ');
$esi->addSurrogateControl($response);
$this->assertEquals('content="ESI/1.0"', $response->headers->get('Surrogate-Control'));
$response = new Response('foo');
$esi->addSurrogateControl($response);
$this->assertEquals('', $response->headers->get('Surrogate-Control'));
}
public function testNeedsEsiParsing()
{
$esi = new Esi();
$response = new Response();
$response->headers->set('Surrogate-Control', 'content="ESI/1.0"');
$this->assertTrue($esi->needsParsing($response));
$response = new Response();
$this->assertFalse($esi->needsParsing($response));
}
public function testRenderIncludeTag()
{
$esi = new Esi();
$this->assertEquals('', $esi->renderIncludeTag('/', '/alt', true));
$this->assertEquals('', $esi->renderIncludeTag('/', '/alt', false));
$this->assertEquals('', $esi->renderIncludeTag('/'));
$this->assertEquals(''."\n".'', $esi->renderIncludeTag('/', '/alt', true, 'some comment'));
}
public function testProcessDoesNothingIfContentTypeIsNotHtml()
{
$esi = new Esi();
$request = Request::create('/');
$response = new Response();
$response->headers->set('Content-Type', 'text/plain');
$esi->process($request, $response);
$this->assertFalse($response->headers->has('x-body-eval'));
}
public function testMultilineEsiRemoveTagsAreRemoved()
{
$esi = new Esi();
$request = Request::create('/');
$response = new Response(' www.example.com Keep this'."\n www.example.com And this");
$esi->process($request, $response);
$this->assertEquals(' Keep this And this', $response->getContent());
}
public function testCommentTagsAreRemoved()
{
$esi = new Esi();
$request = Request::create('/');
$response = new Response(' Keep this');
$esi->process($request, $response);
$this->assertEquals(' Keep this', $response->getContent());
}
public function testProcess()
{
$esi = new Esi();
$request = Request::create('/');
$response = new Response('foo ');
$esi->process($request, $response);
$this->assertEquals('foo surrogate->handle($this, \'...\', \'alt\', true) ?>'."\n", $response->getContent());
$this->assertEquals('ESI', $response->headers->get('x-body-eval'));
$response = new Response('foo ');
$esi->process($request, $response);
$this->assertEquals('foo surrogate->handle($this, \'foo\\\'\', \'bar\\\'\', true) ?>'."\n", $response->getContent());
$response = new Response('foo ');
$esi->process($request, $response);
$this->assertEquals('foo surrogate->handle($this, \'...\', \'\', false) ?>'."\n", $response->getContent());
$response = new Response('foo ');
$esi->process($request, $response);
$this->assertEquals('foo surrogate->handle($this, \'...\', \'\', false) ?>'."\n", $response->getContent());
}
public function testProcessEscapesPhpTags()
{
$esi = new Esi();
$request = Request::create('/');
$response = new Response('');
$esi->process($request, $response);
$this->assertEquals('php cript language=php>', $response->getContent());
}
/**
* @expectedException \RuntimeException
*/
public function testProcessWhenNoSrcInAnEsi()
{
$esi = new Esi();
$request = Request::create('/');
$response = new Response('foo ');
$esi->process($request, $response);
}
public function testProcessRemoveSurrogateControlHeader()
{
$esi = new Esi();
$request = Request::create('/');
$response = new Response('foo ');
$response->headers->set('Surrogate-Control', 'content="ESI/1.0"');
$esi->process($request, $response);
$this->assertEquals('ESI', $response->headers->get('x-body-eval'));
$response->headers->set('Surrogate-Control', 'no-store, content="ESI/1.0"');
$esi->process($request, $response);
$this->assertEquals('ESI', $response->headers->get('x-body-eval'));
$this->assertEquals('no-store', $response->headers->get('surrogate-control'));
$response->headers->set('Surrogate-Control', 'content="ESI/1.0", no-store');
$esi->process($request, $response);
$this->assertEquals('ESI', $response->headers->get('x-body-eval'));
$this->assertEquals('no-store', $response->headers->get('surrogate-control'));
}
public function testHandle()
{
$esi = new Esi();
$cache = $this->getCache(Request::create('/'), new Response('foo'));
$this->assertEquals('foo', $esi->handle($cache, '/', '/alt', true));
}
/**
* @expectedException \RuntimeException
*/
public function testHandleWhenResponseIsNot200()
{
$esi = new Esi();
$response = new Response('foo');
$response->setStatusCode(404);
$cache = $this->getCache(Request::create('/'), $response);
$esi->handle($cache, '/', '/alt', false);
}
public function testHandleWhenResponseIsNot200AndErrorsAreIgnored()
{
$esi = new Esi();
$response = new Response('foo');
$response->setStatusCode(404);
$cache = $this->getCache(Request::create('/'), $response);
$this->assertEquals('', $esi->handle($cache, '/', '/alt', true));
}
public function testHandleWhenResponseIsNot200AndAltIsPresent()
{
$esi = new Esi();
$response1 = new Response('foo');
$response1->setStatusCode(404);
$response2 = new Response('bar');
$cache = $this->getCache(Request::create('/'), array($response1, $response2));
$this->assertEquals('bar', $esi->handle($cache, '/', '/alt', false));
}
protected function getCache($request, $response)
{
$cache = $this->getMockBuilder('Symfony\Component\HttpKernel\HttpCache\HttpCache')->setMethods(array('getRequest', 'handle'))->disableOriginalConstructor()->getMock();
$cache->expects($this->any())
->method('getRequest')
->will($this->returnValue($request))
;
if (is_array($response)) {
$cache->expects($this->any())
->method('handle')
->will(call_user_func_array(array($this, 'onConsecutiveCalls'), $response))
;
} else {
$cache->expects($this->any())
->method('handle')
->will($this->returnValue($response))
;
}
return $cache;
}
}
PK ! 0R R HttpCacheTest.phpnu
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Tests\HttpCache;
use Symfony\Component\HttpKernel\HttpCache\HttpCache;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\HttpKernelInterface;
/**
* @group time-sensitive
*/
class HttpCacheTest extends HttpCacheTestCase
{
public function testTerminateDelegatesTerminationOnlyForTerminableInterface()
{
$storeMock = $this->getMockBuilder('Symfony\\Component\\HttpKernel\\HttpCache\\StoreInterface')
->disableOriginalConstructor()
->getMock();
// does not implement TerminableInterface
$kernel = new TestKernel();
$httpCache = new HttpCache($kernel, $storeMock);
$httpCache->terminate(Request::create('/'), new Response());
$this->assertFalse($kernel->terminateCalled, 'terminate() is never called if the kernel class does not implement TerminableInterface');
// implements TerminableInterface
$kernelMock = $this->getMockBuilder('Symfony\\Component\\HttpKernel\\Kernel')
->disableOriginalConstructor()
->setMethods(array('terminate', 'registerBundles', 'registerContainerConfiguration'))
->getMock();
$kernelMock->expects($this->once())
->method('terminate');
$kernel = new HttpCache($kernelMock, $storeMock);
$kernel->terminate(Request::create('/'), new Response());
}
public function testPassesOnNonGetHeadRequests()
{
$this->setNextResponse(200);
$this->request('POST', '/');
$this->assertHttpKernelIsCalled();
$this->assertResponseOk();
$this->assertTraceContains('pass');
$this->assertFalse($this->response->headers->has('Age'));
}
public function testInvalidatesOnPostPutDeleteRequests()
{
foreach (array('post', 'put', 'delete') as $method) {
$this->setNextResponse(200);
$this->request($method, '/');
$this->assertHttpKernelIsCalled();
$this->assertResponseOk();
$this->assertTraceContains('invalidate');
$this->assertTraceContains('pass');
}
}
public function testDoesNotCacheWithAuthorizationRequestHeaderAndNonPublicResponse()
{
$this->setNextResponse(200, array('ETag' => '"Foo"'));
$this->request('GET', '/', array('HTTP_AUTHORIZATION' => 'basic foobarbaz'));
$this->assertHttpKernelIsCalled();
$this->assertResponseOk();
$this->assertEquals('private', $this->response->headers->get('Cache-Control'));
$this->assertTraceContains('miss');
$this->assertTraceNotContains('store');
$this->assertFalse($this->response->headers->has('Age'));
}
public function testDoesCacheWithAuthorizationRequestHeaderAndPublicResponse()
{
$this->setNextResponse(200, array('Cache-Control' => 'public', 'ETag' => '"Foo"'));
$this->request('GET', '/', array('HTTP_AUTHORIZATION' => 'basic foobarbaz'));
$this->assertHttpKernelIsCalled();
$this->assertResponseOk();
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertTrue($this->response->headers->has('Age'));
$this->assertEquals('public', $this->response->headers->get('Cache-Control'));
}
public function testDoesNotCacheWithCookieHeaderAndNonPublicResponse()
{
$this->setNextResponse(200, array('ETag' => '"Foo"'));
$this->request('GET', '/', array(), array('foo' => 'bar'));
$this->assertHttpKernelIsCalled();
$this->assertResponseOk();
$this->assertEquals('private', $this->response->headers->get('Cache-Control'));
$this->assertTraceContains('miss');
$this->assertTraceNotContains('store');
$this->assertFalse($this->response->headers->has('Age'));
}
public function testDoesNotCacheRequestsWithACookieHeader()
{
$this->setNextResponse(200);
$this->request('GET', '/', array(), array('foo' => 'bar'));
$this->assertHttpKernelIsCalled();
$this->assertResponseOk();
$this->assertEquals('private', $this->response->headers->get('Cache-Control'));
$this->assertTraceContains('miss');
$this->assertTraceNotContains('store');
$this->assertFalse($this->response->headers->has('Age'));
}
public function testRespondsWith304WhenIfModifiedSinceMatchesLastModified()
{
$time = \DateTime::createFromFormat('U', time());
$this->setNextResponse(200, array('Cache-Control' => 'public', 'Last-Modified' => $time->format(DATE_RFC2822), 'Content-Type' => 'text/plain'), 'Hello World');
$this->request('GET', '/', array('HTTP_IF_MODIFIED_SINCE' => $time->format(DATE_RFC2822)));
$this->assertHttpKernelIsCalled();
$this->assertEquals(304, $this->response->getStatusCode());
$this->assertEquals('', $this->response->headers->get('Content-Type'));
$this->assertEmpty($this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
}
public function testRespondsWith304WhenIfNoneMatchMatchesETag()
{
$this->setNextResponse(200, array('Cache-Control' => 'public', 'ETag' => '12345', 'Content-Type' => 'text/plain'), 'Hello World');
$this->request('GET', '/', array('HTTP_IF_NONE_MATCH' => '12345'));
$this->assertHttpKernelIsCalled();
$this->assertEquals(304, $this->response->getStatusCode());
$this->assertEquals('', $this->response->headers->get('Content-Type'));
$this->assertTrue($this->response->headers->has('ETag'));
$this->assertEmpty($this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
}
public function testRespondsWith304OnlyIfIfNoneMatchAndIfModifiedSinceBothMatch()
{
$time = \DateTime::createFromFormat('U', time());
$this->setNextResponse(200, array(), '', function ($request, $response) use ($time) {
$response->setStatusCode(200);
$response->headers->set('ETag', '12345');
$response->headers->set('Last-Modified', $time->format(DATE_RFC2822));
$response->headers->set('Content-Type', 'text/plain');
$response->setContent('Hello World');
});
// only ETag matches
$t = \DateTime::createFromFormat('U', time() - 3600);
$this->request('GET', '/', array('HTTP_IF_NONE_MATCH' => '12345', 'HTTP_IF_MODIFIED_SINCE' => $t->format(DATE_RFC2822)));
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
// only Last-Modified matches
$this->request('GET', '/', array('HTTP_IF_NONE_MATCH' => '1234', 'HTTP_IF_MODIFIED_SINCE' => $time->format(DATE_RFC2822)));
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
// Both matches
$this->request('GET', '/', array('HTTP_IF_NONE_MATCH' => '12345', 'HTTP_IF_MODIFIED_SINCE' => $time->format(DATE_RFC2822)));
$this->assertHttpKernelIsCalled();
$this->assertEquals(304, $this->response->getStatusCode());
}
public function testIncrementsMaxAgeWhenNoDateIsSpecifiedEventWhenUsingETag()
{
$this->setNextResponse(
200,
array(
'ETag' => '1234',
'Cache-Control' => 'public, s-maxage=60',
)
);
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
sleep(2);
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('fresh');
$this->assertEquals(2, $this->response->headers->get('Age'));
}
public function testValidatesPrivateResponsesCachedOnTheClient()
{
$this->setNextResponse(200, array(), '', function ($request, $response) {
$etags = preg_split('/\s*,\s*/', $request->headers->get('IF_NONE_MATCH'));
if ($request->cookies->has('authenticated')) {
$response->headers->set('Cache-Control', 'private, no-store');
$response->setETag('"private tag"');
if (in_array('"private tag"', $etags)) {
$response->setStatusCode(304);
} else {
$response->setStatusCode(200);
$response->headers->set('Content-Type', 'text/plain');
$response->setContent('private data');
}
} else {
$response->headers->set('Cache-Control', 'public');
$response->setETag('"public tag"');
if (in_array('"public tag"', $etags)) {
$response->setStatusCode(304);
} else {
$response->setStatusCode(200);
$response->headers->set('Content-Type', 'text/plain');
$response->setContent('public data');
}
}
});
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('"public tag"', $this->response->headers->get('ETag'));
$this->assertEquals('public data', $this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->request('GET', '/', array(), array('authenticated' => ''));
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('"private tag"', $this->response->headers->get('ETag'));
$this->assertEquals('private data', $this->response->getContent());
$this->assertTraceContains('stale');
$this->assertTraceContains('invalid');
$this->assertTraceNotContains('store');
}
public function testStoresResponsesWhenNoCacheRequestDirectivePresent()
{
$time = \DateTime::createFromFormat('U', time() + 5);
$this->setNextResponse(200, array('Cache-Control' => 'public', 'Expires' => $time->format(DATE_RFC2822)));
$this->request('GET', '/', array('HTTP_CACHE_CONTROL' => 'no-cache'));
$this->assertHttpKernelIsCalled();
$this->assertTraceContains('store');
$this->assertTrue($this->response->headers->has('Age'));
}
public function testReloadsResponsesWhenCacheHitsButNoCacheRequestDirectivePresentWhenAllowReloadIsSetTrue()
{
$count = 0;
$this->setNextResponse(200, array('Cache-Control' => 'public, max-age=10000'), '', function ($request, $response) use (&$count) {
++$count;
$response->setContent(1 == $count ? 'Hello World' : 'Goodbye World');
});
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('store');
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('fresh');
$this->cacheConfig['allow_reload'] = true;
$this->request('GET', '/', array('HTTP_CACHE_CONTROL' => 'no-cache'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Goodbye World', $this->response->getContent());
$this->assertTraceContains('reload');
$this->assertTraceContains('store');
}
public function testDoesNotReloadResponsesWhenAllowReloadIsSetFalseDefault()
{
$count = 0;
$this->setNextResponse(200, array('Cache-Control' => 'public, max-age=10000'), '', function ($request, $response) use (&$count) {
++$count;
$response->setContent(1 == $count ? 'Hello World' : 'Goodbye World');
});
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('store');
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('fresh');
$this->cacheConfig['allow_reload'] = false;
$this->request('GET', '/', array('HTTP_CACHE_CONTROL' => 'no-cache'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceNotContains('reload');
$this->request('GET', '/', array('HTTP_CACHE_CONTROL' => 'no-cache'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceNotContains('reload');
}
public function testRevalidatesFreshCacheEntryWhenMaxAgeRequestDirectiveIsExceededWhenAllowRevalidateOptionIsSetTrue()
{
$count = 0;
$this->setNextResponse(200, array(), '', function ($request, $response) use (&$count) {
++$count;
$response->headers->set('Cache-Control', 'public, max-age=10000');
$response->setETag($count);
$response->setContent(1 == $count ? 'Hello World' : 'Goodbye World');
});
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('store');
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('fresh');
$this->cacheConfig['allow_revalidate'] = true;
$this->request('GET', '/', array('HTTP_CACHE_CONTROL' => 'max-age=0'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Goodbye World', $this->response->getContent());
$this->assertTraceContains('stale');
$this->assertTraceContains('invalid');
$this->assertTraceContains('store');
}
public function testDoesNotRevalidateFreshCacheEntryWhenEnableRevalidateOptionIsSetFalseDefault()
{
$count = 0;
$this->setNextResponse(200, array(), '', function ($request, $response) use (&$count) {
++$count;
$response->headers->set('Cache-Control', 'public, max-age=10000');
$response->setETag($count);
$response->setContent(1 == $count ? 'Hello World' : 'Goodbye World');
});
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('store');
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('fresh');
$this->cacheConfig['allow_revalidate'] = false;
$this->request('GET', '/', array('HTTP_CACHE_CONTROL' => 'max-age=0'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceNotContains('stale');
$this->assertTraceNotContains('invalid');
$this->assertTraceContains('fresh');
$this->request('GET', '/', array('HTTP_CACHE_CONTROL' => 'max-age=0'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceNotContains('stale');
$this->assertTraceNotContains('invalid');
$this->assertTraceContains('fresh');
}
public function testFetchesResponseFromBackendWhenCacheMisses()
{
$time = \DateTime::createFromFormat('U', time() + 5);
$this->setNextResponse(200, array('Cache-Control' => 'public', 'Expires' => $time->format(DATE_RFC2822)));
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('miss');
$this->assertTrue($this->response->headers->has('Age'));
}
public function testDoesNotCacheSomeStatusCodeResponses()
{
foreach (array_merge(range(201, 202), range(204, 206), range(303, 305), range(400, 403), range(405, 409), range(411, 417), range(500, 505)) as $code) {
$time = \DateTime::createFromFormat('U', time() + 5);
$this->setNextResponse($code, array('Expires' => $time->format(DATE_RFC2822)));
$this->request('GET', '/');
$this->assertEquals($code, $this->response->getStatusCode());
$this->assertTraceNotContains('store');
$this->assertFalse($this->response->headers->has('Age'));
}
}
public function testDoesNotCacheResponsesWithExplicitNoStoreDirective()
{
$time = \DateTime::createFromFormat('U', time() + 5);
$this->setNextResponse(200, array('Expires' => $time->format(DATE_RFC2822), 'Cache-Control' => 'no-store'));
$this->request('GET', '/');
$this->assertTraceNotContains('store');
$this->assertFalse($this->response->headers->has('Age'));
}
public function testDoesNotCacheResponsesWithoutFreshnessInformationOrAValidator()
{
$this->setNextResponse();
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceNotContains('store');
}
public function testCachesResponsesWithExplicitNoCacheDirective()
{
$time = \DateTime::createFromFormat('U', time() + 5);
$this->setNextResponse(200, array('Expires' => $time->format(DATE_RFC2822), 'Cache-Control' => 'public, no-cache'));
$this->request('GET', '/');
$this->assertTraceContains('store');
$this->assertTrue($this->response->headers->has('Age'));
}
public function testCachesResponsesWithAnExpirationHeader()
{
$time = \DateTime::createFromFormat('U', time() + 5);
$this->setNextResponse(200, array('Cache-Control' => 'public', 'Expires' => $time->format(DATE_RFC2822)));
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertNotNull($this->response->headers->get('Date'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$values = $this->getMetaStorageValues();
$this->assertCount(1, $values);
}
public function testCachesResponsesWithAMaxAgeDirective()
{
$this->setNextResponse(200, array('Cache-Control' => 'public, max-age=5'));
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertNotNull($this->response->headers->get('Date'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$values = $this->getMetaStorageValues();
$this->assertCount(1, $values);
}
public function testCachesResponsesWithASMaxAgeDirective()
{
$this->setNextResponse(200, array('Cache-Control' => 's-maxage=5'));
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertNotNull($this->response->headers->get('Date'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$values = $this->getMetaStorageValues();
$this->assertCount(1, $values);
}
public function testCachesResponsesWithALastModifiedValidatorButNoFreshnessInformation()
{
$time = \DateTime::createFromFormat('U', time());
$this->setNextResponse(200, array('Cache-Control' => 'public', 'Last-Modified' => $time->format(DATE_RFC2822)));
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
}
public function testCachesResponsesWithAnETagValidatorButNoFreshnessInformation()
{
$this->setNextResponse(200, array('Cache-Control' => 'public', 'ETag' => '"123456"'));
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
}
public function testHitsCachedResponsesWithExpiresHeader()
{
$time1 = \DateTime::createFromFormat('U', time() - 5);
$time2 = \DateTime::createFromFormat('U', time() + 5);
$this->setNextResponse(200, array('Cache-Control' => 'public', 'Date' => $time1->format(DATE_RFC2822), 'Expires' => $time2->format(DATE_RFC2822)));
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('Date'));
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTrue(strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')) < 2);
$this->assertTrue($this->response->headers->get('Age') > 0);
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
}
public function testHitsCachedResponseWithMaxAgeDirective()
{
$time = \DateTime::createFromFormat('U', time() - 5);
$this->setNextResponse(200, array('Date' => $time->format(DATE_RFC2822), 'Cache-Control' => 'public, max-age=10'));
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('Date'));
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTrue(strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')) < 2);
$this->assertTrue($this->response->headers->get('Age') > 0);
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
}
public function testDegradationWhenCacheLocked()
{
if ('\\' === DIRECTORY_SEPARATOR) {
$this->markTestSkipped('Skips on windows to avoid permissions issues.');
}
$this->cacheConfig['stale_while_revalidate'] = 10;
// The prescence of Last-Modified makes this cacheable (because Response::isValidateable() then).
$this->setNextResponse(200, array('Cache-Control' => 'public, s-maxage=5', 'Last-Modified' => 'some while ago'), 'Old response');
$this->request('GET', '/'); // warm the cache
// Now, lock the cache
$concurrentRequest = Request::create('/', 'GET');
$this->store->lock($concurrentRequest);
/*
* After 10s, the cached response has become stale. Yet, we're still within the "stale_while_revalidate"
* timeout so we may serve the stale response.
*/
sleep(10);
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('stale-while-revalidate');
$this->assertEquals('Old response', $this->response->getContent());
/*
* Another 10s later, stale_while_revalidate is over. Resort to serving the old response, but
* do so with a "server unavailable" message.
*/
sleep(10);
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(503, $this->response->getStatusCode());
$this->assertEquals('Old response', $this->response->getContent());
}
public function testHitsCachedResponseWithSMaxAgeDirective()
{
$time = \DateTime::createFromFormat('U', time() - 5);
$this->setNextResponse(200, array('Date' => $time->format(DATE_RFC2822), 'Cache-Control' => 's-maxage=10, max-age=0'));
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('Date'));
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTrue(strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')) < 2);
$this->assertTrue($this->response->headers->get('Age') > 0);
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
}
public function testAssignsDefaultTtlWhenResponseHasNoFreshnessInformation()
{
$this->setNextResponse();
$this->cacheConfig['default_ttl'] = 10;
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=10/', $this->response->headers->get('Cache-Control'));
$this->cacheConfig['default_ttl'] = 10;
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=10/', $this->response->headers->get('Cache-Control'));
}
public function testAssignsDefaultTtlWhenResponseHasNoFreshnessInformationAndAfterTtlWasExpired()
{
$this->setNextResponse();
$this->cacheConfig['default_ttl'] = 2;
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=2/', $this->response->headers->get('Cache-Control'));
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=2/', $this->response->headers->get('Cache-Control'));
// expires the cache
$values = $this->getMetaStorageValues();
$this->assertCount(1, $values);
$tmp = unserialize($values[0]);
$time = \DateTime::createFromFormat('U', time() - 5);
$tmp[0][1]['date'] = $time->format(DATE_RFC2822);
$r = new \ReflectionObject($this->store);
$m = $r->getMethod('save');
$m->setAccessible(true);
$m->invoke($this->store, 'md'.hash('sha256', 'http://localhost/'), serialize($tmp));
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('stale');
$this->assertTraceContains('invalid');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=2/', $this->response->headers->get('Cache-Control'));
$this->setNextResponse();
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=2/', $this->response->headers->get('Cache-Control'));
}
public function testAssignsDefaultTtlWhenResponseHasNoFreshnessInformationAndAfterTtlWasExpiredWithStatus304()
{
$this->setNextResponse();
$this->cacheConfig['default_ttl'] = 2;
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=2/', $this->response->headers->get('Cache-Control'));
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
// expires the cache
$values = $this->getMetaStorageValues();
$this->assertCount(1, $values);
$tmp = unserialize($values[0]);
$time = \DateTime::createFromFormat('U', time() - 5);
$tmp[0][1]['date'] = $time->format(DATE_RFC2822);
$r = new \ReflectionObject($this->store);
$m = $r->getMethod('save');
$m->setAccessible(true);
$m->invoke($this->store, 'md'.hash('sha256', 'http://localhost/'), serialize($tmp));
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('stale');
$this->assertTraceContains('valid');
$this->assertTraceContains('store');
$this->assertTraceNotContains('miss');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=2/', $this->response->headers->get('Cache-Control'));
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertRegExp('/s-maxage=2/', $this->response->headers->get('Cache-Control'));
}
public function testDoesNotAssignDefaultTtlWhenResponseHasMustRevalidateDirective()
{
$this->setNextResponse(200, array('Cache-Control' => 'must-revalidate'));
$this->cacheConfig['default_ttl'] = 10;
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('miss');
$this->assertTraceNotContains('store');
$this->assertNotRegExp('/s-maxage/', $this->response->headers->get('Cache-Control'));
$this->assertEquals('Hello World', $this->response->getContent());
}
public function testFetchesFullResponseWhenCacheStaleAndNoValidatorsPresent()
{
$time = \DateTime::createFromFormat('U', time() + 5);
$this->setNextResponse(200, array('Cache-Control' => 'public', 'Expires' => $time->format(DATE_RFC2822)));
// build initial request
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('Date'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertNotNull($this->response->headers->get('Age'));
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
// go in and play around with the cached metadata directly ...
$values = $this->getMetaStorageValues();
$this->assertCount(1, $values);
$tmp = unserialize($values[0]);
$time = \DateTime::createFromFormat('U', time());
$tmp[0][1]['expires'] = $time->format(DATE_RFC2822);
$r = new \ReflectionObject($this->store);
$m = $r->getMethod('save');
$m->setAccessible(true);
$m->invoke($this->store, 'md'.hash('sha256', 'http://localhost/'), serialize($tmp));
// build subsequent request; should be found but miss due to freshness
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTrue($this->response->headers->get('Age') <= 1);
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('stale');
$this->assertTraceNotContains('fresh');
$this->assertTraceNotContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Hello World', $this->response->getContent());
}
public function testValidatesCachedResponsesWithLastModifiedAndNoFreshnessInformation()
{
$time = \DateTime::createFromFormat('U', time());
$this->setNextResponse(200, array(), 'Hello World', function ($request, $response) use ($time) {
$response->headers->set('Cache-Control', 'public');
$response->headers->set('Last-Modified', $time->format(DATE_RFC2822));
if ($time->format(DATE_RFC2822) == $request->headers->get('IF_MODIFIED_SINCE')) {
$response->setStatusCode(304);
$response->setContent('');
}
});
// build initial request
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('Last-Modified'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertTraceNotContains('stale');
// build subsequent request; should be found but miss due to freshness
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('Last-Modified'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTrue($this->response->headers->get('Age') <= 1);
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('stale');
$this->assertTraceContains('valid');
$this->assertTraceContains('store');
$this->assertTraceNotContains('miss');
}
public function testValidatesCachedResponsesUseSameHttpMethod()
{
$test = $this;
$this->setNextResponse(200, array(), 'Hello World', function ($request, $response) use ($test) {
$test->assertSame('OPTIONS', $request->getMethod());
});
// build initial request
$this->request('OPTIONS', '/');
// build subsequent request
$this->request('OPTIONS', '/');
}
public function testValidatesCachedResponsesWithETagAndNoFreshnessInformation()
{
$this->setNextResponse(200, array(), 'Hello World', function ($request, $response) {
$response->headers->set('Cache-Control', 'public');
$response->headers->set('ETag', '"12345"');
if ($response->getETag() == $request->headers->get('IF_NONE_MATCH')) {
$response->setStatusCode(304);
$response->setContent('');
}
});
// build initial request
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('ETag'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
// build subsequent request; should be found but miss due to freshness
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('ETag'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTrue($this->response->headers->get('Age') <= 1);
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('stale');
$this->assertTraceContains('valid');
$this->assertTraceContains('store');
$this->assertTraceNotContains('miss');
}
public function testServesResponseWhileFreshAndRevalidatesWithLastModifiedInformation()
{
$time = \DateTime::createFromFormat('U', time());
$this->setNextResponse(200, array(), 'Hello World', function (Request $request, Response $response) use ($time) {
$response->setSharedMaxAge(10);
$response->headers->set('Last-Modified', $time->format(DATE_RFC2822));
});
// prime the cache
$this->request('GET', '/');
// next request before s-maxage has expired: Serve from cache
// without hitting the backend
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('fresh');
sleep(15); // expire the cache
$this->setNextResponse(304, array(), '', function (Request $request, Response $response) use ($time) {
$this->assertEquals($time->format(DATE_RFC2822), $request->headers->get('IF_MODIFIED_SINCE'));
});
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('stale');
$this->assertTraceContains('valid');
}
public function testReplacesCachedResponsesWhenValidationResultsInNon304Response()
{
$time = \DateTime::createFromFormat('U', time());
$count = 0;
$this->setNextResponse(200, array(), 'Hello World', function ($request, $response) use ($time, &$count) {
$response->headers->set('Last-Modified', $time->format(DATE_RFC2822));
$response->headers->set('Cache-Control', 'public');
switch (++$count) {
case 1:
$response->setContent('first response');
break;
case 2:
$response->setContent('second response');
break;
case 3:
$response->setContent('');
$response->setStatusCode(304);
break;
}
});
// first request should fetch from backend and store in cache
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('first response', $this->response->getContent());
// second request is validated, is invalid, and replaces cached entry
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('second response', $this->response->getContent());
// third response is validated, valid, and returns cached entry
$this->request('GET', '/');
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('second response', $this->response->getContent());
$this->assertEquals(3, $count);
}
public function testPassesHeadRequestsThroughDirectlyOnPass()
{
$this->setNextResponse(200, array(), 'Hello World', function ($request, $response) {
$response->setContent('');
$response->setStatusCode(200);
$this->assertEquals('HEAD', $request->getMethod());
});
$this->request('HEAD', '/', array('HTTP_EXPECT' => 'something ...'));
$this->assertHttpKernelIsCalled();
$this->assertEquals('', $this->response->getContent());
}
public function testUsesCacheToRespondToHeadRequestsWhenFresh()
{
$this->setNextResponse(200, array(), 'Hello World', function ($request, $response) {
$response->headers->set('Cache-Control', 'public, max-age=10');
$response->setContent('Hello World');
$response->setStatusCode(200);
$this->assertNotEquals('HEAD', $request->getMethod());
});
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals('Hello World', $this->response->getContent());
$this->request('HEAD', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('', $this->response->getContent());
$this->assertEquals(strlen('Hello World'), $this->response->headers->get('Content-Length'));
}
public function testSendsNoContentWhenFresh()
{
$time = \DateTime::createFromFormat('U', time());
$this->setNextResponse(200, array(), 'Hello World', function ($request, $response) use ($time) {
$response->headers->set('Cache-Control', 'public, max-age=10');
$response->headers->set('Last-Modified', $time->format(DATE_RFC2822));
});
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals('Hello World', $this->response->getContent());
$this->request('GET', '/', array('HTTP_IF_MODIFIED_SINCE' => $time->format(DATE_RFC2822)));
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(304, $this->response->getStatusCode());
$this->assertEquals('', $this->response->getContent());
}
public function testInvalidatesCachedResponsesOnPost()
{
$this->setNextResponse(200, array(), 'Hello World', function ($request, $response) {
if ('GET' == $request->getMethod()) {
$response->setStatusCode(200);
$response->headers->set('Cache-Control', 'public, max-age=500');
$response->setContent('Hello World');
} elseif ('POST' == $request->getMethod()) {
$response->setStatusCode(303);
$response->headers->set('Location', '/');
$response->headers->remove('Cache-Control');
$response->setContent('');
}
});
// build initial request to enter into the cache
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
// make sure it is valid
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('fresh');
// now POST to same URL
$this->request('POST', '/helloworld');
$this->assertHttpKernelIsCalled();
$this->assertEquals('/', $this->response->headers->get('Location'));
$this->assertTraceContains('invalidate');
$this->assertTraceContains('pass');
$this->assertEquals('', $this->response->getContent());
// now make sure it was actually invalidated
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('stale');
$this->assertTraceContains('invalid');
$this->assertTraceContains('store');
}
public function testServesFromCacheWhenHeadersMatch()
{
$count = 0;
$this->setNextResponse(200, array('Cache-Control' => 'max-age=10000'), '', function ($request, $response) use (&$count) {
$response->headers->set('Vary', 'Accept User-Agent Foo');
$response->headers->set('Cache-Control', 'public, max-age=10');
$response->headers->set('X-Response-Count', ++$count);
$response->setContent($request->headers->get('USER_AGENT'));
});
$this->request('GET', '/', array('HTTP_ACCEPT' => 'text/html', 'HTTP_USER_AGENT' => 'Bob/1.0'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Bob/1.0', $this->response->getContent());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->request('GET', '/', array('HTTP_ACCEPT' => 'text/html', 'HTTP_USER_AGENT' => 'Bob/1.0'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Bob/1.0', $this->response->getContent());
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
}
public function testStoresMultipleResponsesWhenHeadersDiffer()
{
$count = 0;
$this->setNextResponse(200, array('Cache-Control' => 'max-age=10000'), '', function ($request, $response) use (&$count) {
$response->headers->set('Vary', 'Accept User-Agent Foo');
$response->headers->set('Cache-Control', 'public, max-age=10');
$response->headers->set('X-Response-Count', ++$count);
$response->setContent($request->headers->get('USER_AGENT'));
});
$this->request('GET', '/', array('HTTP_ACCEPT' => 'text/html', 'HTTP_USER_AGENT' => 'Bob/1.0'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertEquals('Bob/1.0', $this->response->getContent());
$this->assertEquals(1, $this->response->headers->get('X-Response-Count'));
$this->request('GET', '/', array('HTTP_ACCEPT' => 'text/html', 'HTTP_USER_AGENT' => 'Bob/2.0'));
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTraceContains('miss');
$this->assertTraceContains('store');
$this->assertEquals('Bob/2.0', $this->response->getContent());
$this->assertEquals(2, $this->response->headers->get('X-Response-Count'));
$this->request('GET', '/', array('HTTP_ACCEPT' => 'text/html', 'HTTP_USER_AGENT' => 'Bob/1.0'));
$this->assertTraceContains('fresh');
$this->assertEquals('Bob/1.0', $this->response->getContent());
$this->assertEquals(1, $this->response->headers->get('X-Response-Count'));
$this->request('GET', '/', array('HTTP_ACCEPT' => 'text/html', 'HTTP_USER_AGENT' => 'Bob/2.0'));
$this->assertTraceContains('fresh');
$this->assertEquals('Bob/2.0', $this->response->getContent());
$this->assertEquals(2, $this->response->headers->get('X-Response-Count'));
$this->request('GET', '/', array('HTTP_USER_AGENT' => 'Bob/2.0'));
$this->assertTraceContains('miss');
$this->assertEquals('Bob/2.0', $this->response->getContent());
$this->assertEquals(3, $this->response->headers->get('X-Response-Count'));
}
public function testShouldCatchExceptions()
{
$this->catchExceptions();
$this->setNextResponse();
$this->request('GET', '/');
$this->assertExceptionsAreCaught();
}
public function testShouldCatchExceptionsWhenReloadingAndNoCacheRequest()
{
$this->catchExceptions();
$this->setNextResponse();
$this->cacheConfig['allow_reload'] = true;
$this->request('GET', '/', array(), array(), false, array('Pragma' => 'no-cache'));
$this->assertExceptionsAreCaught();
}
public function testShouldNotCatchExceptions()
{
$this->catchExceptions(false);
$this->setNextResponse();
$this->request('GET', '/');
$this->assertExceptionsAreNotCaught();
}
public function testEsiCacheSendsTheLowestTtl()
{
$responses = array(
array(
'status' => 200,
'body' => ' ',
'headers' => array(
'Cache-Control' => 's-maxage=300',
'Surrogate-Control' => 'content="ESI/1.0"',
),
),
array(
'status' => 200,
'body' => 'Hello World!',
'headers' => array('Cache-Control' => 's-maxage=300'),
),
array(
'status' => 200,
'body' => 'My name is Bobby.',
'headers' => array('Cache-Control' => 's-maxage=100'),
),
);
$this->setNextResponses($responses);
$this->request('GET', '/', array(), array(), true);
$this->assertEquals('Hello World! My name is Bobby.', $this->response->getContent());
// check for 100 or 99 as the test can be executed after a second change
$this->assertTrue(in_array($this->response->getTtl(), array(99, 100)));
}
public function testEsiCacheForceValidation()
{
$responses = array(
array(
'status' => 200,
'body' => ' ',
'headers' => array(
'Cache-Control' => 's-maxage=300',
'Surrogate-Control' => 'content="ESI/1.0"',
),
),
array(
'status' => 200,
'body' => 'Hello World!',
'headers' => array('ETag' => 'foobar'),
),
array(
'status' => 200,
'body' => 'My name is Bobby.',
'headers' => array('Cache-Control' => 's-maxage=100'),
),
);
$this->setNextResponses($responses);
$this->request('GET', '/', array(), array(), true);
$this->assertEquals('Hello World! My name is Bobby.', $this->response->getContent());
$this->assertNull($this->response->getTtl());
$this->assertTrue($this->response->mustRevalidate());
$this->assertTrue($this->response->headers->hasCacheControlDirective('private'));
$this->assertTrue($this->response->headers->hasCacheControlDirective('no-cache'));
}
public function testEsiRecalculateContentLengthHeader()
{
$responses = array(
array(
'status' => 200,
'body' => '',
'headers' => array(
'Content-Length' => 26,
'Cache-Control' => 's-maxage=300',
'Surrogate-Control' => 'content="ESI/1.0"',
),
),
array(
'status' => 200,
'body' => 'Hello World!',
'headers' => array(),
),
);
$this->setNextResponses($responses);
$this->request('GET', '/', array(), array(), true);
$this->assertEquals('Hello World!', $this->response->getContent());
$this->assertEquals(12, $this->response->headers->get('Content-Length'));
}
public function testClientIpIsAlwaysLocalhostForForwardedRequests()
{
$this->setNextResponse();
$this->request('GET', '/', array('REMOTE_ADDR' => '10.0.0.1'));
$this->assertEquals('127.0.0.1', $this->kernel->getBackendRequest()->server->get('REMOTE_ADDR'));
}
/**
* @dataProvider getTrustedProxyData
*/
public function testHttpCacheIsSetAsATrustedProxy(array $existing, array $expected)
{
Request::setTrustedProxies($existing, Request::HEADER_X_FORWARDED_ALL);
$this->setNextResponse();
$this->request('GET', '/', array('REMOTE_ADDR' => '10.0.0.1'));
$this->assertEquals($expected, Request::getTrustedProxies());
}
public function getTrustedProxyData()
{
return array(
array(array(), array('127.0.0.1')),
array(array('10.0.0.2'), array('10.0.0.2', '127.0.0.1')),
array(array('10.0.0.2', '127.0.0.1'), array('10.0.0.2', '127.0.0.1')),
);
}
/**
* @dataProvider getXForwardedForData
*/
public function testXForwarderForHeaderForForwardedRequests($xForwardedFor, $expected)
{
$this->setNextResponse();
$server = array('REMOTE_ADDR' => '10.0.0.1');
if (false !== $xForwardedFor) {
$server['HTTP_X_FORWARDED_FOR'] = $xForwardedFor;
}
$this->request('GET', '/', $server);
$this->assertEquals($expected, $this->kernel->getBackendRequest()->headers->get('X-Forwarded-For'));
}
public function getXForwardedForData()
{
return array(
array(false, '10.0.0.1'),
array('10.0.0.2', '10.0.0.2, 10.0.0.1'),
array('10.0.0.2, 10.0.0.3', '10.0.0.2, 10.0.0.3, 10.0.0.1'),
);
}
public function testXForwarderForHeaderForPassRequests()
{
$this->setNextResponse();
$server = array('REMOTE_ADDR' => '10.0.0.1');
$this->request('POST', '/', $server);
$this->assertEquals('10.0.0.1', $this->kernel->getBackendRequest()->headers->get('X-Forwarded-For'));
}
public function testEsiCacheRemoveValidationHeadersIfEmbeddedResponses()
{
$time = \DateTime::createFromFormat('U', time());
$responses = array(
array(
'status' => 200,
'body' => '',
'headers' => array(
'Surrogate-Control' => 'content="ESI/1.0"',
'ETag' => 'hey',
'Last-Modified' => $time->format(DATE_RFC2822),
),
),
array(
'status' => 200,
'body' => 'Hey!',
'headers' => array(),
),
);
$this->setNextResponses($responses);
$this->request('GET', '/', array(), array(), true);
$this->assertNull($this->response->getETag());
$this->assertNull($this->response->getLastModified());
}
public function testDoesNotCacheOptionsRequest()
{
$this->setNextResponse(200, array('Cache-Control' => 'public, s-maxage=60'), 'get');
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->setNextResponse(200, array('Cache-Control' => 'public, s-maxage=60'), 'options');
$this->request('OPTIONS', '/');
$this->assertHttpKernelIsCalled();
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertSame('get', $this->response->getContent());
}
}
class TestKernel implements HttpKernelInterface
{
public $terminateCalled = false;
public function terminate(Request $request, Response $response)
{
$this->terminateCalled = true;
}
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
{
}
}
PK ! TestMultipleHttpKernel.phpnu
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Tests\HttpCache;
use Symfony\Component\HttpKernel\Controller\ArgumentResolverInterface;
use Symfony\Component\HttpKernel\HttpKernel;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Controller\ControllerResolverInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;
class TestMultipleHttpKernel extends HttpKernel implements ControllerResolverInterface, ArgumentResolverInterface
{
protected $bodies = array();
protected $statuses = array();
protected $headers = array();
protected $called = false;
protected $backendRequest;
public function __construct($responses)
{
foreach ($responses as $response) {
$this->bodies[] = $response['body'];
$this->statuses[] = $response['status'];
$this->headers[] = $response['headers'];
}
parent::__construct(new EventDispatcher(), $this, null, $this);
}
public function getBackendRequest()
{
return $this->backendRequest;
}
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = false)
{
$this->backendRequest = $request;
return parent::handle($request, $type, $catch);
}
public function getController(Request $request)
{
return array($this, 'callController');
}
public function getArguments(Request $request, $controller)
{
return array($request);
}
public function callController(Request $request)
{
$this->called = true;
$response = new Response(array_shift($this->bodies), array_shift($this->statuses), array_shift($this->headers));
return $response;
}
public function hasBeenCalled()
{
return $this->called;
}
public function reset()
{
$this->called = false;
}
}
PK ! ] HttpCacheTestCase.phpnu
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Tests\HttpCache;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\HttpCache\Esi;
use Symfony\Component\HttpKernel\HttpCache\HttpCache;
use Symfony\Component\HttpKernel\HttpCache\Store;
use Symfony\Component\HttpKernel\HttpKernelInterface;
class HttpCacheTestCase extends TestCase
{
protected $kernel;
protected $cache;
protected $caches;
protected $cacheConfig;
protected $request;
protected $response;
protected $responses;
protected $catch;
protected $esi;
/**
* @var Store
*/
protected $store;
protected function setUp()
{
$this->kernel = null;
$this->cache = null;
$this->esi = null;
$this->caches = array();
$this->cacheConfig = array();
$this->request = null;
$this->response = null;
$this->responses = array();
$this->catch = false;
$this->clearDirectory(sys_get_temp_dir().'/http_cache');
}
protected function tearDown()
{
if ($this->cache) {
$this->cache->getStore()->cleanup();
}
$this->kernel = null;
$this->cache = null;
$this->caches = null;
$this->request = null;
$this->response = null;
$this->responses = null;
$this->cacheConfig = null;
$this->catch = null;
$this->esi = null;
$this->clearDirectory(sys_get_temp_dir().'/http_cache');
}
public function assertHttpKernelIsCalled()
{
$this->assertTrue($this->kernel->hasBeenCalled());
}
public function assertHttpKernelIsNotCalled()
{
$this->assertFalse($this->kernel->hasBeenCalled());
}
public function assertResponseOk()
{
$this->assertEquals(200, $this->response->getStatusCode());
}
public function assertTraceContains($trace)
{
$traces = $this->cache->getTraces();
$traces = current($traces);
$this->assertRegExp('/'.$trace.'/', implode(', ', $traces));
}
public function assertTraceNotContains($trace)
{
$traces = $this->cache->getTraces();
$traces = current($traces);
$this->assertNotRegExp('/'.$trace.'/', implode(', ', $traces));
}
public function assertExceptionsAreCaught()
{
$this->assertTrue($this->kernel->isCatchingExceptions());
}
public function assertExceptionsAreNotCaught()
{
$this->assertFalse($this->kernel->isCatchingExceptions());
}
public function request($method, $uri = '/', $server = array(), $cookies = array(), $esi = false, $headers = array())
{
if (null === $this->kernel) {
throw new \LogicException('You must call setNextResponse() before calling request().');
}
$this->kernel->reset();
$this->store = new Store(sys_get_temp_dir().'/http_cache');
$this->cacheConfig['debug'] = true;
$this->esi = $esi ? new Esi() : null;
$this->cache = new HttpCache($this->kernel, $this->store, $this->esi, $this->cacheConfig);
$this->request = Request::create($uri, $method, array(), $cookies, array(), $server);
$this->request->headers->add($headers);
$this->response = $this->cache->handle($this->request, HttpKernelInterface::MASTER_REQUEST, $this->catch);
$this->responses[] = $this->response;
}
public function getMetaStorageValues()
{
$values = array();
foreach (new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator(sys_get_temp_dir().'/http_cache/md', \RecursiveDirectoryIterator::SKIP_DOTS), \RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
$values[] = file_get_contents($file);
}
return $values;
}
// A basic response with 200 status code and a tiny body.
public function setNextResponse($statusCode = 200, array $headers = array(), $body = 'Hello World', \Closure $customizer = null)
{
$this->kernel = new TestHttpKernel($body, $statusCode, $headers, $customizer);
}
public function setNextResponses($responses)
{
$this->kernel = new TestMultipleHttpKernel($responses);
}
public function catchExceptions($catch = true)
{
$this->catch = $catch;
}
public static function clearDirectory($directory)
{
if (!is_dir($directory)) {
return;
}
$fp = opendir($directory);
while (false !== $file = readdir($fp)) {
if (!in_array($file, array('.', '..'))) {
if (is_link($directory.'/'.$file)) {
unlink($directory.'/'.$file);
} elseif (is_dir($directory.'/'.$file)) {
self::clearDirectory($directory.'/'.$file);
rmdir($directory.'/'.$file);
} else {
unlink($directory.'/'.$file);
}
}
}
closedir($fp);
}
}
PK ! QY? SsiTest.phpnu
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Tests\HttpCache;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\HttpCache\Ssi;
class SsiTest extends TestCase
{
public function testHasSurrogateSsiCapability()
{
$ssi = new Ssi();
$request = Request::create('/');
$request->headers->set('Surrogate-Capability', 'abc="SSI/1.0"');
$this->assertTrue($ssi->hasSurrogateCapability($request));
$request = Request::create('/');
$request->headers->set('Surrogate-Capability', 'foobar');
$this->assertFalse($ssi->hasSurrogateCapability($request));
$request = Request::create('/');
$this->assertFalse($ssi->hasSurrogateCapability($request));
}
public function testAddSurrogateSsiCapability()
{
$ssi = new Ssi();
$request = Request::create('/');
$ssi->addSurrogateCapability($request);
$this->assertEquals('symfony="SSI/1.0"', $request->headers->get('Surrogate-Capability'));
$ssi->addSurrogateCapability($request);
$this->assertEquals('symfony="SSI/1.0", symfony="SSI/1.0"', $request->headers->get('Surrogate-Capability'));
}
public function testAddSurrogateControl()
{
$ssi = new Ssi();
$response = new Response('foo ');
$ssi->addSurrogateControl($response);
$this->assertEquals('content="SSI/1.0"', $response->headers->get('Surrogate-Control'));
$response = new Response('foo');
$ssi->addSurrogateControl($response);
$this->assertEquals('', $response->headers->get('Surrogate-Control'));
}
public function testNeedsSsiParsing()
{
$ssi = new Ssi();
$response = new Response();
$response->headers->set('Surrogate-Control', 'content="SSI/1.0"');
$this->assertTrue($ssi->needsParsing($response));
$response = new Response();
$this->assertFalse($ssi->needsParsing($response));
}
public function testRenderIncludeTag()
{
$ssi = new Ssi();
$this->assertEquals('', $ssi->renderIncludeTag('/', '/alt', true));
$this->assertEquals('', $ssi->renderIncludeTag('/', '/alt', false));
$this->assertEquals('', $ssi->renderIncludeTag('/'));
}
public function testProcessDoesNothingIfContentTypeIsNotHtml()
{
$ssi = new Ssi();
$request = Request::create('/');
$response = new Response();
$response->headers->set('Content-Type', 'text/plain');
$ssi->process($request, $response);
$this->assertFalse($response->headers->has('x-body-eval'));
}
public function testProcess()
{
$ssi = new Ssi();
$request = Request::create('/');
$response = new Response('foo ');
$ssi->process($request, $response);
$this->assertEquals('foo surrogate->handle($this, \'...\', \'\', false) ?>'."\n", $response->getContent());
$this->assertEquals('SSI', $response->headers->get('x-body-eval'));
$response = new Response('foo ');
$ssi->process($request, $response);
$this->assertEquals("foo surrogate->handle(\$this, 'foo\\'', '', false) ?>"."\n", $response->getContent());
}
public function testProcessEscapesPhpTags()
{
$ssi = new Ssi();
$request = Request::create('/');
$response = new Response('');
$ssi->process($request, $response);
$this->assertEquals('php cript language=php>', $response->getContent());
}
/**
* @expectedException \RuntimeException
*/
public function testProcessWhenNoSrcInAnSsi()
{
$ssi = new Ssi();
$request = Request::create('/');
$response = new Response('foo ');
$ssi->process($request, $response);
}
public function testProcessRemoveSurrogateControlHeader()
{
$ssi = new Ssi();
$request = Request::create('/');
$response = new Response('foo ');
$response->headers->set('Surrogate-Control', 'content="SSI/1.0"');
$ssi->process($request, $response);
$this->assertEquals('SSI', $response->headers->get('x-body-eval'));
$response->headers->set('Surrogate-Control', 'no-store, content="SSI/1.0"');
$ssi->process($request, $response);
$this->assertEquals('SSI', $response->headers->get('x-body-eval'));
$this->assertEquals('no-store', $response->headers->get('surrogate-control'));
$response->headers->set('Surrogate-Control', 'content="SSI/1.0", no-store');
$ssi->process($request, $response);
$this->assertEquals('SSI', $response->headers->get('x-body-eval'));
$this->assertEquals('no-store', $response->headers->get('surrogate-control'));
}
public function testHandle()
{
$ssi = new Ssi();
$cache = $this->getCache(Request::create('/'), new Response('foo'));
$this->assertEquals('foo', $ssi->handle($cache, '/', '/alt', true));
}
/**
* @expectedException \RuntimeException
*/
public function testHandleWhenResponseIsNot200()
{
$ssi = new Ssi();
$response = new Response('foo');
$response->setStatusCode(404);
$cache = $this->getCache(Request::create('/'), $response);
$ssi->handle($cache, '/', '/alt', false);
}
public function testHandleWhenResponseIsNot200AndErrorsAreIgnored()
{
$ssi = new Ssi();
$response = new Response('foo');
$response->setStatusCode(404);
$cache = $this->getCache(Request::create('/'), $response);
$this->assertEquals('', $ssi->handle($cache, '/', '/alt', true));
}
public function testHandleWhenResponseIsNot200AndAltIsPresent()
{
$ssi = new Ssi();
$response1 = new Response('foo');
$response1->setStatusCode(404);
$response2 = new Response('bar');
$cache = $this->getCache(Request::create('/'), array($response1, $response2));
$this->assertEquals('bar', $ssi->handle($cache, '/', '/alt', false));
}
protected function getCache($request, $response)
{
$cache = $this->getMockBuilder('Symfony\Component\HttpKernel\HttpCache\HttpCache')->setMethods(array('getRequest', 'handle'))->disableOriginalConstructor()->getMock();
$cache->expects($this->any())
->method('getRequest')
->will($this->returnValue($request))
;
if (is_array($response)) {
$cache->expects($this->any())
->method('handle')
->will(call_user_func_array(array($this, 'onConsecutiveCalls'), $response))
;
} else {
$cache->expects($this->any())
->method('handle')
->will($this->returnValue($response))
;
}
return $cache;
}
}
PK ! ѩg g TestHttpKernel.phpnu
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Tests\HttpCache;
use Symfony\Component\HttpKernel\Controller\ArgumentResolverInterface;
use Symfony\Component\HttpKernel\HttpKernel;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Controller\ControllerResolverInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;
class TestHttpKernel extends HttpKernel implements ControllerResolverInterface, ArgumentResolverInterface
{
protected $body;
protected $status;
protected $headers;
protected $called = false;
protected $customizer;
protected $catch = false;
protected $backendRequest;
public function __construct($body, $status, $headers, \Closure $customizer = null)
{
$this->body = $body;
$this->status = $status;
$this->headers = $headers;
$this->customizer = $customizer;
parent::__construct(new EventDispatcher(), $this, null, $this);
}
public function getBackendRequest()
{
return $this->backendRequest;
}
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = false)
{
$this->catch = $catch;
$this->backendRequest = $request;
return parent::handle($request, $type, $catch);
}
public function isCatchingExceptions()
{
return $this->catch;
}
public function getController(Request $request)
{
return array($this, 'callController');
}
public function getArguments(Request $request, $controller)
{
return array($request);
}
public function callController(Request $request)
{
$this->called = true;
$response = new Response($this->body, $this->status, $this->headers);
if (null !== $customizer = $this->customizer) {
$customizer($request, $response);
}
return $response;
}
public function hasBeenCalled()
{
return $this->called;
}
public function reset()
{
$this->called = false;
}
}
PK ! e, ,
StoreTest.phpnu
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Tests\HttpCache;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\HttpCache\Store;
class StoreTest extends TestCase
{
protected $request;
protected $response;
/**
* @var Store
*/
protected $store;
protected function setUp()
{
$this->request = Request::create('/');
$this->response = new Response('hello world', 200, array());
HttpCacheTestCase::clearDirectory(sys_get_temp_dir().'/http_cache');
$this->store = new Store(sys_get_temp_dir().'/http_cache');
}
protected function tearDown()
{
$this->store = null;
$this->request = null;
$this->response = null;
HttpCacheTestCase::clearDirectory(sys_get_temp_dir().'/http_cache');
}
public function testReadsAnEmptyArrayWithReadWhenNothingCachedAtKey()
{
$this->assertEmpty($this->getStoreMetadata('/nothing'));
}
public function testUnlockFileThatDoesExist()
{
$cacheKey = $this->storeSimpleEntry();
$this->store->lock($this->request);
$this->assertTrue($this->store->unlock($this->request));
}
public function testUnlockFileThatDoesNotExist()
{
$this->assertFalse($this->store->unlock($this->request));
}
public function testRemovesEntriesForKeyWithPurge()
{
$request = Request::create('/foo');
$this->store->write($request, new Response('foo'));
$metadata = $this->getStoreMetadata($request);
$this->assertNotEmpty($metadata);
$this->assertTrue($this->store->purge('/foo'));
$this->assertEmpty($this->getStoreMetadata($request));
// cached content should be kept after purging
$path = $this->store->getPath($metadata[0][1]['x-content-digest'][0]);
$this->assertTrue(is_file($path));
$this->assertFalse($this->store->purge('/bar'));
}
public function testStoresACacheEntry()
{
$cacheKey = $this->storeSimpleEntry();
$this->assertNotEmpty($this->getStoreMetadata($cacheKey));
}
public function testSetsTheXContentDigestResponseHeaderBeforeStoring()
{
$cacheKey = $this->storeSimpleEntry();
$entries = $this->getStoreMetadata($cacheKey);
list($req, $res) = $entries[0];
$this->assertEquals('en9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08', $res['x-content-digest'][0]);
}
public function testFindsAStoredEntryWithLookup()
{
$this->storeSimpleEntry();
$response = $this->store->lookup($this->request);
$this->assertNotNull($response);
$this->assertInstanceOf('Symfony\Component\HttpFoundation\Response', $response);
}
public function testDoesNotFindAnEntryWithLookupWhenNoneExists()
{
$request = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'));
$this->assertNull($this->store->lookup($request));
}
public function testCanonizesUrlsForCacheKeys()
{
$this->storeSimpleEntry($path = '/test?x=y&p=q');
$hitsReq = Request::create($path);
$missReq = Request::create('/test?p=x');
$this->assertNotNull($this->store->lookup($hitsReq));
$this->assertNull($this->store->lookup($missReq));
}
public function testDoesNotFindAnEntryWithLookupWhenTheBodyDoesNotExist()
{
$this->storeSimpleEntry();
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$path = $this->getStorePath($this->response->headers->get('X-Content-Digest'));
@unlink($path);
$this->assertNull($this->store->lookup($this->request));
}
public function testRestoresResponseHeadersProperlyWithLookup()
{
$this->storeSimpleEntry();
$response = $this->store->lookup($this->request);
$this->assertEquals($response->headers->all(), array_merge(array('content-length' => 4, 'x-body-file' => array($this->getStorePath($response->headers->get('X-Content-Digest')))), $this->response->headers->all()));
}
public function testRestoresResponseContentFromEntityStoreWithLookup()
{
$this->storeSimpleEntry();
$response = $this->store->lookup($this->request);
$this->assertEquals($this->getStorePath('en'.hash('sha256', 'test')), $response->getContent());
}
public function testInvalidatesMetaAndEntityStoreEntriesWithInvalidate()
{
$this->storeSimpleEntry();
$this->store->invalidate($this->request);
$response = $this->store->lookup($this->request);
$this->assertInstanceOf('Symfony\Component\HttpFoundation\Response', $response);
$this->assertFalse($response->isFresh());
}
public function testSucceedsQuietlyWhenInvalidateCalledWithNoMatchingEntries()
{
$req = Request::create('/test');
$this->store->invalidate($req);
$this->assertNull($this->store->lookup($this->request));
}
public function testDoesNotReturnEntriesThatVaryWithLookup()
{
$req1 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'));
$req2 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'));
$res = new Response('test', 200, array('Vary' => 'Foo Bar'));
$this->store->write($req1, $res);
$this->assertNull($this->store->lookup($req2));
}
public function testDoesNotReturnEntriesThatSlightlyVaryWithLookup()
{
$req1 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'));
$req2 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bam'));
$res = new Response('test', 200, array('Vary' => array('Foo', 'Bar')));
$this->store->write($req1, $res);
$this->assertNull($this->store->lookup($req2));
}
public function testStoresMultipleResponsesForEachVaryCombination()
{
$req1 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'));
$res1 = new Response('test 1', 200, array('Vary' => 'Foo Bar'));
$key = $this->store->write($req1, $res1);
$req2 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'));
$res2 = new Response('test 2', 200, array('Vary' => 'Foo Bar'));
$this->store->write($req2, $res2);
$req3 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Baz', 'HTTP_BAR' => 'Boom'));
$res3 = new Response('test 3', 200, array('Vary' => 'Foo Bar'));
$this->store->write($req3, $res3);
$this->assertEquals($this->getStorePath('en'.hash('sha256', 'test 3')), $this->store->lookup($req3)->getContent());
$this->assertEquals($this->getStorePath('en'.hash('sha256', 'test 2')), $this->store->lookup($req2)->getContent());
$this->assertEquals($this->getStorePath('en'.hash('sha256', 'test 1')), $this->store->lookup($req1)->getContent());
$this->assertCount(3, $this->getStoreMetadata($key));
}
public function testOverwritesNonVaryingResponseWithStore()
{
$req1 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'));
$res1 = new Response('test 1', 200, array('Vary' => 'Foo Bar'));
$key = $this->store->write($req1, $res1);
$this->assertEquals($this->getStorePath('en'.hash('sha256', 'test 1')), $this->store->lookup($req1)->getContent());
$req2 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'));
$res2 = new Response('test 2', 200, array('Vary' => 'Foo Bar'));
$this->store->write($req2, $res2);
$this->assertEquals($this->getStorePath('en'.hash('sha256', 'test 2')), $this->store->lookup($req2)->getContent());
$req3 = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'));
$res3 = new Response('test 3', 200, array('Vary' => 'Foo Bar'));
$key = $this->store->write($req3, $res3);
$this->assertEquals($this->getStorePath('en'.hash('sha256', 'test 3')), $this->store->lookup($req3)->getContent());
$this->assertCount(2, $this->getStoreMetadata($key));
}
public function testLocking()
{
$req = Request::create('/test', 'get', array(), array(), array(), array('HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'));
$this->assertTrue($this->store->lock($req));
$path = $this->store->lock($req);
$this->assertTrue($this->store->isLocked($req));
$this->store->unlock($req);
$this->assertFalse($this->store->isLocked($req));
}
public function testPurgeHttps()
{
$request = Request::create('https://example.com/foo');
$this->store->write($request, new Response('foo'));
$this->assertNotEmpty($this->getStoreMetadata($request));
$this->assertTrue($this->store->purge('https://example.com/foo'));
$this->assertEmpty($this->getStoreMetadata($request));
}
public function testPurgeHttpAndHttps()
{
$requestHttp = Request::create('https://example.com/foo');
$this->store->write($requestHttp, new Response('foo'));
$requestHttps = Request::create('http://example.com/foo');
$this->store->write($requestHttps, new Response('foo'));
$this->assertNotEmpty($this->getStoreMetadata($requestHttp));
$this->assertNotEmpty($this->getStoreMetadata($requestHttps));
$this->assertTrue($this->store->purge('http://example.com/foo'));
$this->assertEmpty($this->getStoreMetadata($requestHttp));
$this->assertEmpty($this->getStoreMetadata($requestHttps));
}
protected function storeSimpleEntry($path = null, $headers = array())
{
if (null === $path) {
$path = '/test';
}
$this->request = Request::create($path, 'get', array(), array(), array(), $headers);
$this->response = new Response('test', 200, array('Cache-Control' => 'max-age=420'));
return $this->store->write($this->request, $this->response);
}
protected function getStoreMetadata($key)
{
$r = new \ReflectionObject($this->store);
$m = $r->getMethod('getMetadata');
$m->setAccessible(true);
if ($key instanceof Request) {
$m1 = $r->getMethod('getCacheKey');
$m1->setAccessible(true);
$key = $m1->invoke($this->store, $key);
}
return $m->invoke($this->store, $key);
}
protected function getStorePath($key)
{
$r = new \ReflectionObject($this->store);
$m = $r->getMethod('getPath');
$m->setAccessible(true);
return $m->invoke($this->store, $key);
}
}
PK ! _ٺ% ResponseCacheStrategyTest.phpnu
*
* This code is partially based on the Rack-Cache library by Ryan Tomayko,
* which is released under the MIT license.
* (based on commit 02d2b48d75bcb63cf1c0c7149c077ad256542801)
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\Tests\HttpCache;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\HttpCache\ResponseCacheStrategy;
class ResponseCacheStrategyTest extends TestCase
{
public function testMinimumSharedMaxAgeWins()
{
$cacheStrategy = new ResponseCacheStrategy();
$response1 = new Response();
$response1->setSharedMaxAge(60);
$cacheStrategy->add($response1);
$response2 = new Response();
$response2->setSharedMaxAge(3600);
$cacheStrategy->add($response2);
$response = new Response();
$response->setSharedMaxAge(86400);
$cacheStrategy->update($response);
$this->assertSame('60', $response->headers->getCacheControlDirective('s-maxage'));
}
public function testSharedMaxAgeNotSetIfNotSetInAnyEmbeddedRequest()
{
$cacheStrategy = new ResponseCacheStrategy();
$response1 = new Response();
$response1->setSharedMaxAge(60);
$cacheStrategy->add($response1);
$response2 = new Response();
$cacheStrategy->add($response2);
$response = new Response();
$response->setSharedMaxAge(86400);
$cacheStrategy->update($response);
$this->assertFalse($response->headers->hasCacheControlDirective('s-maxage'));
}
public function testSharedMaxAgeNotSetIfNotSetInMasterRequest()
{
$cacheStrategy = new ResponseCacheStrategy();
$response1 = new Response();
$response1->setSharedMaxAge(60);
$cacheStrategy->add($response1);
$response2 = new Response();
$response2->setSharedMaxAge(3600);
$cacheStrategy->add($response2);
$response = new Response();
$cacheStrategy->update($response);
$this->assertFalse($response->headers->hasCacheControlDirective('s-maxage'));
}
public function testMasterResponseNotCacheableWhenEmbeddedResponseRequiresValidation()
{
$cacheStrategy = new ResponseCacheStrategy();
$embeddedResponse = new Response();
$embeddedResponse->setLastModified(new \DateTime());
$cacheStrategy->add($embeddedResponse);
$masterResponse = new Response();
$masterResponse->setSharedMaxAge(3600);
$cacheStrategy->update($masterResponse);
$this->assertTrue($masterResponse->headers->hasCacheControlDirective('no-cache'));
$this->assertTrue($masterResponse->headers->hasCacheControlDirective('must-revalidate'));
$this->assertFalse($masterResponse->isFresh());
}
public function testValidationOnMasterResponseIsNotPossibleWhenItContainsEmbeddedResponses()
{
$cacheStrategy = new ResponseCacheStrategy();
// This master response uses the "validation" model
$masterResponse = new Response();
$masterResponse->setLastModified(new \DateTime());
$masterResponse->setEtag('foo');
// Embedded response uses "expiry" model
$embeddedResponse = new Response();
$masterResponse->setSharedMaxAge(3600);
$cacheStrategy->add($embeddedResponse);
$cacheStrategy->update($masterResponse);
$this->assertFalse($masterResponse->isValidateable());
$this->assertFalse($masterResponse->headers->has('Last-Modified'));
$this->assertFalse($masterResponse->headers->has('ETag'));
$this->assertTrue($masterResponse->headers->hasCacheControlDirective('no-cache'));
$this->assertTrue($masterResponse->headers->hasCacheControlDirective('must-revalidate'));
}
public function testMasterResponseWithValidationIsUnchangedWhenThereIsNoEmbeddedResponse()
{
$cacheStrategy = new ResponseCacheStrategy();
$masterResponse = new Response();
$masterResponse->setLastModified(new \DateTime());
$cacheStrategy->update($masterResponse);
$this->assertTrue($masterResponse->isValidateable());
}
public function testMasterResponseWithExpirationIsUnchangedWhenThereIsNoEmbeddedResponse()
{
$cacheStrategy = new ResponseCacheStrategy();
$masterResponse = new Response();
$masterResponse->setSharedMaxAge(3600);
$cacheStrategy->update($masterResponse);
$this->assertTrue($masterResponse->isFresh());
}
public function testMasterResponseIsNotCacheableWhenEmbeddedResponseIsNotCacheable()
{
$cacheStrategy = new ResponseCacheStrategy();
$masterResponse = new Response();
$masterResponse->setSharedMaxAge(3600); // Public, cacheable
/* This response has no validation or expiration information.
That makes it uncacheable, it is always stale.
(It does *not* make this private, though.) */
$embeddedResponse = new Response();
$this->assertFalse($embeddedResponse->isFresh()); // not fresh, as no lifetime is provided
$cacheStrategy->add($embeddedResponse);
$cacheStrategy->update($masterResponse);
$this->assertTrue($masterResponse->headers->hasCacheControlDirective('no-cache'));
$this->assertTrue($masterResponse->headers->hasCacheControlDirective('must-revalidate'));
$this->assertFalse($masterResponse->isFresh());
}
public function testEmbeddingPrivateResponseMakesMainResponsePrivate()
{
$cacheStrategy = new ResponseCacheStrategy();
$masterResponse = new Response();
$masterResponse->setSharedMaxAge(3600); // public, cacheable
// The embedded response might for example contain per-user data that remains valid for 60 seconds
$embeddedResponse = new Response();
$embeddedResponse->setPrivate();
$embeddedResponse->setMaxAge(60); // this would implicitly set "private" as well, but let's be explicit
$cacheStrategy->add($embeddedResponse);
$cacheStrategy->update($masterResponse);
$this->assertTrue($masterResponse->headers->hasCacheControlDirective('private'));
// Not sure if we should pass "max-age: 60" in this case, as long as the response is private and
// that's the more conservative of both the master and embedded response...?
}
public function testResponseIsExiprableWhenEmbeddedResponseCombinesExpiryAndValidation()
{
/* When "expiration wins over validation" (https://symfony.com/doc/current/http_cache/validation.html)
* and both the main and embedded response provide s-maxage, then the more restricting value of both
* should be fine, regardless of whether the embedded response can be validated later on or must be
* completely regenerated.
*/
$cacheStrategy = new ResponseCacheStrategy();
$masterResponse = new Response();
$masterResponse->setSharedMaxAge(3600);
$embeddedResponse = new Response();
$embeddedResponse->setSharedMaxAge(60);
$embeddedResponse->setEtag('foo');
$cacheStrategy->add($embeddedResponse);
$cacheStrategy->update($masterResponse);
$this->assertSame('60', $masterResponse->headers->getCacheControlDirective('s-maxage'));
}
public function testResponseIsExpirableButNotValidateableWhenMasterResponseCombinesExpirationAndValidation()
{
$cacheStrategy = new ResponseCacheStrategy();
$masterResponse = new Response();
$masterResponse->setSharedMaxAge(3600);
$masterResponse->setEtag('foo');
$masterResponse->setLastModified(new \DateTime());
$embeddedResponse = new Response();
$embeddedResponse->setSharedMaxAge(60);
$cacheStrategy->add($embeddedResponse);
$cacheStrategy->update($masterResponse);
$this->assertSame('60', $masterResponse->headers->getCacheControlDirective('s-maxage'));
$this->assertFalse($masterResponse->isValidateable());
}
}
PK ! ϸ# # EsiTest.phpnu PK ! 0R R %$ HttpCacheTest.phpnu PK ! TestMultipleHttpKernel.phpnu PK ! ] HttpCacheTestCase.phpnu PK ! QY? ' SsiTest.phpnu PK ! ѩg g _E TestHttpKernel.phpnu PK ! e, ,
O StoreTest.phpnu PK ! _ٺ% { ResponseCacheStrategyTest.phpnu PK