pytest-jsonschema-snapshot 0.2.5__tar.gz → 0.2.7__tar.gz

{pytest_jsonschema_snapshot-0.2.5 → pytest_jsonschema_snapshot-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-jsonschema-snapshot
-Version: 0.2.5
+Version: 0.2.7
 Summary: Pytest plugin for automatic JSON Schema generation and validation from examples
 Project-URL: Homepage, https://miskler.github.io/pytest-jsonschema-snapshot/basic/quick_start.html
 Project-URL: Repository, https://github.com/Miskler/pytest-jsonschema-snapshot

{pytest_jsonschema_snapshot-0.2.5 → pytest_jsonschema_snapshot-0.2.7}/pytest_jsonschema_snapshot/__init__.py

@@ -8,5 +8,5 @@ pytest-typed-schema-shot
 
 from .core import SchemaShot
 
-__version__ = "0.2.5"
+__version__ = "0.2.7"
 __all__ = ["SchemaShot"]

{pytest_jsonschema_snapshot-0.2.5 → pytest_jsonschema_snapshot-0.2.7}/pytest_jsonschema_snapshot/core.py

@@ -5,7 +5,7 @@ Core logic of the plugin.
 import json
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Optional, Set
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional
 
 import pathvalidate
 
@@ -35,7 +35,7 @@ class SchemaShot:
         format_mode: str = "on",
         update_mode: bool = False,
         reset_mode: bool = False,
-        update_actions: dict[str, bool] = {},
+        update_actions: Optional[dict[str, bool]] = {},
         save_original: bool = False,
         debug_mode: bool = False,
         snapshot_dir_name: str = "__snapshots__",
@@ -55,11 +55,11 @@ class SchemaShot:
         # self.examples_limit: int = examples_limit
         self.update_mode: bool = update_mode
         self.reset_mode: bool = reset_mode
-        self.update_actions: dict[str, bool] = update_actions
+        self.update_actions: dict[str, bool] = dict(update_actions or {})
         self.save_original: bool = save_original
         self.debug_mode: bool = debug_mode
         self.snapshot_dir: Path = root_dir / snapshot_dir_name
-        self.used_schemas: Set[str] = set()
+        self.used_schemas: set[str] = set()
 
         self.conv = Converter(
             pseudo_handler=PseudoArrayHandler(),
@@ -116,7 +116,7 @@ class SchemaShot:
             pathvalidate.validate_filename(
                 name, platform="auto"
             )  # allow_reserved=False по умолчанию
-        except ValidationError as e:
+        except pathvalidate.ValidationError as e:
             raise ValueError(f"Invalid schema name: {e}") from None
 
         return name
@@ -162,11 +162,7 @@ class SchemaShot:
 
         real_name = self._process_name(name)
 
-        self.conv.clear_data()
-        self.conv.add_schema(data)
-        current_schema = self.conv.run()
-
-        real_name, status = self._base_match(data, current_schema, real_name)
+        real_name, status = self._base_match(data, data, "json", real_name)
 
         if self.update_mode or self.reset_mode:
             self._save_process_original(real_name=real_name, status=status, data=data)
@@ -191,7 +187,7 @@ class SchemaShot:
 
         real_name = self._process_name(name)
 
-        real_name, status = self._base_match(data, schema, real_name)
+        real_name, status = self._base_match(data, schema, "schema", real_name)
 
         if self.update_mode and data is not None:
             self._save_process_original(real_name=real_name, status=status, data=data)
@@ -201,7 +197,8 @@ class SchemaShot:
     def _base_match(
         self,
         data: Optional[dict],
-        current_schema: dict,
+        current_data: dict,
+        type_data: Literal["json", "schema"],
         name: str,
     ) -> tuple[str, Optional[bool]]:
         """
@@ -224,6 +221,16 @@ class SchemaShot:
         # --- состояние ДО проверки ---
         schema_exists_before = schema_path.exists()
 
+        def make_schema(current_data: dict | list, type_data: Literal["json", "schema"]) -> dict:
+            if type_data == "schema":
+                return dict(current_data)
+            elif type_data == "json":
+                self.conv.clear_data()
+                self.conv.add_json(current_data)
+                return self.conv.run()
+            else:
+                raise ValueError("Not correct type argument")
+
         # --- когда схемы ещё нет ---
         if not schema_exists_before:
             if not self.update_mode and not self.reset_mode:
@@ -236,6 +243,8 @@ class SchemaShot:
                     f"Schema `{name}` not found and adding new schemas is disabled."
                 )
 
+            current_schema = make_schema(current_data, type_data)
+
             with open(schema_path, "w", encoding="utf-8") as f:
                 json.dump(current_schema, f, indent=2, ensure_ascii=False)
 
@@ -249,44 +258,59 @@ class SchemaShot:
             # --- схема уже была: сравнение и валидация --------------------------------
             schema_updated = False
 
-            def merge_schemas(old: dict, new: dict) -> dict:
+            def merge_schemas(
+                old: dict, new: dict | list, type_data: Literal["json", "schema"]
+            ) -> dict:
                 self.conv.clear_data()
                 self.conv.add_schema(old)
-                self.conv.add_schema(new)
+                if type_data == "schema":
+                    self.conv.add_schema(dict(new))
+                elif type_data == "json":
+                    self.conv.add_json(new)
+                else:
+                    raise ValueError("Not correct type argument")
                 result = self.conv.run()
                 return result
 
-            if existing_schema != current_schema:  # есть отличия
+            if (
+                type_data == "json" or existing_schema != current_data
+            ):  # есть отличия или могут быть
                 if (self.update_mode or self.reset_mode) and self.update_actions.get("update"):
                     # обновляем файл
                     if self.reset_mode and not self.update_mode:
+                        current_schema = make_schema(current_data, type_data)
+
                         differences = self.differ.compare(
                             dict(existing_schema), current_schema
                         ).render()
-                        GLOBAL_STATS.add_updated(schema_path.name, differences)
+                        diff_count = self.differ.property.calc_diff()
+                        if any(diff_count[key] > 0 for key in diff_count if key != "UNKNOWN"):
+                            GLOBAL_STATS.add_updated(schema_path.name, differences)
 
-                        with open(schema_path, "w", encoding="utf-8") as f:
-                            json.dump(current_schema, f, indent=2, ensure_ascii=False)
-                        self.logger.warning(f"Schema `{name}` updated (reset).\n\n{differences}")
+                            with open(schema_path, "w", encoding="utf-8") as f:
+                                json.dump(current_schema, f, indent=2, ensure_ascii=False)
+                            self.logger.warning(f"Schema `{name}` reseted.\n\n{differences}")
                     elif self.update_mode and not self.reset_mode:
-                        merged_schema = merge_schemas(existing_schema, current_schema)
+                        merged_schema = merge_schemas(existing_schema, current_data, type_data)
 
                         differences = self.differ.compare(
                             dict(existing_schema), merged_schema
                         ).render()
-                        GLOBAL_STATS.add_updated(schema_path.name, differences)
+                        diff_count = self.differ.property.calc_diff()
+                        if any(diff_count[key] > 0 for key in diff_count if key != "UNKNOWN"):
+                            GLOBAL_STATS.add_updated(schema_path.name, differences)
 
-                        with open(schema_path, "w", encoding="utf-8") as f:
-                            json.dump(merged_schema, f, indent=2, ensure_ascii=False)
+                            with open(schema_path, "w", encoding="utf-8") as f:
+                                json.dump(merged_schema, f, indent=2, ensure_ascii=False)
 
-                        self.logger.warning(f"Schema `{name}` updated (update).\n\n{differences}")
+                            self.logger.warning(f"Schema `{name}` updated.\n\n{differences}")
                     else:  # both update_mode and reset_mode are True
                         raise ValueError(
                             "Both update_mode and reset_mode cannot be True at the same time."
                         )
                     schema_updated = True
                 elif data is not None:
-                    merged_schema = merge_schemas(existing_schema, current_schema)
+                    merged_schema = merge_schemas(existing_schema, current_data, type_data)
 
                     differences = self.differ.compare(dict(existing_schema), merged_schema).render()
                     GLOBAL_STATS.add_uncommitted(schema_path.name, differences)
@@ -302,7 +326,7 @@ class SchemaShot:
                         pytest.fail(
                             f"\n\n{differences}\n\nValidation error in `{name}`: {e.message}"
                         )
-            elif data is not None:
+            elif data is not None and type_data == "schema":
                 # схемы совпали – всё равно валидируем на случай формальных ошибок
                 try:
                     validate(
@@ -311,7 +335,7 @@ class SchemaShot:
                         format_checker=FormatChecker(),
                     )
                 except ValidationError as e:
-                    merged_schema = merge_schemas(existing_schema, current_schema)
+                    merged_schema = merge_schemas(existing_schema, current_data, type_data)
 
                     differences = self.differ.compare(dict(existing_schema), merged_schema).render()
                     pytest.fail(f"\n\n{differences}\n\nValidation error in `{name}`: {e.message}")

{pytest_jsonschema_snapshot-0.2.5 → pytest_jsonschema_snapshot-0.2.7}/tests/usage/__snapshots__/some_schema.schema.json

@@ -17,7 +17,27 @@
     },
     "разнотипный_массив": {
       "type": "array",
-      "items": {}
+      "items": {
+        "anyOf": [
+          {
+            "type": "null"
+          },
+          {
+            "type": "string"
+          },
+          {
+            "type": "object",
+            "required": [
+              "ключ"
+            ],
+            "properties": {
+              "ключ": {
+                "type": "string"
+              }
+            }
+          }
+        ]
+      }
     },
     "словарь": {
       "type": "object",
@@ -113,7 +133,19 @@
             "type": "string",
             "format": "date-time"
           },
-          "имя": {},
+          "имя": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              }
+            ]
+          },
           "почта": {
             "type": "string",
             "format": "email"