hestia-earth-models 0.65.11__py3-none-any.whl → 0.67.0__py3-none-any.whl

tests/models/cml2001Baseline/test_abioticResourceDepletionFossilFuels.py

@@ -4,7 +4,7 @@ from unittest.mock import patch
 from pytest import mark
 
 from hestia_earth.models.cml2001Baseline.abioticResourceDepletionFossilFuels import MODEL, TERM_ID, run, _should_run, \
-    download_all_non_renewable_terms
+    get_all_non_renewable_terms
 from tests.utils import fixtures_path, fake_new_indicator
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
@@ -17,7 +17,7 @@ def fake_rounded_indicator(value: float):
     return indicator
 
 
-def fake_download_hestia(filename):
+def fake_download_hestia(filename, column_name):
     data = {
         'fuel.csv': ["lignite", "conventionalCrudeOil", "naturalGas", "coalTar"],
         'electricity.csv': ['electricityGridMarketMix', 'electricityGridHardCoal', 'electricityProducedOnSiteHardCoal',
@@ -27,94 +27,56 @@ def fake_download_hestia(filename):
 
 
 input_lignite_mj = {"@id": "lignite", "name": "lignite (Brown coal)", "termType": "fuel", "units": "MJ"}
-input_coal_tar_kg = {"@id": "coalTar", "name": "Coal tar unknown energy Content", "termType": "fuel", "units": "kg"}
-input_crude_oil_kg_property = {
-    "@id": "conventionalCrudeOil", "name": "Conventional Crude Oil", "termType": "fuel", "units": "kg",
-    "properties": [{"@type": "Property", "value": 45.8,
-                    "term": {"@type": "Term", "@id": "energyContentHigherHeatingValue", "units": "MJ / kg"}, }]}
-input_crude_oil_kg_no_property = {
-    "@id": "conventionalCrudeOil", "name": "Conventional Crude Oil", "termType": "fuel", "units": "kg"}
-input_natural_gas_m3 = {"@id": "naturalGas", "name": "Natural Gas", "termType": "fuel", "units": "m3"}
+
 input_nuclear_fuel_mj = {"@id": "electricityGridNuclear", "name": "Any depleted nuclear fuel",
                          "termType": "electricity", "units": "MJ"}
-input_nuclear_fuel_kwh = {"@id": "electricityGridNuclear", "termType": "electricity", "units": "kWh"}
+
 input_excessIndustrialHeat_mj = {"@id": "excessIndustrialHeat", "name": "Excess industrial heat", "termType": "fuel",
                                  "units": "MJ"}
 
-wrong_indicator = {"term": {"@id": "BAD_INDICATOR_ID", "termType": "resourceUse"},
+wrong_indicator = {"term": {"@id": "BAD_INDICATOR_ID", "termType": "resourceUse", "units": "MJ"},
                    "value": 5,
                    "inputs": [input_lignite_mj]}
 
-indicator_no_inputs = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
-                       "value": 5,
-                       "inputs": []}
+indicator_no_inputs = {
+    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse", "units": "MJ"},
+    "value": 5,
+    "inputs": []}
 
-indicator_2_inputs = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
-                      "value": 5,
-                      "inputs": [input_lignite_mj, input_lignite_mj]}
+indicator_2_inputs = {
+    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse", "units": "MJ"},
+    "value": 5,
+    "inputs": [input_lignite_mj, input_lignite_mj]}
 
 indicator_no_unit = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
                      "value": 5,
-                     "inputs": [{
-                         "@id": "lignite",
-                         "@type": "Term",
-                         "name": "lignite (Brown coal)",
-                         "termType": "fuel",
-                     }]}
-
-indicator_wrong_unit = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+                     "inputs": [input_lignite_mj]}
+
+indicator_wrong_unit = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse",
+                                 "units": "ha"},
                         "value": 5,
-                        "inputs": [
-                            {
-                                "@id": "lignite",
-                                "@type": "Term",
-                                "name": "lignite (Brown coal)",
-                                "termType": "fuel",
-                                "units": "ha"
-                            }
-                        ]}
-
-indicator_bad_input_id = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
-                          "value": 5,
-                          "inputs": [input_excessIndustrialHeat_mj]}
+                        "inputs": [input_lignite_mj]}
 
