def mocked_requests_200() -> typing.Generator[respx.MockTransport, None, None]:
"""Client for easy access to iov42 platform."""
with respx.mock(base_url=PLATFORM_URL,
assert_all_called=False) as respx_mock:
respx_mock.put(
re.compile("/api/v1/requests/(?P<req_id>[^ ].*)$"),
status_code=200,
alias="create_entity",
content=entity_created_response,
)
respx_mock.get(
re.compile(
"/api/v1/asset-types/(?P<asset_type_id>.*)/assets/(?P<asset_id>.*)"
"/claims/(?P<hashed_claim>.*)/endorsements/(?P<endorser_id>.*)"
"?requestId=(?P<request_id>.*)&nodeId=(?P<node_id>[^ ].*)$"),
status_code=200,
alias="read_asset_endorsement",
content=endorsement_response,
)
respx_mock.get(
"/api/v1/node-info",
status_code=200,
alias="read_node_info",
content=
'{"nodeId":"node-1","publicCredentials":{"key":"value","protocolId":"SHA256WithRSA"}}',
)
yield respx_mock
def test_remote_pass_through(using, client_lib, call_count): # pragma: nocover
with respx.mock(using=using) as respx_mock:
# Mock pass-through calls
url = "https://httpbin.org/post"
route = respx_mock.post(url, json__foo="bar").pass_through()
# Make external pass-through call
client = __import__(client_lib)
response = client.post(url, json={"foo": "bar"})
# Assert response is correct library model
assert isinstance(response, client.Response)
assert response.status_code == 200
assert response.content is not None
assert len(response.content) > 0
assert "Content-Length" in response.headers
assert int(response.headers["Content-Length"]) > 0
assert response.json()["json"] == {"foo": "bar"}
assert respx_mock.calls.last.request.url == url
assert respx_mock.calls.last.response is None
assert route.call_count == call_count
assert respx_mock.calls.call_count == call_count
def test_sync_httpx_mocker():
class TestTransport(httpx.BaseTransport):
def handle_request(self, *args, **kwargs):
raise RuntimeError("would pass through")
client = httpx.Client(transport=TestTransport())
@respx.mock(using="httpx")
def test(respx_mock):
mock_route = respx_mock.get("https://example.org/") % 204
pass_route = respx_mock.get(host="pass-through").pass_through()
with client:
response = client.get("https://example.org/")
assert response.status_code == 204
assert mock_route.call_count == 1
with pytest.raises(RuntimeError, match="would pass through"):
client.get("https://pass-through/")
assert pass_route.call_count == 1
with pytest.raises(AllMockedAssertionError):
client.get("https://not-mocked/")
with respx.mock(using="httpx"): # extra registered router
test()
async def setUp(self):
self.ably = await RestSetup.get_ably_rest(use_binary_protocol=False)
# Mocked responses
# without specific headers
self.mocked_api = respx.mock(base_url='http://rest.ably.io')
self.ch1_route = self.mocked_api.get('/channels/channel_name/ch1')
self.ch1_route.return_value = Response(
headers={'content-type': 'application/json'},
status_code=200,
content='[{"id": 0}, {"id": 1}]',
)
# with headers
self.ch2_route = self.mocked_api.get('/channels/channel_name/ch2')
self.ch2_route.side_effect = self.get_response_callback(
headers={
'content-type': 'application/json',
'link':
'<http://rest.ably.io/channels/channel_name/ch2?page=1>; rel="first",'
' <http://rest.ably.io/channels/channel_name/ch2?page=2>; rel="next"'
},
body='[{"id": 0}, {"id": 1}]',
status=200
)
# start intercepting requests
self.mocked_api.start()
self.paginated_result = await PaginatedResult.paginated_query(
self.ably.http,
url='http://rest.ably.io/channels/channel_name/ch1',
response_processor=lambda response: response.to_native())
self.paginated_result_with_headers = await PaginatedResult.paginated_query(
self.ably.http,
url='http://rest.ably.io/channels/channel_name/ch2',
response_processor=lambda response: response.to_native())
async def test_configured_router_reuse(client):
router = respx.mock()
route = router.get("https://foo/bar/") % 404
assert len(router.routes) == 1
assert router.calls.call_count == 0
with router:
route.return_value = httpx.Response(202)
response = await client.get("https://foo/bar/")
assert route.called is True
assert response.status_code == 202
assert router.calls.call_count == 1
assert respx.calls.call_count == 0
assert len(router.routes) == 1
assert route.called is False
assert router.calls.call_count == 0
async with router:
assert router.calls.call_count == 0
response = await client.get("https://foo/bar/")
assert route.called is True
assert response.status_code == 404
assert router.calls.call_count == 1
assert respx.calls.call_count == 0
assert len(router.routes) == 1
assert route.called is False
assert router.calls.call_count == 0
assert respx.calls.call_count == 0
async def test_async_httpx_mocker():
class TestTransport(httpcore.AsyncHTTPTransport):
async def arequest(self, *args, **kwargs):
raise RuntimeError("would pass through")
client = httpx.AsyncClient(transport=TestTransport())
@respx.mock
@respx.mock(using="httpx")
async def test(respx_mock):
respx.get(host="foo.bar")
mock_route = respx_mock.get("https://example.org/") % 204
pass_route = respx_mock.get(host="pass-through").pass_through()
async with client:
response = await client.get("https://example.org/")
assert response.status_code == 204
assert mock_route.call_count == 1
with pytest.raises(RuntimeError, match="would pass through"):
await client.get("https://pass-through/")
assert pass_route.call_count == 1
with pytest.raises(AssertionError, match="not mocked"):
await client.get("https://not-mocked/")
async with respx.mock(using="httpx"): # extra registered router
await test()
async def test_nested_base_url(respx_mock):
request = respx_mock.patch("/egg/") % dict(content="yolk")
async with respx.mock(base_url="https://foo.bar/api/") as foobar_mock:
request1 = foobar_mock.get("/baz/") % dict(content="baz")
request2 = foobar_mock.post(path__regex=r"(?P<slug>\w+)/?$") % dict(
text="slug")
request3 = foobar_mock.route() % dict(content="ok")
request4 = foobar_mock.head("http://localhost/apa/") % 204
async with httpx.AsyncClient(base_url="https://foo.bar/api") as client:
response = await client.get("/baz/")
assert request1.called is True
assert response.text == "baz"
response = await client.post("/apa/")
assert request2.called is True
assert response.text == "slug"
response = await client.put("/")
assert request3.called is True
assert response.text == "ok"
response = await client.head("http://localhost/apa/")
assert request4.called is True
assert response.status_code == 204
response = await client.patch("https://ham.spam/egg/")
assert request.called is True
assert response.text == "yolk"
def mocked_pagination() -> respx.MockTransport:
base_url = "https://ssapi.shipstation.com"
with respx.mock(base_url=base_url, assert_all_called=False) as respx_mock:
respx_mock.get(
"/products",
content=test_list_products_first,
)
respx_mock.get(
"/products?page=2",
content=test_list_products_second,
)
respx_mock.get(
"/products?page=3",
content=test_list_products_third,
)
respx_mock.get("/products",
content=list_products_none,
alias="list_products_none")
respx_mock.get(
"/products?pageSize=3",
content=test_list_products_first,
)
respx_mock.get(
"/products?pageSize=3&page=2",
content=test_list_products_second,
)
respx_mock.get(
"/products?pageSize=3&page=3",
content=test_list_products_third,
)
yield respx_mock
def mocked_order_creation() -> respx.MockTransport:
base_url = "https://ssapi.shipstation.com"
with respx.mock(base_url=base_url, assert_all_called=False) as respx_mock:
respx_mock.post(
"/orders/createorder", content=order_creation, alias="test_order_creation"
)
yield respx_mock
def mocked_director_service_fcts(
minimal_app: FastAPI,
fake_service_details: ServiceDockerData,
fake_service_extras: ServiceExtras,
fake_running_service_details: RunningServiceDetails,
):
with respx.mock(
base_url=minimal_app.state.settings.director_v0.base_url(
include_tag=False),
assert_all_called=False,
assert_all_mocked=True,
) as respx_mock:
respx_mock.get(
"/v0/services/simcore%2Fservices%2Fdynamic%2Fmyservice/1.3.4",
content={"data": [fake_service_details.dict(by_alias=True)]},
alias="get_service_version",
)
respx_mock.get(
"/v0/service_extras/simcore%2Fservices%2Fdynamic%2Fmyservice/1.3.4",
content={"data": fake_service_extras.dict(by_alias=True)},
alias="get_service_extras",
)
pattern = re.compile(
r"v0/running_interactive_services/[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}$"
)
respx_mock.get(
pattern,
content={"data": fake_running_service_details.dict(by_alias=True)},
alias="get_running_service_details",
)
yield respx_mock
def request_mock():
mock = respx.mock(assert_all_mocked=False, assert_all_called=False)
get_apis = [
'http://localhost:3567' + API_VERSION,
'http://localhost:3567' + SESSION_DATA
]
post_apis = [
'http://localhost:3567' + SESSION, 'http://localhost:3567' + HANDSHAKE,
'http://localhost:3567' + SESSION_REMOVE
]
def mock_get(request: httpx.Request, response):
url = str(request.url).split('?')[0]
if url not in get_apis or request.method != 'GET':
return None
res = get(url=request.url, headers=request.headers)
response.content = json.loads(res.content.decode('utf-8'))
response.status_code = res.status_code
return response
def mock_post(request: httpx.Request, response):
url = str(request.url).split('?')[0]
if url not in post_apis or request.method != 'POST':
return None
data = json.loads(request.read().decode())
res = post(url=request.url, json=data, headers=request.headers)
response.content = json.loads(res.content.decode('utf-8'))
response.status_code = res.status_code
return response
mock.add(mock_get)
mock.add(mock_post)
return mock
def test_raise_identity_already_exists_2(client: Client) -> None:
"""Raise exception when an identity (with an other key) already exists."""
client.identity = PrivateIdentity(
CryptoProtocol.SHA256WithECDSA.generate_private_key(), "test-1234")
with respx.mock(base_url=PLATFORM_URL) as respx_mock:
respx_mock.put(
re.compile("/api/v1/requests/.*$"),
status_code=400,
content=
('{"errors":[{"errorCode":2503,"errorType":"Authorisation",'
'"message":"Signature L-IjTeba3wvJn4hHR40GPCG-H7iIeDWOzBo3hCK7x1mLZgif'
"SdgR-YVxOZtvPzHaI86WdhIL3y-sNOwYUf2c0j7OfT31dAX71W9le-Cp2Mx1PgjjqI09f"
"i0Nku-h5lgipQ07VKAm3gUx0foeG9GdDQe_I85QuCqtJsaAXWDVc8r0NeWpa3dnQEflIm"
"W0-gecjO6pYDeyXPALcvp9h8Q_TxkuGVvreqpWvgKzdPMlXHMbN3wYoLNNLM3gpqrqAp"
"Eze1aTqtlK6gCQUuhsJlKe4Bb2Nj8MRxXXXNpxIJqjJHM0IRps5J0U8gsnEEcny8Zf0tB"
'h7NGkTteNv554QUbNVA cannot be verified with public credentials of identity test-1234."},'
'{"errorCode":2503,"errorType":"Authorisation","message":"Signature '
"L2PIREIx1MZsjV-j0fSMoN3u1eHP2wyqUpAs1mOWdp8k8yrnoBTbyH2Uxw8_9zYTzDHrz"
"rI16fNKeRFuLlHosWqzoUf41M0Nip5zbW6gmPYiL05AWPdH1pg9qS-cgQa9IFXiMUkZh9"
"EZltT7HHl9aRn35kcwoJYAoPm96Up1YPI0JWISx1iXXEAcxVOA1N_k-l0tT5Tb7lWNOI4"
"5eh6flW_vVEeBQDjQhkl94rlP3qDFlDYZ9HZS2A3lTkiIo6MsU57pxeTD9FqwZ8uofJ3O"
"Yx05TJKl106GPsscf2mnpnQGEzgS20QsJyqUs_u7dpZbAcjfBsaHucVz8gwkz_PoNg "
'cannot be verified with public credentials of identity test-1234."},'
'{"errorCode":2602,"errorType":"AssetExistence",'
'"message":"Another identity with address test-1234 already exists"}],'
'"requestId":"23343439","proof":"/api/v1/proofs/23343439"}'),
)
with pytest.raises(EntityAlreadyExists) as excinfo:
client.put(client.identity.public_identity, request_id="1234567")
assert str(excinfo.value) == "identity 'test-1234' already exists"
assert excinfo.value.request_id == "1234567"
def mocked_account_manager_api():
with respx.mock(base_url="https://account.demandware.com") as respx_mock:
respx_mock.post(
"/dw/oauth2/access_token",
content=json.dumps(CLIENT_TOKEN),
alias="clienttokenrequest",
)
yield respx_mock
def respx_mock(request):
respx_marker = request.node.get_closest_marker("respx")
mock_router: MockRouter = (respx.mock if respx_marker is None else cast(
MockRouter, respx.mock(**respx_marker.kwargs)))
with mock_router:
yield mock_router
def mocked_api(self, overall_application_performance_throughput):
with respx.mock(base_url="http://localhost:8090",
assert_all_called=False) as respx_mock:
respx_mock.get(
re.compile(r"/controller/rest/.+"), name="query").mock(
httpx.Response(
200, json=overall_application_performance_throughput))
yield respx_mock
def test_local_decorator_with_reference():
router = respx.mock()
@router
def test(respx_mock):
assert respx_mock is router
test()
def mocked_instance_api():
with respx.mock(base_url="https://test01-eu01-example.demandware.net"
) as respx_mock:
respx_mock.post(
f"/dw/oauth2/access_token?client_id={CLIENT_ID}",
content=json.dumps(BM_TOKEN),
alias="bmtokenrequest",
)
yield respx_mock
async def test_async_side_effect__exception(client, using):
async def effect(request):
raise httpx.ConnectTimeout("X-P", request=request)
async with respx.mock(using=using) as respx_mock:
mock_route = respx_mock.get("https://example.org/").mock(side_effect=effect)
with pytest.raises(httpx.ConnectTimeout):
await client.get("https://example.org/")
assert mock_route.called
def mocked_director_service_api(minimal_app):
with respx.mock(
base_url=minimal_app.state.settings.director.base_url,
assert_all_called=False,
assert_all_mocked=True,
) as respx_mock:
respx_mock.get("/services", name="list_services").respond(
200, json={"data": ["one", "two"]})
yield respx_mock
def director_mockup(app: FastAPI) -> Iterator[respx.MockRouter]:
with respx.mock(
base_url=app.state.settings.CATALOG_DIRECTOR.base_url,
assert_all_called=False,
assert_all_mocked=True,
) as respx_mock:
respx_mock.head("/", name="healthcheck").respond(200,
json={"health": "OK"})
respx_mock.get("/services",
name="list_services").respond(200, json={"data": []})
yield respx_mock
def mocked_node_list(self, node_list):
with respx.mock(base_url="http://localhost:8090",
assert_all_called=False) as respx_mock:
respx_mock.get(
"/controller/rest/applications/app-replace/tiers/tier-replace/nodes",
name="nodes",
params={
"output": "JSON"
},
).mock(httpx.Response(200, json=node_list))
yield respx_mock
async def test_local_contextmanager(client):
with respx.mock() as respx_mock:
assert respx_mock.stats.call_count == 0
request = respx_mock.get("https://foo/bar/", status_code=202)
response = await client.get("https://foo/bar/")
assert request.called is True
assert response.status_code == 202
assert respx.stats.call_count == 0
assert respx_mock.stats.call_count == 1
async with respx.mock() as respx_mock:
assert respx_mock.stats.call_count == 0
request = respx_mock.get("https://foo/bar/", status_code=202)
response = await client.get("https://foo/bar/")
assert request.called is True
assert response.status_code == 202
assert respx.stats.call_count == 0
assert respx_mock.stats.call_count == 1
assert respx.stats.call_count == 0
async def test_nested_local_contextmanager(client):
with respx.mock() as respx_mock_1:
get_request = respx_mock_1.get("https://foo/bar/", status_code=202)
with respx.mock() as respx_mock_2:
post_request = respx_mock_2.post("https://foo/bar/", status_code=201)
response = await client.get("https://foo/bar/")
assert get_request.called is True
assert response.status_code == 202
assert respx.stats.call_count == 0
assert respx_mock_1.stats.call_count == 1
assert respx_mock_2.stats.call_count == 0
response = await client.post("https://foo/bar/")
assert post_request.called is True
assert response.status_code == 201
assert respx.stats.call_count == 0
assert respx_mock_1.stats.call_count == 1
assert respx_mock_2.stats.call_count == 1
async def github_server(
monkeypatch: pytest.MonkeyPatch,
) -> typing.AsyncGenerator[respx.MockRouter, None]:
monkeypatch.setattr(github.CachedToken, "STORAGE", {})
async with respx.mock(base_url=config.GITHUB_REST_API_URL) as respx_mock:
respx_mock.post("/app/installations/12345/access_tokens").respond(
200,
json={
"token": "<app_token>",
"expires_at": "2100-12-31T23:59:59Z"
})
yield respx_mock
def mocked_director_service_api(minimal_app: FastAPI) -> MockRouter:
with respx.mock(
base_url=minimal_app.state.settings.CATALOG_DIRECTOR.base_url,
assert_all_called=False,
assert_all_mocked=True,
) as respx_mock:
respx_mock.head("/", name="healthcheck").respond(200, json={"health": "OK"})
respx_mock.get("/services", name="list_services").respond(
200, json={"data": ["one", "two"]}
)
yield respx_mock
def session_mock(dummy_api_url):
"""
Fixture which replaces the client's `_get_session` method with a mock,
returning a mocked session object. Yields the session mock for use in
the test.
Yields
------
unittests.Mock
"""
with respx.mock(base_url=f"{dummy_api_url}/api/0") as respx_mock:
yield respx_mock
async def test_async_side_effect(client, using):
async def effect(request, slug):
assert request.extensions.get("timeout", {}).get("read") == 44.0
return httpx.Response(204, text=slug)
async with respx.mock(using=using) as respx_mock:
mock_route = respx_mock.get(
"https://example.org/", path__regex=r"/(?P<slug>\w+)/"
).mock(side_effect=effect)
response = await client.get("https://example.org/hello/", timeout=44.0)
assert response.status_code == 204
assert response.text == "hello"
assert mock_route.called
def mocked_director_v0_service_api(minimal_app, entrypoint, exp_data: Dict,
resp_alias: str):
with respx.mock(
base_url=minimal_app.state.settings.DIRECTOR_V0.endpoint,
assert_all_called=False,
assert_all_mocked=True,
) as respx_mock:
# lists services
respx_mock.get(
urllib.parse.unquote(entrypoint),
name=resp_alias,
).respond(json=exp_data)
yield respx_mock
def test_raise_duplicate_request_id(client: Client) -> None:
"""Raise exception when the request_id already exists."""
with respx.mock(base_url=PLATFORM_URL) as respx_mock:
respx_mock.put(
re.compile("/api/v1/requests/.*$"),
status_code=409,
content=
('{"errors":[{"errorCode":2701,"errorType":"RequestId",'
'"message":"Found duplicate request id"}],"requestId":"1234567"}'
),
)
with pytest.raises(DuplicateRequestId) as excinfo:
client.put(client.identity.public_identity, request_id="1234567")
assert str(excinfo.value) == "request ID already exists"
assert excinfo.value.request_id == "1234567"
async def setUp(self):
self.test_vars = await RestSetup.get_test_vars()
self.ably = await RestSetup.get_ably_rest(use_binary_protocol=False)
# with headers
self.publish_attempts = 0
self.channel = uuid.uuid4().hex
host = self.test_vars['host']
tokens = ['a_token', 'another_token']
headers = {'Content-Type': 'application/json'}
self.mocked_api = respx.mock(base_url='https://{}'.format(host))
self.request_token_route = self.mocked_api.post(
"/keys/{}/requestToken".format(
self.test_vars["keys"][0]['key_name']),
name="request_token_route")
self.request_token_route.return_value = Response(
status_code=200,
headers=headers,
json={
'token': tokens[self.request_token_route.call_count - 1],
'expires': (time.time() + 60) * 1000
},
)
def call_back(request):
self.publish_attempts += 1
if self.publish_attempts in [1, 3]:
return Response(
status_code=201,
headers=headers,
json=[],
)
return Response(
status_code=401,
headers=headers,
json={
'error': {
'message': 'Authentication failure',
'statusCode': 401,
'code': 40140
}
},
)
self.publish_attempt_route = self.mocked_api.post(
"/channels/{}/messages".format(self.channel),
name="publish_attempt_route")
self.publish_attempt_route.side_effect = call_back
self.mocked_api.start()
