Merge pull request #22 from GitGuardian/sofien/-/fix_previous_version

fix(models): fix PolicyBreak model

Author: SofienM

pygitguardian/__init__.py

@@ -2,7 +2,7 @@
 from .client import GGClient
 
 
-__version__ = "1.3.2"
+__version__ = "1.3.3"
 GGClient._version = __version__
 
 __all__ = [

pygitguardian/models.py

@@ -216,8 +216,8 @@ def __init__(
         self,
         break_type: str,
         policy: str,
+        validity: str,
         matches: List[Match],
-        validity: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
         super().__init__()

tests/test_models.py

@@ -1,6 +1,24 @@
 from typing import OrderedDict
 
-from pygitguardian.models import Document, DocumentSchema, Match, MatchSchema
+import pytest
+
+from pygitguardian.models import (
+    Document,
+    DocumentSchema,
+    HealthCheckResponseSchema,
+    Match,
+    MatchSchema,
+    MultiScanResult,
+    MultiScanResultSchema,
+    PolicyBreak,
+    PolicyBreakSchema,
+    Quota,
+    QuotaResponse,
+    QuotaResponseSchema,
+    QuotaSchema,
+    ScanResult,
+    ScanResultSchema,
+)
 
 
 class TestModel:
@@ -14,26 +32,70 @@ def test_document_model(self):
         assert isinstance(document.to_dict(), dict)
         assert isinstance(str(document), str)
 
-    def test_schema_excludes(self):
+    @pytest.mark.parametrize(
+        "schema_klass, expected_klass, instance_data",
+        [
+            (DocumentSchema, OrderedDict, {"filename": "hello", "document": "hello"}),
+            (
+                HealthCheckResponseSchema,
+                OrderedDict,
+                {"detail": "hello", "status_code": 200},
+            ),
+            (MatchSchema, Match, {"match": "hello", "type": "hello"}),
+            (
+                MultiScanResultSchema,
+                MultiScanResult,
+                {"scan_results": [], "type": "hello"},
+            ),
+            (
+                PolicyBreakSchema,
+                PolicyBreak,
+                {
+                    "type": "hello",
+                    "policy": "hello",
+                    "validity": "hey",
+                    "matches": [{"match": "hello", "type": "hello"}],
+                },
+            ),
+            (
+                QuotaSchema,
+                Quota,
+                {
+                    "count": 1,
+                    "limit": 1,
+                    "remaining": 1,
+                    "since": "2021-04-18",
+                },
+            ),
+            (
+                QuotaResponseSchema,
+                QuotaResponse,
+                {
+                    "content": {
+                        "count": 1,
+                        "limit": 1,
+                        "remaining": 1,
+                        "since": "2021-04-18",
+                    }
+                },
+            ),
+            (
+                ScanResultSchema,
+                ScanResult,
+                {"policy_break_count": 1, "policy_breaks": [], "policies": []},
+            ),
+        ],
+    )
+    def test_schema_loads(self, schema_klass, expected_klass, instance_data):
         """
-        GIVEN a simple document and an extra field in dict format
+        GIVEN the right kwargs  and an extra field in dict format
         WHEN loading using the schema
         THEN the extra field should be excluded
+            AND the result should be an instance of the expected class
         """
-        document = {"filename": "hello", "document": "hello", "extra": "field"}
-        schema = DocumentSchema()
-
-        document_obj = schema.load(document)
-        assert isinstance(document_obj, OrderedDict)
+        schema = schema_klass()
 
-    def test_schema_loads(self):
-        """
-        GIVEN a simple match and an extra field in dict format
-        WHEN loading using the schema
-        THEN the extra field should be excluded and the result should be a Match
-        """
-        match = {"match": "hello", "type": "hello", "extra": "field"}
-        schema = MatchSchema()
+        data = {**instance_data, "field": "extra"}
 
-        match_obj = schema.load(match)
-        assert isinstance(match_obj, Match)
+        obj = schema.load(data)
+        assert isinstance(obj, expected_klass)