Project-Pro/newwalls.pl
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Jacek Pyziak
2024-12-17 13:43:22 +01:00
commit 8e6cd8b410
21292 changed files with 3514826 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

768
modules/psaddonsconnect/vendor/guzzlehttp/cache-subscriber/tests/IntegrationTest.php vendored Normal file
View File

@@ -0,0 +1,768 @@
<?php
namespace GuzzleHttp\Tests\Subscriber\Cache;
require_once __DIR__ . '/../vendor/guzzlehttp/ringphp/tests/Client/Server.php';
require_once __DIR__ . '/../vendor/guzzlehttp/guzzle/tests/Server.php';
use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Exception\ServerException;
use GuzzleHttp\Message\RequestInterface;
use GuzzleHttp\Message\Response;
use GuzzleHttp\Stream\Stream;
use GuzzleHttp\Subscriber\Cache\CacheSubscriber;
use GuzzleHttp\Subscriber\History;
use GuzzleHttp\Tests\Server;
class IntegrationTest extends \PHPUnit_Framework_TestCase
{
protected function setUp()
{
Server::start();
}
protected function tearDown()
{
Server::stop();
}
public function testCachesResponses()
{
Server::enqueue([
new Response(200, [
'Vary' => 'Accept-Encoding,Cookie,X-Use-HHVM',
'Date' => 'Wed, 29 Oct 2014 20:52:15 GMT',
'Cache-Control' => 'private, s-maxage=0, max-age=0, must-revalidate',
'Last-Modified' => 'Wed, 29 Oct 2014 20:30:57 GMT',
'Age' => '1277'
]),
new Response(304, [
'Content-Type' => 'text/html; charset=UTF-8',
'Vary' => 'Accept-Encoding,Cookie,X-Use-HHVM',
'Date' => 'Wed, 29 Oct 2014 20:52:16 GMT',
'Cache-Control' => 'private, s-maxage=0, max-age=0, must-revalidate',
'Last-Modified' => 'Wed, 29 Oct 2014 20:30:57 GMT',
'Age' => '1278'
]),
new Response(200, [
'Vary' => 'Accept-Encoding,Cookie,X-Use-HHVM',
'Date' => 'Wed, 29 Oct 2014 20:52:15 GMT',
'Cache-Control' => 'private, s-maxage=0, max-age=0',
'Last-Modified' => 'Wed, 29 Oct 2014 20:30:57 GMT',
'Age' => '1277'
]),
new Response(200, [
'Vary' => 'Accept-Encoding,Cookie,X-Use-HHVM',
'Date' => 'Wed, 29 Oct 2014 20:53:15 GMT',
'Cache-Control' => 'private, s-maxage=0, max-age=0',
'Last-Modified' => 'Wed, 29 Oct 2014 20:53:00 GMT',
'Age' => '1277'
]),
]);
$history = new History();
$client = $this->setupClient($history);
$response1 = $client->get('/foo');
$this->assertEquals(200, $response1->getStatusCode());
$response2 = $client->get('/foo');
$this->assertEquals(200, $response2->getStatusCode());
$last = $history->getLastResponse();
$this->assertEquals('HIT from GuzzleCache', $last->getHeader('X-Cache-Lookup'));
$this->assertEquals('HIT from GuzzleCache', $last->getHeader('X-Cache'));
// Validate that expired requests without must-revalidate expire.
$response3 = $client->get('/foo');
$this->assertEquals(200, $response3->getStatusCode());
$response4 = $client->get('/foo');
$this->assertEquals(200, $response4->getStatusCode());
$last = $history->getLastResponse();
$this->assertEquals('MISS from GuzzleCache', $last->getHeader('X-Cache-Lookup'));
$this->assertEquals('MISS from GuzzleCache', $last->getHeader('X-Cache'));
// Validate that all of our requests were received.
$this->assertCount(4, Server::received());
}
/**
* Test that Warning headers aren't added to cache misses.
*/
public function testCacheMissNoWarning()
{
Server::enqueue([
new Response(200, [
'Vary' => 'Accept-Encoding,Cookie,X-Use-HHVM',
'Date' => 'Wed, 29 Oct 2014 20:52:15 GMT',
'Cache-Control' => 'private, s-maxage=0, max-age=0, must-revalidate',
'Last-Modified' => 'Wed, 29 Oct 2014 20:30:57 GMT',
'Age' => '1277',
]),
]);
$client = $this->setupClient();
$response = $client->get('/foo');
$this->assertFalse($response->hasHeader('warning'));
}
/**
* Test that the Vary header creates unique cache entries.
*
* @throws \Exception
*/
public function testVaryUniqueResponses()
{
$now = $this->date();
Server::enqueue(
[
new Response(
200, [
'Vary' => 'Accept',
'Content-type' => 'text/html',
'Date' => $now,
'Cache-Control' => 'public, s-maxage=1000, max-age=1000',
'Last-Modified' => $now,
], Stream::factory('It works!')
),
new Response(
200, [
'Vary' => 'Accept',
'Content-type' => 'application/json',
'Date' => $now,
'Cache-Control' => 'public, s-maxage=1000, max-age=1000',
'Last-Modified' => $now,
], Stream::factory(json_encode(['body' => 'It works!']))
),
]
);
$client = $this->setupClient();
$response1 = $client->get(
'/foo',
['headers' => ['Accept' => 'text/html']]
);
$this->assertEquals('It works!', $this->getResponseBody($response1));
$response2 = $client->get(
'/foo',
['headers' => ['Accept' => 'application/json']]
);
$this->assertEquals(
'MISS from GuzzleCache',
$response2->getHeader('x-cache')
);
$decoded = json_decode($this->getResponseBody($response2));
if (!isset($decoded) || !isset($decoded->body)) {
$this->fail('JSON response could not be decoded.');
} else {
$this->assertEquals('It works!', $decoded->body);
}
}
public function testCachesResponsesForWithoutVaryHeader()
{
$now = $this->date();
Server::enqueue(
[
new Response(
200, [
'Content-type' => 'text/html',
'Date' => $now,
'Cache-Control' => 'public, s-maxage=1000, max-age=1000, must-revalidate',
'Last-Modified' => $now,
], Stream::factory()
),
new Response(
200, [
'Content-type' => 'text/html',
'Date' => $now,
'Cache-Control' => 'public, s-maxage=1000, max-age=1000, must-revalidate',
'Last-Modified' => $now,
], Stream::factory()
),
]
);
$client = $this->setupClient();
$response1 = $client->get('/foo');
$this->assertEquals(200, $response1->getStatusCode());
$response2 = $client->get('/foo');
$this->assertEquals(200, $response2->getStatusCode());
$this->assertEquals('HIT from GuzzleCache', $response2->getHeader('X-Cache'));
}
/**
* Test that requests varying on both Accept and User-Agent properly split
* different User-Agents into different cache items.
*/
public function testVaryUserAgent()
{
$this->setupMultipleVaryResponses();
$client = $this->setupClient();
$response1 = $client->get(
'/foo',
[
'headers' => [
'Accept' => 'text/html',
'User-Agent' => 'Testing/1.0',
]
]
);
$this->assertEquals(
'Test/1.0 request.',
$this->getResponseBody($response1)
);
$response2 = $client->get(
'/foo',
[
'headers' => [
'Accept' => 'text/html',
'User-Agent' => 'Testing/2.0',
]
]
);
$this->assertEquals(
'MISS from GuzzleCache',
$response2->getHeader('x-cache')
);
$this->assertEquals(
'Test/2.0 request.',
$this->getResponseBody($response2)
);
// Test that we get cache hits where both Vary headers match.
$response5 = $client->get(
'/foo',
[
'headers' => [
'Accept' => 'text/html',
'User-Agent' => 'Testing/2.0',
]
]
);
$this->assertEquals(
'HIT from GuzzleCache',
$response5->getHeader('x-cache')
);
$this->assertEquals(
'Test/2.0 request.',
$this->getResponseBody($response5)
);
}
/**
* Test that requests varying on Accept but not User-Agent return different responses.
*/
public function testVaryAccept()
{
$this->setupMultipleVaryResponses();
$client = $this->setupClient();
// Prime the cache.
$client->get(
'/foo',
[
'headers' => [
'Accept' => 'text/html',
'User-Agent' => 'Testing/1.0',
]
]
);
$client->get(
'/foo',
[
'headers' => [
'Accept' => 'text/html',
'User-Agent' => 'Testing/2.0',
]
]
);
$response1 = $client->get(
'/foo',
[
'headers' => [
'Accept' => 'application/json',
'User-Agent' => 'Testing/1.0',
]
]
);
$this->assertEquals(
'MISS from GuzzleCache',
$response1->getHeader('x-cache')
);
$this->assertEquals(
'Test/1.0 request.',
json_decode($this->getResponseBody($response1))->body
);
$response2 = $client->get(
'/foo',
[
'headers' => [
'Accept' => 'application/json',
'User-Agent' => 'Testing/2.0',
]
]
);
$this->assertEquals(
'MISS from GuzzleCache',
$response2->getHeader('x-cache')
);
$this->assertEquals(
'Test/2.0 request.',
json_decode($this->getResponseBody($response2))->body
);
}
/**
* Test that we return cached responses when multiple Vary headers match.
*/
public function testMultipleVaryMatch()
{
$this->setupMultipleVaryResponses();
$client = $this->setupClient();
// Prime the cache.
$client->get('/foo',
[
'headers' => [
'Accept' => 'text/html',
'User-Agent' => 'Testing/1.0',
]
]
);
$client->get('/foo',
[
'headers' => [
'Accept' => 'text/html',
'User-Agent' => 'Testing/2.0',
]
]
);
$client->get('/foo',
[
'headers' => [
'Accept' => 'application/json',
'User-Agent' => 'Testing/1.0',
]
]
);
$client->get('/foo',
[
'headers' => [
'Accept' => 'application/json',
'User-Agent' => 'Testing/2.0',
]
]
);
$response = $client->get(
'/foo',
[
'headers' => [
'Accept' => 'application/json',
'User-Agent' => 'Testing/2.0',
]
]
);
$this->assertEquals(
'HIT from GuzzleCache',
$response->getHeader('x-cache')
);
$this->assertEquals(
'Test/2.0 request.',
json_decode($this->getResponseBody($response))->body
);
}
/**
* Test that stale responses are used on errors if allowed.
*/
public function testOnErrorStaleResponse()
{
$now = $this->date();
Server::enqueue([
new Response(200, [
'Date' => $now,
'Cache-Control' => 'private, max-age=0, must-revalidate, stale-if-error=666',
'Last-Modified' => 'Wed, 29 Oct 2014 20:30:57 GMT',
], Stream::factory('It works!')),
new Response(503, [
'Date' => $now,
'Cache-Control' => 'private, s-maxage=0, max-age=0, must-revalidate',
'Last-Modified' => 'Wed, 29 Oct 2014 20:30:57 GMT',
'Age' => '1277'
]),
]);
$client = $this->setupClient();
// Prime the cache.
$response1 = $client->get('/foo');
$this->assertEquals(200, $response1->getStatusCode());
// This should return the first request.
$response2 = $client->get('/foo');
$this->assertEquals(200, $response2->getStatusCode());
$this->assertEquals('It works!', $this->getResponseBody($response2));
$this->assertEquals('HIT_ERROR from GuzzleCache', $response2->getHeader('x-cache'));
$this->assertCount(2, Server::received());
}
/**
* Test that expired stale responses aren't returned.
*/
public function testOnErrorStaleResponseExpired()
{
// These dates are in the past, so the responses will be expired.
Server::enqueue([
new Response(200, [
'Date' => 'Wed, 29 Oct 2014 20:52:15 GMT',
'Cache-Control' => 'private, max-age=0, must-revalidate, stale-if-error=10',
'Last-Modified' => 'Wed, 29 Oct 2014 20:30:57 GMT',
]),
new Response(503, [
'Date' => 'Wed, 29 Oct 2014 20:55:15 GMT',
'Cache-Control' => 'private, s-maxage=0, max-age=0, must-revalidate',
'Last-Modified' => 'Wed, 29 Oct 2014 20:30:57 GMT',
]),
]);
$client = $this->setupClient();
// Prime the cache.
$response1 = $client->get('/foo');
$this->assertEquals(200, $response1->getStatusCode());
$this->assertEquals('Wed, 29 Oct 2014 20:52:15 GMT', $response1->getHeader('Date'));
try {
$client->get('/foo');
$this->fail('503 was not thrown with an expired cache entry.');
} catch (ServerException $e) {
$this->assertEquals(503, $e->getCode());
$this->assertEquals('Wed, 29 Oct 2014 20:55:15 GMT', $e->getResponse()->getHeader('Date'));
$this->assertCount(2, Server::received());
}
}
/**
* Test that the can_cache option can modify cache behaviour.
*/
public function testCanCache()
{
$now = $this->date();
// Return an uncacheable response, that is then cached by can_cache
// returning TRUE.
Server::enqueue(
[
new Response(
200, [
'Date' => $now,
'Cache-Control' => 'private, max-age=0, no-cache',
'Last-Modified' => $now,
], Stream::factory('It works!')),
new Response(
304, [
'Date' => $now,
'Cache-Control' => 'private, max-age=0, no-cache',
'Last-Modified' => $now,
'Age' => 0,
]),
]
);
$client = new Client(['base_url' => Server::$url]);
CacheSubscriber::attach(
$client,
[
'can_cache' => function (RequestInterface $request) {
return true;
}
]
);
$response1 = $client->get('/foo');
$this->assertEquals('MISS from GuzzleCache', $response1->getHeader('X-Cache-Lookup'));
$response2 = $client->get('/foo');
$this->assertEquals('HIT from GuzzleCache', $response2->getHeader('X-Cache-Lookup'));
$this->assertEquals('It works!', $this->getResponseBody($response2));
}
/**
* Test that PURGE can delete cached responses.
*/
public function testCanPurge()
{
$now = $this->date();
// Return a cached response that is then purged, and requested again
Server::enqueue(
[
new Response(
200, [
'Date' => $now,
'Cache-Control' => 'public, max-age=60',
'Last-Modified' => $now,
], Stream::factory('It is foo!')),
new Response(
200, [
'Date' => $now,
'Cache-Control' => 'public, max-age=60',
'Last-Modified' => $now,
], Stream::factory('It is bar!')),
]
);
$client = $this->setupClient();
$response1 = $client->get('/foo');
$this->assertEquals('MISS from GuzzleCache', $response1->getHeader('X-Cache-Lookup'));
$this->assertEquals('It is foo!', $this->getResponseBody($response1));
$response2 = $client->get('/foo');
$this->assertEquals('HIT from GuzzleCache', $response2->getHeader('X-Cache-Lookup'));
$this->assertEquals('It is foo!', $this->getResponseBody($response2));
$response3 = $client->send($client->createRequest('PURGE', '/foo'));
$this->assertEquals(204, $response3->getStatusCode());
$response4 = $client->get('/foo');
$this->assertEquals('MISS from GuzzleCache', $response4->getHeader('X-Cache-Lookup'));
$this->assertEquals('It is bar!', $this->getResponseBody($response4));
}
/**
* Test that cache entries are deleted when a response 404s.
*/
public function test404CacheDelete()
{
$this->fourXXCacheDelete(404);
}
/**
* Test that cache entries are deleted when a response 410s.
*/
public function test410CacheDelete()
{
$this->fourXXCacheDelete(410);
}
/**
* Test the resident_time calculation (RFC7234 4.2.3)
*/
public function testAgeIsIncremented()
{
Server::enqueue([
new Response(200, [
'Date' => $this->date(),
'Cache-Control' => 'public, max-age=60',
'Age' => '59'
], Stream::factory('Age is 59!')),
new Response(200, [
'Date' => $this->date(),
'Cache-Control' => 'public, max-age=60',
'Age' => '0'
], Stream::factory('It works!')),
]);
$client = $this->setupClient();
// First request : the response is cached
$response1 = $client->get('/foo');
$this->assertEquals(200, $response1->getStatusCode());
$this->assertEquals('MISS from GuzzleCache', $response1->getHeader('X-Cache-Lookup'));
$this->assertEquals('Age is 59!', $this->getResponseBody($response1));
// Second request : cache hit, age is now 60
sleep(1);
$response2 = $client->get('/foo');
$this->assertEquals(200, $response1->getStatusCode());
$this->assertEquals('HIT from GuzzleCache', $response2->getHeader('X-Cache-Lookup'));
// This request should not be valid anymore : age is 59 + 2 = 61 which is strictly greater than 60
sleep(1);
$response3 = $client->get('/foo');
$this->assertEquals(200, $response3->getStatusCode());
$this->assertEquals('MISS from GuzzleCache', $response3->getHeader('X-Cache-Lookup'));
$this->assertEquals('It works!', $this->getResponseBody($response3));
$this->assertCount(2, Server::received());
}
/**
* Decode a response body from TestServer.
*
* TestServer encodes all responses with base64, so we need to decode them
* before we can do any assert's on them.
*
* @param Response $response The response with a body to decode.
*
* @return string
*/
private function getResponseBody($response)
{
return base64_decode($response->getBody());
}
/**
* Set up responses used by our Vary tests.
*
* @throws \Exception
*/
private function setupMultipleVaryResponses()
{
$now = $this->date();
Server::enqueue(
[
new Response(
200, [
'Vary' => 'Accept, User-Agent',
'Content-type' => 'text/html',
'Date' => $now,
'Cache-Control' => 'public, s-maxage=1000, max-age=1000',
'Last-Modified' => $now,
], Stream::factory('Test/1.0 request.')
),
new Response(
200,
[
'Vary' => 'Accept, User-Agent',
'Content-type' => 'text/html',
'Date' => $now,
'Cache-Control' => 'public, s-maxage=1000, max-age=1000',
'Last-Modified' => $now,
],
Stream::factory('Test/2.0 request.')
),
new Response(
200, [
'Vary' => 'Accept, User-Agent',
'Content-type' => 'application/json',
'Date' => $now,
'Cache-Control' => 'public, s-maxage=1000, max-age=1000',
'Last-Modified' => $now,
], Stream::factory(json_encode(['body' => 'Test/1.0 request.']))
),
new Response(
200, [
'Vary' => 'Accept, User-Agent',
'Content-type' => 'application/json',
'Date' => $now,
'Cache-Control' => 'public, s-maxage=1000, max-age=1000',
'Last-Modified' => $now,
], Stream::factory(json_encode(['body' => 'Test/2.0 request.']))
),
]
);
}
/**
* Setup a Guzzle client for testing.
*
* @param History $history (optional) parameter of a History to track
* requests in.
*
* @return Client A client ready to run test requests against.
*/
private function setupClient(History $history = null)
{
$client = new Client(['base_url' => Server::$url]);
CacheSubscriber::attach($client);
if ($history) {
$client->getEmitter()->attach($history);
}
return $client;
}
/**
* Return a date string suitable for using in an HTTP header.
*
* @param int $timestamp (optional) A Unix timestamp to generate the date.
*
* @return string The generated date string.
*/
private function date($timestamp = null)
{
if (!$timestamp) {
$timestamp = time();
}
return gmdate("D, d M Y H:i:s", $timestamp) . ' GMT';
}
/**
* Helper to test that a 400 response deletes cache entries.
*
* @param int $errorCode The error code to test, such as 404 or 410.
*
* @throws \Exception
*/
private function fourXXCacheDelete($errorCode)
{
$now = $this->date();
Server::enqueue(
[
new Response(
200, [
'Date' => $now,
'Cache-Control' => 'public, max-age=1000, must-revalidate',
'Last-Modified' => $now,
]
),
new Response(
304, [
'Date' => $now,
'Cache-Control' => 'public, max-age=1000, must-revalidate',
'Last-Modified' => $now,
'Age' => 0,
]
),
new Response(
$errorCode, [
'Date' => $now,
'Cache-Control' => 'public, max-age=1000, must-revalidate',
'Last-Modified' => $now,
]
),
new Response(
200, [
'Date' => $now,
'Cache-Control' => 'public, max-age=1000, must-revalidate',
'Last-Modified' => $now,
]
),
]
);
$client = $this->setupClient();
$response1 = $client->get('/foo');
$this->assertEquals('MISS from GuzzleCache', $response1->getHeader('X-Cache-Lookup'));
$response2 = $client->get('/foo');
$this->assertEquals('HIT from GuzzleCache', $response2->getHeader('X-Cache-Lookup'));
try {
$client->get('/foo');
$this->fail($errorCode . ' was not thrown.');
} catch (RequestException $e) {
$response3 = $e->getResponse();
$this->assertEquals($errorCode, $response3->getStatusCode());
$this->assertEquals('MISS from GuzzleCache', $response3->getHeader('X-Cache-Lookup'));
}
$response4 = $client->get('/foo');
$this->assertEquals('MISS from GuzzleCache', $response4->getHeader('X-Cache-Lookup'));
}
}