Skip to content

Commit 7b2a303

Browse files
adamtheturtleadamtheturtle
authored
Use sync clients in respx transport tests (#3020)
1 parent ab425f1 commit 7b2a303

File tree

1 file changed

+84
-98
lines changed

1 file changed

+84
-98
lines changed

‎tests/mock_vws/test_respx_mock_usage.py‎

Lines changed: 84 additions & 98 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,16 @@
1-
"""Tests for ``MockVWS`` intercepting ``httpx`` via asynchronous ``vws``
1+
"""Tests for ``MockVWS`` intercepting ``httpx`` via synchronous ``vws``
22
clients.
33
"""
44

5-
import asyncio
65
import io
76
import uuid
87

98
import httpx
109
import pytest
11-
from vws import AsyncCloudRecoService, AsyncVuMarkService, AsyncVWS
10+
from vws import VWS, CloudRecoService, VuMarkService
1211
from vws.exceptions.vws_exceptions import UnknownTargetError
1312
from vws.reports import TargetStatuses
13+
from vws.transports import HTTPXTransport
1414
from vws.vumark_accept import VuMarkAccept
1515

1616
from mock_vws import MockVWS
@@ -19,157 +19,143 @@
1919
from mock_vws.target import VuMarkTarget
2020

2121

22-
class TestAsyncVWS:
23-
"""Asynchronous ``vws-python`` client usage through the mock."""
22+
class TestVWS:
23+
"""Synchronous ``vws-python`` client usage through the mock via
24+
``httpx``.
25+
"""
2426

2527
@staticmethod
2628
def test_response_delay_causes_httpx_timeout() -> None:
27-
"""``httpx`` timeouts are surfaced through ``AsyncVWS``."""
29+
"""``httpx`` timeouts are surfaced through ``VWS``."""
2830
database = CloudDatabase()
2931
calls: list[float] = []
3032

31-
async def run_test() -> None:
32-
"""Trigger a timed request through the client."""
33-
async with AsyncVWS(
34-
server_access_key=database.server_access_key,
35-
server_secret_key=database.server_secret_key,
36-
request_timeout_seconds=0.1,
37-
) as client:
38-
await client.get_database_summary_report()
39-
4033
with MockVWS(
4134
response_delay_seconds=5.0,
4235
sleep_fn=calls.append,
4336
processing_time_seconds=0,
4437
) as mock:
4538
mock.add_cloud_database(cloud_database=database)
39+
client = VWS(
40+
server_access_key=database.server_access_key,
41+
server_secret_key=database.server_secret_key,
42+
request_timeout_seconds=0.1,
43+
transport=HTTPXTransport(),
44+
)
4645
with pytest.raises(expected_exception=httpx.ReadTimeout):
47-
asyncio.run(run_test())
46+
client.get_database_summary_report()
4847

4948
assert calls == [0.1]
5049

5150
@staticmethod
5251
def test_custom_base_vws_url_with_path_prefix() -> None:
53-
"""``AsyncVWS`` works with a custom VWS base URL path prefix."""
52+
"""``VWS`` works with a custom VWS base URL path prefix."""
5453
database = CloudDatabase()
5554
base_vws_url = "https://vuforia.vws.example.com/prefix"
5655

57-
async def run_test() -> str:
58-
"""Return the database name via the custom base URL."""
59-
async with AsyncVWS(
56+
with MockVWS(base_vws_url=base_vws_url) as mock:
57+
mock.add_cloud_database(cloud_database=database)
58+
client = VWS(
6059
server_access_key=database.server_access_key,
6160
server_secret_key=database.server_secret_key,
6261
base_vws_url=base_vws_url,
63-
) as client:
64-
report = await client.get_database_summary_report()
65-
return report.name
66-
67-
with MockVWS(base_vws_url=base_vws_url) as mock:
68-
mock.add_cloud_database(cloud_database=database)
69-
database_name = asyncio.run(run_test())
62+
transport=HTTPXTransport(),
63+
)
64+
report = client.get_database_summary_report()
65+
database_name = report.name
7066

7167
assert database_name == database.database_name
7268

7369
@staticmethod
7470
def test_add_get_and_delete_target(
7571
image_file_success_state_low_rating: io.BytesIO,
7672
) -> None:
77-
"""A target life cycle works through ``AsyncVWS``."""
73+
"""A target life cycle works through ``VWS``."""
7874
database = CloudDatabase()
7975
target_name = "async-target"
8076

81-
async def run_test() -> None:
82-
"""Exercise the target life cycle."""
83-
async with AsyncVWS(
77+
with MockVWS(processing_time_seconds=0) as mock:
78+
mock.add_cloud_database(cloud_database=database)
79+
client = VWS(
8480
server_access_key=database.server_access_key,
8581
server_secret_key=database.server_secret_key,
86-
) as client:
87-
target_id = await client.add_target(
88-
name=target_name,
89-
width=1,
90-
image=image_file_success_state_low_rating,
91-
application_metadata=None,
92-
active_flag=True,
93-
)
94-
await client.wait_for_target_processed(target_id=target_id)
95-
target_record = await client.get_target_record(
96-
target_id=target_id,
97-
)
98-
assert target_record.status == TargetStatuses.SUCCESS
99-
assert target_record.target_record.name == target_name
100-
101-
await client.delete_target(target_id=target_id)
102-
103-
with pytest.raises(expected_exception=UnknownTargetError):
104-
await client.get_target_record(target_id=target_id)
82+
transport=HTTPXTransport(),
83+
)
84+
target_id = client.add_target(
85+
name=target_name,
86+
width=1,
87+
image=image_file_success_state_low_rating,
88+
application_metadata=None,
89+
active_flag=True,
90+
)
91+
client.wait_for_target_processed(target_id=target_id)
92+
target_record = client.get_target_record(target_id=target_id)
93+
assert target_record.status == TargetStatuses.SUCCESS
94+
assert target_record.target_record.name == target_name
10595

106-
with MockVWS(processing_time_seconds=0) as mock:
107-
mock.add_cloud_database(cloud_database=database)
108-
asyncio.run(run_test())
96+
client.delete_target(target_id=target_id)
10997

98+
with pytest.raises(expected_exception=UnknownTargetError):
99+
client.get_target_record(target_id=target_id)
110100

111-
class TestAsyncCloudRecoService:
112-
"""Asynchronous cloud query usage through the mock."""
101+
102+
class TestCloudRecoService:
103+
"""Synchronous cloud query usage through the mock via ``httpx``."""
113104

114105
@staticmethod
115106
def test_query_returns_match(high_quality_image: io.BytesIO) -> None:
116-
"""``AsyncCloudRecoService`` returns a match via the mock."""
107+
"""``CloudRecoService`` returns a match via the mock."""
117108
database = CloudDatabase()
118109

119-
async def run_test() -> None:
120-
"""Add a target and query it using the clients."""
121-
async with (
122-
AsyncVWS(
123-
server_access_key=database.server_access_key,
124-
server_secret_key=database.server_secret_key,
125-
) as vws_client,
126-
AsyncCloudRecoService(
127-
client_access_key=database.client_access_key,
128-
client_secret_key=database.client_secret_key,
129-
) as query_client,
130-
):
131-
target_id = await vws_client.add_target(
132-
name="query-target",
133-
width=1,
134-
image=high_quality_image,
135-
application_metadata=None,
136-
active_flag=True,
137-
)
138-
await vws_client.wait_for_target_processed(target_id=target_id)
139-
results = await query_client.query(image=high_quality_image)
140-
assert [result.target_id for result in results] == [target_id]
141-
142110
with MockVWS(
143111
processing_time_seconds=0,
144112
query_match_checker=ExactMatcher(),
145113
) as mock:
146114
mock.add_cloud_database(cloud_database=database)
147-
asyncio.run(run_test())
148-
149-
150-
class TestAsyncVuMarkService:
151-
"""Asynchronous VuMark generation usage through the mock."""
115+
vws_client = VWS(
116+
server_access_key=database.server_access_key,
117+
server_secret_key=database.server_secret_key,
118+
transport=HTTPXTransport(),
119+
)
120+
query_client = CloudRecoService(
121+
client_access_key=database.client_access_key,
122+
client_secret_key=database.client_secret_key,
123+
transport=HTTPXTransport(),
124+
)
125+
target_id = vws_client.add_target(
126+
name="query-target",
127+
width=1,
128+
image=high_quality_image,
129+
application_metadata=None,
130+
active_flag=True,
131+
)
132+
vws_client.wait_for_target_processed(target_id=target_id)
133+
results = query_client.query(image=high_quality_image)
134+
assert [result.target_id for result in results] == [target_id]
135+
136+
137+
class TestVuMarkService:
138+
"""Synchronous VuMark generation usage through the mock via
139+
``httpx``.
140+
"""
152141

153142
@staticmethod
154143
def test_generate_vumark_instance_returns_png_bytes() -> None:
155-
"""``AsyncVuMarkService`` returns VuMark image bytes."""
144+
"""``VuMarkService`` returns VuMark image bytes."""
156145
vumark_target = VuMarkTarget(name="test-target")
157146
database = VuMarkDatabase(vumark_targets={vumark_target})
158147

159-
async def run_test() -> bytes:
160-
"""Generate a VuMark instance image and return its bytes."""
161-
async with AsyncVuMarkService(
162-
server_access_key=database.server_access_key,
163-
server_secret_key=database.server_secret_key,
164-
) as client:
165-
return await client.generate_vumark_instance(
166-
target_id=vumark_target.target_id,
167-
instance_id=uuid.uuid4().hex,
168-
accept=VuMarkAccept.PNG,
169-
)
170-
171148
with MockVWS() as mock:
172149
mock.add_vumark_database(vumark_database=database)
173-
response_content = asyncio.run(run_test())
150+
client = VuMarkService(
151+
server_access_key=database.server_access_key,
152+
server_secret_key=database.server_secret_key,
153+
transport=HTTPXTransport(),
154+
)
155+
response_content = client.generate_vumark_instance(
156+
target_id=vumark_target.target_id,
157+
instance_id=uuid.uuid4().hex,
158+
accept=VuMarkAccept.PNG,
159+
)
174160

175161
assert response_content.startswith(b"\x89PNG")

0 commit comments

Comments
 (0)