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

tests/models/cml2001Baseline/test_abioticResourceDepletionFossilFuels.py

@@ -17,7 +17,7 @@ def fake_rounded_indicator(value: float):
     return indicator
 
 
-def fake_download_hestia(filename, column_name):
+def fake_get_terms(filename, column_name):
     data = {
         'fuel.csv': ["lignite", "conventionalCrudeOil", "naturalGas", "coalTar"],
         'electricity.csv': ['electricityGridMarketMix', 'electricityGridHardCoal', 'electricityProducedOnSiteHardCoal',
@@ -105,7 +105,7 @@ good_nuclear_indicator_mj = {
          "good nuclear fuel use indicator in mj",
          ]
 )
-@patch(f"{class_path}.get_all_non_renewable_terms", side_effect=fake_download_hestia)
+@patch(f"{class_path}.get_all_non_renewable_terms", side_effect=fake_get_terms)
 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)
@@ -117,7 +117,7 @@ def test_should_run(mock_get_all_non_renewable_terms, resources, expected, num_i
     assert len(resources) == num_inputs
 
 
-@patch(f"{class_path}.get_all_non_renewable_terms", side_effect=fake_download_hestia)
+@patch(f"{class_path}.get_all_non_renewable_terms", side_effect=fake_get_terms)
 @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:

tests/models/cml2001Baseline/test_resourceUseEnergyDepletionDuringCycle.py

@@ -9,38 +9,72 @@ 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}
+diesel_input = {
+    "term": {"termType": "fuel", "units": "kg", "@id": "diesel"},
+    "value": 2,
+    "properties": [{"term": {"@id": "energyContentLowerHeatingValue", }, "value": 70}]
+}
+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": "energyContentLowerHeatingValue", }, "value": 70}]
+}
+diesel_input_with_properties2 = {
+    "term": {"termType": "fuel", "units": "kg", "@id": "diesel"},
+    "value": 2,
+    "properties": [{"term": {"@id": "energyContentLowerHeatingValue", }, "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": "energyContentLowerHeatingValue", "units": "MJ / kg"},
+    }]
+}
+
+input_natural_gas_m3 = {
+    "term": {"@id": "naturalGas", "termType": "fuel", "units": "m3"},
+    "value": 5,
+    "properties": [{
+        "@type": "Property",
+        "value": 45.8,
+        "term": {"@type": "Term", "@id": "energyContentLowerHeatingValue", "units": "MJ / kg"},
+    }, {
+        "@type": "Property",
+        "value": 45.8,
+        "term": {"@type": "Term", "@id": "density", "units": "kg / m3"},
+    }]
+}
+
+input_nuclear_fuel_kwh = {
+    "term": {"@id": "electricityGridNuclear", "termType": "electricity", "units": "kWh"},
+    "value": 1.3889
+}
 
 
 @pytest.mark.parametrize(
@@ -57,7 +91,6 @@ input_nuclear_fuel_kwh = {"term": {"@id": "electricityGridNuclear", "termType":
         ([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),
@@ -74,13 +107,13 @@ input_nuclear_fuel_kwh = {"term": {"@id": "electricityGridNuclear", "termType":
         "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):
+@patch('hestia_earth.models.utils.property.download_term', return_value={})
+def test_should_run(mock_download, inputs, expected, num_inputs):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
         cycle = json.load(f)
 

tests/models/cycle/test_coldCarcassWeightPerHead.py

@@ -34,7 +34,7 @@ def test_should_run():
     assert should_run is True
 
 
-@patch("hestia_earth.models.utils.property.download_hestia", return_value={'units': '%'})
+@patch("hestia_earth.models.utils.property.download_term", return_value={'units': '%'})
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/cycle/test_coldDressedCarcassWeightPerHead.py

@@ -34,7 +34,7 @@ def test_should_run():
     assert should_run is True
 
 
-@patch("hestia_earth.models.utils.property.download_hestia", return_value={'units': '%'})
+@patch("hestia_earth.models.utils.property.download_term", return_value={'units': '%'})
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/cycle/test_concentrateFeed.py

@@ -37,7 +37,7 @@ def test_should_run(mock_primary_product, *args):
     assert should_run is True
 
 
-@patch('hestia_earth.models.utils.property.download_hestia', return_value={})  # make sure default props are not loaded
+@patch('hestia_earth.models.utils.property.download_term', return_value={})  # make sure default props are not loaded
 @patch(f"{class_path}.get_energy_digestibility_terms", return_value=ED_TERM_IDS)
 @patch(f"{class_path}.get_digestible_energy_terms", return_value=DE_TERM_IDS)
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)

tests/models/cycle/test_energyContentLowerHeatingValue.py

@@ -24,7 +24,7 @@ def test_should_run_input():
     assert _should_run_input({})(input) is True
 
 
-@patch("hestia_earth.models.utils.property.download_hestia", return_value={'units': '%'})
+@patch("hestia_earth.models.utils.property.download_term", return_value={'units': '%'})
 @patch(f"{class_path}.get_wood_fuel_terms", return_value=['woodPellets', 'woodFuel'])
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)
 def test_run(*args):

tests/models/cycle/test_excretaKgMass.py

@@ -84,7 +84,7 @@ def test_should_run():
     assert should_run is True
 
 
-@patch(f"{class_path}.download_hestia", side_effect=lambda id, *args: TERMS[id])
+@patch(f"{class_path}.download_term", side_effect=lambda id, *args: TERMS[id])
 @patch(f"{class_path}._new_product", side_effect=fake_new_product)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/cycle/test_feedConversionRatio.py

@@ -14,7 +14,7 @@ TERMS_BY_ID = {
 }
 
 
-def fake_download_hestia(term_id: str, *args): return TERMS_BY_ID[term_id]
+def fake_download_term(term_id: str, *args): return TERMS_BY_ID[term_id]
 
 
 @patch(f"{class_path}.get_total_value_converted_with_min_ratio", return_value=10)
@@ -37,7 +37,7 @@ def test_should_run(*args):
     assert should_run is True
 
 
-@patch("hestia_earth.models.utils.property.download_hestia", side_effect=fake_download_hestia)
+@patch("hestia_earth.models.utils.property.download_term", side_effect=fake_download_term)
 @patch(f"{class_path}.is_run_required", return_value=True)
 @patch(f"{class_path}._new_practice", side_effect=fake_new_practice)
 def test_run(*args):
@@ -51,7 +51,7 @@ def test_run(*args):
     assert value == expected
 
 
-@patch("hestia_earth.models.utils.property.download_hestia", side_effect=fake_download_hestia)
+@patch("hestia_earth.models.utils.property.download_term", side_effect=fake_download_term)
 @patch(f"{class_path}.is_run_required", return_value=True)
 @patch(f"{class_path}._new_practice", side_effect=fake_new_practice)
 def test_run_with_carcass(*args):

tests/models/cycle/test_pastureGrass.py

@@ -18,7 +18,7 @@ def test_should_run():
     assert _should_run(cycle) is True
 
 
-@patch(f"{class_path}.download_hestia", return_value={'@type': 'Term', '@id': KEY_TERM_ID})
+@patch(f"{class_path}.download_term", return_value={'@type': 'Term', '@id': KEY_TERM_ID})
 @patch(f"{class_path}._new_practice", side_effect=fake_new_practice)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/cycle/test_readyToCookWeightPerHead.py

@@ -34,7 +34,7 @@ def test_should_run():
     assert should_run is True
 
 
-@patch("hestia_earth.models.utils.property.download_hestia", return_value={'units': '%'})
+@patch("hestia_earth.models.utils.property.download_term", return_value={'units': '%'})
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/environmentalFootprintV3_1/test_environmentalFootprintSingleOverallScore.py

@@ -18,31 +18,55 @@ def fake_rounded_indicator(value: float):
     return indicator
 
 
+methodModelEFV31 = {"@type": "Term", "@id": "environmentalFootprintV3-1"}
+methodModelFantkeEtAl2016 = {"@type": "Term", "@id": "fantkeEtAl2016"}
+
 ozone_indicator = {"@type": "Indicator",
                    "term": {"@id": "ozoneDepletionPotential", "termType": "characterisedIndicator"},
-                   "value": 0}
+                   "value": 0,
+                   "methodModel": {"@type": "Term", "@id": "edip2003"}}
 
+other_valid_ozone_indicator = {"@type": "Indicator",
+                               "term": {"@id": "ozoneDepletionPotential", "termType": "characterisedIndicator"},
+                               "value": 0,
+                               "methodModel": {"@type": "Term", "@id": "recipe2016Hierarchist"}}
 acid_indicator = {
     "@type": "Indicator",
     "term": {"@id": "terrestrialAcidificationPotentialAccumulatedExceedance", "termType": "characterisedIndicator"},
-    "value": 0.000420443840380047}
+    "value": 0.000420443840380047,
+    "methodModel": {"@type": "Term", "@id": "poschEtAl2008"}
+}
 
 bad_indicator_id = {"@type": "Indicator",
                     "term": {"@id": "no_a_real_id", "termType": "characterisedIndicator"},
-                    "value": 0.000420443840380047}
+                    "value": 0.000420443840380047,
+                    "methodModel": methodModelEFV31
+                    }
 
 not_pef_indicator = {"@type": "Indicator",
                      "term": {"@id": "gwpStar", "termType": "characterisedIndicator"},
-                     "value": 0.000420443840380047}
+                     "value": 0.000420443840380047,
+                     "methodModel": methodModelEFV31
+                     }
 
 bad_indicator_no_val = {"@type": "Indicator",
                         "term": {"@id": "damageToHumanHealthParticulateMatterFormation",
-                                 "termType": "characterisedIndicator"}}
+                                 "termType": "characterisedIndicator"},
+                        "methodModel": methodModelFantkeEtAl2016
+                        }
 
 bad_indicator_bad_val = {"@type": "Indicator",
                          "term": {"@id": "damageToHumanHealthParticulateMatterFormation",
                                   "termType": "characterisedIndicator"},
-                         "value": None}
+                         "value": None,
+                         "methodModel": methodModelFantkeEtAl2016
+                         }
+
+bad_indicator_no_method_model = {
+    "@type": "Indicator",
+    "term": {"@id": "terrestrialAcidificationPotentialAccumulatedExceedance", "termType": "characterisedIndicator"},
+    "value": 0.000420443840380047
+}
 
 
 @mark.parametrize(
@@ -53,10 +77,13 @@ bad_indicator_bad_val = {"@type": "Indicator",
         ([not_pef_indicator], False, 0),
         ([bad_indicator_no_val], False, 0),
         ([bad_indicator_bad_val], False, 0),
+        ([bad_indicator_no_method_model], False, 0),
+        ([other_valid_ozone_indicator], 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)
+        ([ozone_indicator, other_valid_ozone_indicator], True, 1),
+        ([bad_indicator_no_val, acid_indicator], False, 1),
     ],
     ids=[
         "No indicators => no run",
@@ -64,9 +91,12 @@ bad_indicator_bad_val = {"@type": "Indicator",
         "not_pef_indicator => no run",
         "bad_indicator_no_val => no run",
         "bad_indicator_bad_val => no run",
-        "ozone_indicator => run",
+        "bad_indicator_no_method_model =>  no run",
+        "ozone_indicator not pef=> no run",
+        "ozone_indicator pef => run",
         "2 ozone_indicator => no run",
         "2 good indicators => run",
+        "2 ozone_indicator different methodModel => run with 1",
         "one bad one good indicator => no run",
     ]
 )

tests/models/environmentalFootprintV3_1/test_photochemicalOzoneCreationPotentialHumanHealthNmvocEq.py

@@ -0,0 +1,30 @@
+import json
+from unittest.mock import patch
+
+from hestia_earth.models.environmentalFootprintV3_1 import MODEL_FOLDER
+from hestia_earth.models.environmentalFootprintV3_1.photochemicalOzoneCreationPotentialHumanHealthNmvocEq import (
+    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}"
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(
+            f"{fixtures_path}/impact_assessment/emissions/impact-assessment.jsonld",
+            encoding="utf-8",
+    ) as f:
+        impact = json.load(f)
+    with open(f"{fixtures_folder}/emissions.jsonld", encoding="utf-8") as f:
+        emissions = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding="utf-8") as f:
+        expected = json.load(f)
+
+    impact["emissionsResourceUse"] = emissions
+    value = run(impact)
+    assert value == expected

