datacontract-cli 0.9.6.post2__py3-none-any.whl → 0.9.8__py3-none-any.whl

datacontract/breaking/breaking.py

@@ -1,13 +1,84 @@
 from datacontract.breaking.breaking_rules import BreakingRules
-from datacontract.model.breaking_change import BreakingChanges, BreakingChange, Location
-from datacontract.model.data_contract_specification import Field, Model
+from datacontract.model.breaking_change import BreakingChange, Location, Severity
+from datacontract.model.data_contract_specification import Field, Model, Quality
+
+
+def quality_breaking_changes(
+    old_quality: Quality,
+    new_quality: Quality,
+    new_path: str,
+    include_severities: [Severity],
+) -> list[BreakingChange]:
+    results = list[BreakingChange]()
+
+    if not old_quality and new_quality:
+        rule_name = "quality_added"
+        severity = _get_rule(rule_name)
+        description = "added quality"
+
+        if severity in include_severities:
+            results.append(
+                BreakingChange(
+                    description=description,
+                    check_name=rule_name,
+                    severity=severity,
+                    location=Location(path=new_path, composition=["quality"]),
+                )
+            )
+    elif old_quality and not new_quality:
+        rule_name = "quality_removed"
+        severity = _get_rule(rule_name)
+        description = "removed quality"
+
+        if severity in include_severities:
+            results.append(
+                BreakingChange(
+                    description=description,
+                    check_name=rule_name,
+                    severity=severity,
+                    location=Location(path=new_path, composition=["quality"]),
+                )
+            )
+
+    elif old_quality and new_quality:
+        if old_quality.type != new_quality.type:
+            rule_name = "quality_type_updated"
+            severity = _get_rule(rule_name)
+            description = f"changed from `{old_quality.type}` to `{new_quality.type}`"
+
+            if severity in include_severities:
+                results.append(
+                    BreakingChange(
+                        description=description,
+                        check_name=rule_name,
+                        severity=severity,
+                        location=Location(path=new_path, composition=["quality", "type"]),
+                    )
+                )
+
+        if old_quality.specification != new_quality.specification:
+            rule_name = "quality_specification_updated"
+            severity = _get_rule(rule_name)
+            description = f"changed from `{old_quality.specification}` to `{new_quality.specification}`"
+            if severity in include_severities:
+                results.append(
+                    BreakingChange(
+                        description=description,
+                        check_name=rule_name,
+                        severity=severity,
+                        location=Location(path=new_path, composition=["quality", "specification"]),
+                    )
+                )
+
+    return results
 
 
 def models_breaking_changes(
     old_models: dict[str, Model],
     new_models: dict[str, Model],
-    new_path: str
-) -> BreakingChanges:
+    new_path: str,
+    include_severities: [Severity],
+) -> list[BreakingChange]:
     composition = ["models"]
     results = list[BreakingChange]()
 
@@ -15,31 +86,29 @@ def models_breaking_changes(
         if model_name not in old_models.keys():
             rule_name = "model_added"
             severity = _get_rule(rule_name)
-            if severity != "info":
+            if severity in include_severities:
                 results.append(
                     BreakingChange(
                         description="added the model",
                         check_name=rule_name,
                         severity=severity,
-                        location=Location(
-                            path=new_path,
-                            composition=composition + [model_name]
-                        )))
+                        location=Location(path=new_path, composition=composition + [model_name]),
+                    )
+                )
 
     for model_name, old_model in old_models.items():
         if model_name not in new_models.keys():
             rule_name = "model_removed"
             severity = _get_rule(rule_name)
-            if severity != "info":
+            if severity in include_severities:
                 results.append(
                     BreakingChange(
                         description="removed the model",
                         check_name=rule_name,
                         severity=severity,
-                        location=Location(
-                            path=new_path,
-                            composition=composition + [model_name]
-                        )))
+                        location=Location(path=new_path, composition=composition + [model_name]),
+                    )
+                )
             continue
 
         results.extend(
@@ -47,17 +116,16 @@ def models_breaking_changes(
                 old_model=old_model,
                 new_model=new_models[model_name],
                 new_path=new_path,
-                composition=composition + [model_name]
-            ))
+                composition=composition + [model_name],
+                include_severities=include_severities,
+            )
+        )
 
