Merge pull request #1384 from VWS-Python/conn-error

Update exception handling to match the latest reality - mostly around how the query endpoint handles matching deleted targets

Author: adamtheturtle

CHANGELOG.rst

@@ -6,14 +6,8 @@ Changelog
 Next
 ----
 
-2020.09.28.0
-------------
-
-2020.09.25.0
-------------
-
-2020.09.08.0
-------------
+* Breaking change: The ``vws.exceptions.cloud_reco_exceptions.MatchProcessing`` is now ``vws.exceptions.custom_exceptions.ActiveMatchingTargetsDeleteProcessing``.
+* Added new exception ``vws.exceptions.custom_exceptions.RequestEntityTooLarge``.
 
 2020.09.07.0
 ------------

dev-requirements.txt

@@ -5,7 +5,7 @@ PyYAML==5.4.1
 Pygments==2.8.1
 Sphinx-Substitution-Extensions==2020.9.30.0
 Sphinx==3.5.3
-VWS-Python-Mock==2020.10.3.0
+VWS-Python-Mock==2021.3.27.1
 VWS-Test-Fixtures==2020.9.25.1
 autoflake==1.4
 check-manifest==0.46

src/vws/exceptions/cloud_reco_exceptions.py

@@ -6,13 +6,6 @@
 from vws.exceptions.base_exceptions import CloudRecoException
 
 
-class MatchProcessing(CloudRecoException):
-    """
-    Exception raised when a query is made with an image which matches a target
-    which is processing or has recently been deleted.
-    """
-
-
 class MaxNumResultsOutOfRange(CloudRecoException):
     """
     Exception raised when the ``max_num_results`` given to the Cloud

src/vws/exceptions/custom_exceptions.py

@@ -4,8 +4,6 @@
 or simple errors given by the cloud recognition service.
 """
 
-import requests
-
 
 class UnknownVWSErrorPossiblyBadName(Exception):
     """
@@ -16,14 +14,20 @@ class UnknownVWSErrorPossiblyBadName(Exception):
     """
 
 
-class ConnectionErrorPossiblyImageTooLarge(requests.ConnectionError):
+class RequestEntityTooLarge(Exception):
     """
-    Exception raised when a ConnectionError is raised from a query. This has
-    been seen to happen when the given image is too large.
+    Exception raised when the given image is too large.
     """
 
 
 class TargetProcessingTimeout(Exception):
     """
     Exception raised when waiting for a target to be processed times out.
     """
+
+
+class ActiveMatchingTargetsDeleteProcessing(Exception):
+    """
+    Exception raised when a query is made with an image which matches a target
+    which has recently been deleted.
+    """

src/vws/query.py

@@ -6,6 +6,7 @@
 
 import datetime
 import io
+from http import HTTPStatus
 from urllib.parse import urljoin
 
 import requests
@@ -16,12 +17,12 @@
     AuthenticationFailure,
     BadImage,
     InactiveProject,
-    MatchProcessing,
     MaxNumResultsOutOfRange,
     RequestTimeTooSkewed,
 )
 from vws.exceptions.custom_exceptions import (
-    ConnectionErrorPossiblyImageTooLarge,
+    ActiveMatchingTargetsDeleteProcessing,
+    RequestEntityTooLarge,
 )
 from vws.include_target_data import CloudRecoIncludeTargetData
 from vws.reports import QueryResult, TargetData