-good_indicator_inputs_production_mj = {
-    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+indicator_bad_input_id = {
+    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse", "units": "MJ"},
     "value": 5,
-    "inputs": [input_lignite_mj]
-}
+    "inputs": [input_excessIndustrialHeat_mj]}
 
-good_indicator_during_cycle_mj = {"term": {"@id": "resourceUseEnergyDepletionDuringCycle", "termType": "resourceUse"},
-                                  "value": 5,
-                                  "inputs": [input_lignite_mj]}
-
-good_indicator_inputs_production_with_property = {
-    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+good_indicator_inputs_production_mj = {
+    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse", "units": "MJ"},
     "value": 5,
-    "inputs": [input_crude_oil_kg_property]
+    "inputs": [input_lignite_mj]
 }
 
-good_indicator_inputs_production_with_no_property = {
-    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+good_indicator_during_cycle_mj = {
+    "term": {"@id": "resourceUseEnergyDepletionDuringCycle", "termType": "resourceUse", "units": "MJ"},
     "value": 5,
-    "inputs": [input_crude_oil_kg_no_property]
-}
-
-good_indicator_m3 = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
-                     "value": 5,
-                     "inputs": [input_natural_gas_m3]}
-
-good_nuclear_indicator_mj = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
-                             "value": 5,
-                             "inputs": [input_nuclear_fuel_mj]}
-good_nuclear_indicator_kwh = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
-                              "value": 1.3889,
-                              "inputs": [input_nuclear_fuel_kwh]}
+    "inputs": [input_lignite_mj]}
 
-bad_fuel_indicator_no_property_lookup = {
-    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+good_nuclear_indicator_mj = {
+    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse", "units": "MJ"},
     "value": 5,
-    "inputs": [input_coal_tar_kg]}
+    "inputs": [input_nuclear_fuel_mj]}
 
 
 @mark.parametrize(
@@ -124,26 +86,27 @@ bad_fuel_indicator_no_property_lookup = {
         ([wrong_indicator], False, 0),
         ([indicator_no_inputs], False, 0),
         ([indicator_2_inputs], False, 2),
-        ([indicator_no_unit], False, 0),
-        ([indicator_wrong_unit], False, 0),
+        ([indicator_no_unit], False, 1),
+        ([indicator_wrong_unit], False, 1),
         ([indicator_bad_input_id], False, 0),
         ([good_indicator_inputs_production_mj], True, 1),
         ([good_indicator_during_cycle_mj], True, 1),
-        ([good_indicator_inputs_production_with_property], True, 1),
-        ([good_indicator_inputs_production_with_no_property], True, 1),
-        ([good_indicator_m3], True, 1),
         ([good_nuclear_indicator_mj], True, 1),
-        ([good_nuclear_indicator_kwh], True, 1),
-        ([bad_fuel_indicator_no_property_lookup], False, 0),
     ],
-    ids=["No indicators", "wrong indicator", "indicator no inputs", "indicator 2 inputs", "missing unit", "wrong unit",
-         "input id not in requirements", "good input production mj", "good during cycle mj",
-         "good input with input property", "good input with no input property", "good indicator in m^3",
-         "good nuclear fuel use indicator in mj", "good nuclear fuel use indicator in kWh",
-         "bad indicator input in kg no property to convert to mj"]
+    ids=["No indicators",
+         "wrong indicator",
+         "indicator no inputs",
+         "indicator 2 inputs",
+         "missing unit",
+         "wrong unit",
+         "input id not in requirements",
+         "good input production mj",
+         "good during cycle mj",
+         "good nuclear fuel use indicator in mj",
+         ]
 )
-@patch(f"{class_path}.download_all_non_renewable_terms", side_effect=fake_download_hestia)
-def test_should_run(mock_download_all_non_renewable_terms, resources, expected, num_inputs):
+@patch(f"{class_path}.get_all_non_renewable_terms", side_effect=fake_download_hestia)
+def test_should_run(mock_get_all_non_renewable_terms, resources, expected, num_inputs):
     with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
         impactassessment = json.load(f)
 