-    return BreakingChanges(breaking_changes=results)
+    return results
 
 
 def model_breaking_changes(
-    old_model: Model,
-    new_model: Model,
-    new_path: str,
-    composition: list[str]
+    old_model: Model, new_model: Model, new_path: str, composition: list[str], include_severities: [Severity]
 ) -> list[BreakingChange]:
     results = list[BreakingChange]()
 
@@ -87,24 +155,25 @@ def model_breaking_changes(
 
         if rule_name is not None:
             severity = _get_rule(rule_name)
-            if severity != "info":
+            if severity in include_severities:
                 results.append(
                     BreakingChange(
                         description=description,
                         check_name=rule_name,
                         severity=severity,
-                        location=Location(
-                            path=new_path,
-                            composition=composition + [model_definition_field]
-                        )))
+                        location=Location(path=new_path, composition=composition + [model_definition_field]),
+                    )
+                )
 
     results.extend(
         fields_breaking_changes(
             old_fields=old_model.fields,
             new_fields=new_model.fields,
             new_path=new_path,
-            composition=composition
-        ))
+            composition=composition + ["fields"],
+            include_severities=include_severities,
+        )
+    )
 
     return results
 
@@ -113,7 +182,8 @@ def fields_breaking_changes(
     old_fields: dict[str, Field],
     new_fields: dict[str, Field],
     new_path: str,
-    composition: list[str]
+    composition: list[str],
+    include_severities: [Severity],
 ) -> list[BreakingChange]:
     results = list[BreakingChange]()
 
@@ -121,31 +191,29 @@ def fields_breaking_changes(
         if field_name not in old_fields.keys():
             rule_name = "field_added"
             severity = _get_rule(rule_name)
-            if severity != "info":
+            if severity in include_severities:
                 results.append(
                     BreakingChange(
                         description="added the field",
                         check_name=rule_name,
                         severity=severity,
-                        location=Location(
-                            path=new_path,
-                            composition=composition + [field_name]
-                        )))
+                        location=Location(path=new_path, composition=composition + [field_name]),
+                    )
+                )
 
     for field_name, old_field in old_fields.items():
         if field_name not in new_fields.keys():
             rule_name = "field_removed"
             severity = _get_rule(rule_name)
-            if severity != "info":
+            if severity in include_severities:
                 results.append(
                     BreakingChange(
-                        description='removed the field',
+                        description="removed the field",
                         check_name=rule_name,
                         severity=severity,
-                        location=Location(
-                            path=new_path,
-                            composition=composition + [field_name]
-                        )))
+                        location=Location(path=new_path, composition=composition + [field_name]),
+                    )
+                )
             continue
 
         results.extend(
@@ -154,7 +222,9 @@ def fields_breaking_changes(
                 new_field=new_fields[field_name],
                 composition=composition + [field_name],
                 new_path=new_path,
-            ))
+                include_severities=include_severities,
+            )
+        )
     return results
 
 
@@ -163,14 +233,13 @@ def field_breaking_changes(
     new_field: Field,
     composition: list[str],
     new_path: str,
+    include_severities: [Severity],
 ) -> list[BreakingChange]:
     results = list[BreakingChange]()
 
     field_definition_fields = vars(new_field)
     for field_definition_field in field_definition_fields.keys():
-
-        # TODO(torbenkeller): handle ref case
-        if field_definition_field == "ref":
+        if field_definition_field == "ref_obj":
             continue
 
         old_value = getattr(old_field, field_definition_field)
@@ -182,7 +251,8 @@ def field_breaking_changes(
                     old_fields=old_field.fields,
                     new_fields=new_field.fields,
                     new_path=new_path,
-                    composition=composition + [field_definition_field]
+                    composition=composition + [field_definition_field],
+                    include_severities=include_severities,
                 )
             )
             continue
