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