def test_custom(
        self,
        high_quality_image: io.BytesIO,
        monkeypatch: MonkeyPatch,
    ) -> 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()
        databases_url = _EXAMPLE_URL_FOR_TARGET_MANAGER + '/databases'
        requests.post(url=databases_url, json=database.to_dict())
        monkeypatch.setenv(
            name='DELETION_PROCESSING_SECONDS',
            value=str(query_processes_deletion),
        )
        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
Пример #2
0
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
Пример #3
0
    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
Пример #4
0
 def test_default(self) -> None:
     """
     By default, the database has a random name.
     """
     database_details = VuforiaDatabase()
     other_database_details = VuforiaDatabase()
     assert (database_details.database_name !=
             other_database_details.database_name)
Пример #5
0
def _enable_use_docker_in_memory(
    working_database: VuforiaDatabase,
    inactive_database: VuforiaDatabase,
    monkeypatch: MonkeyPatch,
) -> Generator:
    # We set ``wsgi.input_terminated`` to ``True`` so that when going through
    # ``requests``, the Flask applications
    # have the given ``Content-Length`` headers and the given data in
    # ``request.headers`` and ``request.data``.
    #
    # We do not set these in the Flask application itself.
    # This is because when running the Flask application, if this is set,
    # reading ``request.data`` hangs.
    #
    # Therefore, when running the real Flask application, the behavior is not
    # the same as the real Vuforia.
    # This is documented as a difference in the documentation for this package.
    VWS_FLASK_APP.config['TERMINATE_WSGI_INPUT'] = True
    CLOUDRECO_FLASK_APP.config['TERMINATE_WSGI_INPUT'] = True

    target_manager_base_url = 'http://example.com'
    monkeypatch.setenv(
        name='TARGET_MANAGER_BASE_URL',
        value=target_manager_base_url,
    )

    with requests_mock.Mocker(real_http=False) as mock:
        add_flask_app_to_mock(
            mock_obj=mock,
            flask_app=VWS_FLASK_APP,
            base_url='https://vws.vuforia.com',
        )

        add_flask_app_to_mock(
            mock_obj=mock,
            flask_app=CLOUDRECO_FLASK_APP,
            base_url='https://cloudreco.vuforia.com',
        )

        add_flask_app_to_mock(
            mock_obj=mock,
            flask_app=TARGET_MANAGER_FLASK_APP,
            base_url=target_manager_base_url,
        )

        databases_url = target_manager_base_url + '/databases'
        databases = requests.get(url=databases_url).json()
        for database in databases:
            database_name = database['database_name']
            requests.delete(url=databases_url + '/' + database_name)

        requests.post(url=databases_url, json=working_database.to_dict())
        requests.post(url=databases_url, json=inactive_database.to_dict())

        yield
Пример #6
0
    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,
            )
Пример #7
0
    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
Пример #8
0
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 == ''
Пример #9
0
    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
Пример #10
0
    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
Пример #11
0
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
Пример #12
0
    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
Пример #13
0
def fixture_mock_database() -> Iterator[VuforiaDatabase]:
    """
    Yield a mock ``VuforiaDatabase``.
    """
    with MockVWS() as mock:
        database = VuforiaDatabase()
        mock.add_database(database=database)
        yield database
Пример #14
0
    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
Пример #15
0
    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_default(
        self,
        image_file_failed_state: io.BytesIO,
    ) -> None:
        """
        By default, targets in the mock take 0.5 seconds to be processed.
        """
        database = VuforiaDatabase()
        databases_url = _EXAMPLE_URL_FOR_TARGET_MANAGER + '/databases'
        requests.post(url=databases_url, json=database.to_dict())

        time_taken = processing_time_seconds(
            vuforia_database=database,
            image=image_file_failed_state,
        )

        expected = 0.5
        assert abs(expected - time_taken) < self.LEEWAY
Пример #17
0
    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
Пример #18
0
def get_all_databases() -> Set[VuforiaDatabase]:
    """
    Get all database objects from the task manager back-end.
    """
    target_manager_base_url = os.environ['TARGET_MANAGER_BASE_URL']
    response = requests.get(url=f'{target_manager_base_url}/databases')
    return {
        VuforiaDatabase.from_dict(database_dict=database_dict)
        for database_dict in response.json()
    }
    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".')

        databases_url = _EXAMPLE_URL_FOR_TARGET_MANAGER + '/databases'
        requests.post(url=databases_url, json=database.to_dict())

        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),
        ):
            response = requests.post(
                url=databases_url,
                json=bad_database.to_dict(),
            )

            assert response.status_code == HTTPStatus.CONFLICT
            assert response.text == expected_message
    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()
        databases_url = _EXAMPLE_URL_FOR_TARGET_MANAGER + '/databases'
        requests.post(url=databases_url, json=database.to_dict())
        time_taken = process_deletion_seconds(
            high_quality_image=high_quality_image,
            vuforia_database=database,
        )

        expected = 3
        assert abs(expected - time_taken) < self.LEEWAY
Пример #21
0
def vuforia_database() -> VuforiaDatabase:
    """
    Return VWS credentials from environment variables.
    """
    credentials: VuforiaDatabase = VuforiaDatabase(
        database_name=os.environ['VUFORIA_TARGET_MANAGER_DATABASE_NAME'],
        server_access_key=os.environ['VUFORIA_SERVER_ACCESS_KEY'],
        server_secret_key=os.environ['VUFORIA_SERVER_SECRET_KEY'],
        client_access_key=os.environ['VUFORIA_CLIENT_ACCESS_KEY'],
        client_secret_key=os.environ['VUFORIA_CLIENT_SECRET_KEY'],
        state=States.WORKING,
    )
    return credentials
Пример #22
0
    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_custom(
        self,
        image_file_failed_state: io.BytesIO,
        monkeypatch: MonkeyPatch,
    ) -> None:
        """
        It is possible to set a custom processing time.
        """
        monkeypatch.setenv(
            name='PROCESSING_TIME_SECONDS',
            value='0.1',
        )
        database = VuforiaDatabase()
        databases_url = _EXAMPLE_URL_FOR_TARGET_MANAGER + '/databases'
        requests.post(url=databases_url, json=database.to_dict())

        time_taken = processing_time_seconds(
            vuforia_database=database,
            image=image_file_failed_state,
        )

        expected = 0.1
        assert abs(expected - time_taken) < self.LEEWAY
Пример #24
0
    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
Пример #25
0
    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
Пример #26
0
def inactive_database() -> VuforiaDatabase:
    """
    Return VWS credentials for an inactive project from environment variables.
    """
    credentials: VuforiaDatabase = VuforiaDatabase(
        database_name=os.environ[
            'INACTIVE_VUFORIA_TARGET_MANAGER_DATABASE_NAME'
        ],
        server_access_key=os.environ['INACTIVE_VUFORIA_SERVER_ACCESS_KEY'],
        server_secret_key=os.environ['INACTIVE_VUFORIA_SERVER_SECRET_KEY'],
        client_access_key=os.environ['INACTIVE_VUFORIA_CLIENT_ACCESS_KEY'],
        client_secret_key=os.environ['INACTIVE_VUFORIA_CLIENT_SECRET_KEY'],
        state=States.PROJECT_INACTIVE,
    )
    return credentials
Пример #27
0
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
Пример #28
0
    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_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_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