@@ -191,50 +261,56 @@ def field_breaking_changes(
         description = None
 
         # logic for enum, tags and other arrays
-        if type(old_value) is list and type(new_value) is list:
+        if isinstance(old_value, list) and isinstance(new_value, list):
             if not old_value and new_value:
-                rule_name = f"field_{field_definition_field}_added"
+                rule_name = f"field_{_camel_to_snake(field_definition_field)}_added"
                 description = f"added with value: `{new_value}`"
             elif old_value and not new_value:
-                rule_name = f"field_{field_definition_field}_removed"
+                rule_name = f"field_{_camel_to_snake(field_definition_field)}_removed"
                 description = "removed field property"
             elif sorted(old_value) != sorted(new_value):
-                rule_name = f"field_{field_definition_field}_updated"
+                rule_name = f"field_{_camel_to_snake(field_definition_field)}_updated"
                 description = f"changed from `{old_value}` to `{new_value}`"
 
         # logic for normal fields
         elif old_value is None and new_value is not None:
-            rule_name = f"field_{field_definition_field}_added"
-            description = f"added with value: `{str(new_value).lower() if type(new_value) is bool else new_value}`"
+            rule_name = f"field_{_camel_to_snake(field_definition_field)}_added"
+            description = f"added with value: `{str(new_value).lower() if isinstance(new_value, bool) else new_value}`"
 
         elif old_value is not None and new_value is None:
-            rule_name = f"field_{field_definition_field}_removed"
+            rule_name = f"field_{_camel_to_snake(field_definition_field)}_removed"
             description = "removed field property"
 
         elif old_value != new_value:
-            rule_name = f"field_{field_definition_field}_updated"
-            description = (f"changed from `{str(old_value).lower() if type(old_value) is bool else old_value}` "
-                           f"to `{str(new_value).lower() if type(new_value) is bool else new_value}`")
+            rule_name = f"field_{_camel_to_snake(field_definition_field)}_updated"
+            description = (
+                f"changed from `{str(old_value).lower() if isinstance(old_value, bool) else old_value}` "
+                f"to `{str(new_value).lower() if isinstance(new_value, bool) else new_value}`"
+            )
 
         if rule_name is not None:
             severity = _get_rule(rule_name)
-            if severity != "info":
+            field_schema_name = "$ref" if field_definition_field == "ref" else field_definition_field
+            if severity in include_severities:
                 results.append(
                     BreakingChange(
                         description=description,
                         check_name=rule_name,
                         severity=severity,
-                        location=Location(
-                            path=new_path,
-                            composition=composition + [field_definition_field]
-                        )))
+                        location=Location(path=new_path, composition=composition + [field_schema_name]),
+                    )
+                )
 
     return results
 
 
-def _get_rule(rule_name):
+def _get_rule(rule_name) -> Severity:
     try:
         return getattr(BreakingRules, rule_name)
     except AttributeError:
-        print(f'WARNING: Breaking Rule not found for {rule_name}!')
-        return 'error'
+        print(f"WARNING: Breaking Rule not found for {rule_name}!")
+        return Severity.ERROR
+
+
+def _camel_to_snake(s):
+    return "".join(["_" + c.lower() if c.isupper() else c for c in s]).lstrip("_")

datacontract/breaking/breaking_rules.py

@@ -1,77 +1,94 @@
+from datacontract.model.breaking_change import Severity
+
+
 class BreakingRules:
     # model rules
-    model_added = 'info'
-    model_removed = 'error'
+    model_added = Severity.INFO
+    model_removed = Severity.ERROR
 
-    model_description_added = 'info'
-    model_description_removed = 'info'
-    model_description_updated = 'info'
+    model_description_added = Severity.INFO
+    model_description_removed = Severity.INFO
+    model_description_updated = Severity.INFO
 
-    model_type_updated = 'error'
+    model_type_updated = Severity.ERROR
 
     # field rules
-    field_added = 'info'
-    field_removed = 'error'
+    field_added = Severity.INFO
+    field_removed = Severity.ERROR
+
+    field_ref_added = Severity.WARNING
+    field_ref_removed = Severity.WARNING
+    field_ref_updated = Severity.WARNING
+
+    field_type_added = Severity.WARNING
+    field_type_removed = Severity.WARNING
+    field_type_updated = Severity.ERROR
+
+    field_format_added = Severity.WARNING
+    field_format_removed = Severity.WARNING
+    field_format_updated = Severity.ERROR
+
+    field_required_updated = Severity.ERROR
 
