@hestia-earth/data-validation 0.37.7

package/tests/validators/test_emission.py

@@ -0,0 +1,170 @@
+import json
+
+from tests.utils import fixtures_path
+from hestia_earth.validation.validators.emission import (
+    validate_linked_terms,
+    validate_method_not_relevant,
+    validate_methodTier_not_relevant,
+    validate_methodTier_background,
+)
+
+
+def test_validate_linked_terms_valid():
+    # no emissions should be valid
+    assert validate_linked_terms({}, "emissions", "inputs", "inputs") is True
+
+    with open(f"{fixtures_path}/emission/linked-terms/inputs/valid.json") as f:
+        data = json.load(f)
+    assert validate_linked_terms(data, "emissions", "inputs", "inputs") is True
+
+    with open(f"{fixtures_path}/emission/linked-terms/transformation/valid.json") as f:
+        data = json.load(f)
+    assert (
+        validate_linked_terms(data, "emissions", "transformation", "transformations")
+        is True
+    )
+
+
+def test_validate_linked_terms_invalid():
+    with open(f"{fixtures_path}/emission/linked-terms/inputs/invalid.json") as f:
+        data = json.load(f)
+    assert validate_linked_terms(data, "emissions", "inputs", "inputs", True) == {
+        "level": "warning",
+        "dataPath": ".emissions[1]",
+        "message": "should add the linked inputs to the cycle",
+        "params": {
+            "term": {
+                "@type": "Term",
+                "@id": "ch4ToAirEntericFermentation",
+                "termType": "emission",
+            },
+            "expected": [
+                {"@id": "seed", "@type": "Term", "name": "Seed", "termType": "seed"}
+            ],
+        },
+    }
+
+    with open(f"{fixtures_path}/emission/linked-terms/transformation/error.json") as f:
+        data = json.load(f)
+    assert validate_linked_terms(
+        data, "emissions", "transformation", "transformations"
+    ) == {
+        "level": "error",
+        "dataPath": ".emissions[1]",
+        "message": "must add the linked transformations to the cycle",
+        "params": {
+            "term": {
+                "@type": "Term",
+                "@id": "ch4ToAirEntericFermentation",
+                "termType": "emission",
+            },
+            "expected": {
+                "@id": "compostingInVessel",
+                "@type": "Term",
+                "name": "Composting - In Vessel",
+                "termType": "excretaManagement",
+            },
+        },
+    }
+
+    with open(
+        f"{fixtures_path}/emission/linked-terms/transformation/warning.json"
+    ) as f:
+        data = json.load(f)
+    assert validate_linked_terms(
+        data, "emissions", "transformation", "transformations"
+    ) == {
+        "level": "error",
+        "dataPath": ".emissions[1]",
+        "message": "must add the linked transformations to the cycle",
+        "params": {
+            "term": {
+                "@type": "Term",
+                "@id": "ch4ToAirEntericFermentation",
+                "termType": "emission",
+            },
+            "expected": {
+                "@id": "compostingInVessel",
+                "@type": "Term",
+                "name": "Composting - In Vessel",
+                "termType": "excretaManagement",
+            },
+        },
+    }
+
+
+def test_validate_method_not_relevant_valid():
+    # no emissions should be valid
+    assert validate_method_not_relevant({}, "emissions") is True
+
+    with open(f"{fixtures_path}/emission/not-relevant/valid.json") as f:
+        data = json.load(f)
+    assert validate_method_not_relevant(data, "emissions") is True
+
+
+def test_validate_method_not_relevant_invalid():
+    with open(f"{fixtures_path}/emission/not-relevant/invalid.json") as f:
+        data = json.load(f)
+    assert validate_method_not_relevant(data, "emissions") == {
+        "level": "warning",
+        "dataPath": ".emissions[1].methodModel.@id",
+        "message": "should not use not relevant model",
+        "params": {
+            "term": {
+                "@type": "Term",
+                "@id": "ch4ToAirEntericFermentation",
+                "termType": "emission",
+            },
+            "model": {
+                "@type": "Term",
+                "@id": "emissionNotRelevant",
+                "termType": "model",
+            },
+        },
+    }
+
+
+def test_validate_methodTier_not_relevant_valid():
+    # no emissions should be valid
+    assert validate_methodTier_not_relevant({}, "emissions") is True
+
+    with open(f"{fixtures_path}/emission/not-relevant-methodTier/valid.json") as f:
+        data = json.load(f)
+    assert validate_methodTier_not_relevant(data, "emissions") is True
+
+
+def test_validate_methodTier_not_relevant_invalid():
+    with open(f"{fixtures_path}/emission/not-relevant-methodTier/invalid.json") as f:
+        data = json.load(f)
+    assert validate_methodTier_not_relevant(data, "emissions") == {
+        "level": "warning",
+        "dataPath": ".emissions[1].methodTier",
+        "message": "should not use not relevant methodTier",
+        "params": {
+            "term": {
+                "@type": "Term",
+                "@id": "ch4ToAirEntericFermentation",
+                "termType": "emission",
+            }
+        },
+    }
+
+
+def test_validate_methodTier_background_valid():
+    # no emissions should be valid
+    assert validate_methodTier_background({}, "emissions") is True
+
+    with open(f"{fixtures_path}/emission/methodTier-background/valid.json") as f:
+        data = json.load(f)
+    assert validate_methodTier_background(data, "emissions") is True
+
+
+def test_validate_methodTier_background_invalid():
+    with open(f"{fixtures_path}/emission/methodTier-background/invalid.json") as f:
+        data = json.load(f)
+    assert validate_methodTier_background(data, "emissions") == {
+        "level": "error",
+        "dataPath": ".emissions[0].methodTier",
+        "message": "should be equal to one of the allowed values",
+        "params": {"allowedValues": ["measured", "tier 1", "tier 2", "tier 3"]},
+    }

