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 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 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 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,
}
}
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
)
)
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 = {
'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 = {
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)
)