Only test a limited number of image files

Author: adamtheturtle

pyproject.toml

@@ -141,6 +141,7 @@ warn_untyped_fields = true
 
 module = [
     "brisque",
+    "cv2",
     "docker",
     "docker.errors",
     "docker.models.networks",
@@ -252,6 +253,7 @@ requires-python = ">=3.10"
 dependencies = [
     "Pillow",
     "brisque",
+    "opencv-python",
     "flask",
     "multipart",
     "numpy",

src/mock_vws/target.py

@@ -55,6 +55,12 @@ def _time_now() -> datetime.datetime:
 
 def _quality(image_content: bytes) -> int:
     """
+    Get a quality score for an image.
+
+    This is a rough approximation of the quality score used by Vuforia, but
+    is not accurate. For example, our "corrupted_image" fixture is rated as -2
+    by Vuforia, but is rated as 0 by this function.
+
     Args:
         image_content: The image content.
 
@@ -65,15 +71,15 @@ def _quality(image_content: bytes) -> int:
     image = Image.open(fp=image_file)
     image_array = np.asarray(a=image)
     obj = brisque.BRISQUE(url=False)
-    min_height = min_width = 2
-    if image.height < min_height or image.width < min_width:
-        return -2
     # We avoid a barrage of warnings from the BRISQUE library.
     with np.errstate(divide="ignore", invalid="ignore"):
-        score = obj.score(img=image_array)
+        try:
+            score = obj.score(img=image_array)
+        except cv2.error:  # pylint: disable=no-member
+            return 0
     if math.isnan(score):
         return 0
-    return min(int(score / 5), 5)
+    return int(score / 20)
 
 
 @dataclass(frozen=True, eq=True)
@@ -172,14 +178,7 @@ def tracking_rating(self) -> int:
         if time_since_upload <= pre_rating_time:
             return -1
 
-        try:
-            return _quality(image_content=self.image_value)
-        except cv2.error as exc:
-            breakpoint()
-            print(exc)
-            return -2
-        else:
-            return 0
+        return _quality(image_content=self.image_value)
 
     @classmethod
     def from_dict(cls, target_dict: TargetDict) -> Target:

tests/mock_vws/test_get_target.py

@@ -6,7 +6,6 @@
 from __future__ import annotations
 
 import uuid
-from enum import Enum, auto
 from typing import TYPE_CHECKING
 
 import pytest
@@ -120,73 +119,60 @@ def test_success_status(
         assert new_tracking_rating == tracking_rating
 
 
+def _get_target_tracking_rating(
+    vws_client: VWS,
+    image_file: io.BytesIO,
+) -> int:
+    """
+    Get the tracking rating of a target.
+    """
+    target_id = vws_client.add_target(
+        name=f"example_{uuid.uuid4().hex}",
+        width=1,
+        image=image_file,
+        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)
+    return target_details.target_record.tracking_rating
+
+
 @pytest.mark.usefixtures("verify_mock_vuforia")
 class TestTargetTrackingRating:
     """
-    Tests which exercise the target tracking_rating, and check the image fixtures we
-    use.
+    Tests which exercise the target tracking_rating, and check the image
+    fixtures we use.
     """
 
     @staticmethod
-    # We use almost all of the image fixtures here.
-    # We do not use images which we expect to fail to upload (`png_too_large`, `bad_image_file`).
     def test_target_quality(
         vws_client: VWS,
         high_quality_image: io.BytesIO,
-        image_file_failed_state: io.BytesIO,
         image_file_success_state_low_rating: io.BytesIO,
         corrupted_image_file: io.BytesIO,
-        different_high_quality_image: io.BytesIO,
     ) -> None:
         """
         The target tracking rating is as expected.
         """
-
-        class TrackingRating(Enum):
-            ZERO = auto()
-            NEGATIVE = auto()
-            POSITIVE = auto()
-
-        target_id_expected_rating_pairs = []
-        for image_file in (
-            high_quality_image,
-            image_file_failed_state,
-            # image_file_success_state_low_rating,
-            corrupted_image_file,
-            # different_high_quality_image,
-        ):
-            target_id = vws_client.add_target(
-                name=f"example_{uuid.uuid4().hex}",
-                width=1,
-                image=image_file,
-                active_flag=True,
-                application_metadata=None,
-            )
-
-            expected_tracking_rating = {
-                high_quality_image: TrackingRating.POSITIVE,
-                image_file_failed_state: TrackingRating.ZERO,
-                image_file_success_state_low_rating: TrackingRating.ZERO,
-                corrupted_image_file: TrackingRating.NEGATIVE,
-                different_high_quality_image: TrackingRating.ZERO,
-            }[image_file]
-            target_id_expected_rating_pairs.append(
-                (target_id, expected_tracking_rating),
-            )
-
-        for (
-            target_id,
-            expected_tracking_rating,
-        ) in target_id_expected_rating_pairs:
-            vws_client.wait_for_target_processed(target_id=target_id)
-
-            target_details = vws_client.get_target_record(target_id=target_id)
-            if expected_tracking_rating == TrackingRating.ZERO:
-                assert target_details.target_record.tracking_rating == 0
-            elif expected_tracking_rating == TrackingRating.NEGATIVE:
-                assert target_details.target_record.tracking_rating < 0
-            else:
-                assert target_details.target_record.tracking_rating > 0
+        high_quality_image_tracking_rating = _get_target_tracking_rating(
+            vws_client=vws_client,
+            image_file=high_quality_image,
+        )
+        low_quality_image_tracking_rating = _get_target_tracking_rating(
+            vws_client=vws_client,
+            image_file=image_file_success_state_low_rating,
+        )
+        corrupted_image_file_tracking_rating = _get_target_tracking_rating(
+            vws_client=vws_client,
+            image_file=corrupted_image_file,
+        )
+        assert (
+            high_quality_image_tracking_rating
+            > low_quality_image_tracking_rating
+            >= corrupted_image_file_tracking_rating
+        )
 
 
 @pytest.mark.usefixtures("verify_mock_vuforia")