class TestSerializer(object):
    def setup(self):
        self.serializer = Serializer()
        self.response_data = {
            u"response": {
                # Encode the body as bytes b/c it will eventually be
                # converted back into a BytesIO object.
                u"body": "Hello World".encode("utf-8"),
                u"headers": {
                    u"Content-Type": u"text/plain",
                    u"Expires": u"87654",
                    u"Cache-Control": u"public",
                },
                u"status": 200,
                u"version": 11,
                u"reason": u"",
                u"strict": True,
                u"decode_content": True,
            }
        }

    def test_load_by_version_v0(self):
        data = b"cc=0,somedata"
        req = Mock()
        resp = self.serializer.loads(req, data)
        assert resp is None

    def test_read_version_v1(self):
        req = Mock()
        resp = self.serializer._loads_v1(req, pickle.dumps(self.response_data))
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == "Hello World".encode("utf-8")

    def test_read_version_v2(self):
        req = Mock()
        compressed_base64_json = b"x\x9c%O\xb9\n\x83@\x10\xfd\x97\xa9-\x92%E\x14R\xe4 +\x16\t\xe6\x10\xbb\xb0\xc7\xe0\x81\xb8\xb2\xbb*A\xfc\xf7\x8c\xa6|\xe7\xbc\x99\xc0\xa2\xebL\xeb\x10\xa2\t\xa4\xd1_\x88\xe0\xc93'\xf9\xbe\xc8X\xf8\x95<=@\x00\x1a\x95\xd1\xf8Q\xa6\xf5\xd8z\x88\xbc\xed1\x80\x12\x85F\xeb\x96h\xca\xc2^\xf3\xac\xd7\xe7\xed\x1b\xf3SC5\x04w\xfa\x1c\x8e\x92_;Y\x1c\x96\x9a\x94]k\xc1\xdf~u\xc7\xc9 \x8fDG\xa0\xe2\xac\x92\xbc\xa9\xc9\xf1\xc8\xcbQ\xe4I\xa3\xc6U\xb9_\x14\xbb\xbdh\xc2\x1c\xd0R\xe1LK$\xd9\x9c\x17\xbe\xa7\xc3l\xb3Y\x80\xad\x94\xff\x0b\x03\xed\xa9V\x17[2\x83\xb0\xf4\xd14\xcf?E\x03Im"
        resp = self.serializer._loads_v2(req, compressed_base64_json)
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == "Hello World".encode("utf-8")

    def test_load_by_version_v3(self):
        data = b"cc=3,somedata"
        req = Mock()
        resp = self.serializer.loads(req, data)
        assert resp is None

    def test_read_version_v4(self):
        req = Mock()
        resp = self.serializer._loads_v4(req,
                                         msgpack.dumps(self.response_data))
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == "Hello World".encode("utf-8")

    def test_read_v1_serialized_with_py2_TypeError(self):
        # This tests how the code handles in reading data that was pickled
        # with an old version of cachecontrol running under Python 2
        req = Mock()
        py2_pickled_data = b"".join([
            b"(dp1\nS'response'\np2\n(dp3\nS'body'\np4\nS'Hello World'\n",
            b"p5\nsS'version'\np6\nS'2'\nsS'status'\np7\nI200\n",
            b"sS'reason'\np8\nS''\nsS'decode_content'\np9\nI01\n",
            b"sS'strict'\np10\nS''\nsS'headers'\np11\n(dp12\n",
            b"S'Content-Type'\np13\nS'text/plain'\np14\n",
            b"sS'Cache-Control'\np15\nS'public'\np16\n",
            b"sS'Expires'\np17\nS'87654'\np18\nsss.",
        ])
        resp = self.serializer._loads_v1(req, py2_pickled_data)
        # We have to decode our urllib3 data back into a unicode
        # string.
        assert resp.data == "Hello World".encode("utf-8")

    def test_read_v2_corrupted_cache(self):
        # This should prevent a regression of bug #134
        req = Mock()
        assert self.serializer._loads_v2(req, b"") is None

    def test_read_latest_version_streamable(self, url):
        original_resp = requests.get(url, stream=True)
        req = original_resp.request

        resp = self.serializer.loads(
            req,
            self.serializer.dumps(req, original_resp.raw,
                                  original_resp.content))

        assert resp.read()

    def test_read_latest_version(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        resp = self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, data))

        assert resp.read() == data

    def test_no_vary_header(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        # We make sure our response has a Vary header and that the
        # request doesn't have the header.
        original_resp.raw.headers["vary"] = "Foo"

        assert self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, data))

    def test_no_body_creates_response_file_handle_on_dumps(self, url):
        original_resp = requests.get(url, stream=True)
        data = None
        req = original_resp.request

        assert self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, data))

        # By passing in data=None it will force a read of the file
        # handle. Reading it again proves we're resetting the internal
        # file handle with a buffer.
        assert original_resp.raw.read()
