Merge pull request #673 from adamtheturtle/corrupted-test-add

Add proper tests for image too large

Author: adamtheturtle

src/mock_vws/_validators.py

@@ -688,8 +688,6 @@ def validate_image_size(
         The result of calling the endpoint.
         An `UNPROCESSABLE_ENTITY` response if the image is given and is not
         under a certain file size threshold.
-        This threshold is documented as being 2 MB but it is actually
-        slightly larger. See the `png_large` fixture for more details.
     """
     request, context = args
 

tests/mock_vws/fixtures/images.py

@@ -50,28 +50,6 @@ def png_greyscale() -> io.BytesIO:
     )
 
 
-@pytest.fixture()
-def png_large(
-    png_rgb: io.BytesIO,  # pylint: disable=redefined-outer-name
-) -> io.BytesIO:
-    """
-    Return a PNG file of the maximum allowed file size.
-
-    https://library.vuforia.com/articles/Training/Cloud-Recognition-Guide
-    describes that the maximum allowed file size of an image is 2 MB.
-    However, tests using this fixture demonstrate that the maximum allowed
-    size is actually slightly greater than that.
-    """
-    png_size = len(png_rgb.getbuffer())
-    max_size = 2359293
-    filler_length = max_size - png_size
-    filler_data = b'\x00' * int(filler_length)
-    original_data = png_rgb.getvalue()
-    longer_data = original_data.replace(b'IEND', filler_data + b'IEND')
-    png = io.BytesIO(longer_data)
-    return png
-
-
 @pytest.fixture
 def jpeg_cmyk() -> io.BytesIO:
     """
@@ -114,7 +92,7 @@ def tiff_rgb() -> io.BytesIO:
     )
 
 
-@pytest.fixture(params=['png_rgb', 'jpeg_rgb', 'png_greyscale', 'png_large'])
+@pytest.fixture(params=['png_rgb', 'jpeg_rgb', 'png_greyscale'])
 def image_file(request: SubRequest) -> io.BytesIO:
     """
     Return an image file which is expected to work on Vuforia.

tests/mock_vws/test_add_target.py

@@ -15,6 +15,7 @@
 from tests.mock_vws.utils import (
     add_target_to_vws,
     delete_target,
+    make_image_file,
     wait_for_target_processed,
 )
 from tests.mock_vws.utils.assertions import (
@@ -388,10 +389,7 @@ def test_image_valid(
     ) -> None:
         """
         JPEG and PNG files in the RGB and greyscale color spaces are
-        allowed. The image must be under a threshold.
-
-        This threshold is documented as being 2 MB but it is actually
-        slightly larger. See the `png_large` fixture for more details.
+        allowed.
         """
         image_data = image_file.read()
         image_data_encoded = base64.b64encode(image_data).decode('ascii')
@@ -468,24 +466,33 @@ def test_corrupted(
 
         assert_success(response=response)
 
-    def test_too_large_and_corrupted(
+    def test_image_too_large(
         self,
         vuforia_database_keys: VuforiaDatabaseKeys,
-        png_large: io.BytesIO,
     ) -> None:
         """
         An `ImageTooLarge` result is returned if the image is above a certain