@@ -77,22 +78,21 @@ def query(
                 client access key pair is not correct.
             ~vws.exceptions.cloud_reco_exceptions.MaxNumResultsOutOfRange:
                 ``max_num_results`` is not within the range (1, 50).
-            ~vws.exceptions.cloud_reco_exceptions.MatchProcessing: The given
-                image matches a target which was recently added, updated or
-                deleted and Vuforia returns an error in this case.
             ~vws.exceptions.cloud_reco_exceptions.InactiveProject: The project
                 is inactive.
-            ~vws.exceptions.custom_exceptions.ConnectionErrorPossiblyImageTooLarge:
-                The given image is too large.
             ~vws.exceptions.cloud_reco_exceptions.RequestTimeTooSkewed: There
                 is an error with the time sent to Vuforia.
             ~vws.exceptions.cloud_reco_exceptions.BadImage: There is a problem
                 with the given image.  For example, it must be a JPEG or PNG
                 file in the grayscale or RGB color space.
+            ~vws.exceptions.custom_exceptions.RequestEntityTooLarge: The given
+                image is too large.
+            ~vws.exceptions.custom_exceptions.ActiveMatchingTargetsDeleteProcessing:
+                The given image matches a target which was recently deleted.
 
         Returns:
             An ordered list of target details of matching targets.
-        """
+        """  # noqa: E501
         image_content = image.getvalue()
         body = {
             'image': ('image.jpeg', image_content, 'image/jpeg'),
@@ -125,24 +125,21 @@ def query(
             'Content-Type': content_type_header,
         }
 
-        try:
-            response = requests.request(
-                method=method,
-                url=urljoin(base=self._base_vwq_url, url=request_path),
-                headers=headers,
-                data=content,
-            )
-        except requests.exceptions.ConnectionError as exc:
-            raise ConnectionErrorPossiblyImageTooLarge(
-                request=exc.request,
-                response=exc.response,
-            ) from exc
+        response = requests.request(
+            method=method,
+            url=urljoin(base=self._base_vwq_url, url=request_path),
+            headers=headers,
+            data=content,
+        )
+
+        if response.status_code == HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
+            raise RequestEntityTooLarge
 
         if 'Integer out of range' in response.text:
             raise MaxNumResultsOutOfRange(response=response)
 
         if 'No content to map due to end-of-input' in response.text:
-            raise MatchProcessing(response=response)
+            raise ActiveMatchingTargetsDeleteProcessing
 
         result_code = response.json()['result_code']
         if result_code != 'Success':

tests/test_cloud_reco_exceptions.py

@@ -3,10 +3,10 @@
 """
 
 import io
+import time
 from http import HTTPStatus
 
 import pytest
-import requests
 from mock_vws import MockVWS
 from mock_vws.database import VuforiaDatabase
 from mock_vws.states import States
@@ -15,12 +15,14 @@
 from vws.exceptions.base_exceptions import CloudRecoException
 from vws.exceptions.cloud_reco_exceptions import (
     AuthenticationFailure,
+    BadImage,
     InactiveProject,
-    MatchProcessing,
     MaxNumResultsOutOfRange,
+    RequestTimeTooSkewed,
 )
 from vws.exceptions.custom_exceptions import (
-    ConnectionErrorPossiblyImageTooLarge,
+    ActiveMatchingTargetsDeleteProcessing,
+    RequestEntityTooLarge,
 )
 
 
@@ -50,68 +52,49 @@ def test_image_too_large(
     png_too_large: io.BytesIO,
 ) -> None:
     """
-    A ``ConnectionErrorPossiblyImageTooLarge`` exception is raised if an
-    image which is too large is given.
+    A ``RequestEntityTooLarge`` exception is raised if an image which is too
+    large is given.
     """
-    with pytest.raises(ConnectionErrorPossiblyImageTooLarge) as exc:
+    with pytest.raises(RequestEntityTooLarge):
         cloud_reco_client.query(image=png_too_large)
 
-    assert isinstance(exc.value, requests.ConnectionError)
-
 
 def test_cloudrecoexception_inheritance() -> None:
     """
     CloudRecoService-specific exceptions inherit from CloudRecoException.
     """
     subclasses = [
-        MatchProcessing,
         MaxNumResultsOutOfRange,
+        InactiveProject,
+        BadImage,
+        AuthenticationFailure,
+        RequestTimeTooSkewed,
     ]
     for subclass in subclasses:
         assert issubclass(subclass, CloudRecoException)
 
 
-def test_base_exception(
-    vws_client: VWS,
-    cloud_reco_client: CloudRecoService,
-    high_quality_image: io.BytesIO,
-) -> None:
-    """
-    ``CloudRecoException``s has a response property.
-    """
-    vws_client.add_target(
-        name='x',
-        width=1,
-        image=high_quality_image,
-        active_flag=True,
-        application_metadata=None,
-    )
-
-    with pytest.raises(CloudRecoException) as exc:
-        cloud_reco_client.query(image=high_quality_image)
-
-    assert exc.value.response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
-
-
-def test_match_processing(
+def test_active_matching_targets_delete_processing(
     vws_client: VWS,
     cloud_reco_client: CloudRecoService,
     high_quality_image: io.BytesIO,
 ) -> None:
     """
-    A ``MatchProcessing`` exception is raised when a target in processing is
-    matched.
+    A ``ActiveMatchingTargetsDeleteProcessing`` exception is raised when a
+    target which has recently been deleted is matched.
     """
-    vws_client.add_target(
+    target_id = vws_client.add_target(
         name='x',
         width=1,
         image=high_quality_image,
         active_flag=True,
         application_metadata=None,
     )
-    with pytest.raises(MatchProcessing) as exc:
+    vws_client.wait_for_target_processed(target_id=target_id)
+    vws_client.delete_target(target_id=target_id)
+    time.sleep(0.2)
+    with pytest.raises(ActiveMatchingTargetsDeleteProcessing):
         cloud_reco_client.query(image=high_quality_image)
-    assert exc.value.response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
 
 
 def test_authentication_failure(high_quality_image: io.BytesIO) -> None: