<?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'));
    }
}