tests/models/environmentalFootprintV3_1/test_soilQualityIndexLandTransformation.py

@@ -22,91 +22,120 @@ def fake_rounded_indicator(value: float):
 crop_land = {"@id": "cropland", "termType": "landCover"}
 sea_land_cover = {"@id": "seaOrOcean", "termType": "landCover"}
 forest = {"@id": "forest", "termType": "landCover"}
-indicator = {
+
+indicator_inputs_production = {
     "@id": "landTransformation20YearAverageInputsProduction",
     "termType": "resourceUse",
     "units": "m2 / year"
 }
+
+indicator_during_cycle = {
+    "@id": "landTransformation20YearAverageDuringCycle",
+    "termType": "resourceUse",
+    "units": "m2 / year"
+}
+
 wrong_indicator = {"term": {"@id": "NOT_VALID_INDICATOR_ID", "termType": "resourceUse", "units": "m2 / year"},
                    "value": 0.5, "landCover": crop_land, "previousLandCover": forest}
 
 indicator_no_land_cover = {
-    "term": indicator,
+    "term": indicator_during_cycle,
     "previousLandCover": forest,
     "value": 0.5}
 
 indicator_no_previous_land_cover = {
-    "term": indicator,
+    "term": indicator_during_cycle,
     "landCover": crop_land,
     "value": 0.5}
 
 indicator_bad_area_value = {
-    "term": indicator,
+    "term": indicator_during_cycle,
     "value": -10,
     "previousLandCover": forest,
     "landCover": crop_land}
 
+indicator_zero_area_value = {
+    "term": indicator_during_cycle,
+    "value": 0,
+    "previousLandCover": forest,
+    "landCover": crop_land}
+
 inputs_production_indicator_from_forest_to_no_cf = {
-    "term": indicator,
+    "term": indicator_inputs_production,
+    "value": 0.5,
+    "previousLandCover": forest,
+    "landCover": sea_land_cover}
+
+during_cycle_indicator_from_forest_to_no_cf = {
+    "term": indicator_during_cycle,
     "value": 0.5,
     "previousLandCover": forest,
     "landCover": sea_land_cover}
 
 good_inputs_production_indicator_from_forest_to_cropland = {
-    "term": indicator,
+    "term": indicator_inputs_production,
     "value": 0.5,
     "previousLandCover": forest,
     "landCover": crop_land}
 
 good_inputs_production_indicator_from_forest_to_forest = {
-    "term": indicator,
+    "term": indicator_inputs_production,
     "value": 0.5,
     "previousLandCover": forest,
     "landCover": forest}
 
 good_during_cycle_indicator_from_forest_to_cropland = {
-    "term": indicator | {'@id': 'landTransformation20YearAverageDuringCycle'},
+    "term": indicator_during_cycle,
     "value": 0.5,
     "previousLandCover": forest,
     "landCover": crop_land}
 
 good_during_cycle_indicator_from_forest_to_forest = {
-    "term": indicator | {'@id': 'landTransformation20YearAverageDuringCycle'},
+    "term": indicator_during_cycle,
     "value": 0.5,
     "previousLandCover": forest,
     "landCover": forest}
 
 
 @mark.parametrize(
-    "resources, expected, num_inputs",
+    "test_name, resources, expected, num_inputs",
     [
-        ([], False, 0),
-        ([wrong_indicator], False, 0),
-        ([indicator_no_land_cover], False, 0),
-        ([indicator_no_previous_land_cover], False, 0),
-        ([indicator_bad_area_value], False, 0),
-        ([good_during_cycle_indicator_from_forest_to_cropland], True, 1),
-        ([good_during_cycle_indicator_from_forest_to_forest], True, 1),
-        ([good_inputs_production_indicator_from_forest_to_cropland], True, 1),
-        ([good_inputs_production_indicator_from_forest_to_forest], True, 1),
-        ([inputs_production_indicator_from_forest_to_no_cf], True, 0),  # todo check
-        ([good_inputs_production_indicator_from_forest_to_cropland,
-          good_during_cycle_indicator_from_forest_to_cropland], True, 2)
-    ],
-    ids=["No emissionsResourceUse => no run, 0 dict",
-         "Wrong indicator termid => no run, 0 dict",
-         "Indicator no landcover terms => no run",
-         "Indicator no previousLandCover terms => no run",
-         "Bad m2 / year value => no run",
-         "One good during cycle transformation => run, 1 dict",
-         "One 0 during cycle transformation => run, 1 dict",
-         "One good inputs production transformation => run, 1 dict",
-         "One 0 inputs production transformation => run, 1 dict",
-         "One good from transformation and One with no CF (ocean) => run, 2 dict",  # todo
-         "Multiple good indicators => run, 2 dict",
-         ]
+        ("No emissionsResourceUse => no run, 0 dict", [], False, 0),
+        ("Wrong indicator termid => no run, 0 dict", [wrong_indicator], False, 0),
+        ("Indicator no landcover terms => no run", [indicator_no_land_cover], False, 0),
+        ("Indicator no previousLandCover terms => no run", [indicator_no_previous_land_cover], False, 0),
+        ("Bad m2 / year area value => no run", [indicator_bad_area_value], False, 0),
+        ("One good and one Bad m2 / year area value => no run", [
+            good_during_cycle_indicator_from_forest_to_cropland,
+            indicator_bad_area_value], False, 1),
+        ("One 0 m2 / year area value => filter and run, 0 dict", [indicator_zero_area_value], True, 1),
+        ("One good during cycle transformation => run, 1 dict", [good_during_cycle_indicator_from_forest_to_cropland
+                                                                 ], True, 1),
+        ("One 0 during cycle transformation => run, 1 dict", [good_during_cycle_indicator_from_forest_to_forest
+                                                              ], True, 1),
+        ("Only one good inputs production transformation => no run", [
+            good_inputs_production_indicator_from_forest_to_cropland], False, 1),
+        ("Good during cycle AND inputs production transformation => run, 2 dict", [
+            good_during_cycle_indicator_from_forest_to_cropland,
+            good_inputs_production_indicator_from_forest_to_cropland], True, 2),
+        ("One 0 inputs production transformation => no run", [
+            good_inputs_production_indicator_from_forest_to_forest], False, 1),
+        ("Good during cycle AND inputs production 0 transformation => run, 2 dict", [
+            good_during_cycle_indicator_from_forest_to_cropland,
+            good_inputs_production_indicator_from_forest_to_forest], True, 2),
+        ("One transformation with no CF (ocean) => run, 0 dict", [during_cycle_indicator_from_forest_to_no_cf
+                                                                  ], True, 0),
+        ("One good from transformation and One with no CF (ocean) => run, 1 dict", [
+            good_inputs_production_indicator_from_forest_to_cropland,
+            during_cycle_indicator_from_forest_to_no_cf], True, 1),
+        ("Multiple good indicators => run, 2 dict", [good_inputs_production_indicator_from_forest_to_cropland,
+                                                     good_during_cycle_indicator_from_forest_to_cropland], True, 2),
+        ("One good, one wrong indicator => filter and run, 1 dict", [
+            good_during_cycle_indicator_from_forest_to_cropland,
+            wrong_indicator], True, 1),
+    ]
 )
