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_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_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_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_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_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_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_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_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_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_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_random_url():
url = "http://www.example.com"
Entry.single_register(Entry.GET, url)
requests.get(url)
assert Mocket.has_requests()
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_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_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_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 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_version_endpoint_no_json(raw_api):
"""
Invalid endpoint, since returned data is not json. RawAPI will not
identify this issue. Instead, the issue needs to be handled seperately.
"""
Entry.single_register(Entry.GET, "http://api-unittest/version", body="I'm not json")
with Mocketizer():
result = raw_api.query_raw_version()
assert result == "I'm not json"
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_parse_conditions_no_status(self, core_client, dummy_host):
node_with_conditions = {"items": [{"status": {}}]} # type: ignore
Entry.single_register(
Entry.GET,
f"{dummy_host}/api/v1/nodes",
body=json.dumps(node_with_conditions),
headers={"content-type": "application/json"},
)
with Mocketizer():
node = list(core_client.list_node().items)[0]
assert node_conditions(node.status) is None
def test_mockhttp_entry_collect_duplicates(self):
Entry.single_register(
Entry.POST, "http://testme.org/", status=200, match_querystring=False
)
requests.post(
"http://testme.org/?foo=bar",
data="{'foo': 'bar'}",
headers={"content-type": "application/json"},
)
requests.post("http://testme.org/")
self.assertEqual(len(Mocket._requests), 2)
self.assertEqual(Mocket.last_request().path, "/")
async def test_connection_httpbin(api):
url_to_mock = 'http://httpbin.org/get'
Entry.single_register(Entry.GET,
url_to_mock,
body=json.dumps({"args": {}}),
headers={'content-type': 'application/json'})
with Mocketizer():
session = asks.Session()
resp = await session.get(url_to_mock, )
assert "args" in resp.json() and resp["args"] == {}
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_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(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_connection_success(api, data: int):
url_to_mock = api.get_url('Time', private=False)
Entry.single_register(Entry.POST,
url_to_mock,
body=json.dumps({'data': data}),
headers={'content-type': 'application/json'})
with Mocketizer():
resp = api.query_public('Time')
assert "args" in resp.json() and resp.json() == {'data': data}
# ensure mocket actually replied to that
assert len(Mocket._requests) == 1
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_version_endpoint(version_json: Mapping[str, str], _, raw_api):
# arrange
version_json_dump = json.dumps(version_json)
Entry.single_register(
Entry.GET,
"http://api-unittest/version",
body=version_json_dump,
headers={"content-type": "application/json"},
)
# act
with Mocketizer():
queried_version = raw_api.query_raw_version()
# assert
assert queried_version == version_json_dump
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)
