Python cache.DictCache类代码示例

class TestETag(object):
    """Test our equal priority caching with ETags

    Equal Priority Caching is a term I've defined to describe when
    ETags are cached orthgonally from Time Based Caching.
    """

    @pytest.fixture()
    def sess(self, server):
        self.etag_url = urljoin(server.application_url, "/etag")
        self.update_etag_url = urljoin(server.application_url, "/update_etag")
        self.cache = DictCache()
        sess = CacheControl(requests.Session(), cache=self.cache, serializer=NullSerializer())
        return sess

    def test_etags_get_example(self, sess, server):
        """RFC 2616 14.26

        The If-None-Match request-header field is used with a method to make
        it conditional. A client that has one or more entities previously
        obtained from the resource can verify that none of those entities
        is current by including a list of their associated entity tags in
        the If-None-Match header field. The purpose of this feature is to
        allow efficient updates of cached information with a minimum amount
        of transaction overhead

        If any of the entity tags match the entity tag of the entity that
        would have been returned in the response to a similar GET request
        (without the If-None-Match header) on that resource, [...] then
        the server MUST NOT perform the requested method, [...]. Instead, if
        the request method was GET or HEAD, the server SHOULD respond with
        a 304 (Not Modified) response, including the cache-related header
        fields (particularly ETag) of one of the entities that matched.

        (Paraphrased) A server may provide an ETag header on a response. On
        subsequent queries, the client may reference the value of this Etag
        header in an If-None-Match header; on receiving such a header, the
        server can check whether the entity at that URL has changed from the
        clients last version, and if not, it can return a 304 to indicate
        the client can use it's current representation.
        """
        r = sess.get(self.etag_url)

        # make sure we cached it
        assert self.cache.get(self.etag_url) == r.raw

        # make the same request
        resp = sess.get(self.etag_url)
        assert resp.raw == r.raw
        assert resp.from_cache

        # tell the server to change the etags of the response
        sess.get(self.update_etag_url)

        resp = sess.get(self.etag_url)
        assert resp != r
        assert not resp.from_cache

        # Make sure we updated our cache with the new etag'd response.
        assert self.cache.get(self.etag_url) == resp.raw

class TestDisabledETags(object):
    """Test our use of ETags when the response is stale and the
    response has an ETag.
    """

    @pytest.fixture()
    def sess(self, server):
        self.etag_url = urljoin(server.application_url, "/etag")
        self.update_etag_url = urljoin(server.application_url, "/update_etag")
        self.cache = DictCache()
        sess = CacheControl(requests.Session(), cache=self.cache, cache_etags=False, serializer=NullSerializer())
        return sess

    def test_expired_etags_if_none_match_response(self, sess):
        """Make sure an expired response that contains an ETag uses
        the If-None-Match header.
        """
        # get our response
        r = sess.get(self.etag_url)

        # expire our request by changing the date. Our test endpoint
        # doesn't provide time base caching headers, so we add them
        # here in order to expire the request.
        r.headers["Date"] = "Tue, 26 Nov 2012 00:50:49 GMT"
        self.cache.set(self.etag_url, r)

        r = sess.get(self.etag_url)
        assert r.from_cache
        assert "if-none-match" in r.request.headers
        assert r.status_code == 200

class TestMaxAge(object):

    @pytest.fixture()
    def sess(self, url):
        self.url = url
        self.cache = DictCache()
        sess = Session()
        sess.mount(
            'http://',
            CacheControlAdapter(self.cache, serializer=NullSerializer()),
        )
        return sess

    def test_client_max_age_0(self, sess):
        """
        Making sure when the client uses max-age=0 we don't get a
        cached copy even though we're still fresh.
        """
        print('first request')
        r = sess.get(self.url)
        assert self.cache.get(self.url) == r.raw

        print('second request')
        r = sess.get(self.url, headers={'Cache-Control': 'max-age=0'})

        # don't remove from the cache
        assert self.cache.get(self.url)
        assert not r.from_cache

    def test_client_max_age_3600(self, sess):
        """
        Verify we get a cached value when the client has a
        reasonable max-age value.
        """
        r = sess.get(self.url)
        assert self.cache.get(self.url) == r.raw

        # request that we don't want a new one unless
        r = sess.get(self.url, headers={'Cache-Control': 'max-age=3600'})
        assert r.from_cache is True

        # now lets grab one that forces a new request b/c the cache
        # has expired. To do that we'll inject a new time value.
        resp = self.cache.get(self.url)
        resp.headers['date'] = 'Tue, 15 Nov 1994 08:12:31 GMT'
        r = sess.get(self.url)
        assert not r.from_cache

 def sess(self, url):
     self.url = url
     self.cache = DictCache()
     sess = Session()
     sess.mount(
         "http://", CacheControlAdapter(self.cache, serializer=NullSerializer())
     )
     return sess

 def sess(self, server):
     self.etag_url = urljoin(server.application_url, '/etag')
     self.update_etag_url = urljoin(server.application_url, '/update_etag')
     self.cache = DictCache()
     sess = CacheControl(requests.Session(),
                         cache=self.cache,
                         cache_etags=False)
     return sess

 def sess(self, server, url):
     self.etag_url = urljoin(url, '/etag')
     self.update_etag_url = urljoin(url, '/update_etag')
     self.cache = DictCache()
     sess = CacheControl(requests.Session(),
                         cache=self.cache,
                         cache_etags=False,
                         serializer=NullSerializer())
     return sess

 def sess(self, server):
     self.url = server.application_url
     self.cache = DictCache()
     sess = Session()
     sess.mount(
         'http://',
         CacheControlAdapter(self.cache, serializer=NullSerializer()),
     )
     return sess

 def sess(self, chunking_server):
     self.url = chunking_server.base_url
     self.cache = DictCache()
     sess = Session()
     sess.mount(
         'http://',
         CacheControlAdapter(self.cache, serializer=NullSerializer()),
     )
     return sess

    def sess(self, url):
        self.etag_url = urljoin(url, "/etag")
        self.update_etag_url = urljoin(url, "/update_etag")
        self.cache = DictCache()
        sess = CacheControl(
            requests.Session(), cache=self.cache, serializer=NullSerializer()
        )
        yield sess

        # closing session object
        sess.close()