-def test_should_run(resources: list, expected: bool, num_inputs: int):
+def test_should_run(test_name: str, resources: list, expected: bool, num_inputs: int):
     with open(f"{fixtures_folder}/multipleTransformations/impact-assessment.jsonld", encoding='utf-8') as f:
         impact = json.load(f)
 

tests/models/environmentalFootprintV3_1/test_soilQualityIndexTotalLandUseEffects.py

@@ -10,14 +10,37 @@ 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}"
 
-transform_indicator = {'term': {'@id': 'soilQualityIndexLandTransformation'}, 'value': 10}
-occupation_indicator = {'term': {'@id': 'soilQualityIndexLandOccupation'}, 'value': 10}
-missing_value_indicator = {'term': {'@id': 'soilQualityIndexLandOccupation'}}
-bad_value_indicator = {'term': {'@id': 'soilQualityIndexLandOccupation'}, 'value': "42"}
+transform_indicator = {
+    "term": {
+        "@id": "soilQualityIndexLandTransformation",
+        "termType": "characterisedIndicator",
+    },
+    "value": 10,
+}
+occupation_indicator = {
+    "term": {
+        "@id": "soilQualityIndexLandOccupation",
+        "termType": "characterisedIndicator",
+    },
+    "value": 10,
+}
+missing_value_indicator = {
+    "term": {
+        "@id": "soilQualityIndexLandOccupation",
+        "termType": "characterisedIndicator",
+    }
+}
+bad_value_indicator = {
+    "term": {
+        "@id": "soilQualityIndexLandOccupation",
+        "termType": "characterisedIndicator",
+    },
+    "value": "42",
+}
 
 
 @mark.parametrize(
-    "emissions_resource_use, expected, num_expected",
+    "impacts, expected, num_expected",
     [
         ([], False, 0),
         ([transform_indicator], False, 1),
@@ -32,11 +55,11 @@ bad_value_indicator = {'term': {'@id': 'soilQualityIndexLandOccupation'}, 'value
     ids=["Empty", "missing obligatory occupation", "duplicate entry", "no value in entry", "bad value in entry",
          "correct assessment", "just occupation", "multiple occupations and transformations"]
 )
-def test_should_run(emissions_resource_use, expected, num_expected):
+def test_should_run(impacts, expected, num_expected):
     with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
         impactassessment = json.load(f)
 
-    impactassessment['emissionsResourceUse'] = emissions_resource_use
+    impactassessment['impacts'] = impacts
 
     should_run, indicators = _should_run(impactassessment)
     assert should_run is expected