def test_duplicate_keys(self) -> None:
"""
It is not possible to have multiple databases with matching keys.
"""
with MockVWS() as mock:
mock.add_database(database=VuforiaDatabase(server_access_key='1'))
with pytest.raises(ValueError) as exc:
mock.add_database(
database=VuforiaDatabase(server_access_key='1'),
)
expected_message = (
'All server access keys must be unique. '
'There is already a database with the server access key "1".'
)
assert str(exc.value) == expected_message
with MockVWS() as mock:
mock.add_database(database=VuforiaDatabase(server_secret_key='1'))
with pytest.raises(ValueError) as exc:
mock.add_database(
database=VuforiaDatabase(server_secret_key='1'),
)
expected_message = (
'All server secret keys must be unique. '
'There is already a database with the server secret key "1".'
)
assert str(exc.value) == expected_message
with MockVWS() as mock:
mock.add_database(database=VuforiaDatabase(client_access_key='1'))
with pytest.raises(ValueError) as exc:
mock.add_database(
database=VuforiaDatabase(client_access_key='1'),
)
expected_message = (
'All client access keys must be unique. '
'There is already a database with the client access key "1".'
)
assert str(exc.value) == expected_message
with MockVWS() as mock:
mock.add_database(database=VuforiaDatabase(client_secret_key='1'))
with pytest.raises(ValueError) as exc:
mock.add_database(
database=VuforiaDatabase(client_secret_key='1'),
)
expected_message = (
'All client secret keys must be unique. '
'There is already a database with the client secret key "1".'
)
assert str(exc.value) == expected_message
def test_project_inactive(
high_quality_image: io.BytesIO,
tmp_path: Path,
) -> None:
"""
An error is given if the project is inactive and the desired action cannot
be taken because of this.
"""
new_file = tmp_path / uuid.uuid4().hex
image_data = high_quality_image.getvalue()
new_file.write_bytes(data=image_data)
database = VuforiaDatabase(state=States.PROJECT_INACTIVE)
with MockVWS() as mock:
mock.add_database(database=database)
runner = CliRunner(mix_stderr=False)
commands = [
'add-target',
'--name',
'foo',
'--width',
'0.1',
'--image',
str(new_file),
'--server-access-key',
database.server_access_key,
'--server-secret-key',
database.server_secret_key,
]
result = runner.invoke(vws_group, commands, catch_exceptions=False)
assert result.exit_code == 1
expected_stderr = (
'Error: The project associated with the given keys is inactive.\n')
assert result.stderr == expected_stderr
assert result.stdout == ''
def test_processing_images(
self,
image_file_success_state_low_rating: io.BytesIO,
) -> None:
"""
The number of images in the processing state is returned.
"""
database = VuforiaDatabase()
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key=database.server_secret_key,
)
with MockVWS() as mock:
mock.add_database(database=database)
vws_client.add_target(
name=uuid.uuid4().hex,
width=1,
image=image_file_success_state_low_rating,
active_flag=True,
application_metadata=None,
)
_wait_for_image_numbers(
vws_client=vws_client,
active_images=0,
inactive_images=0,
failed_images=0,
processing_images=1,
)
def test_default(self, image_file_failed_state: io.BytesIO) -> None:
"""
By default, targets in the mock take 0.5 seconds to be processed.
"""
database = VuforiaDatabase()
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key=database.server_secret_key,
)
with MockVWS() as mock:
mock.add_database(database=database)
target_id = vws_client.add_target(
name='example',
width=1,
image=image_file_failed_state,
active_flag=True,
application_metadata=None,
)
start_time = datetime.now()
while True:
target_details = vws_client.get_target_record(
target_id=target_id,
)
status = target_details.status
if status != TargetStatuses.PROCESSING:
elapsed_time = datetime.now() - start_time
# There is a race condition in this test - if it starts to
# fail, maybe extend the acceptable range.
assert elapsed_time < timedelta(seconds=0.55)
assert elapsed_time > timedelta(seconds=0.49)
return
def _enable_use_mock_vuforia(
working_database: VuforiaDatabase,
inactive_database: VuforiaDatabase,
monkeypatch: MonkeyPatch,
) -> Generator:
assert monkeypatch
working_database = VuforiaDatabase(
database_name=working_database.database_name,
server_access_key=working_database.server_access_key,
server_secret_key=working_database.server_secret_key,
client_access_key=working_database.client_access_key,
client_secret_key=working_database.client_secret_key,
)
inactive_database = VuforiaDatabase(
state=States.PROJECT_INACTIVE,
database_name=inactive_database.database_name,
server_access_key=inactive_database.server_access_key,
server_secret_key=inactive_database.server_secret_key,
client_access_key=inactive_database.client_access_key,
client_secret_key=inactive_database.client_secret_key,
)
with MockVWS(processing_time_seconds=0.2) as mock:
mock.add_database(database=working_database)
mock.add_database(database=inactive_database)
yield
def test_to_dict_deleted(self, high_quality_image: io.BytesIO) -> None:
"""
It is possible to dump a deleted target to a dictionary and load it
back.
"""
database = VuforiaDatabase()
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key=database.server_secret_key,
)
with MockVWS() as mock:
mock.add_database(database=database)
target_id = vws_client.add_target(
name='example',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
vws_client.delete_target(target_id=target_id)
(target, ) = database.targets
target_dict = target.to_dict()
# The dictionary is JSON dump-able
assert json.dumps(target_dict)
new_target = Target.from_dict(target_dict=target_dict)
assert new_target.delete_date == target.delete_date
def test_to_dict(self, high_quality_image: io.BytesIO) -> None:
"""
It is possible to dump a database to a dictionary and load it back.
"""
database = VuforiaDatabase()
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key=database.server_secret_key,
)
# We test a database with a target added.
with MockVWS() as mock:
mock.add_database(database=database)
vws_client.add_target(
name='example',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
database_dict = database.to_dict()
# The dictionary is JSON dump-able
assert json.dumps(database_dict)
new_database = VuforiaDatabase.from_dict(database_dict=database_dict)
assert new_database == database
def test_custom(self, image_file_failed_state: io.BytesIO) -> None:
"""
It is possible to set a custom processing time.
"""
database = VuforiaDatabase()
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key=database.server_secret_key,
)
with MockVWS(processing_time_seconds=0.1) as mock:
mock.add_database(database=database)
target_id = vws_client.add_target(
name='example',
width=1,
image=image_file_failed_state,
active_flag=True,
application_metadata=None,
)
start_time = datetime.now()
while True:
target_details = vws_client.get_target_record(
target_id=target_id,
)
status = target_details.status
if status != TargetStatuses.PROCESSING:
elapsed_time = datetime.now() - start_time
assert elapsed_time < timedelta(seconds=0.15)
assert elapsed_time > timedelta(seconds=0.09)
return
def test_custom_base_url(self, high_quality_image: io.BytesIO) -> None:
"""
It is possible to use query a target to a database under a custom VWQ
URL.
"""
base_vwq_url = 'http://example.com'
with MockVWS(base_vwq_url=base_vwq_url) as mock:
database = VuforiaDatabase()
mock.add_database(database=database)
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key=database.server_secret_key,
)
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
cloud_reco_client = CloudRecoService(
client_access_key=database.client_access_key,
client_secret_key=database.client_secret_key,
base_vwq_url=base_vwq_url,
)
matches = cloud_reco_client.query(image=high_quality_image)
assert len(matches) == 1
match = matches[0]
assert match.target_id == target_id
def test_authentication_failure(high_quality_image: io.BytesIO) -> None:
"""
An ``AuthenticationFailure`` exception is raised when the server access key
exists but the server secret key is incorrect, or when a client key is
incorrect.
"""
database = VuforiaDatabase()
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key='a',
)
with MockVWS() as mock:
mock.add_database(database=database)
with pytest.raises(AuthenticationFailure) as exc:
vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
assert exc.value.response.status_code == HTTPStatus.UNAUTHORIZED
def test_no_scheme(self) -> None:
"""
An error if raised if a URL is given with no scheme.
"""
with pytest.raises(MissingSchema) as exc:
MockVWS(base_vws_url='vuforia.vws.example.com')
expected = (
'Invalid URL "vuforia.vws.example.com": No scheme supplied. '
'Perhaps you meant "https://vuforia.vws.example.com".')
assert str(exc.value) == expected
with pytest.raises(MissingSchema) as exc:
MockVWS(base_vwq_url='vuforia.vwq.example.com')
expected = (
'Invalid URL "vuforia.vwq.example.com": No scheme supplied. '
'Perhaps you meant "https://vuforia.vwq.example.com".')
assert str(exc.value) == expected
def fixture_mock_database() -> Iterator[VuforiaDatabase]:
"""
Yield a mock ``VuforiaDatabase``.
"""
with MockVWS() as mock:
database = VuforiaDatabase()
mock.add_database(database=database)
yield database
def test_real_http(self) -> None:
"""
When the `real_http` parameter given to the context manager is set to
`True`, requests made to unmocked addresses are not stopped.
"""
with MockVWS(real_http=True):
with pytest.raises(requests.exceptions.ConnectionError):
request_unmocked_address()
def test_custom_seconds_between_requests(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to customize the time waited between polling requests.
"""
runner = CliRunner()
with MockVWS(processing_time_seconds=0.5) as mock:
mock_database = VuforiaDatabase()
mock.add_database(database=mock_database)
vws_client = VWS(
server_access_key=mock_database.server_access_key,
server_secret_key=mock_database.server_secret_key,
)
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
commands = [
'wait-for-target-processed',
'--target-id',
target_id,
'--seconds-between-requests',
'0.3',
'--server-access-key',
mock_database.server_access_key,
'--server-secret-key',
mock_database.server_secret_key,
]
result = runner.invoke(vws_group, commands, catch_exceptions=False)
assert result.exit_code == 0
assert result.stdout == ''
report = vws_client.get_database_summary_report()
expected_requests = (
# Add target request
1 +
# Database summary request
1 +
# Initial request
1 +
# Request after 0.3 seconds - not processed
# This assumes that there is less than 0.2 seconds taken
# between the start of the target processing and the start of
# waiting for the target to be processed.
1 +
# Request after 0.6 seconds - processed
1)
# At the time of writing there is a bug which prevents request
# usage from being tracked so we cannot track this.
expected_requests = 0
assert report.request_usage == expected_requests
def test_custom_timeout(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to set a maximum timeout.
"""
runner = CliRunner(mix_stderr=False)
with MockVWS(processing_time_seconds=0.5) as mock:
mock_database = VuforiaDatabase()
mock.add_database(database=mock_database)
vws_client = VWS(
server_access_key=mock_database.server_access_key,
server_secret_key=mock_database.server_secret_key,
)
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status == TargetStatuses.PROCESSING
commands = [
'wait-for-target-processed',
'--target-id',
target_id,
'--timeout-seconds',
'0.1',
'--server-access-key',
mock_database.server_access_key,
'--server-secret-key',
mock_database.server_secret_key,
]
result = runner.invoke(vws_group, commands, catch_exceptions=False)
assert result.exit_code != 0
assert result.stderr == 'Timeout of 0.1 seconds reached.\n'
commands = [
'wait-for-target-processed',
'--target-id',
target_id,
'--timeout-seconds',
'0.5',
'--server-access-key',
mock_database.server_access_key,
'--server-secret-key',
mock_database.server_secret_key,
]
result = runner.invoke(vws_group, commands, catch_exceptions=False)
assert result.exit_code == 0
report = vws_client.get_target_summary_report(target_id=target_id)
assert report.status != TargetStatuses.PROCESSING
def test_custom_base_vwq_url(self) -> None:
"""
It is possible to use a custom base cloud recognition URL.
"""
with MockVWS(
base_vwq_url='https://vuforia.vwq.example.com',
real_http=False,
):
with pytest.raises(NoMockAddress):
requests.post('https://cloudreco.vuforia.com/v1/query')
requests.post(url='https://vuforia.vwq.example.com/v1/query')
requests.get('https://vws.vuforia.com/summary')
def test_custom_seconds_between_requests(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to customize the time waited between polling requests.
"""
with MockVWS(processing_time_seconds=0.5) as mock:
database = VuforiaDatabase()
mock.add_database(database=database)
vws_client = VWS(
server_access_key=database.server_access_key,
server_secret_key=database.server_secret_key,
)
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(
target_id=target_id,
seconds_between_requests=0.3,
)
report = vws_client.get_database_summary_report()
expected_requests = (
# Add target request
1
+
# Database summary request
1
+
# Initial request
1
+
# Request after 0.3 seconds - not processed
# This assumes that there is less than 0.2 seconds taken
# between the start of the target processing and the start of
# waiting for the target to be processed.
1
+
# Request after 0.6 seconds - processed
1
)
# At the time of writing there is a bug which prevents request
# usage from being tracked so we cannot track this.
expected_requests = 0
assert report.request_usage == expected_requests
def test_default(self, image_file_failed_state: io.BytesIO) -> None:
"""
By default, targets in the mock take 0.5 seconds to be processed.
"""
database = VuforiaDatabase()
with MockVWS() as mock:
mock.add_database(database=database)
time_taken = processing_time_seconds(
vuforia_database=database,
image=image_file_failed_state,
)
expected = 0.5
assert abs(expected - time_taken) < self.LEEWAY
def test_custom(self, image_file_failed_state: io.BytesIO) -> None:
"""
It is possible to set a custom processing time.
"""
database = VuforiaDatabase()
with MockVWS(processing_time_seconds=0.1) as mock:
mock.add_database(database=database)
time_taken = processing_time_seconds(
vuforia_database=database,
image=image_file_failed_state,
)
expected = 0.1
assert abs(expected - time_taken) < self.LEEWAY
def test_date_changes(self) -> None:
"""
The date that the response is sent is in the response Date header.
"""
new_year = 2012
new_time = datetime(new_year, 1, 1)
with MockVWS():
with freeze_time(new_time):
response = requests.get('https://vws.vuforia.com/summary')
date_response = response.headers['Date']
date_from_response = email.utils.parsedate(date_response)
assert date_from_response is not None
year = date_from_response[0]
assert year == new_year
def test_default(self) -> None:
"""
By default, the mock stops any requests made with `requests` to
non-Vuforia addresses, but not to mocked Vuforia endpoints.
"""
with MockVWS():
with pytest.raises(NoMockAddress):
request_unmocked_address()
# No exception is raised when making a request to a mocked
# endpoint.
request_mocked_address()
# The mocking stops when the context manager stops.
with pytest.raises(requests.exceptions.ConnectionError):
request_unmocked_address()
def test_duplicate_keys(self) -> None:
"""
It is not possible to have multiple databases with matching keys.
"""
database = VuforiaDatabase(
server_access_key='1',
server_secret_key='2',
client_access_key='3',
client_secret_key='4',
database_name='5',
)
bad_server_access_key_db = VuforiaDatabase(server_access_key='1')
bad_server_secret_key_db = VuforiaDatabase(server_secret_key='2')
bad_client_access_key_db = VuforiaDatabase(client_access_key='3')
bad_client_secret_key_db = VuforiaDatabase(client_secret_key='4')
bad_database_name_db = VuforiaDatabase(database_name='5')
server_access_key_conflict_error = (
'All server access keys must be unique. '
'There is already a database with the server access key "1".')
server_secret_key_conflict_error = (
'All server secret keys must be unique. '
'There is already a database with the server secret key "2".')
client_access_key_conflict_error = (
'All client access keys must be unique. '
'There is already a database with the client access key "3".')
client_secret_key_conflict_error = (
'All client secret keys must be unique. '
'There is already a database with the client secret key "4".')
database_name_conflict_error = (
'All names must be unique. '
'There is already a database with the name "5".')
with MockVWS() as mock:
mock.add_database(database=database)
for bad_database, expected_message in (
(bad_server_access_key_db, server_access_key_conflict_error),
(bad_server_secret_key_db, server_secret_key_conflict_error),
(bad_client_access_key_db, client_access_key_conflict_error),
(bad_client_secret_key_db, client_secret_key_conflict_error),
(bad_database_name_db, database_name_conflict_error),
):
with pytest.raises(ValueError) as exc:
mock.add_database(database=bad_database)
assert str(exc.value) == expected_message
def test_base_vwq_url(high_quality_image: io.BytesIO, tmp_path: Path) -> None:
"""
It is possible to use query a target to a database under a custom VWQ
URL.
"""
runner = CliRunner(mix_stderr=False)
base_vwq_url = 'http://example.com'
new_file = tmp_path / uuid.uuid4().hex
image_data = high_quality_image.getvalue()
new_file.write_bytes(data=image_data)
with MockVWS(base_vwq_url=base_vwq_url) as mock:
mock_database = VuforiaDatabase()
mock.add_database(database=mock_database)
vws_client = VWS(
server_access_key=mock_database.server_access_key,
server_secret_key=mock_database.server_secret_key,
)
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
commands = [
str(new_file),
'--client-access-key',
mock_database.client_access_key,
'--client-secret-key',
mock_database.client_secret_key,
'--base-vwq-url',
base_vwq_url,
]
result = runner.invoke(
vuforia_cloud_reco,
commands,
catch_exceptions=False,
)
assert result.exit_code == 0
[match] = yaml.load(result.stdout, Loader=yaml.FullLoader)
assert match['target_id'] == target_id
def test_authentication_failure(high_quality_image: io.BytesIO) -> None:
"""
An ``AuthenticationFailure`` exception is raised when the client access key
exists but the client secret key is incorrect.
"""
database = VuforiaDatabase()
cloud_reco_client = CloudRecoService(
client_access_key=database.client_access_key,
client_secret_key='a',
)
with MockVWS() as mock:
mock.add_database(database=database)
with pytest.raises(AuthenticationFailure) as exc:
cloud_reco_client.query(image=high_quality_image)
assert exc.value.response.status_code == HTTPStatus.UNAUTHORIZED
def test_with_no_processing_time(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
This exercises some otherwise untouched code.
"""
database = VuforiaDatabase()
with MockVWS(query_processes_deletion_seconds=0) as mock:
mock.add_database(database=database)
time_taken = recognize_deletion_seconds(
high_quality_image=high_quality_image,
vuforia_database=database,
)
expected = 0.2
assert abs(expected - time_taken) < self.LEEWAY
def test_inactive_project(high_quality_image: io.BytesIO) -> None:
"""
An ``InactiveProject`` exception is raised when querying an inactive
database.
"""
database = VuforiaDatabase(state=States.PROJECT_INACTIVE)
with MockVWS() as mock:
mock.add_database(database=database)
cloud_reco_client = CloudRecoService(
client_access_key=database.client_access_key,
client_secret_key=database.client_secret_key,
)
with pytest.raises(InactiveProject) as exc:
cloud_reco_client.query(image=high_quality_image)
assert exc.value.response.status_code == HTTPStatus.FORBIDDEN
def test_fail(high_quality_image: io.BytesIO) -> None:
"""
A ``Fail`` exception is raised when the server access key does not exist.
"""
with MockVWS():
vws_client = VWS(
server_access_key='a',
server_secret_key='a',
)
with pytest.raises(Fail) as exc:
vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
assert exc.value.response.status_code == HTTPStatus.BAD_REQUEST
def test_default(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
By default it takes zero seconds for the Query API on the mock to
recognize that a target has been deleted.
The real Query API takes between zero and two seconds.
See ``test_query`` for more information.
"""
database = VuforiaDatabase()
with MockVWS() as mock:
mock.add_database(database=database)
recognize_deletion_seconds = self._recognize_deletion_seconds(
high_quality_image=high_quality_image,
vuforia_database=database,
)
expected = 0.2
assert abs(expected - recognize_deletion_seconds) < 0.15
def test_custom(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to use set a custom amount of time that it takes for the
Query API on the mock to process that a target has been deleted.
"""
# We choose a low time for a quick test.
query_processes_deletion = 0.1
database = VuforiaDatabase()
with MockVWS(query_processes_deletion_seconds=query_processes_deletion,
) as mock:
mock.add_database(database=database)
time_taken = process_deletion_seconds(
high_quality_image=high_quality_image,
vuforia_database=database,
)
expected = query_processes_deletion
assert abs(expected - time_taken) < self.LEEWAY
def test_default(
self,
high_quality_image: io.BytesIO,
) -> None:
"""
By default it takes three seconds for the Query API on the mock to
process that a target has been deleted.
The real Query API takes between seven and thirty seconds.
See ``test_query`` for more information.
"""
database = VuforiaDatabase()
with MockVWS() as mock:
mock.add_database(database=database)
time_taken = process_deletion_seconds(
high_quality_image=high_quality_image,
vuforia_database=database,
)
expected = 3
assert abs(expected - time_taken) < self.LEEWAY
