def test_width_invalid(
self,
vuforia_database: VuforiaDatabase,
vws_client: VWS,
width: Any,
target_id: str,
) -> None:
"""
The width must be a number greater than zero.
"""
vws_client.wait_for_target_processed(target_id=target_id)
target_details = vws_client.get_target_record(target_id=target_id)
original_width = target_details.target_record.width
response = update_target(
vuforia_database=vuforia_database,
data={'width': width},
target_id=target_id,
)
assert_vws_failure(
response=response,
status_code=HTTPStatus.BAD_REQUEST,
result_code=ResultCodes.FAIL,
)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.target_record.width == original_width
def test_no_fields_given(
self,
vuforia_database: VuforiaDatabase,
vws_client: VWS,
target_id: str,
) -> None:
"""
No data fields are required.
"""
vws_client.wait_for_target_processed(target_id=target_id)
response = update_target(
vuforia_database=vuforia_database,
data={},
target_id=target_id,
)
assert_vws_response(
response=response,
status_code=HTTPStatus.OK,
result_code=ResultCodes.SUCCESS,
)
assert response.json().keys() == {'result_code', 'transaction_id'}
target_details = vws_client.get_target_record(target_id=target_id)
# Targets go back to processing after being updated.
assert target_details.status == TargetStatuses.PROCESSING
vws_client.wait_for_target_processed(target_id=target_id)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.status == TargetStatuses.SUCCESS
def test_success_status(
self,
image_file_success_state_low_rating: io.BytesIO,
vws_client: VWS,
) -> None:
"""
When a random, large enough image is given, the status changes from
'processing' to 'success' after some time.
The mock is much more lenient than the real implementation of VWS.
The test image does not prove that what is counted as a success in the
mock will be counted as a success in the real implementation.
"""
target_id = vws_client.add_target(
name='example',
width=1,
image=image_file_success_state_low_rating,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.status == TargetStatuses.SUCCESS
# Tracking rating is between 0 and 5 when status is 'success'
tracking_rating = target_details.target_record.tracking_rating
assert tracking_rating in range(6)
# The tracking rating stays stable across requests
target_details = vws_client.get_target_record(target_id=target_id)
new_tracking_rating = target_details.target_record.tracking_rating
assert new_tracking_rating == tracking_rating
def test_request_time_too_skewed(
vws_client: VWS,
high_quality_image: io.BytesIO,
) -> None:
"""
A ``RequestTimeTooSkewed`` exception is raised when the request time is
more than five minutes different from the server time.
"""
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
vws_max_time_skew = 60 * 5
leeway = 10
time_difference_from_now = vws_max_time_skew + leeway
# We use a custom tick because we expect the following:
#
# * At least one time check when creating the request
# * At least one time check when processing the request
#
# >= 1 ticks are acceptable.
with freeze_time(auto_tick_seconds=time_difference_from_now):
with pytest.raises(RequestTimeTooSkewed) as exc:
vws_client.get_target_record(target_id=target_id)
assert exc.value.response.status_code == HTTPStatus.FORBIDDEN
def test_inactive_project(
self,
inactive_vws_client: VWS,
) -> None:
"""
The project's active state does not affect getting a target.
"""
with pytest.raises(UnknownTarget):
inactive_vws_client.get_target_record(target_id=uuid.uuid4().hex)
def test_processed(
self,
target_id: str,
vws_client: VWS,
) -> None:
"""
When a target has finished processing, it can be deleted.
"""
vws_client.wait_for_target_processed(target_id=target_id)
vws_client.delete_target(target_id=target_id)
with pytest.raises(UnknownTarget):
vws_client.get_target_record(target_id=target_id)
def test_bad_secret_key_services(
self,
vuforia_database: VuforiaDatabase,
) -> None:
"""
If the server secret key given is incorrect, an
``AuthenticationFailure`` response is returned.
"""
vws_client = VWS(
server_access_key=vuforia_database.server_access_key,
server_secret_key='example',
)
with pytest.raises(AuthenticationFailure):
vws_client.get_target_record(target_id=uuid.uuid4().hex)
def test_rating_can_change(
self,
image_file_success_state_low_rating: io.BytesIO,
high_quality_image: io.BytesIO,
vuforia_database: VuforiaDatabase,
vws_client: VWS,
) -> None:
"""
If the target is updated with an image of different quality, the
tracking rating can change.
"quality" refers to Vuforia's internal rating system.
The mock randomly assigns a quality and makes sure that the new quality
is different to the old quality.
"""
good_image = high_quality_image.read()
good_image_data_encoded = base64.b64encode(good_image).decode('ascii')
target_id = vws_client.add_target(
name=uuid.uuid4().hex,
width=1,
image=image_file_success_state_low_rating,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.status == TargetStatuses.SUCCESS
# Tracking rating is between 0 and 5 when status is 'success'
original_tracking_rating = target_details.target_record.tracking_rating
assert original_tracking_rating in range(6)
update_target(
vuforia_database=vuforia_database,
data={'image': good_image_data_encoded},
target_id=target_id,
)
vws_client.wait_for_target_processed(target_id=target_id)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.status == TargetStatuses.SUCCESS
# Tracking rating is between 0 and 5 when status is 'success'
new_tracking_rating = target_details.target_record.tracking_rating
assert new_tracking_rating in range(6)
assert original_tracking_rating != new_tracking_rating
def test_get_target_record(
self,
vws_client: VWS,
high_quality_image: io.BytesIO,
) -> None:
"""
Details of a target are returned by ``get_target_record``.
"""
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
result = vws_client.get_target_record(target_id=target_id)
expected_target_record = TargetRecord(
target_id=target_id,
active_flag=True,
name='x',
width=1,
tracking_rating=-1,
reco_rating='',
)
assert result.target_record == expected_target_record
assert result.status == TargetStatuses.PROCESSING
def test_active_flag(
self,
vws_client: VWS,
image_file_success_state_low_rating: io.BytesIO,
initial_active_flag: bool,
desired_active_flag: bool,
) -> None:
"""
Setting the active flag to a Boolean value changes it.
"""
target_id = vws_client.add_target(
name=uuid.uuid4().hex,
width=1,
image=image_file_success_state_low_rating,
active_flag=initial_active_flag,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
vws_client.update_target(
target_id=target_id,
active_flag=desired_active_flag,
)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.target_record.active_flag == desired_active_flag
def test_same_name_given(
self,
image_file_success_state_low_rating: io.BytesIO,
vuforia_database: VuforiaDatabase,
vws_client: VWS,
) -> None:
"""
Updating a target with its own name does not give an error.
"""
name = 'example'
target_id = vws_client.add_target(
name=name,
width=1,
image=image_file_success_state_low_rating,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
response = update_target(
vuforia_database=vuforia_database,
data={'name': name},
target_id=target_id,
)
assert_vws_failure(
response=response,
status_code=HTTPStatus.OK,
result_code=ResultCodes.SUCCESS,
)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.target_record.name == name
def processing_time_seconds(
vuforia_database: VuforiaDatabase,
image: io.BytesIO,
) -> float:
"""
Return the time taken to process a target in the database.
"""
vws_client = VWS(
server_access_key=vuforia_database.server_access_key,
server_secret_key=vuforia_database.server_secret_key,
)
target_id = vws_client.add_target(
name='example',
width=1,
image=image,
active_flag=True,
application_metadata=None,
)
start_time = datetime.now()
while (vws_client.get_target_record(
target_id=target_id).status == TargetStatuses.PROCESSING):
pass
return (datetime.now() - start_time).total_seconds()
def test_set_to_none(
self,
vuforia_database: VuforiaDatabase,
vws_client: VWS,
image_file_failed_state: io.BytesIO,
) -> None:
"""
The active flag defaults to True if it is set to NULL.
"""
image_data = image_file_failed_state.read()
image_data_encoded = base64.b64encode(image_data).decode('ascii')
data = {
'name': 'my_example_name',
'width': 1234,
'image': image_data_encoded,
'active_flag': None,
}
response = add_target_to_vws(
vuforia_database=vuforia_database,
data=data,
)
target_id = response.json()['target_id']
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.target_record.active_flag is True
def test_status(
self,
image_file_failed_state: io.BytesIO,
vws_client: VWS,
) -> None:
"""
Targets are not duplicates if the status is not 'success'.
"""
original_target_id = vws_client.add_target(
name=uuid.uuid4().hex,
width=1,
image=image_file_failed_state,
active_flag=True,
application_metadata=None,
)
similar_target_id = vws_client.add_target(
name=uuid.uuid4().hex,
width=1,
image=image_file_failed_state,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=original_target_id)
vws_client.wait_for_target_processed(target_id=similar_target_id)
target_details = vws_client.get_target_record(
target_id=original_target_id, )
assert target_details.status == TargetStatuses.FAILED
duplicates = vws_client.get_duplicate_targets(
target_id=original_target_id, )
assert duplicates == []
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_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 test_bad_access_key_services(
self,
vuforia_database: VuforiaDatabase,
) -> None:
"""
If the server access key given does not match any database, a ``Fail``
response is returned.
"""
vws_client = VWS(
server_access_key='example',
server_secret_key=vuforia_database.server_secret_key,
)
with pytest.raises(Fail) as exc:
vws_client.get_target_record(target_id=uuid.uuid4().hex)
assert exc.value.response.status_code == HTTPStatus.BAD_REQUEST
def test_update_target(
self,
vws_client: VWS,
high_quality_image: io.BytesIO,
different_high_quality_image: io.BytesIO,
cloud_reco_client: CloudRecoService,
) -> None:
"""
It is possible to update a target.
"""
old_name = uuid.uuid4().hex
old_width = random.uniform(a=0.01, b=50)
target_id = vws_client.add_target(
name=old_name,
width=old_width,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
[matching_target] = cloud_reco_client.query(image=high_quality_image)
assert matching_target.target_id == target_id
query_target_data = matching_target.target_data
assert query_target_data is not None
query_metadata = query_target_data.application_metadata
assert query_metadata is None
new_name = uuid.uuid4().hex
new_width = random.uniform(a=0.01, b=50)
new_application_metadata = base64.b64encode(b'a').decode('ascii')
vws_client.update_target(
target_id=target_id,
name=new_name,
width=new_width,
active_flag=True,
image=different_high_quality_image,
application_metadata=new_application_metadata,
)
vws_client.wait_for_target_processed(target_id=target_id)
[
matching_target,
] = cloud_reco_client.query(image=different_high_quality_image)
assert matching_target.target_id == target_id
query_target_data = matching_target.target_data
assert query_target_data is not None
query_metadata = query_target_data.application_metadata
assert query_metadata == new_application_metadata
vws_client.update_target(
target_id=target_id,
active_flag=False,
)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.target_record.name == new_name
assert target_details.target_record.width == new_width
assert not target_details.target_record.active_flag
def test_width_valid(self, vws_client: VWS, target_id: str) -> None:
"""
Positive numbers are valid widths.
"""
vws_client.wait_for_target_processed(target_id=target_id)
width = 0.01
vws_client.update_target(target_id=target_id, width=width)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.target_record.width == width
def test_base_exception(
vws_client: VWS,
high_quality_image: io.BytesIO,
) -> None:
"""
``VWSException``s has a response property.
"""
with pytest.raises(VWSException) as exc:
vws_client.get_target_record(target_id='a')
assert exc.value.response.status_code == HTTPStatus.NOT_FOUND
vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
def test_name_valid(
self,
name: str,
target_id: str,
vws_client: VWS,
) -> None:
"""
A target's name must be a string of length 0 < N < 65.
We test characters out of range in another test as that gives a
different error.
"""
vws_client.wait_for_target_processed(target_id=target_id)
vws_client.update_target(target_id=target_id, name=name)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.target_record.name == name
def test_add_target(
self,
mock_database: VuforiaDatabase,
vws_client: VWS,
high_quality_image: io.BytesIO,
tmp_path: Path,
cloud_reco_client: CloudRecoService,
) -> None:
"""
It is possible to add a target.
"""
runner = CliRunner()
new_file = tmp_path / uuid.uuid4().hex
name = uuid.uuid4().hex
image_data = high_quality_image.getvalue()
new_file.write_bytes(data=image_data)
width = random.uniform(a=0.01, b=50)
commands = [
'add-target',
'--name',
name,
'--width',
str(width),
'--image',
str(new_file),
'--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
target_id = result.stdout.strip()
target_details = vws_client.get_target_record(target_id=target_id)
target_record = target_details.target_record
assert target_record.name == name
assert target_record.width == width
assert target_record.active_flag is True
vws_client.wait_for_target_processed(target_id=target_id)
[query_result] = cloud_reco_client.query(image=high_quality_image)
assert query_result.target_id == target_id
target_data = query_result.target_data
assert target_data is not None
assert target_data.application_metadata is None
def test_after_processing(
self,
vws_client: VWS,
request: SubRequest,
image_fixture_name: str,
expected_status: TargetStatuses,
) -> None:
"""
After processing is completed, the tracking rating is in the range of
0 to 5.
The documentation says:
> Note: tracking_rating and reco_rating are provided only when
> status = success.
However, this shows that ``tracking_rating`` is given when the status
is not success.
It also shows that ``reco_rating`` is not provided even when the status
is success.
"""
image_file = request.getfixturevalue(image_fixture_name)
target_id = vws_client.add_target(
name='example',
width=1,
image=image_file,
active_flag=True,
application_metadata=None,
)
# The tracking rating may change during processing.
# Therefore we wait until processing ends.
vws_client.wait_for_target_processed(target_id=target_id)
report = vws_client.get_target_summary_report(target_id=target_id)
target_details = vws_client.get_target_record(target_id=target_id)
tracking_rating = target_details.target_record.tracking_rating
assert report.tracking_rating == tracking_rating
assert report.tracking_rating in range(6)
assert report.status == expected_status
assert report.total_recos == 0
assert report.current_month_recos == 0
assert report.previous_month_recos == 0
def test_add_target(
self,
vws_client: VWS,
high_quality_image: io.BytesIO,
active_flag: bool,
application_metadata: Optional[bytes],
cloud_reco_client: CloudRecoService,
) -> None:
"""
No exception is raised when adding one target.
"""
name = 'x'
width = 1
if application_metadata is None:
encoded_metadata = None
else:
encoded_metadata_bytes = base64.b64encode(application_metadata)
encoded_metadata = encoded_metadata_bytes.decode('utf-8')
target_id = vws_client.add_target(
name=name,
width=width,
image=high_quality_image,
application_metadata=encoded_metadata,
active_flag=active_flag,
)
target_record = vws_client.get_target_record(
target_id=target_id,
).target_record
assert target_record.name == name
assert target_record.width == width
assert target_record.active_flag is active_flag
vws_client.wait_for_target_processed(target_id=target_id)
matching_targets = cloud_reco_client.query(image=high_quality_image)
if active_flag:
[matching_target] = matching_targets
assert matching_target.target_id == target_id
assert matching_target.target_data is not None
query_metadata = matching_target.target_data.application_metadata
assert query_metadata == encoded_metadata
else:
assert matching_targets == []
def test_fail_status(
self,
vws_client: VWS,
image_file_failed_state: io.BytesIO,
) -> None:
"""
When a 1x1 image is given, the status changes from 'processing' to
'failed' after some time.
"""
target_id = vws_client.add_target(
name='my_example_name',
width=1,
image=image_file_failed_state,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=target_id)
target_details = vws_client.get_target_record(target_id=target_id)
assert target_details.status == TargetStatuses.FAILED
# Tracking rating is 0 when status is 'failed'
assert target_details.target_record.tracking_rating == 0
def test_processing(
self,
high_quality_image: io.BytesIO,
vws_client: VWS,
) -> None:
"""
If a target is in the processing state, it can have duplicates.
Targets can have duplicates in the processing state.
"""
processed_target_id = vws_client.add_target(
name=uuid.uuid4().hex,
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
vws_client.wait_for_target_processed(target_id=processed_target_id)
processing_target_id = vws_client.add_target(
name=uuid.uuid4().hex,
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
duplicates = vws_client.get_duplicate_targets(
target_id=processed_target_id, )
assert duplicates == []
duplicates = vws_client.get_duplicate_targets(
target_id=processing_target_id, )
target_details = vws_client.get_target_record(
target_id=processing_target_id, )
assert target_details.status == TargetStatuses.PROCESSING
assert duplicates == [processed_target_id]
def get_target_record(
server_access_key: str,
server_secret_key: str,
target_id: str,
base_vws_url: str,
) -> None:
"""
Get a target record.
\b
See
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Retrieve-a-Target-Record.
"""
vws_client = VWS(
server_access_key=server_access_key,
server_secret_key=server_secret_key,
base_vws_url=base_vws_url,
)
record = vws_client.get_target_record(target_id=target_id).target_record
yaml_record = yaml.dump(dataclasses.asdict(record))
click.echo(yaml_record)
def test_custom_active_flag(
self,
mock_database: VuforiaDatabase,
vws_client: VWS,
high_quality_image: io.BytesIO,
tmp_path: Path,
active_flag_given: str,
active_flag_expected: bool,
) -> None:
"""
The Active Flag of the new target can be chosen.
"""
runner = CliRunner()
new_file = tmp_path / uuid.uuid4().hex
image_data = high_quality_image.getvalue()
new_file.write_bytes(data=image_data)
commands = [
'add-target',
'--name',
'foo',
'--width',
'0.1',
'--image',
str(new_file),
'--active-flag',
active_flag_given,
'--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
target_id = result.stdout.strip()
target_details = vws_client.get_target_record(target_id=target_id)
active_flag = target_details.target_record.active_flag
assert active_flag is active_flag_expected
def test_relative_path(
self,
mock_database: VuforiaDatabase,
vws_client: VWS,
high_quality_image: io.BytesIO,
tmp_path: Path,
) -> None:
"""
Image file paths are resolved.
"""
runner = CliRunner(mix_stderr=False)
new_filename = uuid.uuid4().hex
original_image_file = tmp_path / 'foo'
image_data = high_quality_image.getvalue()
original_image_file.write_bytes(image_data)
name = uuid.uuid4().hex
commands = [
'add-target',
'--name',
name,
'--width',
'1',
'--image',
new_filename,
'--server-access-key',
mock_database.server_access_key,
'--server-secret-key',
mock_database.server_secret_key,
]
with runner.isolated_filesystem():
new_file = Path(new_filename)
new_file.symlink_to(original_image_file)
result = runner.invoke(vws_group, commands, catch_exceptions=False)
assert result.exit_code == 0
target_id = result.stdout.strip()
target_record = vws_client.get_target_record(target_id=target_id)
assert target_record.target_record.name == name
def test_get_vws_target(
self,
vws_client: VWS,
image_file_failed_state: io.BytesIO,
) -> None:
"""
Details of a target are returned.
"""
name = 'my_example_name'
width = 1234
target_id = vws_client.add_target(
name=name,
width=width,
image=image_file_failed_state,
active_flag=False,
application_metadata=None,
)
target_details = vws_client.get_target_record(target_id=target_id)
target_record = target_details.target_record
tracking_rating = target_record.tracking_rating
# Tracking rating may be -1 while processing.
assert tracking_rating in range(-1, 6)
target_id = target_record.target_id
expected_target_record = TargetRecord(
target_id=target_id,
active_flag=False,
name=name,
width=width,
tracking_rating=tracking_rating,
reco_rating='',
)
assert target_record == expected_target_record
