def callback(url, **kwargs):
if kwargs['json']['file'] == '/dimensigon/logs/log1':
self.assertDictEqual(
{"file": '/dimensigon/logs/log1', 'data': base64.b64encode('content1'.encode()).decode('ascii')},
kwargs['json'])
return CallbackResult('POST', payload={'offset': 8}, status=200)
elif kwargs['json']['file'] == '/dimensigon/logs/dir1/log2':
self.assertDictEqual(
{"file": '/dimensigon/logs/dir1/log2',
'data': base64.b64encode('newcontent2'.encode()).decode('ascii')},
kwargs['json'])
return CallbackResult('POST', payload={'offset': 11}, status=200)
else:
raise
def request_callback(url, **kwargs):
# burn some time for sla to fail
time.sleep(0.5)
headers = {'content-type': 'application/json'}
return CallbackResult(status=200,
body=WORLD_CLOCK_RESPONSE_STRING,
headers=headers)
def check_pr_post(url: str, **kwargs: Any) -> CallbackResult:
changes = [
"Update frozen Python dependencies",
"Update ambv/black pre-commit hook from 19.10b0 to 20.0.0",
]
body = "- " + "\n- ".join(changes) + "\n"
assert json.loads(kwargs["data"]) == {
"title": CommitMessage.title,
"body": body,
"head": "u/neophile",
"base": "main",
"maintainer_can_modify": True,
"draft": False,
}
repo = Repo(str(tmp_path / "work" / "bar"))
assert repo.head.ref.name == "u/neophile"
yaml = YAML()
data = yaml.load(tmp_path / "work" / "bar" / ".pre-commit-config.yaml")
assert data["repos"][2]["rev"] == "20.0.0"
commit = repo.head.commit
assert commit.author.name == "Someone"
assert commit.author.email == "*****@*****.**"
assert commit.message == f"{CommitMessage.title}\n\n{body}"
nonlocal created_pr
created_pr = True
return CallbackResult(status=201)
def callback(request, **kwargs):
if isinstance(request, PreparedRequest):
self.assertDictEqual(data, json.loads(request.body))
return status, {}, json.dumps(msg)
else:
self.assertDictEqual(kwargs['json'], data)
return CallbackResult(status=status, payload=msg)
async def handler(url, **kwargs):
await event.wait()
return CallbackResult(
status=200,
content_type='application/octet-stream',
body=
b'<html><head><title>foo</title></head><body></body></html>')
async def handler(url, **kwargs):
await event.wait()
return CallbackResult(
status=200,
content_type='text/html',
body=
b'<html><head><title>foo</title></head><body></body></html>')
async def test_client_response_error_when_read(mock_aioresponse,
download_order):
"""Tests ClientResponseError when read."""
class MockClientResponse(ClientResponse):
async def read(self):
raise ClientResponseError(
RequestInfo("", "", CIMultiDictProxy(CIMultiDict()), ""),
())
mock_aioresponse.get(
InstanceResource.URL_TWITTER_IMAGE,
status=200,
callback=lambda url, **kwargs: CallbackResult(
response_class=MockClientResponse) # noqa
# Reason: AioResponse's bug.
)
with pytest.raises(HttpTimeoutError) as error:
semaphore = asyncio.Semaphore(5)
async with aiohttp.ClientSession() as client_session:
await MediaDownloadCoroutine(MediaSaveCoroutine()
).execute(semaphore,
client_session,
download_order)
assert str(error.value) == (
"HttpTimeoutError. URL = "
"https://pbs.twimg.com/media/CeBmNUIUUAAZoQ3?format=jpg&name=medium"
)
def async_callback(url, **kwargs):
mock_rsp = mock_get_request(str(url), **kwargs)
return CallbackResult(
status=mock_rsp.status_code,
payload=mock_rsp.content,
headers=mock_rsp.headers,
reason="irrelevant",
)
def callback_prevent(url, **kwargs):
assert kwargs['json'] == {
'scope': 'CATALOG',
'datemark': self.datemark,
'applicant': [Server.get_current().id, self.n1.id, self.n2.id]
}
return CallbackResult("{'message': 'Preventing lock acquired'}",
status=200)
def callback_lock(url, **kwargs):
self.assertDictEqual(
kwargs['json'], {
'scope': 'ORCHESTRATION',
'applicant': [str(self.n1.id),
str(self.n2.id)]
})
return CallbackResult("{'message': 'Locked'}", status=200)
def patch_callback4(_: URL, **kwargs: Any) -> CallbackResult:
json = kwargs["json"]
assert json.get("sleepModeEnable")
assert robot.sleep_mode_start_time
assert json.get("sleepModeTime") in (
robot.sleep_mode_start_time.timestamp(),
(robot.sleep_mode_start_time + timedelta(hours=24)).timestamp(),
)
return CallbackResult(payload={**robot._data, **json})
def _callback(url, json, **kwargs):
assert json == {
"externalId": 1,
"name": "name1",
"actualTemp": 30,
"targetTemp": None,
"valuePosition": None,
"climateSystems": [1],
}
return CallbackResult(method="POST")
def check_pr_update(url: str, **kwargs: Any) -> CallbackResult:
change = "Update gafaelfawr Helm chart from 1.0.0 to 2.0.0"
assert json.loads(kwargs["data"]) == {
"title": CommitMessage.title,
"body": f"- {change}\n",
}
nonlocal updated_pr
updated_pr = True
return CallbackResult(status=200)
def callback_prevent(url, **kwargs):
self.assertDictEqual(
kwargs['json'], {
'scope': 'ORCHESTRATION',
'datemark': self.datamark,
'applicant': [str(self.n1.id),
str(self.n2.id)]
})
return CallbackResult("{'message': 'Preventing lock acquired'}",
status=200)
def callback_lock(url, **kwargs):
assert kwargs['json'] == {
'scope':
'CATALOG',
'applicant': [
str(Server.get_current().id),
str(self.n1.id),
str(self.n2.id)
]
}
return CallbackResult("{'message': 'Locked'}", status=200)
def post_callback_client(url, **kwargs):
kwargs.pop('allow_redirects')
r = self.client2.post(url.path,
json=kwargs['json'],
headers=kwargs['headers'])
return CallbackResult('POST',
status=r.status_code,
body=r.data,
content_type=r.content_type,
headers=r.headers)
async def test_fetch():
session = aiohttp.ClientSession()
with aioresponses() as m:
m.get(
URL,
callback=lambda *args, **kwargs: CallbackResult(
status=200, body="Amsterdam: -1"
),
)
response = await fetch(URL, session)
assert response == "Amsterdam: -1"
def check_pr_post(url: str, **kwargs: Any) -> CallbackResult:
assert json.loads(kwargs["data"]) == {
"title": CommitMessage.title,
"body": "- Update gafaelfawr Helm chart from 1.3.1 to v1.4.0\n",
"head": "u/neophile",
"base": "main",
"maintainer_can_modify": True,
"draft": False,
}
nonlocal created_pr
created_pr = True
return CallbackResult(status=201)
def callback_prevent(url, **kwargs):
self.assertDictEqual(
kwargs['json'], {
'scope':
'CATALOG',
'applicant': [
str(Server.get_current().id),
str(self.n1.id),
str(self.n2.id)
]
})
return CallbackResult("{'message': 'Preventing lock acquired'}",
status=200)
def callback_client(url, **kwargs):
kwargs.pop('allow_redirects')
# workarround for https://github.com/pnuckowski/aioresponses/issues/111
headers = {
'Authorization':
f"Bearer {create_access_token('00000000-0000-0000-0000-000000000001')}"
}
r = self.client.post(url.path,
json=kwargs['json'],
headers=headers)
return CallbackResult(r.data, status=r.status_code)
def handler(url: str, **kwargs: Any) -> CallbackResult:
nonlocal probe
user_url = f"https://data.example.com/moneypenny/users/{username}"
if str(url) == "https://data.example.com/moneypenny/users":
assert kwargs["json"] == {
"username": username,
"uid": uid,
"groups": groups,
}
return CallbackResult(status=303, headers={"Location": user_url})
elif str(url) == user_url:
result = {
"username": username,
"status": "commissioning" if probe == 0 else "active",
"uid": uid,
"groups": groups,
}
return CallbackResult(status=200, body=json.dumps(result))
elif str(url) == f"{user_url}/wait":
probe += 1
return CallbackResult(status=303, headers={"Location": user_url})
else:
assert False, f"unknown URL {str(url)}"
def callback_unlock(url, **kwargs):
self.assertDictEqual(
kwargs['json'], {
'scope':
'CATALOG',
'action':
'UNLOCK',
'applicant': [
str(Server.get_current().id),
str(self.n1.id),
str(self.n2.id)
]
})
return CallbackResult("{'message': 'UnLocked'}", status=200)
def handler(url: str, **kwargs: Any) -> CallbackResult:
assert kwargs["headers"] == {"Authorization": f"bearer {admin_token}"}
assert kwargs["json"] == {
"username": "******",
"token_type": "user",
"token_name": ANY,
"scopes": ["exec:notebook"],
"expires": ANY,
"uid": 1234,
}
assert kwargs["json"]["token_name"].startswith("mobu ")
assert kwargs["json"]["expires"] > time.time()
response = {"token": make_gafaelfawr_token()}
return CallbackResult(payload=response, status=200)
def _validate_request(self, url, **kwargs):
self.assertEqual(self.url, str(url))
req_headers = kwargs['headers']
self.assertEqual(req_headers.get('Tus-Resumable'), '1.0.0')
body = kwargs['data']
with open('./LICENSE', 'rb') as stream:
expected_content = stream.read()
self.assertEqual(expected_content, body)
response_headers = {
'upload-offset':
str(self.async_uploader.offset +
self.async_uploader.get_request_length())
}
return CallbackResult(status=204, headers=response_headers)
def callback(request, **kwargs):
if isinstance(request, PreparedRequest):
self.assertEqual(str(self.server.id),
request.headers.get('D-Destination'))
self.assertEqual(str(self.server.id),
request.headers.get('D-Source'))
self.assertEqual("True", request.headers.get('D-Securizer'))
self.assertEqual(f"Bearer {self.token}",
request.headers.get('Authorization'))
return status, {}, json.dumps(msg)
else:
self.assertEqual(str(self.server.id),
kwargs['headers'].get('D-Destination'))
self.assertEqual(str(self.server.id),
kwargs['headers'].get('D-Source'))
self.assertEqual("True", kwargs['headers'].get('D-Securizer'))
self.assertEqual(f"Bearer {self.token}",
kwargs['headers'].get('Authorization'))
return CallbackResult(status=status, payload=msg)
def check_pr_post(url: str, **kwargs: Any) -> CallbackResult:
change = "Update gafaelfawr Helm chart from 1.3.1 to 1.4.0"
assert json.loads(kwargs["data"]) == {
"title": CommitMessage.title,
"body": f"- {change}\n",
"head": "u/neophile",
"base": "master",
"maintainer_can_modify": True,
"draft": False,
}
assert repo.head.ref.name == "u/neophile"
yaml = YAML()
data = yaml.load(dst)
assert data["dependencies"][0]["version"] == "1.4.0"
commit = repo.head.commit
assert commit.author.name == "Someone"
assert commit.author.email == "*****@*****.**"
assert commit.message == f"{CommitMessage.title}\n\n- {change}\n"
nonlocal created_pr
created_pr = True
return CallbackResult(status=201)
def callback_unlock(url, **kwargs):
return CallbackResult("{'message': 'UnLocked'}", status=200)
def callback_prevent(url, **kwargs):
return CallbackResult("{'message': 'Preventing lock acquired'}",
status=200)
def plus_service_callback(url, **kwargs):
data = kwargs["json"]
return CallbackResult(
status=200, body=json.dumps({"result": data["left"] + data["right"]})
)
def handler(url: str, **kwargs: Any) -> CallbackResult:
assert kwargs["headers"] == {"Authorization": "bearer user-token"}
return CallbackResult(payload=data, status=200)