class TestVary(object):

    @pytest.fixture()
    def sess(self, server):
        self.url = urljoin(server.application_url, '/vary_accept')
        self.cache = DictCache()
        sess = CacheControl(requests.Session(), cache=self.cache)
        return sess

    def test_vary_example(self, sess):
        """RFC 2616 13.6

        When the cache receives a subsequent request whose Request-URI
        specifies one or more cache entries including a Vary header field,
        the cache MUST NOT use such a cache entry to construct a response
        to the new request unless all of the selecting request-headers
        present in the new request match the corresponding stored
        request-headers in the original request.

        Or, in simpler terms, when you make a request and the server
        returns defines a Vary header, unless all the headers listed
        in the Vary header are the same, it won't use the cached
        value.
        """
        r = sess.get(self.url)

        # make sure we cached it
        assert self.cache.get(self.url) == r

        # make the same request
        resp = sess.get(self.url)
        assert resp == r
        assert resp.from_cache

        # make a similar request, changing the accept header
        resp = sess.get(self.url, headers={'Accept': 'text/plain, text/html'})
        assert resp != r
        assert not resp.from_cache

        # Just confirming two things here:
        #
        #   1) The server used the vary header
        #   2) We have more than one header we vary on
        #
        # The reason for this is that when we don't specify the header
        # in the request, it is considered the same in terms of
        # whether or not to use the cached value.
        assert 'vary' in r.headers
        assert len(r.headers['vary'].replace(' ', '').split(',')) == 2

class TestChunkedResponse(object):

    @pytest.fixture()
    def sess(self, chunking_server):
        self.url = chunking_server.base_url
        self.cache = DictCache()
        sess = Session()
        sess.mount(
            'http://',
            CacheControlAdapter(self.cache, serializer=NullSerializer()),
        )
        return sess

    def test_cache_chunked_response(self, sess):
        """
        Verify that an otherwise cacheable response is cached when the response
        is chunked.
        """
        r = sess.get(self.url)
        assert self.cache.get(self.url) == r.raw

        r = sess.get(self.url, headers={'Cache-Control': 'max-age=3600'})
        assert r.from_cache is True

 def sess(self, server):
     self.url = urljoin(server.application_url, '/vary_accept')
     self.cache = DictCache()
     sess = CacheControl(requests.Session(), cache=self.cache)
     return sess

 def sess(self, server):
     self.etag_url = urljoin(server.application_url, "/etag")
     self.update_etag_url = urljoin(server.application_url, "/update_etag")
     self.cache = DictCache()
     sess = CacheControl(requests.Session(), cache=self.cache, cache_etags=False, serializer=NullSerializer())
     return sess

 def sess(self, url):
     self.url = urljoin(url, '/vary_accept')
     self.cache = DictCache()
     sess = CacheControl(requests.Session(), cache=self.cache)
     return sess

class TestVary(object):

    @pytest.fixture()
    def sess(self, url):
        self.url = urljoin(url, '/vary_accept')
        self.cache = DictCache()
        sess = CacheControl(requests.Session(), cache=self.cache)
        return sess

    def cached_equal(self, cached, resp):
        # remove any transfer-encoding headers as they don't apply to
        # a cached value
        if 'chunked' in resp.raw.headers.get('transfer-encoding', ''):
            resp.raw.headers.pop('transfer-encoding')

        checks = [
            cached._fp.getvalue() == resp.content,
            cached.headers == resp.raw.headers,
            cached.status == resp.raw.status,
            cached.version == resp.raw.version,
            cached.reason == resp.raw.reason,
            cached.strict == resp.raw.strict,
            cached.decode_content == resp.raw.decode_content,
        ]

        print(checks)
        pprint(dict(cached.headers))
        pprint(dict(resp.raw.headers))
        return all(checks)

    def test_vary_example(self, sess):
        """RFC 2616 13.6

        When the cache receives a subsequent request whose Request-URI
        specifies one or more cache entries including a Vary header field,
        the cache MUST NOT use such a cache entry to construct a response
        to the new request unless all of the selecting request-headers
        present in the new request match the corresponding stored
        request-headers in the original request.

        Or, in simpler terms, when you make a request and the server
        returns defines a Vary header, unless all the headers listed
        in the Vary header are the same, it won't use the cached
        value.
        """
        s = sess.adapters["http://"].controller.serializer
        r = sess.get(self.url)
        c = s.loads(r.request, self.cache.get(self.url))

        # make sure we cached it
        assert self.cached_equal(c, r)

        # make the same request
        resp = sess.get(self.url)
        assert self.cached_equal(c, resp)
        assert resp.from_cache

        # make a similar request, changing the accept header
        resp = sess.get(self.url, headers={'Accept': 'text/plain, text/html'})
        assert not self.cached_equal(c, resp)
        assert not resp.from_cache

        # Just confirming two things here:
        #
        #   1) The server used the vary header
        #   2) We have more than one header we vary on
        #
        # The reason for this is that when we don't specify the header
        # in the request, it is considered the same in terms of
        # whether or not to use the cached value.
        assert 'vary' in r.headers
        assert len(r.headers['vary'].replace(' ', '').split(',')) == 2