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)