@@ -154,7 +117,7 @@ def test_should_run(mock_download_all_non_renewable_terms, resources, expected,
     assert len(resources) == num_inputs
 
 
-@patch(f"{class_path}.download_all_non_renewable_terms", side_effect=fake_download_hestia)
+@patch(f"{class_path}.get_all_non_renewable_terms", side_effect=fake_download_hestia)
 @patch(f"{class_path}._indicator", side_effect=fake_rounded_indicator)
 def test_run(*args):
     with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
@@ -167,16 +130,17 @@ def test_run(*args):
     assert value == expected
 
 
-def test_download_all_non_renewable_terms(*args):
+def test_get_all_non_renewable_terms(*args):
     """
-    make sure download_all_non_renewable_terms() only returns terms we want
+    make sure get_all_non_renewable_terms() only returns terms we want
     """
-    electricity_terms = download_all_non_renewable_terms("electricity.csv")
+    electricity_terms = get_all_non_renewable_terms("electricity.csv", "consideredFossilFuelUnderCml2001Baseline")
 
     assert "electricityGridHardCoal" in electricity_terms
     assert "electricityGridWind" not in electricity_terms
 
-    fuel_terms = download_all_non_renewable_terms("fuel.csv")
+    fuel_terms = get_all_non_renewable_terms("fuel.csv", "consideredFossilFuelUnderCml2001Baseline")
 
     assert "coalTar" in fuel_terms
     assert "sodPeat" in fuel_terms
+    assert "bioJetKerosene" not in fuel_terms

tests/models/cml2001Baseline/test_resourceUseEnergyDepletionDuringCycle.py

@@ -0,0 +1,103 @@
+import json
+from unittest.mock import patch
+
+import pytest
+
+from hestia_earth.models.cml2001Baseline.resourceUseEnergyDepletionDuringCycle import MODEL, TERM_ID, run, _should_run
+from tests.utils import fixtures_path, fake_new_indicator
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+diesel_input = {"term": {"termType": "fuel", "units": "kg", "@id": "diesel"}, "value": 2}
+diesel_input_in_mj = {"term": {"termType": "fuel", "units": "MJ", "@id": "diesel"}, "value": 111}
+diesel_input_wrong_unit = {"term": {"termType": "fuel", "units": "foobedoos", "@id": "diesel"}, "value": 2}
+diesel_input_no_unit = {"term": {"termType": "fuel", "@id": "diesel"}, "value": 2}
+diesel_input_with_properties = {"term": {"termType": "fuel", "units": "kg", "@id": "diesel"},
+                                "value": 2,
+                                "properties": [{"term": {"@id": "energyContentHigherHeatingValue", }, "value": 70}]
+                                }
+diesel_input_with_properties2 = {"term": {"termType": "fuel", "units": "kg", "@id": "diesel"},
+                                 "value": 2,
+                                 "properties": [{"term": {"@id": "energyContentHigherHeatingValue", }, "value": 4}]
+                                 }
+
+electricity_input = {"term": {"termType": "electricity", "units": "kWh", "@id": "electricityGridOil"}, "value": 30}
+
+input_coal_tar_kg = {"term": {"@id": "coalTar", "termType": "fuel", "units": "kg",
+                              "name": "Coal tar unknown energy Content"},
+                     "value": 5}
+
+input_crude_oil_kg_property = {"term": {"@id": "conventionalCrudeOil", "termType": "fuel", "units": "kg"},
+                               "value": 5,
+                               "properties": [{"@type": "Property", "value": 45.8,
+                                               "term": {"@type": "Term", "@id": "energyContentHigherHeatingValue",
+                                                        "units": "MJ / kg"}, }]}
+
+input_crude_oil_kg_no_property = {"term": {"@id": "conventionalCrudeOil", "termType": "fuel", "units": "kg"},
+                                  "value": 5}
+
+input_natural_gas_m3 = {"term": {"@id": "naturalGas", "termType": "fuel", "units": "m3"}, "value": 5}
+
+input_nuclear_fuel_kwh = {"term": {"@id": "electricityGridNuclear", "termType": "electricity", "units": "kWh"},
+                          "value": 1.3889}
+
+
+@pytest.mark.parametrize(
+    "inputs, expected, num_inputs",
+    [
+        ([], False, 0),
+        ([diesel_input_wrong_unit], False, 0),
+        ([diesel_input_no_unit], False, 0),
+        ([diesel_input], True, 1),
+        ([diesel_input, diesel_input, diesel_input_in_mj], True, 1),
+        ([diesel_input, diesel_input_with_properties], True, 1),
+        ([diesel_input_with_properties, diesel_input_with_properties], True, 1),
+        ([diesel_input_with_properties2, diesel_input_with_properties], True, 1),
+        ([electricity_input], True, 1),
+        ([electricity_input, electricity_input, electricity_input], True, 1),
+        ([input_crude_oil_kg_property], True, 1),
+        ([input_crude_oil_kg_no_property], True, 1),
+        ([input_natural_gas_m3], True, 1),
+        ([input_nuclear_fuel_kwh], True, 1),
+        ([input_coal_tar_kg], False, 0),
+    ],
+    ids=[
+        "No inputs => no run, empty input",
+        "bad input unit => no run, empty input",
+        "bad input no unit => no run, empty input",
+        "good fuel input => run",
+        "multiple good merg-able fuel inputs => run",
+        "multiple good distinct fuel inputs => run",
+        "multiple good fuel inputs with same prop=> run",
+        "multiple good fuel inputs with distinct prop=> run",
+        "good electric input => run",
+        "multiple good merg-able electric inputs => run",
+        "good fuel with input property",
+        "good fuel with no input property",
+        "good fuel in m^3",
+        "good nuclear fuel use indicator in kWh",
+        "bad indicator input in kg no property to convert to mj"
+    ]
+)
+def test_should_run(inputs, expected, num_inputs):
+    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    cycle['inputs'] = inputs
+
+    should_run, grouped_energy_terms = _should_run(cycle)
+    assert should_run is expected
+    assert len(grouped_energy_terms.keys()) == num_inputs
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/cml2001Baseline/test_resourceUseEnergyDepletionInputsProduction.py

@@ -0,0 +1,23 @@
+import json
+from unittest.mock import patch
+
+from hestia_earth.models.cml2001Baseline import MODEL
+from hestia_earth.models.cml2001Baseline.resourceUseEnergyDepletionInputsProduction import TERM_ID, run
+from tests.utils import fixtures_path, fake_new_indicator, fake_load_impacts
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+utils_class_path = "hestia_earth.models.linkedImpactAssessment.utils"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{utils_class_path}.load_impacts", side_effect=fake_load_impacts)
+@patch(f"{utils_class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(f"{fixtures_folder}/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impact)
+    assert value == expected

tests/models/cml2001Baseline/test_resourceUseMineralsAndMetalsDuringCycle.py

@@ -0,0 +1,58 @@
+import json
+from unittest.mock import patch
+
+import pytest
+
+from hestia_earth.models.cml2001Baseline.resourceUseMineralsAndMetalsDuringCycle import MODEL, TERM_ID, run, _should_run
+from tests.utils import fixtures_path, fake_new_indicator
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+antimony = {"term": {"termType": "material", "@id": "antimony", "units": "kg"}, "value": [3]}
+antimony_bad_unit = {"term": {"termType": "material", "@id": "antimony", "units": "boogiewoogiw"}, "value": [3]}
+boron = {"term": {"termType": "soilAmendment", "@id": "boron", "units": "kg"}, "value": [3]}
+tellurium = {"term": {"termType": "otherInorganicChemical", "@id": "CAS-13494-80-9", "units": "kg"}, "value": [30]}
+
+
+@pytest.mark.parametrize(
+    "cycle_inputs, expected, num_inputs",
+    [
+        ([], False, 0),
+        ([antimony_bad_unit], False, 0),
+        ([antimony], True, 1),
+        ([antimony, antimony, antimony], True, 1),
+        ([antimony, boron], True, 2),
+        ([antimony, boron, tellurium], True, 3),
+
+    ],
+    ids=[
+        "No inputs => no run, empty input",
+        "bad input => no run, empty input",
+        "good fuel input => run",
+        "multiple good merg-able material inputs => run",
+        "multiple good non merg-able material inputs => run",
+        "all termTypes inputs => run",
+    ]
+)
+def test_should_run(cycle_inputs, expected, num_inputs):
+    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    cycle['inputs'] = cycle_inputs
+
+    should_run, grouped_energy_terms = _should_run(cycle)
+    assert should_run is expected
+    assert len(grouped_energy_terms.keys()) == num_inputs
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/cml2001Baseline/test_resourceUseMineralsAndMetalsInputsProduction.py

@@ -0,0 +1,23 @@
+import json
+from unittest.mock import patch
+
+from hestia_earth.models.cml2001Baseline import MODEL
+from hestia_earth.models.cml2001Baseline.resourceUseMineralsAndMetalsInputsProduction import TERM_ID, run
+from tests.utils import fixtures_path, fake_new_indicator, fake_load_impacts
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+utils_class_path = "hestia_earth.models.linkedImpactAssessment.utils"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{utils_class_path}.load_impacts", side_effect=fake_load_impacts)
+@patch(f"{utils_class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(f"{fixtures_folder}/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impact)
+    assert value == expected

tests/models/environmentalFootprintV3_1/test_environmentalFootprintSingleOverallScore.py

@@ -0,0 +1,93 @@
+import json
+from unittest.mock import patch, Mock
+
+from pytest import mark
+
+from hestia_earth.models.environmentalFootprintV3_1 import MODEL_FOLDER
+from hestia_earth.models.environmentalFootprintV3_1.environmentalFootprintSingleOverallScore import MODEL, TERM_ID, \
+    run, _should_run
+from tests.utils import fixtures_path, fake_new_indicator
+
+class_path = f"hestia_earth.models.{MODEL_FOLDER}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL_FOLDER}/{TERM_ID}"
+
+
+def fake_rounded_indicator(value: float):
+    indicator = fake_new_indicator(TERM_ID, MODEL)
+    indicator['value'] = round(value, 20)
+    return indicator
+
+
+ozone_indicator = {"@type": "Indicator",
+                   "term": {"@id": "ozoneDepletionPotential", "termType": "characterisedIndicator"},
+                   "value": 0}
+
+acid_indicator = {
+    "@type": "Indicator",
+    "term": {"@id": "terrestrialAcidificationPotentialAccumulatedExceedance", "termType": "characterisedIndicator"},
+    "value": 0.000420443840380047}
+
+bad_indicator_id = {"@type": "Indicator",
+                    "term": {"@id": "no_a_real_id", "termType": "characterisedIndicator"},
+                    "value": 0.000420443840380047}
+
+not_pef_indicator = {"@type": "Indicator",
+                     "term": {"@id": "gwpStar", "termType": "characterisedIndicator"},
+                     "value": 0.000420443840380047}
+
+bad_indicator_no_val = {"@type": "Indicator",
+                        "term": {"@id": "damageToHumanHealthParticulateMatterFormation",
+                                 "termType": "characterisedIndicator"}}
+
+bad_indicator_bad_val = {"@type": "Indicator",
+                         "term": {"@id": "damageToHumanHealthParticulateMatterFormation",
+                                  "termType": "characterisedIndicator"},
+                         "value": None}
+
+
+@mark.parametrize(
+    "impacts, expected, num_inputs",
+    [
+        ([], False, 0),
+        ([bad_indicator_id], False, 0),
+        ([not_pef_indicator], False, 0),
+        ([bad_indicator_no_val], False, 0),
+        ([bad_indicator_bad_val], False, 0),
+        ([ozone_indicator], True, 1),
+        ([ozone_indicator, ozone_indicator], False, 2),
+        ([ozone_indicator, acid_indicator], True, 2),
+        ([bad_indicator_no_val, acid_indicator], False, 1)
+    ],
+    ids=[
+        "No indicators => no run",
+        "bad_indicator_id => no run",
+        "not_pef_indicator => no run",
+        "bad_indicator_no_val => no run",
+        "bad_indicator_bad_val => no run",
+        "ozone_indicator => run",
+        "2 ozone_indicator => no run",
+        "2 good indicators => run",
+        "one bad one good indicator => no run",
+    ]
+)
+def test_should_run(impacts, expected, num_inputs):
+    with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    impactassessment['impacts'] = impacts
+
+    should_run, resources = _should_run(impactassessment)
+    assert should_run is expected
+    assert len(resources) == num_inputs
+
+
+@patch(f"{class_path}._indicator", side_effect=fake_rounded_indicator)
+def test_run(_mocked_indicator: Mock, *args):
+    with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impactassessment)
+    assert value == expected

