def test_multipart(self):
url = 'http://httpbin.org/post'
data = '--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="content"\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: 68\r\n\r\nAction: comment\nText: Comment with attach\nAttachment: x1.txt, x2.txt\r\n--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="attachment_2"; filename="x.txt"\r\nContent-Type: text/plain\r\nContent-Length: 4\r\n\r\nbye\n\r\n--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="attachment_1"; filename="x.txt"\r\nContent-Type: text/plain\r\nContent-Length: 4\r\n\r\nbye\n\r\n--xXXxXXyYYzzz--\r\n'
headers = {
'Content-Length': '495',
'Content-Type': 'multipart/form-data; boundary=xXXxXXyYYzzz',
'Accept': 'text/plain',
'User-Agent': 'Mocket',
'Accept-encoding': 'identity',
}
Entry.register(Entry.POST, url)
response = requests.post(url, data=data, headers=headers)
self.assertEqual(response.status_code, 200)
last_request = Mocket.last_request()
self.assertEqual(last_request.method, 'POST')
self.assertEqual(last_request.path, '/post')
self.assertEqual(last_request.body, data)
sent_headers = dict(last_request.headers)
self.assertEqualHeaders(
sent_headers,
{
'accept': 'text/plain',
'accept-encoding': 'identity',
'content-length': '495',
'content-type': 'multipart/form-data; boundary=xXXxXXyYYzzz',
'host': 'httpbin.org',
'user-agent': 'Mocket',
'connection': 'keep-alive',
}
)
def test_multi_register(self):
url = "http://foobar.com/path"
Entry.register(
Entry.POST,
url,
Response(body='{"foo":"bar0"}', status=200),
Response(body='{"foo":"bar1"}', status=201),
Response(body='{"foo":"bar2"}', status=202),
)
response = requests.post(url, json={"test": 0})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), {"foo": "bar0"})
response = requests.post(url, json={"test": 1})
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json(), {"foo": "bar1"})
response = requests.post(url, json={"test": 2})
self.assertEqual(response.status_code, 202)
self.assertEqual(response.json(), {"foo": "bar2"})
response = requests.post(url, json={"test": 22})
self.assertEqual(response.status_code, 202)
self.assertEqual(response.json(), {"foo": "bar2"})
def test_register(self):
with mock.patch('time.gmtime') as tt:
tt.return_value = time.struct_time((2013, 4, 30, 10, 39, 21, 1, 120, 0))
Entry.register(
Entry.GET,
'http://testme.org/get?a=1&b=2#test',
Response('{"a": "€"}', headers={'content-type': 'application/json'})
)
entries = Mocket._entries[('testme.org', 80)]
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.method, 'GET')
self.assertEqual(entry.schema, 'http')
self.assertEqual(entry.path, '/get')
self.assertEqual(entry.query, 'a=1&b=2')
self.assertEqual(len(entry.responses), 1)
response = entry.responses[0]
self.assertEqual(response.body, b'{"a": "\xe2\x82\xac"}')
self.assertEqual(response.status, 200)
self.assertEqual(response.headers, {
'Status': '200',
'Date': 'Tue, 30 Apr 2013 10:39:21 GMT',
'Connection': 'close',
'Server': 'Python/Mocket',
'Content-Length': '12',
'Content-Type': 'application/json',
})
def test_parse_metadata_missing_annotations_and_labels(self, core_client, dummy_host):
namespace_metadata = {
"items": [
{
"metadata": {
"name": "checkmk-monitoring",
"uid": "753292ba-5e0e-4267-a0f1-77a3c6b4d55e",
"resourceVersion": "509",
"creationTimestamp": "2022-03-25T13:24:42Z",
},
},
],
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/api/v1/namespaces",
body=json.dumps(namespace_metadata),
headers={"content-type": "application/json"},
)
with Mocketizer():
namespace = list(core_client.list_namespace().items)[0]
metadata = parse_namespace_metadata(namespace.metadata)
assert metadata.labels == {}
assert metadata.annotations == {}
def test_random_url():
url = "http://www.example.com"
Entry.single_register(Entry.GET, url)
requests.get(url)
assert Mocket.has_requests()
def test_parse_status_no_matching_node(self, apps_client, dummy_host):
"""
Some DaemonSets may have no Nodes, on which they want to schedule Pods (because of their
NodeSelector or NodeAffinity). In this case, some status fields are omitted.
"""
daemon_sets_data = {
"items": [{
"status": {
"currentNumberScheduled": 0,
"numberMisscheduled": 0,
"desiredNumberScheduled": 0,
"numberReady": 0,
"observedGeneration": 1,
}
}]
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/apis/apps/v1/daemonsets",
body=json.dumps(daemon_sets_data),
headers={"content-type": "application/json"},
)
with Mocketizer():
daemon_set = list(
apps_client.list_daemon_set_for_all_namespaces().items)[0]
status = parse_daemonset_status(daemon_set.status)
assert status.number_misscheduled == 0
assert status.number_ready == 0
assert status.desired_number_scheduled == 0
assert status.updated_number_scheduled == 0
def test_multipart(self):
url = 'http://httpbin.org/post'
data = '--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="content"\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: 68\r\n\r\nAction: comment\nText: Comment with attach\nAttachment: x1.txt, x2.txt\r\n--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="attachment_2"; filename="x.txt"\r\nContent-Type: text/plain\r\nContent-Length: 4\r\n\r\nbye\n\r\n--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="attachment_1"; filename="x.txt"\r\nContent-Type: text/plain\r\nContent-Length: 4\r\n\r\nbye\n\r\n--xXXxXXyYYzzz--\r\n'
headers = {
'Content-Length': '495',
'Content-Type': 'multipart/form-data; boundary=xXXxXXyYYzzz',
'Accept': 'text/plain',
'User-Agent': 'Mocket',
'Accept-encoding': 'identity',
}
Entry.register(Entry.POST, url)
response = requests.post(url, data=data, headers=headers)
self.assertEqual(response.status_code, 200)
last_request = Mocket.last_request()
self.assertEqual(last_request.method, 'POST')
self.assertEqual(last_request.path, '/post')
self.assertEqual(last_request.body, data)
sent_headers = dict(last_request.headers)
self.assertEqualHeaders(
sent_headers, {
'accept': 'text/plain',
'accept-encoding': 'identity',
'content-length': '495',
'content-type': 'multipart/form-data; boundary=xXXxXXyYYzzz',
'host': 'httpbin.org',
'user-agent': 'Mocket',
'connection': 'keep-alive',
})
self.assertEqual(len(Mocket._requests), 1)
def test_post_file_object(self):
url = "http://github.com/fluidicon.png"
Entry.single_register(Entry.POST, url, status=201)
file_obj = open("tests/fluidicon.png", "rb")
files = {"content": file_obj}
r = requests.post(url, files=files, data={}, verify=False)
self.assertEqual(r.status_code, 201)
def test_parse_conditions(self, core_client, dummy_host):
node_with_conditions = {
"items": [
{
"status": {
"conditions": [
{
"type": "Ready",
"status": "False",
"reason": None,
"message": None,
"lastTransitionTime": "2021-10-08T07:39:10Z",
},
],
},
},
],
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/api/v1/pods",
body=json.dumps(node_with_conditions),
headers={"content-type": "application/json"},
)
with Mocketizer():
pod = list(core_client.list_pod_for_all_namespaces().items)[0]
condition = pod_conditions(pod.status.conditions)[0]
assert condition.detail is None
assert condition.status is False
assert condition.detail is None
assert condition.type == api.ConditionType.READY
def test_parse_status_failed_creation(self, apps_client, dummy_host):
daemon_sets_data = {
"items": [{
"status": {
"currentNumberScheduled": 1,
"numberMisscheduled": 0,
"desiredNumberScheduled": 2,
"numberReady": 0,
"observedGeneration": 1,
"updatedNumberScheduled": 1,
"numberUnavailable": 1,
}
}]
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/apis/apps/v1/daemonsets",
body=json.dumps(daemon_sets_data),
headers={"content-type": "application/json"},
)
with Mocketizer():
daemon_set = list(
apps_client.list_daemon_set_for_all_namespaces().items)[0]
status = parse_daemonset_status(daemon_set.status)
assert status.number_misscheduled == 0
assert status.number_ready == 0
assert status.desired_number_scheduled == 2
assert status.updated_number_scheduled == 1
def test_multipart(self):
url = "http://httpbin.org/post"
data = '--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="content"\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: 68\r\n\r\nAction: comment\nText: Comment with attach\nAttachment: x1.txt, x2.txt\r\n--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="attachment_2"; filename="x.txt"\r\nContent-Type: text/plain\r\nContent-Length: 4\r\n\r\nbye\n\r\n--xXXxXXyYYzzz\r\nContent-Disposition: form-data; name="attachment_1"; filename="x.txt"\r\nContent-Type: text/plain\r\nContent-Length: 4\r\n\r\nbye\n\r\n--xXXxXXyYYzzz--\r\n'
headers = {
"Content-Length": "495",
"Content-Type": "multipart/form-data; boundary=xXXxXXyYYzzz",
"Accept": "text/plain",
"User-Agent": "Mocket",
"Accept-encoding": "identity",
}
Entry.register(Entry.POST, url)
response = requests.post(url, data=data, headers=headers)
self.assertEqual(response.status_code, 200)
last_request = Mocket.last_request()
self.assertEqual(last_request.method, "POST")
self.assertEqual(last_request.path, "/post")
self.assertEqual(last_request.body, data)
sent_headers = dict(last_request.headers)
self.assertEqualHeaders(
sent_headers,
{
"accept": "text/plain",
"accept-encoding": "identity",
"content-length": "495",
"content-type": "multipart/form-data; boundary=xXXxXXyYYzzz",
"host": "httpbin.org",
"user-agent": "Mocket",
"connection": "keep-alive",
},
)
self.assertEqual(len(Mocket._requests), 1)
def test_parse_node_info(self, dummy_host, core_client):
node_list_with_info = {
"items": [{
"status": {
"nodeInfo": {
"machineID": "abd0bd9c2f234af099e849787da63620",
"systemUUID": "e2902c84-10c9-4d81-b52b-85a27d62b7ca",
"bootID": "04bae495-8ea7-4230-9bf0-9ce841201c0c",
"kernelVersion": "5.4.0-88-generic",
"osImage": "Ubuntu 20.04.3 LTS",
"containerRuntimeVersion": "docker://20.10.7",
"kubeletVersion": "v1.21.7",
"kubeProxyVersion": "v1.21.7",
"operatingSystem": "linux",
"architecture": "amd64",
},
},
}]
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/api/v1/nodes",
body=json.dumps(node_list_with_info),
headers={"content-type": "application/json"},
)
with Mocketizer():
node = list(core_client.list_node().items)[0]
parsed_node_info = node_info(node)
assert isinstance(parsed_node_info, api.NodeInfo)
assert parsed_node_info.kernel_version == "5.4.0-88-generic"
assert parsed_node_info.os_image == "Ubuntu 20.04.3 LTS"
def test_parse_metadata_missing_annotations_and_labels(
self, apps_client, dummy_host):
daemon_sets_metadata = {
"items": [{
"metadata": {
"name": "node-collector-container-metrics",
"namespace": "checkmk-monitoring",
"uid": "6f07cb60-26c7-41ce-afe0-48c97d15a07b",
"resourceVersion": "2967286",
"generation": 1,
"creationTimestamp": "2022-02-16T10:03:21Z",
}
}]
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/apis/apps/v1/daemonsets",
body=json.dumps(daemon_sets_metadata),
headers={"content-type": "application/json"},
)
with Mocketizer():
daemon_set = list(
apps_client.list_daemon_set_for_all_namespaces().items)[0]
metadata = parse_metadata(daemon_set.metadata)
assert metadata.labels == {}
assert metadata.annotations == {}
def test_parse_status_successful_creation(self, apps_client, dummy_host):
statefulsets_data = {
"items": [{
"status": {
"observedGeneration": 1,
"replicas": 3,
"readyReplicas": 3,
"currentReplicas": 3,
"updatedReplicas": 3,
"currentRevision": "web-578cfc4b46",
"updateRevision": "web-578cfc4b46",
"collisionCount": 0,
"availableReplicas": 3,
}
}]
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/apis/apps/v1/statefulsets",
body=json.dumps(statefulsets_data),
headers={"content-type": "application/json"},
)
with Mocketizer():
statefulset = list(
apps_client.list_stateful_set_for_all_namespaces().items)[0]
status = parse_statefulset_status(statefulset.status)
assert status.ready_replicas == 3
assert status.updated_replicas == 3
def test_user_get_userid(self):
# Handler for `user2 = User.get(...)`
Entry.single_register(
Entry.POST,
self.lastuser.endpoint_url(current_app.lastuser_config['getuser_userid_endpoint']),
body=json.dumps({
"status": "ok",
"type": "user",
"buid": "1234567890123456789012",
"userid": "1234567890123456789012",
"name": "user1",
"title": "User 1",
"label": "User 1 (@user1)",
"oldids": ['0987654321098765432109'],
"timezone": "Asia/Kolkata",
}),
headers={'content-type': 'application/json'}
)
user1 = User.get(userid=u"1234567890123456789012")
user2 = User.get(userid=u"0987654321098765432109")
user3 = User.get(userid=u"1234567890987654321234")
self.assertEqual(user1, self.user1)
self.assertEqual(user2, self.user1) # Merged, so returns .merged_user()
self.assertEqual(user3, self.user3)
def test_parse_metadata_missing_annotations_and_labels(
self, apps_client, dummy_host):
statefulsets_metadata = {
"items": [{
"metadata": {
"name": "web",
"namespace": "default",
"uid": "29be93ae-eba8-4b2b-8eb9-2e76378b4e87",
"resourceVersion": "54122",
"generation": 1,
"creationTimestamp": "2022-03-09T07:44:17Z",
},
}]
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/apis/apps/v1/statefulsets",
body=json.dumps(statefulsets_metadata),
headers={"content-type": "application/json"},
)
with Mocketizer():
statefulset = list(
apps_client.list_stateful_set_for_all_namespaces().items)[0]
metadata = parse_metadata(statefulset.metadata)
assert metadata.labels == {}
assert metadata.annotations == {}
def apply_safety_net(fake_getaddrinfo):
fake_getaddrinfo.append(
(
socket.AF_INET6,
socket.SOCK_STREAM,
socket.IPPROTO_TCP,
"",
("2606:2800:220:1:248:1893:25c8:1946", 80),
)
)
# Set up a fake entry to return some data for all of the IP's so mocket
# doesn't try to connect if it can't find an entry.
mocket_entry = Entry(
"http://example.com/info.json",
Entry.GET,
Entry.response_cls(
body=json.dumps({"ip": "2606:2800:220:1:248:1893:25c8:1946"}),
status=200,
headers=None,
),
)
mocket_entry.location = ("2606:2800:220:1:248:1893:25c8:1946", 80)
Mocket.register(mocket_entry)
def test_sendall_json(self):
with mock.patch("time.gmtime") as tt:
tt.return_value = time.struct_time((2013, 4, 30, 10, 39, 21, 1, 120, 0))
Entry.single_register(
Entry.GET,
"http://testme.org/get?a=1&b=2#test",
body='{"a": "€"}',
headers={"content-type": "application/json"},
)
response = urlopen("http://testme.org/get?b=2&a=1#test", timeout=10)
self.assertEqual(response.code, 200)
self.assertEqual(response.read(), b'{"a": "\xe2\x82\xac"}')
self.assertEqualHeaders(
dict(response.headers),
{
"status": "200",
"content-length": "12",
"server": "Python/Mocket",
"connection": "close",
"date": "Tue, 30 Apr 2013 10:39:21 GMT",
"content-type": "application/json",
},
)
self.assertEqual(len(Mocket._requests), 1)
def test_parse_metadata_missing_annotations_and_labels(
self, apps_client, dummy_host):
mocked_deployments = {
"items": [
{
"metadata": {
"name": "cluster-collector",
"namespace": "checkmk-monitoring",
"uid": "debc9fe4-9e45-4688-ad04-a95604fa1f30",
"resourceVersion": "207264",
"generation": 2,
"creationTimestamp": "2022-03-25T13:24:42Z",
},
},
]
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/apis/apps/v1/deployments",
body=json.dumps(mocked_deployments),
headers={"content-type": "application/json"},
)
with Mocketizer():
deployment = list(
apps_client.list_deployment_for_all_namespaces().items)[0]
metadata = parse_metadata(deployment.metadata)
assert metadata.name == "cluster-collector"
assert metadata.namespace == "checkmk-monitoring"
assert isinstance(metadata.creation_timestamp, float)
assert metadata.labels == {}
assert metadata.annotations == {}
def test_http_session(self):
url = "http://httpbin.org/ip"
body = "asd" * 100
Entry.single_register(Entry.GET, url, body=body, status=404)
Entry.single_register(Entry.POST, url, body=body * 2, status=201)
async def main(_loop):
async with aiohttp.ClientSession(loop=_loop) as session:
with async_timeout.timeout(3):
async with session.get(url) as get_response:
assert get_response.status == 404
assert await get_response.text() == body
with async_timeout.timeout(3):
async with session.post(url,
data=body * 6) as post_response:
assert post_response.status == 201
assert await post_response.text() == body * 2
assert Mocket.last_request().method == "POST"
assert Mocket.last_request().body == body * 6
loop = asyncio.get_event_loop()
loop.set_debug(True)
loop.run_until_complete(main(loop))
self.assertEqual(len(Mocket.request_list()), 2)
def test_parse_cron_job_spec(self, dummy_host, batch_client):
cron_job_list_with_info = {
"items": [
{
"spec": {
"schedule": "*/5 * * * *",
"concurrencyPolicy": "Allow",
"jobTemplate": {
"metadata": {},
"spec": {
"template": {
"metadata": {},
"spec": {
"containers": []
},
},
},
},
},
},
],
}
Entry.single_register(
Entry.GET,
f"{dummy_host}/apis/batch/v1/cronjobs",
body=json.dumps(cron_job_list_with_info),
headers={"content-type": "application/json"},
)
with Mocketizer():
cron_job = list(
batch_client.list_cron_job_for_all_namespaces().items)[0]
spec = parse_cron_job_spec(cron_job.spec)
assert isinstance(spec.concurrency_policy, api.ConcurrencyPolicy)
assert spec.schedule is not None
assert spec.schedule == "*/5 * * * *"
def test_sockets(self):
"""
https://github.com/mindflayer/python-mocket/issues/111
https://gist.github.com/amotl/015ef6b336db55128798d7f1a9a67dea
"""
# Define HTTP conversation.
url = "http://127.0.0.1:8080/api/data"
Entry.single_register(Entry.POST, url)
# Define HTTP url segments and data.
host = "127.0.0.1"
port = 8080
method = "POST"
path = "/api/data"
data = json.dumps({"hello": "world"})
# Invoke HTTP request.
address = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0]
sock = socket.socket(address[0], address[1], address[2])
sock.connect(address[-1])
sock.write("%s %s HTTP/1.0\r\n" % (method, path))
sock.write("Host: %s\r\n" % host)
sock.write("Content-Type: application/json\r\n")
sock.write("Content-Length: %d\r\n" % len(data))
sock.write("Connection: close\r\n\r\n")
sock.write(data)
sock.close()
# Proof that worked.
self.assertEqual(Mocket.last_request().body, '{"hello": "world"}')
def test_register(self):
with mock.patch('time.gmtime') as tt:
tt.return_value = time.struct_time(
(2013, 4, 30, 10, 39, 21, 1, 120, 0))
Entry.register(
Entry.GET, 'http://testme.org/get?a=1&b=2#test',
Response('{"a": "€"}',
headers={'content-type': 'application/json'}))
entries = Mocket._entries[('testme.org', 80)]
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.method, 'GET')
self.assertEqual(entry.schema, 'http')
self.assertEqual(entry.path, '/get')
self.assertEqual(entry.query, 'a=1&b=2')
self.assertEqual(len(entry.responses), 1)
response = entry.responses[0]
self.assertEqual(response.body, b'{"a": "\xe2\x82\xac"}')
self.assertEqual(response.status, 200)
self.assertEqual(
response.headers, {
u'Status': u'200',
u'Date': u'Tue, 30 Apr 2013 10:39:21 GMT',
u'Connection': u'close',
u'Server': u'Python/Mocket',
u'Content-Length': u'12',
u'Content-Type': u'application/json',
})
def test_register(self):
with mock.patch("time.gmtime") as tt:
tt.return_value = time.struct_time((2013, 4, 30, 10, 39, 21, 1, 120, 0))
Entry.register(
Entry.GET,
"http://testme.org/get?a=1&b=2#test",
Response('{"a": "€"}', headers={"content-type": "application/json"}),
)
entries = Mocket._entries[("testme.org", 80)]
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.method, "GET")
self.assertEqual(entry.schema, "http")
self.assertEqual(entry.path, "/get")
self.assertEqual(entry.query, "a=1&b=2")
self.assertEqual(len(entry.responses), 1)
response = entry.responses[0]
self.assertEqual(response.body, b'{"a": "\xe2\x82\xac"}')
self.assertEqual(response.status, 200)
self.assertEqual(
response.headers,
{
"Status": "200",
"Date": "Tue, 30 Apr 2013 10:39:21 GMT",
"Connection": "close",
"Server": "Python/Mocket",
"Content-Length": "12",
"Content-Type": "application/json",
},
)
def test_fail_because_entry_not_served(self):
url = "http://github.com/fluidicon.png"
Entry.single_register(Entry.GET, url)
Entry.single_register(Entry.GET, "http://github.com/fluidicon.jpg")
requests.get(url)
with self.assertRaises(AssertionError):
Mocket.assert_fail_if_entries_not_served()
def test_sendall_double(self):
Entry.register(Entry.GET, 'http://testme.org/', Response(status=404), Response())
self.assertRaises(HTTPError, urlopen, 'http://testme.org/')
response = urlopen('http://testme.org/')
self.assertEqual(response.code, 200)
response = urlopen('http://testme.org/')
self.assertEqual(response.code, 200)
self.assertEqual(len(Mocket._requests), 3)
def test_suggestion_for_register_and_body(self):
url = "http://foobar.com/path"
with self.assertRaises(AttributeError):
Entry.register(
Entry.POST,
url,
body='{"foo":"bar0"}',
)
def test_suggestion_for_register_and_status(self):
url = "http://foobar.com/path"
with self.assertRaises(AttributeError):
Entry.register(
Entry.POST,
url,
status=201,
)
def test_raw_api_get_healthz_ok(raw_api):
Entry.single_register(Entry.GET, "http://api-unittest/some_health_endpoint", body="response-ok")
with Mocketizer():
result = raw_api._get_healthz("/some_health_endpoint")
assert result.status_code == 200
assert result.response == "response-ok"
assert result.verbose_response is None
def test_does_not_fail_because_all_entries_are_served(self):
url = "http://github.com/fluidicon.png"
second_url = "http://github.com/fluidicon.jpg"
Entry.single_register(Entry.GET, url)
Entry.single_register(Entry.GET, second_url)
requests.get(url)
requests.get(second_url)
Mocket.assert_fail_if_entries_not_served()
def test_200(self):
Entry.single_register(Entry.GET,
RATES_API_URL,
body='mocked_body',
status=200)
response = urlopen(RATES_API_URL)
body = response.read()
self.assertEqual(body, b'mocked_body')
def test_random_url_with_redis(redis_client: Redis):
url = "http://www.example.com"
Entry.single_register(Entry.GET, url)
redis_client.set("key", "value")
requests.get(url)
assert Mocket.has_requests()
def test_sendall_double(self):
Entry.register(Entry.GET, 'http://testme.org/', Response(status=404),
Response())
self.assertRaises(HTTPError, urlopen, 'http://testme.org/')
response = urlopen('http://testme.org/')
self.assertEqual(response.code, 200)
response = urlopen('http://testme.org/')
self.assertEqual(response.code, 200)
self.assertEqual(len(Mocket._requests), 3)
def test_request_bodies(self):
url = "http://bit.ly/fakeurl/{0}"
for e in range(5):
u = url.format(e)
Entry.single_register(Entry.POST, u, body=str(e))
request_body = urlencode({"key-{0}".format(e): "value={0}".format(e)})
urlopen(u, request_body.encode("utf-8"))
last_request = Mocket.last_request()
assert last_request.body == request_body
def test_request_bodies(self):
url = 'http://bit.ly/fakeurl/{0}'
for e in range(5):
u = url.format(e)
Entry.single_register(Entry.POST, u, body=str(e))
request_body = urlencode({'key-{0}'.format(e): 'value={0}'.format(e)})
urlopen(u, request_body.encode('utf-8'))
last_request = Mocket.last_request()
assert last_request.body == request_body
def test_file_object(self):
url = 'http://github.com/fluidicon.png'
filename = 'tests/fluidicon.png'
file_obj = open(filename, 'rb')
Entry.single_register(Entry.GET, url, body=file_obj)
r = requests.get(url)
remote_content = r.content
local_file_obj = open(filename, 'rb')
local_content = local_file_obj.read()
self.assertEqual(remote_content, local_content)
self.assertEqual(len(remote_content), len(local_content))
self.assertEqual(int(r.headers['Content-Length']), len(local_content))
self.assertEqual(r.headers['Content-Type'], 'image/png')
def test_json(response):
url_to_mock = 'https://testme.org/json'
Entry.single_register(
Entry.GET,
url_to_mock,
body=json.dumps(response),
headers={'content-type': 'application/json'})
mocked_response = requests.get(url_to_mock).json()
assert response == mocked_response
mocked_response = json.loads(urlopen(url_to_mock).read().decode('utf-8'))
assert response == mocked_response
def test_file_object_with_no_lib_magic(self):
url = 'http://github.com/fluidicon.png'
filename = 'tests/fluidicon.png'
file_obj = open(filename, 'rb')
Entry.register(Entry.GET, url, Response(body=file_obj, lib_magic=None))
r = requests.get(url)
remote_content = r.content
local_file_obj = open(filename, 'rb')
local_content = local_file_obj.read()
self.assertEqual(remote_content, local_content)
self.assertEqual(len(remote_content), len(local_content))
self.assertEqual(int(r.headers['Content-Length']), len(local_content))
with self.assertRaises(KeyError):
self.assertEqual(r.headers['Content-Type'], 'image/png')
def test_sendall(self):
with mock.patch('time.gmtime') as tt:
tt.return_value = time.struct_time((2013, 4, 30, 10, 39, 21, 1, 120, 0))
Entry.single_register(Entry.GET, 'http://testme.org/get/p/?a=1&b=2', body='test_body')
resp = urlopen('http://testme.org/get/p/?b=2&a=1', timeout=10)
self.assertEqual(resp.code, 200)
self.assertEqual(resp.read(), b'test_body')
self.assertEqualHeaders(dict(resp.headers), {
'Status': '200',
'Content-length': '9',
'Server': 'Python/Mocket',
'Connection': 'close',
'Date': 'Tue, 30 Apr 2013 10:39:21 GMT',
'Content-type': 'text/plain; charset=utf-8'
})
self.assertEqual(len(Mocket._requests), 1)
def test_same_url_different_methods(self):
url = 'http://bit.ly/fakeurl'
response_to_mock = {
'content': 0,
'method': None,
}
responses = []
methods = [Entry.PUT, Entry.GET, Entry.POST]
for m in methods:
response_to_mock['method'] = m
Entry.single_register(m, url, body=json.dumps(response_to_mock))
response_to_mock['content'] += 1
for m in methods:
responses.append(requests.request(m, url).json())
methods_from_responses = [r['method'] for r in responses]
contents_from_responses = [r['content'] for r in responses]
self.assertEquals(methods, methods_from_responses)
self.assertEquals(list(range(len(methods))), contents_from_responses)
def test_sendall_json(self):
with mock.patch('time.gmtime') as tt:
tt.return_value = time.struct_time((2013, 4, 30, 10, 39, 21, 1, 120, 0))
Entry.single_register(
Entry.GET,
'http://testme.org/get?a=1&b=2#test',
body='{"a": "€"}',
headers={'content-type': 'application/json'}
)
response = urlopen('http://testme.org/get?b=2&a=1#test', timeout=10)
self.assertEqual(response.code, 200)
self.assertEqual(response.read(), b'{"a": "\xe2\x82\xac"}')
self.assertEqualHeaders(dict(response.headers), {
'status': '200',
'content-length': '12',
'server': 'Python/Mocket',
'connection': 'close',
'date': 'Tue, 30 Apr 2013 10:39:21 GMT',
'content-type': 'application/json',
})
self.assertEqual(len(Mocket._requests), 1)
def test_wrongpath_truesendall(self):
Entry.register(Entry.GET, 'http://httpbin.org/user.agent', Response())
response = urlopen('http://httpbin.org/ip')
self.assertEqual(response.code, 200)
