@hestia-earth/data-validation 0.37.7

package/tests/validators/test_product.py

@@ -0,0 +1,291 @@
+from unittest.mock import patch
+import json
+import os
+
+from tests.utils import fixtures_path
+from hestia_earth.validation.validators.product import (
+    validate_economicValueShare,
+    validate_value_empty,
+    validate_value_0,
+    validate_primary,
+    validate_product_ha_functional_unit_ha,
+    validate_product_yield,
+    validate_excreta_product,
+)
+
+
+class_path = "hestia_earth.validation.validators.product"
+distribution_class_path = "hestia_earth.validation.validators.distribution"
+fixtures_folder = os.path.join(fixtures_path, "product")
+
+
+def test_validate_economicValueShare_valid():
+    # no products should be valid
+    assert validate_economicValueShare([]) is True
+
+    with open(f"{fixtures_folder}/economicValueShare/valid.json") as f:
+        data = json.load(f)
+    assert validate_economicValueShare(data.get("nodes")) is True
+
+
+def test_validate_economicValueShare_invalid():
+    with open(f"{fixtures_folder}/economicValueShare/invalid.json") as f:
+        data = json.load(f)
+    assert validate_economicValueShare(data.get("nodes")) == {
+        "level": "error",
+        "dataPath": ".products",
+        "message": "economicValueShare should sum to 100 or less across all products",
+        "params": {"sum": 110},
+    }
+
+
+def test_validate_value_empty_valid():
+    # no products should be valid
+    assert validate_value_empty([]) is True
+
+    with open(f"{fixtures_folder}/value/valid.json") as f:
+        data = json.load(f)
+    assert validate_value_empty(data.get("nodes")) is True
+
+
+def test_validate_value_empty_warning():
+    with open(f"{fixtures_folder}/value/value-empty/warning.json") as f:
+        data = json.load(f)
+    assert validate_value_empty(data.get("nodes")) == {
+        "level": "warning",
+        "dataPath": ".products[1]",
+        "message": "may not be 0",
+    }
+
+
+def test_validate_value_0_valid():
+    # no products should be valid
+    assert validate_value_0([]) is True
+
+    with open(f"{fixtures_folder}/value/valid.json") as f:
+        data = json.load(f)
+    assert validate_value_0(data.get("nodes")) is True
+
+
+def test_validate_value_0_error():
+    with open(f"{fixtures_folder}/value/value-0/error.json") as f:
+        data = json.load(f)
+    assert validate_value_0(data.get("nodes")) == [
+        {
+            "level": "error",
+            "dataPath": ".products[1].value",
+            "message": "economicValueShare must be 0 for product value 0",
+            "params": {
+                "value": 100,
+                "term": {
+                    "@type": "Term",
+                    "name": "Generic Crop, seed",
+                    "@id": "genericCropSeed",
+                },
+            },
+        },
+        {
+            "level": "error",
+            "dataPath": ".products[1].value",
+            "message": "revenue must be 0 for product value 0",
+            "params": {
+                "value": 100,
+                "term": {
+                    "@type": "Term",
+                    "name": "Generic Crop, seed",
+                    "@id": "genericCropSeed",
+                },
+            },
+        },
+    ]
+
+
+def test_validate_primary_valid():
+    # no products should be valid
+    assert validate_primary([]) is True
+
+    with open(f"{fixtures_folder}/primary/valid.json") as f:
+        data = json.load(f)
+    assert validate_primary(data.get("nodes")) is True
+
+
+def test_validate_primary_error():
+    with open(f"{fixtures_folder}/primary/invalid.json") as f:
+        data = json.load(f)
+    assert validate_primary(data.get("nodes")) == {
+        "level": "error",
+        "dataPath": ".products",
+        "message": "only 1 primary product allowed",
+    }
+
+
+def test_validate_product_ha_functional_unit_ha_valid():
+    # no products should be valid
+    assert validate_product_ha_functional_unit_ha({"products": []}, "products") is True
+
+    with open(f"{fixtures_folder}/fu_ha/valid.json") as f:
+        cycle = json.load(f)
+    assert validate_product_ha_functional_unit_ha(cycle, "products") is True
+
+
+def test_validate_product_ha_functional_unit_ha_error():
+    with open(f"{fixtures_folder}/fu_ha/invalid.json") as f:
+        cycle = json.load(f)
+    assert validate_product_ha_functional_unit_ha(cycle, "products") == {
+        "level": "error",
+        "dataPath": ".products[0].value",
+        "message": "must be below or equal to 1 for unit in ha",
+        "params": {"term": {"@type": "Term", "@id": "adzukiBeanVines", "units": "ha"}},
+    }
+
+
+MU = 8000
+SD = 1000
+
+
+@patch(f"{distribution_class_path}.get_post_yield", return_value=(MU, SD))
+def test_validate_product_yield_valid(*args):
+    # no products should be valid
+    assert validate_product_yield({"products": []}, {}, "products") is True
+
+    # no value on products should be valid
+    with open(f"{fixtures_folder}/yield/no-value.json") as f:
+        cycle = json.load(f)
+    assert validate_product_yield(cycle, cycle.get("site")) is True
+
+
+@patch(f"{distribution_class_path}.get_post_yield", return_value=(MU, SD))
+def test_validate_product_yield_valid_with_posterior(*args):
+    with open(f"{fixtures_folder}/yield/valid.json") as f:
+        cycle = json.load(f)
+    assert validate_product_yield(cycle, cycle.get("site")) is True
+
+
+@patch(f"{distribution_class_path}.get_post_yield", return_value=(MU, SD))
+def test_validate_product_yield_invalid_with_posterior(*args):
+    with open(f"{fixtures_folder}/yield/invalid.json") as f:
+        cycle = json.load(f)
+    assert validate_product_yield(cycle, cycle.get("site")) == {
+        "level": "warning",
+        "dataPath": ".products[0].value",
+        "message": "is outside confidence interval",
+        "params": {
+            "term": {"@type": "Term", "termType": "crop", "@id": "wheatGrain"},
+            "country": {"@type": "Term", "@id": "GADM-GBR"},
+            "outliers": [1000],
+            "threshold": 0.95,
+            "min": 6040,
+            "max": 9960,
+        },
+    }
+
+
+@patch(f"{distribution_class_path}.get_prior_yield", return_value=(MU, SD))
+@patch(f"{distribution_class_path}.get_post_yield", return_value=(None, None))
+def test_validate_product_yield_valid_with_prior_no_posterior(*args):
+    with open(f"{fixtures_folder}/yield/valid.json") as f:
+        cycle = json.load(f)
+    assert validate_product_yield(cycle, cycle.get("site")) is True
+
+
+@patch(f"{distribution_class_path}.get_prior_yield", return_value=(MU, SD))
+@patch(f"{distribution_class_path}.get_post_yield", return_value=(None, None))
+def test_validate_product_yield_invalid_with_prior_no_posterior(*args):
+    with open(f"{fixtures_folder}/yield/invalid.json") as f:
+        cycle = json.load(f)
+    assert validate_product_yield(cycle, cycle.get("site")) == {
+        "level": "warning",
+        "dataPath": ".products[0].value",
+        "message": "is outside confidence interval",
+        "params": {
+            "term": {"@type": "Term", "termType": "crop", "@id": "wheatGrain"},
+            "country": {"@type": "Term", "@id": "GADM-GBR"},
+            "outliers": [1000],
+            "threshold": 0.95,
+            "min": 6040,
+            "max": 9960,
+        },
+    }
+
+
+@patch(f"{distribution_class_path}.get_prior_yield", return_value=(None, None))
+@patch(f"{distribution_class_path}.get_post_yield", return_value=(None, None))
+def test_validate_product_yield_valid_no_prior_no_posterior(*args):
+    with open(f"{fixtures_folder}/yield/valid.json") as f:
+        cycle = json.load(f)
+    assert validate_product_yield(cycle, cycle.get("site")) is True
+
+
+@patch(f"{distribution_class_path}.get_post_yield", return_value=Exception)
+def test_validate_product_yield_handle_exception(*args):
+    with open(f"{fixtures_folder}/yield/invalid.json") as f:
+        cycle = json.load(f)
+    assert validate_product_yield(cycle, cycle.get("site")) is True
+
+
+def test_validate_excreta_product_valid():
+    # no products should be valid
+    assert validate_excreta_product({}, "products") is True
+
+    with open(f"{fixtures_folder}/excreta/valid.json") as f:
+        data = json.load(f)
+    assert validate_excreta_product(data) is True
+
+    with open(f"{fixtures_folder}/excreta/with-system/valid.json") as f:
+        data = json.load(f)
+    assert validate_excreta_product(data) is True
+
+
+def test_validate_excreta_product_invalid():
+    with open(f"{fixtures_folder}/excreta/invalid.json") as f:
+        data = json.load(f)
+    assert validate_excreta_product(data) == {
+        "level": "error",
+        "dataPath": ".products[1].term.@id",
+        "message": "is not an allowed excreta product",
+        "params": {"current": "excretaCamelsKgN", "expected": ["excretaPoultryKgN"]},
+    }
+
+    with open(f"{fixtures_folder}/excreta/with-system/invalid.json") as f:
+        data = json.load(f)
+    assert validate_excreta_product(data) == {
+        "level": "error",
+        "dataPath": ".products[1].term.@id",
+        "message": "is not an allowed excreta product",
+        "params": {
+            "current": "excretaBeefCattleExceptFeedlotFedKgN",
+            "expected": ["excretaBeefCattleFeedlotFedKgN"],
+        },
+    }
+
+
+def test_validate_excreta_product_warning():
+    with open(f"{fixtures_folder}/excreta/warning.json") as f:
+        data = json.load(f)
+    assert validate_excreta_product(data) == {
+        "level": "warning",
+        "dataPath": ".products[0]",
+        "message": "should add an excreta product",
+        "params": {
+            "expected": [
+                "excretaPoultryKgMass",
+                "excretaPoultryKgN",
+                "excretaPoultryKgVs",
+            ]
+        },
+    }
+
+    with open(f"{fixtures_folder}/excreta/with-system/warning.json") as f:
+        data = json.load(f)
+    assert validate_excreta_product(data) == {
+        "level": "warning",
+        "dataPath": ".products[0]",
+        "message": "should add an excreta product",
+        "params": {
+            "expected": [
+                "excretaBeefCattleFeedlotFedKgMass",
+                "excretaBeefCattleFeedlotFedKgN",
+                "excretaBeefCattleFeedlotFedKgVs",
+            ]
+        },
+    }