tests/models/{environmentalFootprintV3 → environmentalFootprintV3_1}/test_freshwaterEcotoxicityPotentialCtue.py

@@ -1,11 +1,12 @@
-from unittest.mock import patch
 import json
-from tests.utils import fixtures_path, fake_new_indicator
+from unittest.mock import patch
 
-from hestia_earth.models.environmentalFootprintV3.freshwaterEcotoxicityPotentialCtue import MODEL, TERM_ID, run
+from hestia_earth.models.environmentalFootprintV3_1 import MODEL_FOLDER
+from hestia_earth.models.environmentalFootprintV3_1.freshwaterEcotoxicityPotentialCtue import TERM_ID, run
+from tests.utils import fixtures_path, fake_new_indicator
 
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+class_path = f"hestia_earth.models.{MODEL_FOLDER}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL_FOLDER}/{TERM_ID}"
 
 
 with open(f"{fixtures_path}/impact_assessment/emissions/impact-assessment.jsonld", encoding='utf-8') as f:

tests/models/environmentalFootprintV3_1/test_marineEutrophicationPotential.py

@@ -0,0 +1,27 @@
+import json
+from unittest.mock import patch
+
+from hestia_earth.models.environmentalFootprintV3_1 import MODEL_FOLDER
+from hestia_earth.models.environmentalFootprintV3_1.marineEutrophicationPotential import MODEL, TERM_ID, run
+from tests.utils import fixtures_path, fake_new_indicator
+
+class_path = f"hestia_earth.models.{MODEL_FOLDER}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL_FOLDER}/{TERM_ID}"
+
+
+def fake_rounded_indicator(value: float):
+    indicator = fake_new_indicator(TERM_ID, MODEL)
+    indicator['value'] = round(value, 7)
+    return indicator
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(f"{fixtures_folder}/impact-assessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    with open(f"{fixtures_folder}/region-world/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impactassessment)
+    assert value == expected