package/tests/validators/test_impact_assessment.py

@@ -0,0 +1,80 @@
+from unittest.mock import patch
+import os
+import json
+
+from tests.utils import fixtures_path, fake_get_terms
+from hestia_earth.validation.validators.impact_assessment import (
+    validate_impact_assessment,
+    validate_empty,
+    validate_linked_cycle_product,
+    validate_linked_cycle_endDate,
+)
+
+fixtures_folder = os.path.join(fixtures_path, "impactAssessment")
+
+
+@patch(
+    "hestia_earth.validation.validators.indicator.get_terms",
+    return_value=fake_get_terms,
+)
+def test_validate_impact_assessment_valid(*args):
+    with open(f"{fixtures_folder}/valid.json") as f:
+        node = json.load(f)
+    results = validate_impact_assessment(node)
+    assert all([r is True for r in results])
+
+
+def test_validate_empty_valid():
+    # with a cycle => valid
+    assert validate_empty({"cycle": {"id": "test"}}) is True
+    # with emissionsResourceUse => valid
+    assert validate_empty({"emissionsResourceUse": [{}]}) is True
+    # with impacts => valid
+    assert validate_empty({"impacts": [{}]}) is True
+    # with endpoints => valid
+    assert validate_empty({"endpoints": [{}]}) is True
+
+
+def test_validate_empty_invalid():
+    assert validate_empty({}) == {
+        "level": "error",
+        "dataPath": "",
+        "message": "should not be empty",
+        "params": {"type": "ImpactAssessment"},
+    }
+
+
+def test_validate_linked_cycle_product_valid():
+    with open(f"{fixtures_folder}/cycle-contains-product/valid.json") as f:
+        data = json.load(f)
+    assert validate_linked_cycle_product(data, data.get("cycle")) is True
+
+
+def test_validate_linked_cycle_product_invalid():
+    with open(f"{fixtures_folder}/cycle-contains-product/invalid.json") as f:
+        data = json.load(f)
+    assert validate_linked_cycle_product(data, data.get("cycle")) == {
+        "level": "error",
+        "dataPath": ".product",
+        "message": "should be included in the cycle products",
+        "params": {
+            "product": {"@type": "Term", "@id": "maizeGrain"},
+            "node": {"type": "Cycle", "id": "fake-cycle"},
+        },
+    }
+
+
+def test_validate_linked_cycle_endDate_valid():
+    with open(f"{fixtures_folder}/cycle-endDate/valid.json") as f:
+        data = json.load(f)
+    assert validate_linked_cycle_endDate(data, data.get("cycle")) is True
+
+
+def test_validate_linked_cycle_endDate_invalid():
+    with open(f"{fixtures_folder}/cycle-endDate/invalid.json") as f:
+        data = json.load(f)
+    assert validate_linked_cycle_endDate(data, data.get("cycle")) == {
+        "level": "error",
+        "dataPath": ".endDate",
+        "message": "must be equal to the Cycle endDate",
+    }

package/tests/validators/test_indicator.py