class TestSerializer(object):

    def setup(self):
        self.serializer = Serializer()
        self.response_data = {
            'response': {
                # Encode the body as bytes b/c it will eventually be
                # converted back into a BytesIO object.
                'body': 'Hello World'.encode('utf-8'),
                'headers': {
                    'Content-Type': 'text/plain',
                    'Expires': '87654',
                    'Cache-Control': 'public',
                },
                'status': 200,
                'version': '2',
                'reason': '',
                'strict': '',
                'decode_content': True,
            },
        }

    def test_load_by_version_one(self):
        data = b'cc=0,somedata'
        req = Mock()
        resp = self.serializer.loads(req, data)
        assert resp is None

    def test_read_version_two(self):
        req = Mock()
        resp = self.serializer._loads_v1(req, pickle.dumps(self.response_data))
        # We have to decode our urllib3 data back into a unicode
        # string.
        assert resp.data == 'Hello World'.encode('utf-8')

    def test_read_v1_serialized_with_py2_TypeError(self):
        # This tests how the code handles in reading data that was pickled
        # with an old version of cachecontrol running under Python 2
        req = Mock()
        py2_pickled_data = b"".join([
            b"(dp1\nS'response'\np2\n(dp3\nS'body'\np4\nS'Hello World'\n",
            b"p5\nsS'version'\np6\nS'2'\nsS'status'\np7\nI200\n",
            b"sS'reason'\np8\nS''\nsS'decode_content'\np9\nI01\n",
            b"sS'strict'\np10\nS''\nsS'headers'\np11\n(dp12\n",
            b"S'Content-Type'\np13\nS'text/plain'\np14\n",
            b"sS'Cache-Control'\np15\nS'public'\np16\n",
            b"sS'Expires'\np17\nS'87654'\np18\nsss."])
        resp = self.serializer._loads_v1(req, py2_pickled_data)
        # We have to decode our urllib3 data back into a unicode
        # string.
        assert resp.data == 'Hello World'.encode('utf-8')

    def test_read_version_three_streamable(self, url):
        original_resp = requests.get(url, stream=True)
        req = original_resp.request

        resp = self.serializer.loads(
            req, self.serializer.dumps(
                req,
                original_resp.raw
            )
        )

        assert resp.read()

    def test_read_version_three(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        resp = self.serializer.loads(
            req, self.serializer.dumps(
                req,
                original_resp.raw,
                body=data
            )
        )

        assert resp.read() == data

    def test_no_vary_header(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        # We make sure our response has a Vary header and that the
        # request doesn't have the header.
        original_resp.raw.headers['vary'] = 'Foo'

        assert self.serializer.loads(
            req, self.serializer.dumps(
                req,
                original_resp.raw,
                body=data
            )
        )
Exemple #3
0
class TestSerializer(object):
    def setup(self):
        self.serializer = Serializer()
        self.response_data = {
            'response': {
                # Encode the body as bytes b/c it will eventually be
                # converted back into a BytesIO object.
                'body': 'Hello World'.encode('utf-8'),
                'headers': {
                    'Content-Type': 'text/plain',
                    'Expires': '87654',
                    'Cache-Control': 'public',
                },
                'status': 200,
                'version': '2',
                'reason': '',
                'strict': '',
                'decode_content': True,
            },
        }

    def test_load_by_version_v0(self):
        data = b'cc=0,somedata'
        req = Mock()
        resp = self.serializer.loads(req, data)
        assert resp is None

    def test_read_version_v1(self):
        req = Mock()
        resp = self.serializer._loads_v1(req, pickle.dumps(self.response_data))
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == 'Hello World'.encode('utf-8')

    def test_read_version_v2(self):
        req = Mock()
        compressed_base64_json = b"x\x9c%O\xb9\n\x83@\x10\xfd\x97\xa9-\x92%E\x14R\xe4 +\x16\t\xe6\x10\xbb\xb0\xc7\xe0\x81\xb8\xb2\xbb*A\xfc\xf7\x8c\xa6|\xe7\xbc\x99\xc0\xa2\xebL\xeb\x10\xa2\t\xa4\xd1_\x88\xe0\xc93'\xf9\xbe\xc8X\xf8\x95<=@\x00\x1a\x95\xd1\xf8Q\xa6\xf5\xd8z\x88\xbc\xed1\x80\x12\x85F\xeb\x96h\xca\xc2^\xf3\xac\xd7\xe7\xed\x1b\xf3SC5\x04w\xfa\x1c\x8e\x92_;Y\x1c\x96\x9a\x94]k\xc1\xdf~u\xc7\xc9 \x8fDG\xa0\xe2\xac\x92\xbc\xa9\xc9\xf1\xc8\xcbQ\xe4I\xa3\xc6U\xb9_\x14\xbb\xbdh\xc2\x1c\xd0R\xe1LK$\xd9\x9c\x17\xbe\xa7\xc3l\xb3Y\x80\xad\x94\xff\x0b\x03\xed\xa9V\x17[2\x83\xb0\xf4\xd14\xcf?E\x03Im"
        resp = self.serializer._loads_v2(req, compressed_base64_json)
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == 'Hello World'.encode('utf-8')

    def test_read_version_v3(self):
        req = Mock()
        resp = self.serializer._loads_v3(req,
                                         msgpack.dumps(self.response_data))
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == 'Hello World'.encode('utf-8')

    def test_read_v1_serialized_with_py2_TypeError(self):
        # This tests how the code handles in reading data that was pickled
        # with an old version of cachecontrol running under Python 2
        req = Mock()
        py2_pickled_data = b"".join([
            b"(dp1\nS'response'\np2\n(dp3\nS'body'\np4\nS'Hello World'\n",
            b"p5\nsS'version'\np6\nS'2'\nsS'status'\np7\nI200\n",
            b"sS'reason'\np8\nS''\nsS'decode_content'\np9\nI01\n",
            b"sS'strict'\np10\nS''\nsS'headers'\np11\n(dp12\n",
            b"S'Content-Type'\np13\nS'text/plain'\np14\n",
            b"sS'Cache-Control'\np15\nS'public'\np16\n",
            b"sS'Expires'\np17\nS'87654'\np18\nsss."
        ])
        resp = self.serializer._loads_v1(req, py2_pickled_data)
        # We have to decode our urllib3 data back into a unicode
        # string.
        assert resp.data == 'Hello World'.encode('utf-8')

    def test_read_v2_corrupted_cache(self):
        # This should prevent a regression of bug #134
        req = Mock()
        assert self.serializer._loads_v2(req, b'') is None

    def test_read_latest_version_streamable(self, url):
        original_resp = requests.get(url, stream=True)
        req = original_resp.request

        resp = self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw))

        assert resp.read()

    def test_read_latest_version(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        resp = self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, body=data))

        assert resp.read() == data

    def test_no_vary_header(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        # We make sure our response has a Vary header and that the
        # request doesn't have the header.
        original_resp.raw.headers['vary'] = 'Foo'

        assert self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, body=data))