tests/models/environmentalFootprintV3_1/test_scarcityWeightedWaterUse.py

@@ -0,0 +1,32 @@
+import json
+import os
+from unittest.mock import patch
+
+from pytest import mark
+
+from hestia_earth.models.environmentalFootprintV3_1 import MODEL_FOLDER
+from hestia_earth.models.environmentalFootprintV3_1.scarcityWeightedWaterUse import MODEL, TERM_ID, run
+from tests.utils import fixtures_path, fake_new_indicator
+
+class_path = f"hestia_earth.models.{MODEL_FOLDER}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL_FOLDER}/{TERM_ID}"
+_folders = [d for d in os.listdir(fixtures_folder) if os.path.isdir(os.path.join(fixtures_folder, d))]
+
+
+def fake_rounded_indicator(value: float):
+    indicator = fake_new_indicator(TERM_ID, MODEL)
+    indicator['value'] = round(value, 13)
+    return indicator
+
+
+@mark.parametrize("folder", _folders)
+@patch(f"{class_path}._indicator", side_effect=fake_rounded_indicator)
+def test_run(mock_indicator, folder):
+    with open(f"{fixtures_folder}/{folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    with open(f"{fixtures_folder}/{folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impactassessment)
+    assert value == expected, folder

tests/models/{environmentalFootprintV3 → environmentalFootprintV3_1}/test_soilQualityIndexLandOccupation.py

@@ -3,12 +3,13 @@ from unittest.mock import patch
 
 import pytest
 
-from hestia_earth.models.environmentalFootprintV3.soilQualityIndexLandOccupation import MODEL, TERM_ID, run, \
+from hestia_earth.models.environmentalFootprintV3_1 import MODEL_FOLDER
+from hestia_earth.models.environmentalFootprintV3_1.soilQualityIndexLandOccupation import TERM_ID, run, \
     _should_run
 from tests.utils import fixtures_path, fake_new_indicator
 
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+class_path = f"hestia_earth.models.{MODEL_FOLDER}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL_FOLDER}/{TERM_ID}"
 
 crop_land = {"@id": "cropland", "termType": "landCover"}
 sea_land_cover = {"@id": "seaOrOcean", "termType": "landCover"}