def test_deleted_existing_target_name(
self,
image_file_failed_state: io.BytesIO,
vuforia_database: VuforiaDatabase,
vws_client: VWS,
) -> None:
"""
A target can be added with the name of a deleted target.
"""
image_data = image_file_failed_state.read()
image_data_encoded = base64.b64encode(image_data).decode('ascii')
data = {
'name': 'example_name',
'width': 1,
'image': image_data_encoded,
}
response = add_target_to_vws(
vuforia_database=vuforia_database,
data=data,
)
target_id = response.json()['target_id']
vws_client.wait_for_target_processed(target_id=target_id)
vws_client.delete_target(target_id=target_id)
response = add_target_to_vws(
vuforia_database=vuforia_database,
data=data,
)
assert_success(response=response)
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_not_real_id(
self,
vws_client: VWS,
endpoint: Endpoint,
target_id: str,
) -> None:
"""
A `NOT_FOUND` error is returned when an endpoint is given a target ID
of a target which does not exist.
"""
if not endpoint.prepared_request.path_url.endswith(target_id):
return
vws_client.wait_for_target_processed(target_id=target_id)
vws_client.delete_target(target_id=target_id)
session = requests.Session()
response = session.send( # type: ignore
request=endpoint.prepared_request,
)
assert_vws_failure(
response=response,
status_code=HTTPStatus.NOT_FOUND,
result_code=ResultCodes.UNKNOWN_TARGET,
)
def _delete_all_targets(database_keys: VuforiaDatabase) -> None:
"""
Delete all targets.
Args:
database_keys: The credentials to the Vuforia target database to delete
all targets in.
"""
vws_client = VWS(
server_access_key=database_keys.server_access_key,
server_secret_key=database_keys.server_secret_key,
)
targets = vws_client.list_targets()
for target in targets:
vws_client.wait_for_target_processed(target_id=target)
# Even deleted targets can be matched by a query for a few seconds so
# we change the target to inactive before deleting it.
try:
vws_client.update_target(target_id=target, active_flag=False)
except TargetStatusNotSuccess:
pass
vws_client.wait_for_target_processed(target_id=target)
vws_client.delete_target(target_id=target)
def test_deleted(
self,
image_file_failed_state: io.BytesIO,
vws_client: VWS,
) -> None:
"""
Deleted targets are not shown in the summary.
"""
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=target_id)
vws_client.delete_target(target_id=target_id)
_wait_for_image_numbers(
vws_client=vws_client,
active_images=0,
inactive_images=0,
failed_images=0,
processing_images=0,
)
def test_invalid_given_id(vws_client: VWS) -> None:
"""
Giving an invalid ID to a helper which requires a target ID to be given
causes an ``UnknownTarget`` exception to be raised.
"""
target_id = '12345abc'
with pytest.raises(UnknownTarget) as exc:
vws_client.delete_target(target_id=target_id)
assert exc.value.response.status_code == HTTPStatus.NOT_FOUND
assert exc.value.target_id == target_id
def test_deleted(
self,
vws_client: VWS,
target_id: str,
) -> None:
"""
Deleted targets are not returned in the list.
"""
vws_client.wait_for_target_processed(target_id=target_id)
vws_client.delete_target(target_id=target_id)
assert vws_client.list_targets() == []
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_inactive_project(
self,
inactive_vws_client: VWS,
) -> None:
"""
If the project is inactive, a FORBIDDEN response is returned.
"""
target_id = 'abc12345a'
with pytest.raises(ProjectInactive) as exc:
inactive_vws_client.delete_target(target_id=target_id)
assert_vws_failure(
response=exc.value.response,
status_code=HTTPStatus.FORBIDDEN,
result_code=ResultCodes.PROJECT_INACTIVE,
)
def test_active_matching_targets_delete_processing(
mock_database: VuforiaDatabase,
tmp_path: Path,
high_quality_image: io.BytesIO,
vws_client: VWS,
) -> None:
"""
An error is given when the image matches a target which has recently been
deleted.
"""
runner = CliRunner(mix_stderr=False)
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)
vws_client.delete_target(target_id=target_id)
time.sleep(0.2)
new_file = tmp_path / uuid.uuid4().hex
image_data = high_quality_image.getvalue()
new_file.write_bytes(data=image_data)
commands: list[str] = [
str(new_file),
'--client-access-key',
mock_database.client_access_key,
'--client-secret-key',
mock_database.client_secret_key,
]
result = runner.invoke(
vuforia_cloud_reco,
commands,
catch_exceptions=False,
)
expected_stderr = (
'Error: The given image matches a target which was recently deleted.\n'
)
assert result.stderr == expected_stderr
assert result.stdout == ''
def test_delete_target(
self,
vws_client: VWS,
high_quality_image: io.BytesIO,
) -> None:
"""
It is possible to delete a target.
"""
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)
assert target_id in vws_client.list_targets()
vws_client.delete_target(target_id=target_id)
assert target_id not in vws_client.list_targets()
def delete_target(
server_access_key: str,
server_secret_key: str,
target_id: str,
base_vws_url: str,
) -> None:
"""
Delete a target.
\b
See
https://library.vuforia.com/articles/Solution/How-To-Use-the-Vuforia-Web-Services-API.html#How-To-Delete-a-Target.
"""
vws_client = VWS(
server_access_key=server_access_key,
server_secret_key=server_secret_key,
base_vws_url=base_vws_url,
)
vws_client.delete_target(target_id=target_id)
def _add_and_delete_target(
image: io.BytesIO,
vuforia_database: VuforiaDatabase,
) -> None:
"""
Add and delete a target with the given image.
"""
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_name',
width=1,
image=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)
def test_target_status_processing(
vws_client: VWS,
high_quality_image: io.BytesIO,
) -> None:
"""
A ``TargetStatusProcessing`` exception is raised if trying to delete a
target which is processing.
"""
target_id = vws_client.add_target(
name='x',
width=1,
image=high_quality_image,
active_flag=True,
application_metadata=None,
)
with pytest.raises(TargetStatusProcessing) as exc:
vws_client.delete_target(target_id=target_id)
assert exc.value.response.status_code == HTTPStatus.FORBIDDEN
assert exc.value.target_id == target_id
def test_active_matching_targets_delete_processing(
vws_client: VWS,
cloud_reco_client: CloudRecoService,
high_quality_image: io.BytesIO,
) -> None:
"""
A ``ActiveMatchingTargetsDeleteProcessing`` exception is raised when a
target which has recently been deleted is matched.
"""
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)
vws_client.delete_target(target_id=target_id)
time.sleep(0.2)
with pytest.raises(ActiveMatchingTargetsDeleteProcessing):
cloud_reco_client.query(image=high_quality_image)
def test_no_wait(
self,
target_id: str,
vws_client: VWS,
) -> None:
"""
When attempting to delete a target immediately after creating it, a
`FORBIDDEN` response is returned.
This is because the target goes into a processing state.
There is a race condition here - if the target goes into a success or
fail state before the deletion attempt.
"""
with pytest.raises(TargetStatusProcessing) as exc:
vws_client.delete_target(target_id=target_id)
assert_vws_failure(
response=exc.value.response,
status_code=HTTPStatus.FORBIDDEN,
result_code=ResultCodes.TARGET_STATUS_PROCESSING,
)