-    field_ref_added = 'warning'
-    field_ref_removed = 'error'
+    field_primary_updated = Severity.WARNING
 
-    field_type_added = 'warning'
-    field_type_removed = 'warning'
-    field_type_updated = 'error'
+    field_references_added = Severity.WARNING
+    field_references_removed = Severity.WARNING
+    field_references_updated = Severity.WARNING
 
-    field_format_added = 'warning'
-    field_format_removed = 'warning'
-    field_format_updated = 'error'
+    field_unique_updated = Severity.ERROR
 
-    field_required_updated = 'error'
+    field_description_added = Severity.INFO
+    field_description_removed = Severity.INFO
+    field_description_updated = Severity.INFO
 
-    field_unique_updated = 'error'
+    field_pii_added = Severity.WARNING
+    field_pii_removed = Severity.ERROR
+    field_pii_updated = Severity.ERROR
 
-    field_description_added = 'info'
-    field_description_removed = 'info'
-    field_description_updated = 'info'
+    field_classification_added = Severity.WARNING
+    field_classification_removed = Severity.ERROR
+    field_classification_updated = Severity.ERROR
 
-    field_pii_added = 'warning'
-    field_pii_removed = 'error'
-    field_pii_updated = 'error'
+    field_pattern_added = Severity.WARNING
+    field_pattern_removed = Severity.ERROR
+    field_pattern_updated = Severity.ERROR
 
-    field_classification_added = 'warning'
-    field_classification_removed = 'error'
-    field_classification_updated = 'error'
+    field_min_length_added = Severity.WARNING
+    field_min_length_removed = Severity.WARNING
+    field_min_length_updated = Severity.ERROR
 
-    field_pattern_added = 'warning'
-    field_pattern_removed = 'error'
-    field_pattern_updated = 'error'
+    field_max_length_added = Severity.WARNING
+    field_max_length_removed = Severity.WARNING
+    field_max_length_updated = Severity.ERROR
 
-    field_minLength_added = 'warning'
-    field_minLength_removed = 'warning'
-    field_minLength_updated = 'error'
+    field_minimum_added = Severity.WARNING
+    field_minimum_removed = Severity.WARNING
+    field_minimum_updated = Severity.ERROR
 
-    field_maxLength_added = 'warning'
-    field_maxLength_removed = 'warning'
-    field_maxLength_updated = 'error'
+    field_exclusive_minimum_added = Severity.WARNING
+    field_exclusive_minimum_removed = Severity.WARNING
+    field_exclusive_minimum_updated = Severity.ERROR
 
-    field_minimum_added = 'warning'
-    field_minimum_removed = 'warning'
-    field_minimum_updated = 'error'
+    field_maximum_added = Severity.WARNING
+    field_maximum_removed = Severity.WARNING
+    field_maximum_updated = Severity.ERROR
 
-    field_minimumExclusive_added = 'warning'
-    field_minimumExclusive_removed = 'warning'
-    field_minimumExclusive_updated = 'error'
+    field_exclusive_maximum_added = Severity.WARNING
+    field_exclusive_maximum_removed = Severity.WARNING
+    field_exclusive_maximum_updated = Severity.ERROR
 
-    field_maximum_added = 'warning'
-    field_maximum_removed = 'warning'
-    field_maximum_updated = 'error'
+    field_enum_added = Severity.WARNING
+    field_enum_removed = Severity.INFO
+    field_enum_updated = Severity.ERROR
 
-    field_maximumExclusive_added = 'warning'
-    field_maximumExclusive_removed = 'warning'
-    field_maximumExclusive_updated = 'error'
+    field_tags_added = Severity.INFO
+    field_tags_removed = Severity.INFO
+    field_tags_updated = Severity.INFO
 
-    field_enum_added = 'warning'
-    field_enum_removed = 'info'
-    field_enum_updated = 'error'
+    # quality Rules
+    quality_added = Severity.INFO
+    quality_removed = Severity.WARNING
 
-    field_tags_added = 'info'
-    field_tags_removed = 'info'
-    field_tags_updated = 'info'
+    quality_type_updated = Severity.WARNING
+    quality_specification_updated = Severity.WARNING