@@ -0,0 +1,120 @@
+import os
+import json
+from unittest.mock import patch
+
+from tests.utils import MODEL_TERM_IDS, fixtures_path, fake_get_terms
+from hestia_earth.validation.validators.indicator import (
+    validate_characterisedIndicator_model,
+    validate_landTransformation,
+    validate_inonising_compounds_waste,
+)
+
+class_path = "hestia_earth.validation.validators.indicator"
+fixtures_folder = os.path.join(fixtures_path, "indicator")
+
+
+@patch(f"{class_path}.get_terms", side_effect=fake_get_terms)
+def test_validate_characterisedIndicator_model_valid(*args):
+    # no infrastructure should be valid
+    assert validate_characterisedIndicator_model({}, "impacts") is True
+
+    with open(f"{fixtures_folder}/characterisedIndicator-methodModel/valid.json") as f:
+        data = json.load(f)
+    assert validate_characterisedIndicator_model(data, "impacts") is True
+
+
+@patch(f"{class_path}.get_terms", side_effect=fake_get_terms)
+def test_validate_characterisedIndicator_model_invalid(*args):
+    with open(
+        f"{fixtures_folder}/characterisedIndicator-methodModel/invalid.json"
+    ) as f:
+        data = json.load(f)
+    assert validate_characterisedIndicator_model(data, "impacts") == {
+        "level": "error",
+        "dataPath": ".impacts[0].methodModel.@id",
+        "message": "is not allowed for this characterisedIndicator",
+        "params": {
+            "term": {"@type": "Term", "@id": "gwp20"},
+            "model": {"@type": "Term", "@id": "ipcc2013"},
+            "allowedValues": MODEL_TERM_IDS,
+        },
+    }
+
+
+@patch(f"{class_path}.get_terms", side_effect=fake_get_terms)
+def test_validate_landTransformation_valid(*args):
+    # no infrastructure should be valid
+    assert validate_landTransformation({}) is True
+
+    with open(f"{fixtures_folder}/landTransformation/valid.json") as f:
+        data = json.load(f)
+    assert (
+        validate_landTransformation(
+            {"emissionsResourceUse": data["nodes"]}, "emissionsResourceUse"
+        )
+        is True
+    )
+
+    with open(f"{fixtures_folder}/landTransformation/valid-grouped.json") as f:
+        data = json.load(f)
+    assert validate_landTransformation(data, "emissionsResourceUse") is True
+
+
+@patch(f"{class_path}.get_terms", side_effect=fake_get_terms)
+def test_validate_landTransformation_invalid(*args):
+    with open(f"{fixtures_folder}/landTransformation/invalid.json") as f:
+        data = json.load(f)
+    assert validate_landTransformation(
+        {"emissionsResourceUse": data["nodes"]}, "emissionsResourceUse"
+    ) == {
+        "level": "error",
+        "dataPath": ".emissionsResourceUse[1].value",
+        "message": "must be less than or equal to land occupation",
+        "params": {"current": 0.2, "max": 0.1},
+    }
+
+    with open(f"{fixtures_folder}/landTransformation/invalid-grouped.json") as f:
+        data = json.load(f)
+    assert validate_landTransformation(data, "emissionsResourceUse") == [
+        {
+            "level": "error",
+            "dataPath": ".emissionsResourceUse[3].value",
+            "message": "must be less than or equal to land occupation",
+            "params": {"current": 0.1, "max": 0.01},
+        },
+        {
+            "level": "error",
+            "dataPath": ".emissionsResourceUse[6].value",
+            "message": "must be less than or equal to land occupation",
+            "params": {"current": 2, "max": 1},
+        },
+    ]
+
+
+@patch(f"{class_path}.get_terms", side_effect=fake_get_terms)
+def test_validate_inonising_compounds_waste_valid(*args):
+    # no infrastructure should be valid
+    assert validate_inonising_compounds_waste({}) is True
+
+    with open(f"{fixtures_folder}/ionisingCompounds/valid.json") as f:
+        data = json.load(f)
+    assert (
+        validate_inonising_compounds_waste(
+            {"emissionsResourceUse": data["nodes"]}, "emissionsResourceUse"
+        )
+        is True
+    )
+
+
+@patch(f"{class_path}.get_terms", side_effect=fake_get_terms)
+def test_validate_inonising_compounds_waste_invalid(*args):
+    with open(f"{fixtures_folder}/ionisingCompounds/invalid.json") as f:
+        data = json.load(f)
+    assert validate_inonising_compounds_waste(
+        {"emissionsResourceUse": data["nodes"]}, "emissionsResourceUse"
+    ) == {
+        "level": "error",
+        "dataPath": ".emissionsResourceUse[0].key.termType",
+        "message": "should be equal to one of the allowed values",
+        "params": {"allowedValues": ["waste"]},
+    }

package/tests/validators/test_infrastructure.py

@@ -0,0 +1,26 @@
+import json
+
+from tests.utils import fixtures_path
+from hestia_earth.validation.validators.infrastructure import validate_lifespan
+
+
+def test_validate_lifespan_valid():
+    # no infrastructure should be valid
+    assert validate_lifespan([]) is True
+
+    with open(f"{fixtures_path}/infrastructure/lifespan/valid.json") as f:
+        data = json.load(f)
+    assert validate_lifespan(data.get("nodes")) is True
+
+
+def test_validate_lifespan_invalid():
+    with open(f"{fixtures_path}/infrastructure/lifespan/invalid.json") as f:
+        data = json.load(f)
+    assert validate_lifespan(data.get("nodes")) == {
+        "level": "error",
+        "dataPath": ".infrastructure[1].defaultLifespan",
+        "message": "must equal to endDate - startDate in decimal years",
+        "params": {
+            "expected": 2.6,
+        },
+    }