class TestSerializer(object):
    def setup(self):
        self.serializer = Serializer()
        self.response_data = {
            'response': {
                # Encode the body as bytes b/c it will eventually be
                # converted back into a BytesIO object.
                'body': 'Hello World'.encode('utf-8'),
                'headers': {
                    'Content-Type': 'text/plain',
                    'Expires': '87654',
                    'Cache-Control': 'public',
                },
                'status': 200,
                'version': '2',
                'reason': '',
                'strict': '',
                'decode_content': True,
            },
        }

    def test_load_by_version_one(self):
        data = b'cc=0,somedata'
        req = Mock()
        resp = self.serializer.loads(req, data)
        assert resp is None

    def test_read_version_two(self):
        req = Mock()
        resp = self.serializer._loads_v1(req, pickle.dumps(self.response_data))
        # We have to decode our urllib3 data back into a unicode
        # string.
        assert resp.data == 'Hello World'.encode('utf-8')

    def test_read_v1_serialized_with_py2_TypeError(self):
        # This tests how the code handles in reading data that was pickled
        # with an old version of cachecontrol running under Python 2
        req = Mock()
        py2_pickled_data = b"".join([
            b"(dp1\nS'response'\np2\n(dp3\nS'body'\np4\nS'Hello World'\n",
            b"p5\nsS'version'\np6\nS'2'\nsS'status'\np7\nI200\n",
            b"sS'reason'\np8\nS''\nsS'decode_content'\np9\nI01\n",
            b"sS'strict'\np10\nS''\nsS'headers'\np11\n(dp12\n",
            b"S'Content-Type'\np13\nS'text/plain'\np14\n",
            b"sS'Cache-Control'\np15\nS'public'\np16\n",
            b"sS'Expires'\np17\nS'87654'\np18\nsss."
        ])
        resp = self.serializer._loads_v1(req, py2_pickled_data)
        # We have to decode our urllib3 data back into a unicode
        # string.
        assert resp.data == 'Hello World'.encode('utf-8')

    def test_read_v2_corrupted_cache(self):
        # This should prevent a regression of bug #134
        req = Mock()
        assert self.serializer._loads_v2(req, b'') is None

    def test_read_version_three_streamable(self, url):
        original_resp = requests.get(url, stream=True)
        req = original_resp.request

        resp = self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw))

        assert resp.read()

    def test_read_version_three(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        resp = self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, body=data))

        assert resp.read() == data

    def test_no_vary_header(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        # We make sure our response has a Vary header and that the
        # request doesn't have the header.
        original_resp.raw.headers['vary'] = 'Foo'

        assert self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, body=data))