-        threshold and is corrupted.
-
-        This threshold is documented as being 2 MB but it is actually
-        slightly larger. See the `png_large` fixture for more details.
+        threshold.
         """
-        original_data = png_large.getvalue()
-        longer_data = original_data.replace(b'IEND', b'\x00' + b'IEND')
-        too_large_file = io.BytesIO(longer_data)
+        max_bytes = 2.3 * 1024 * 1024
+        width = height = 886
+        png_not_too_large = make_image_file(
+            file_format='PNG',
+            color_space='RGB',
+            width=width,
+            height=height,
+        )
 
-        image_data = too_large_file.read()
+        image_data = png_not_too_large.read()
         image_data_encoded = base64.b64encode(image_data).decode('ascii')
+        image_content_size = len(image_data)
+        # We check that the image we created is just slightly smaller than the
+        # maximum file size.
+        #
+        # This is just because of the implementation details of
+        # ``max_image_file``.
+        assert image_content_size < max_bytes
+        assert (image_content_size * 1.05) > max_bytes
 
         data = {
             'name': 'example_name',
@@ -498,6 +505,39 @@ def test_too_large_and_corrupted(
             data=data,
         )
 
+        assert_success(response=response)
+
+        width = width + 1
+        height = height + 1
+        png_too_large = make_image_file(
+            file_format='PNG',
+            color_space='RGB',
+            width=width,
+            height=height,
+        )
+
+        image_data = png_too_large.read()
+        image_data_encoded = base64.b64encode(image_data).decode('ascii')
+        image_content_size = len(image_data)
+        # We check that the image we created is just slightly smaller than the
+        # maximum file size.
+        #
+        # This is just because of the implementation details of
+        # ``max_image_file``.
+        assert image_content_size < max_bytes
+        assert (image_content_size * 1.05) > max_bytes
+
+        data = {
+            'name': 'example_name_2',
+            'width': 1,
+            'image': image_data_encoded,
+        }
+
+        response = add_target_to_vws(
+            vuforia_database_keys=vuforia_database_keys,
+            data=data,
+        )
+
         assert_vws_failure(
             response=response,
             status_code=codes.UNPROCESSABLE_ENTITY,

tests/mock_vws/test_update_target.py

@@ -15,6 +15,7 @@
 from tests.mock_vws.utils import (
     add_target_to_vws,
     get_vws_target,
+    make_image_file,
     update_target,
     wait_for_target_processed,
 )
@@ -710,9 +711,6 @@ def test_image_valid(
         """
         JPEG and PNG files in the RGB and greyscale color spaces are
         allowed. The image must be under a threshold.
-
-        This threshold is documented as being 2 MB but it is actually
-        slightly larger. See the `png_large` fixture for more details.
         """
         image_data = image_file.read()
         image_data_encoded = base64.b64encode(image_data).decode('ascii')
@@ -796,31 +794,77 @@ def test_corrupted(
             result_code=ResultCodes.SUCCESS,
         )
 
-    def test_too_large_and_corrupted(
+    def test_image_too_large(
         self,
         vuforia_database_keys: VuforiaDatabaseKeys,
-        png_large: io.BytesIO,
         target_id: str,
     ) -> None:
         """
         An `ImageTooLarge` result is returned if the image is above a certain
-        threshold and is corrupted.
-
-        This threshold is documented as being 2 MB but it is actually
-        slightly larger. See the `png_large` fixture for more details.
+        threshold.
         """
-        original_data = png_large.getvalue()
-        longer_data = original_data.replace(b'IEND', b'\x00' + b'IEND')
-        too_large_file = io.BytesIO(longer_data)
+        max_bytes = 2.3 * 1024 * 1024
+        width = height = 886
+        png_not_too_large = make_image_file(
+            file_format='PNG',
+            color_space='RGB',
+            width=width,
+            height=height,
+        )
+
+        wait_for_target_processed(
+            vuforia_database_keys=vuforia_database_keys,
+            target_id=target_id,
+        )
 
-        image_data = too_large_file.read()
+        image_data = png_not_too_large.read()
         image_data_encoded = base64.b64encode(image_data).decode('ascii')
+        image_content_size = len(image_data)
+        # We check that the image we created is just slightly smaller than the
+        # maximum file size.
+        #
+        # This is just because of the implementation details of
+        # ``max_image_file``.
+        assert image_content_size < max_bytes
+        assert (image_content_size * 1.05) > max_bytes
+
+        response = update_target(
+            vuforia_database_keys=vuforia_database_keys,
+            data={'image': image_data_encoded},
+            target_id=target_id,
+        )
+
+        assert_vws_response(
+            response=response,
+            status_code=codes.OK,
+            result_code=ResultCodes.SUCCESS,
+        )
 
         wait_for_target_processed(
             vuforia_database_keys=vuforia_database_keys,
             target_id=target_id,
         )
 
+        width = width + 1
+        height = height + 1
+        png_too_large = make_image_file(
+            file_format='PNG',
+            color_space='RGB',
+            width=width,
+            height=height,
+        )
+
+        image_data = png_too_large.read()
+        image_data_encoded = base64.b64encode(image_data).decode('ascii')
+        image_content_size = len(image_data)
+        # We check that the image we created is just slightly smaller than the
+        # maximum file size.
+        #
+        # This is just because of the implementation details of
+        # ``max_image_file``.
+        assert image_content_size < max_bytes
+        assert (image_content_size * 1.05) > max_bytes
+
         response = update_target(
             vuforia_database_keys=vuforia_database_keys,
             data={'image': image_data_encoded},