Use verify_mock_vuforia on TestTargetStatusNotSuccess

tests/mock_vws/fixtures/credentials.py

@@ -2,8 +2,10 @@
 
 from dataclasses import dataclass, field
 from pathlib import Path
+from uuid import uuid4
 
 import pytest
+from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from mock_vws.database import CloudDatabase
@@ -43,6 +45,7 @@ class _VuMarkCloudDatabaseSettings(BaseSettings):
     server_access_key: str
     server_secret_key: str
     target_id: str
+    processing_target_id: str = Field(default_factory=lambda: uuid4().hex)
 
     model_config = SettingsConfigDict(
         env_prefix="VUMARK_VUFORIA_",
@@ -59,6 +62,7 @@ class VuMarkCloudDatabase:
     server_access_key: str = field(repr=False)
     server_secret_key: str = field(repr=False)
     target_id: str = field(repr=False)
+    processing_target_id: str = field(repr=False)
 
 
 @pytest.fixture
@@ -102,4 +106,5 @@ def vumark_vuforia_database() -> VuMarkCloudDatabase:
         server_access_key=settings.server_access_key,
         server_secret_key=settings.server_secret_key,
         target_id=settings.target_id,
+        processing_target_id=settings.processing_target_id,
     )

tests/mock_vws/fixtures/vuforia_backends.py

@@ -72,11 +72,16 @@ def _vumark_database(
         name="mock-vumark-target",
         target_id=vumark_vuforia_database.target_id,
     )
+    processing_target = VuMarkTarget(
+        name="mock-processing-vumark-target",
+        target_id=vumark_vuforia_database.processing_target_id,
+        processing_time_seconds=9999,
+    )
     return VuMarkDatabase(
         database_name=vumark_vuforia_database.target_manager_database_name,
         server_access_key=vumark_vuforia_database.server_access_key,
         server_secret_key=vumark_vuforia_database.server_secret_key,
-        vumark_targets={vumark_target},
+        vumark_targets={vumark_target, processing_target},
     )
 
 
