fix error handling

Author: cx-lukas-salkauskas-x

inapppy/appstore.py

@@ -93,10 +93,23 @@ def _prepare_receipt(self, receipt: str, shared_secret: str, exclude_old_transac
     def post_json(self, request_json: dict) -> dict:
         self._change_url_by_sandbox()
 
+        response = None
         try:
-            return requests.post(self.url, json=request_json, timeout=self.http_timeout).json()
-        except (ValueError, RequestException):
-            raise InAppPyValidationError("HTTP error")
+            response = requests.post(self.url, json=request_json, timeout=self.http_timeout)
+            return response.json()
+        except (ValueError, RequestException) as e:
+            # Build raw_response with available information
+            raw_response = {"error": str(e)}
+
+            # Try to include response details if available
+            if response is not None:
+                raw_response["status_code"] = response.status_code
+                try:
+                    raw_response["content"] = response.text
+                except Exception:
+                    pass
+
+            raise InAppPyValidationError("HTTP error", raw_response=raw_response)
 
     @staticmethod
     def _ms_timestamp_expired(ms_timestamp: str) -> bool:

inapppy/asyncio/appstore.py

@@ -27,13 +27,29 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
 
     async def post_json(self, request_json: dict) -> dict:
         self._change_url_by_sandbox()
+        response_text = None
+        status_code = None
         try:
             async with self._session.post(
                 self.url, json=request_json, timeout=ClientTimeout(total=self.http_timeout)
             ) as resp:
-                return await resp.json(content_type=None)
-        except (ValueError, ClientError):
-            raise InAppPyValidationError("HTTP error")
+                status_code = resp.status
+                response_text = await resp.text()
+                # Try to parse as JSON
+                import json
+
+                return json.loads(response_text)
+        except (ValueError, ClientError) as e:
+            # Build raw_response with available information
+            raw_response = {"error": str(e)}
+
+            # Try to include response details if available
+            if status_code is not None:
+                raw_response["status_code"] = status_code
+            if response_text is not None:
+                raw_response["content"] = response_text
+
+            raise InAppPyValidationError("HTTP error", raw_response=raw_response)
 
     async def validate(self, receipt: str, shared_secret: str = None, exclude_old_transactions: bool = False) -> dict:
         """Validates receipt against apple services.

tests/asyncio/test_asyncio_appstore.py

@@ -1,4 +1,4 @@
-from unittest.mock import patch
+from unittest.mock import Mock, patch
 
 import pytest
 
@@ -119,3 +119,67 @@ async def test_appstore_async_context_manager():
 
     # Verify session is closed after exiting context
     assert validator._session is None
+
+
+@pytest.mark.asyncio
+async def test_appstore_async_http_error_includes_raw_response(appstore_validator: AppStoreValidator):
+    """Test that async HTTP errors include raw_response with status code and content"""
+    from unittest.mock import AsyncMock, Mock
+
+    # Create a mock response
+    mock_resp = Mock()
+    mock_resp.status = 503
+    mock_resp.text = AsyncMock(return_value="Service Unavailable")
+
+    # Create a mock session post that returns our mock response
+    def mock_post(*args, **kwargs):
+        class MockContext:
+            async def __aenter__(self):
+                return mock_resp
+
+            async def __aexit__(self, *args):
+                pass
+
+        return MockContext()
+
+    with pytest.raises(InAppPyValidationError) as exc_info:
+        appstore_validator._session = Mock()
+        appstore_validator._session.post = mock_post
+        # Mock json.loads to raise ValueError (simulating invalid JSON)
+        with patch("json.loads", side_effect=ValueError("Invalid JSON")):
+            await appstore_validator.post_json({"receipt-data": "test"})
+
+    # Verify raw_response is not None and contains useful information
+    assert exc_info.value.raw_response is not None
+    assert "error" in exc_info.value.raw_response
+    assert "status_code" in exc_info.value.raw_response
+    assert exc_info.value.raw_response["status_code"] == 503
+    assert "content" in exc_info.value.raw_response
+    assert exc_info.value.raw_response["content"] == "Service Unavailable"
+
+
+@pytest.mark.asyncio
+async def test_appstore_async_network_error_includes_raw_response(appstore_validator: AppStoreValidator):
+    """Test that async network errors include raw_response with error details"""
+    from aiohttp import ClientError
+
+    # Create a mock session that raises ClientError
+    def mock_post(*args, **kwargs):
+        class MockContext:
+            async def __aenter__(self):
+                raise ClientError("Connection timeout")
+
+            async def __aexit__(self, *args):
+                pass
+
+        return MockContext()
+
+    with pytest.raises(InAppPyValidationError) as exc_info:
+        appstore_validator._session = Mock()
+        appstore_validator._session.post = mock_post
+        await appstore_validator.post_json({"receipt-data": "test"})
+
+    # Verify raw_response is not None and contains error information
+    assert exc_info.value.raw_response is not None
+    assert "error" in exc_info.value.raw_response
+    assert "Connection timeout" in exc_info.value.raw_response["error"]

tests/test_appstore.py

@@ -91,3 +91,40 @@ def test_appstore_auto_retry_wrong_env_request(appstore_validator_auto_retry_on_
             assert mock_method.call_count == 1
             assert validator.url == "https://buy.itunes.apple.com/verifyReceipt"
             assert mock_method.call_args[0][0] == {"receipt-data": "test-receipt", "password": "shared-secret"}
+
+
+def test_appstore_http_error_includes_raw_response(appstore_validator: AppStoreValidator):
+    """Test that HTTP errors include raw_response with status code and content"""
+    from unittest.mock import Mock
+
+    # Mock a response that has status code but invalid JSON
+    mock_response = Mock()
+    mock_response.status_code = 503
+    mock_response.text = "Service Unavailable"
+    mock_response.json.side_effect = ValueError("No JSON object could be decoded")
+
+    with pytest.raises(InAppPyValidationError) as exc_info:
+        with patch("requests.post", return_value=mock_response):
+            appstore_validator.post_json({"receipt-data": "test"})
+
+    # Verify raw_response is not None and contains useful information
+    assert exc_info.value.raw_response is not None
+    assert "error" in exc_info.value.raw_response
+    assert "status_code" in exc_info.value.raw_response
+    assert exc_info.value.raw_response["status_code"] == 503
+    assert "content" in exc_info.value.raw_response
+    assert exc_info.value.raw_response["content"] == "Service Unavailable"
+
+
+def test_appstore_network_error_includes_raw_response(appstore_validator: AppStoreValidator):
+    """Test that network errors include raw_response with error details"""
+    from requests.exceptions import RequestException
+
+    with pytest.raises(InAppPyValidationError) as exc_info:
+        with patch("requests.post", side_effect=RequestException("Connection timeout")):
+            appstore_validator.post_json({"receipt-data": "test"})
+
+    # Verify raw_response is not None and contains error information
+    assert exc_info.value.raw_response is not None
+    assert "error" in exc_info.value.raw_response
+    assert "Connection timeout" in exc_info.value.raw_response["error"]