class TestSerializer(object):

    def setup(self):
        self.serializer = Serializer()
        self.response_data = {
            u"response": {
                # Encode the body as bytes b/c it will eventually be
                # converted back into a BytesIO object.
                u"body": "Hello World".encode("utf-8"),
                u"headers": {
                    u"Content-Type": u"text/plain",
                    u"Expires": u"87654",
                    u"Cache-Control": u"public",
                },
                u"status": 200,
                u"version": 11,
                u"reason": u"",
                u"strict": True,
                u"decode_content": True,
            }
        }

    def test_load_by_version_v0(self):
        data = b"cc=0,somedata"
        req = Mock()
        resp = self.serializer.loads(req, data)
        assert resp is None

    def test_read_version_v1(self):
        req = Mock()
        resp = self.serializer._loads_v1(req, pickle.dumps(self.response_data))
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == "Hello World".encode("utf-8")

    def test_read_version_v2(self):
        req = Mock()
        compressed_base64_json = b"x\x9c%O\xb9\n\x83@\x10\xfd\x97\xa9-\x92%E\x14R\xe4 +\x16\t\xe6\x10\xbb\xb0\xc7\xe0\x81\xb8\xb2\xbb*A\xfc\xf7\x8c\xa6|\xe7\xbc\x99\xc0\xa2\xebL\xeb\x10\xa2\t\xa4\xd1_\x88\xe0\xc93'\xf9\xbe\xc8X\xf8\x95<=@\x00\x1a\x95\xd1\xf8Q\xa6\xf5\xd8z\x88\xbc\xed1\x80\x12\x85F\xeb\x96h\xca\xc2^\xf3\xac\xd7\xe7\xed\x1b\xf3SC5\x04w\xfa\x1c\x8e\x92_;Y\x1c\x96\x9a\x94]k\xc1\xdf~u\xc7\xc9 \x8fDG\xa0\xe2\xac\x92\xbc\xa9\xc9\xf1\xc8\xcbQ\xe4I\xa3\xc6U\xb9_\x14\xbb\xbdh\xc2\x1c\xd0R\xe1LK$\xd9\x9c\x17\xbe\xa7\xc3l\xb3Y\x80\xad\x94\xff\x0b\x03\xed\xa9V\x17[2\x83\xb0\xf4\xd14\xcf?E\x03Im"
        resp = self.serializer._loads_v2(req, compressed_base64_json)
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == "Hello World".encode("utf-8")

    def test_load_by_version_v3(self):
        data = b"cc=3,somedata"
        req = Mock()
        resp = self.serializer.loads(req, data)
        assert resp is None

    def test_read_version_v4(self):
        req = Mock()
        resp = self.serializer._loads_v4(req, msgpack.dumps(self.response_data))
        # We have to decode our urllib3 data back into a unicode string.
        assert resp.data == "Hello World".encode("utf-8")

    def test_read_v1_serialized_with_py2_TypeError(self):
        # This tests how the code handles in reading data that was pickled
        # with an old version of cachecontrol running under Python 2
        req = Mock()
        py2_pickled_data = b"".join(
            [
                b"(dp1\nS'response'\np2\n(dp3\nS'body'\np4\nS'Hello World'\n",
                b"p5\nsS'version'\np6\nS'2'\nsS'status'\np7\nI200\n",
                b"sS'reason'\np8\nS''\nsS'decode_content'\np9\nI01\n",
                b"sS'strict'\np10\nS''\nsS'headers'\np11\n(dp12\n",
                b"S'Content-Type'\np13\nS'text/plain'\np14\n",
                b"sS'Cache-Control'\np15\nS'public'\np16\n",
                b"sS'Expires'\np17\nS'87654'\np18\nsss.",
            ]
        )
        resp = self.serializer._loads_v1(req, py2_pickled_data)
        # We have to decode our urllib3 data back into a unicode
        # string.
        assert resp.data == "Hello World".encode("utf-8")

    def test_read_v2_corrupted_cache(self):
        # This should prevent a regression of bug #134
        req = Mock()
        assert self.serializer._loads_v2(req, b"") is None

    def test_read_latest_version_streamable(self, url):
        original_resp = requests.get(url, stream=True)
        req = original_resp.request

        resp = self.serializer.loads(req, self.serializer.dumps(req, original_resp.raw))

        assert resp.read()

    def test_read_latest_version(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        resp = self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, body=data)
        )

        assert resp.read() == data

    def test_no_vary_header(self, url):
        original_resp = requests.get(url)
        data = original_resp.content
        req = original_resp.request

        # We make sure our response has a Vary header and that the
        # request doesn't have the header.
        original_resp.raw.headers["vary"] = "Foo"

        assert self.serializer.loads(
            req, self.serializer.dumps(req, original_resp.raw, body=data)
        )