@@ -165,7 +170,6 @@ def _enable_use_docker_in_memory(
     vumark_database = _vumark_database(
         vumark_vuforia_database=vumark_vuforia_database,
     )
-    (vumark_target,) = vumark_database.vumark_targets
 
     with responses.RequestsMock(assert_all_requests_are_fired=False) as mock:
         add_flask_app_to_mock(
@@ -219,14 +223,15 @@ def _enable_use_docker_in_memory(
             json=vumark_database.to_dict(),
             timeout=30,
         )
-        requests.post(
-            url=(
-                f"{vumark_databases_url}"
-                f"/{vumark_database.database_name}/vumark_targets"
-            ),
-            json=vumark_target.to_dict(),
-            timeout=30,
-        )
+        for vumark_target in vumark_database.vumark_targets:
+            requests.post(
+                url=(
+                    f"{vumark_databases_url}"
+                    f"/{vumark_database.database_name}/vumark_targets"
+                ),
+                json=vumark_target.to_dict(),
+                timeout=30,
+            )
 
         yield
 

tests/mock_vws/test_vumark_generation_api.py

@@ -16,10 +16,8 @@
 from vws.vumark_accept import VuMarkAccept
 from vws_auth_tools import authorization_header, rfc_1123_date
 
-from mock_vws import MockVWS
 from mock_vws._constants import ResultCodes
-from mock_vws.database import CloudDatabase, VuMarkDatabase
-from mock_vws.target import VuMarkTarget
+from mock_vws.database import CloudDatabase
 from tests.mock_vws.fixtures.credentials import VuMarkCloudDatabase
 from tests.mock_vws.utils import make_image_file
 
@@ -263,98 +261,83 @@ def test_non_vumark_database(
             == ResultCodes.INVALID_TARGET_TYPE.value
         )
 
+    @staticmethod
+    def test_successful_target(
+        vumark_vuforia_database: VuMarkCloudDatabase,
+    ) -> None:
+        """A VuMark target that has finished processing succeeds."""
+        vumark_client = _make_vumark_service(
+            server_access_key=vumark_vuforia_database.server_access_key,
+            server_secret_key=vumark_vuforia_database.server_secret_key,
+        )
+        vumark_bytes = vumark_client.generate_vumark_instance(
+            target_id=vumark_vuforia_database.target_id,
+            instance_id=uuid4().hex,
+            accept=VuMarkAccept.PNG,
+        )
+
+        assert vumark_bytes.strip().startswith(_PNG_SIGNATURE)
+
 
-class TestTargetStatusNotSuccess:
-    """Tests for VuMark generation when the target is not in success
-    state.
+# VuMark targets cannot be added via the VWS API — they are configured
+# through the Vuforia Target Manager portal.  This means we cannot
+# create a target that is perpetually in PROCESSING state against real
+# Vuforia.  The mock controls processing time via the
+# ``processing_time_seconds`` attribute on ``VuMarkTarget``, so these
+# tests are inherently mock-only.
+@pytest.mark.usefixtures("mock_only_vuforia")
+class TestProcessingTarget:
+    """Tests for VuMark generation when the target is still processing.
+
+    These use ``mock_only_vuforia`` because there is no way to keep a
+    VuMark target in PROCESSING state indefinitely on real Vuforia.
     """
 
     @staticmethod
-    def test_processing_target() -> None:
+    def test_processing_target(
+        vumark_vuforia_database: VuMarkCloudDatabase,
+    ) -> None:
         """A VuMark target still processing returns
         TargetStatusNotSuccess.
         """
-        vumark_target = VuMarkTarget(
-            name="processing-target",
-            processing_time_seconds=9999,
-        )
-        vumark_database = VuMarkDatabase(
-            vumark_targets={vumark_target},
-        )
         vumark_client = _make_vumark_service(
-            server_access_key=vumark_database.server_access_key,
-            server_secret_key=vumark_database.server_secret_key,
+            server_access_key=vumark_vuforia_database.server_access_key,
+            server_secret_key=vumark_vuforia_database.server_secret_key,
         )
-
-        with MockVWS() as mock:
-            mock.add_vumark_database(vumark_database=vumark_database)
-            with pytest.raises(
-                expected_exception=TargetStatusNotSuccessError,
-            ) as exc:
-                vumark_client.generate_vumark_instance(
-                    target_id=vumark_target.target_id,
-                    instance_id=uuid4().hex,
-                    accept=VuMarkAccept.PNG,
-                )
-
-            assert exc.value.response.status_code == HTTPStatus.FORBIDDEN
-            response_json = json.loads(s=exc.value.response.text)
-            assert (
-                response_json["result_code"]
-                == ResultCodes.TARGET_STATUS_NOT_SUCCESS.value
+        with pytest.raises(
+            expected_exception=TargetStatusNotSuccessError,
+        ) as exc:
+            vumark_client.generate_vumark_instance(
+                target_id=vumark_vuforia_database.processing_target_id,
+                instance_id=uuid4().hex,
+                accept=VuMarkAccept.PNG,
             )
 
+        assert exc.value.response.status_code == HTTPStatus.FORBIDDEN
+        response_json = json.loads(s=exc.value.response.text)
+        assert (
+            response_json["result_code"]
+            == ResultCodes.TARGET_STATUS_NOT_SUCCESS.value
+        )
+
     @staticmethod
-    def test_processing_target_raw_response() -> None:
+    def test_processing_target_raw_response(
+        vumark_vuforia_database: VuMarkCloudDatabase,
+    ) -> None:
         """The raw HTTP response for a processing target has the expected
         status code and result code.
         """
-        vumark_target = VuMarkTarget(
-            name="processing-target",
-            processing_time_seconds=9999,
-        )
-        vumark_database = VuMarkDatabase(
-            vumark_targets={vumark_target},
+        response = _make_vumark_request(
+            server_access_key=vumark_vuforia_database.server_access_key,
+            server_secret_key=vumark_vuforia_database.server_secret_key,
+            target_id=vumark_vuforia_database.processing_target_id,
+            instance_id=uuid4().hex,
+            accept="image/png",
         )
 
-        with MockVWS() as mock:
-            mock.add_vumark_database(vumark_database=vumark_database)
-            response = _make_vumark_request(
-                server_access_key=vumark_database.server_access_key,
-                server_secret_key=vumark_database.server_secret_key,
-                target_id=vumark_target.target_id,
-                instance_id=uuid4().hex,
-                accept="image/png",
-            )
-
         assert response.status_code == HTTPStatus.FORBIDDEN
         response_json = response.json()
         assert (
             response_json["result_code"]
             == ResultCodes.TARGET_STATUS_NOT_SUCCESS.value
         )
-
-    @staticmethod
-    def test_successful_target() -> None:
-        """A VuMark target that has finished processing succeeds."""
-        vumark_target = VuMarkTarget(
-            name="ready-target",
-            processing_time_seconds=0,
-        )
-        vumark_database = VuMarkDatabase(
-            vumark_targets={vumark_target},
-        )
-        vumark_client = _make_vumark_service(
-            server_access_key=vumark_database.server_access_key,
-            server_secret_key=vumark_database.server_secret_key,
-        )
-
-        with MockVWS() as mock:
-            mock.add_vumark_database(vumark_database=vumark_database)
-            vumark_bytes = vumark_client.generate_vumark_instance(
-                target_id=vumark_target.target_id,
-                instance_id=uuid4().hex,
-                accept=VuMarkAccept.PNG,
-            )
-
-        assert vumark_bytes.strip().startswith(_PNG_SIGNATURE)