package/tests/validators/test_property.py

@@ -0,0 +1,143 @@
+import os
+import json
+
+from tests.utils import fixtures_path
+from hestia_earth.validation.validators.property import (
+    validate_property_valueType,
+    validate_term_type,
+    validate_default_value,
+    validate_volatileSolidsContent,
+    validate_value_min_max,
+)
+
+fixtures_folder = os.path.join(fixtures_path, "property")
+
+
+def test_validate_property_valueType_valid():
+    # no properties should be valid
+    assert validate_property_valueType({}, "products") is True
+
+    with open(f"{fixtures_folder}/valueType/valid.json") as f:
+        data = json.load(f)
+    assert validate_property_valueType(data, "products") is True
+
+
+def test_validate_property_valueType_invalid():
+    with open(f"{fixtures_folder}/valueType/invalid.json") as f:
+        data = json.load(f)
+    assert validate_property_valueType(data, "products") == [
+        {
+            "level": "error",
+            "dataPath": ".products[1].properties[0].value",
+            "message": "the property value type is incorrect",
+            "params": {"expected": "number"},
+        },
+        {
+            "level": "error",
+            "dataPath": ".products[1].properties[1].value",
+            "message": "the property value type is incorrect",
+            "params": {"expected": "boolean"},
+        },
+    ]
+
+
+def test_validate_term_type_valid():
+    # no properties should be valid
+    assert validate_term_type({}, "products") is True
+
+    with open(f"{fixtures_folder}/termType/valid.json") as f:
+        data = json.load(f)
+    assert validate_term_type(data, "products") is True
+
+
+def test_validate_term_type_invalid():
+    with open(f"{fixtures_folder}/termType/invalid.json") as f:
+        data = json.load(f)
+    assert validate_term_type(data, "products") == {
+        "level": "error",
+        "dataPath": ".products[0].properties[0].term.termType",
+        "message": "can not be used on this termType",
+        "params": {"current": "crop", "expected": ["liveAnimal", "liveAquaticSpecies"]},
+    }
+
+
+def test_validate_default_value_valid():
+    with open(f"{fixtures_folder}/default-value/valid.json") as f:
+        node = json.load(f)
+    assert validate_default_value(node, "inputs") is True
+
+    with open(f"{fixtures_folder}/default-value/valid-allowed-exception.json") as f:
+        node = json.load(f)
+    assert validate_default_value(node, "inputs") is True
+
+
+def test_validate_default_value_warning():
+    with open(f"{fixtures_folder}/default-value/warning.json") as f:
+        node = json.load(f)
+    assert validate_default_value(node, "inputs") == {
+        "level": "warning",
+        "dataPath": ".inputs[0].properties[0].value",
+        "message": "should be within percentage of default value",
+        "params": {
+            "current": 67.0,
+            "default": 52.87673036,
+            "percentage": 26.71,
+            "threshold": 0.25,
+        },
+    }
+
+
+def test_validate_volatileSolidsContent_valid():
+    with open(f"{fixtures_folder}/volatileSolidsContent/valid.json") as f:
+        node = json.load(f)
+    assert validate_volatileSolidsContent(node, "inputs") is True
+
+
+def test_validate_volatileSolidsContent_error():
+    with open(f"{fixtures_folder}/volatileSolidsContent/invalid.json") as f:
+        node = json.load(f)
+    assert validate_volatileSolidsContent(node, "inputs") == [
+        {
+            "level": "error",
+            "dataPath": ".inputs[0].properties[0].value",
+            "message": "must be between 0 and 100",
+        },
+        {
+            "level": "error",
+            "dataPath": ".inputs[1].properties[0].value",
+            "message": "must be above 0",
+        },
+        {
+            "level": "error",
+            "dataPath": ".inputs[2].properties[0].value",
+            "message": "must be 100",
+        },
+    ]
+
+
+def test_validate_value_min_max_valid():
+    with open(f"{fixtures_folder}/value-min-max/valid.json") as f:
+        node = json.load(f)
+    assert validate_value_min_max(node, "inputs") is True
+
+    with open(f"{fixtures_folder}/value-min-max/valid-skip-maximum.json") as f:
+        node = json.load(f)
+    assert validate_value_min_max(node, "inputs") is True
+
+
+def test_validate_value_min_max_invalid():
+    with open(f"{fixtures_folder}/value-min-max/invalid.json") as f:
+        node = json.load(f)
+    assert validate_value_min_max(node, "inputs") == [
+        {
+            "level": "error",
+            "dataPath": ".inputs[0].properties[0].value",
+            "message": "must be between min and max",
+            "params": {"min": 20, "max": 80},
+        },
+        {
+            "level": "error",
+            "dataPath": ".inputs[1].properties[0].value",
+            "message": "should be below 100.0",
+        },
+    ]