hestia-earth-models 0.66.0__py3-none-any.whl → 0.67.1__py3-none-any.whl

tests/models/cml2001Baseline/test_resourceUseEnergyDepletionDuringCycle.py

@@ -0,0 +1,136 @@
+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,
+    "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(
+    "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_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 in m^3",
+        "good nuclear fuel use indicator in kWh",
+        "bad indicator input in kg no property to convert to mj"
+    ]
+)
+@patch('hestia_earth.models.utils.property.download_hestia', 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)
+
+    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 → environmentalFootprintV3_1}/test_environmentalFootprintSingleOverallScore.py

@@ -3,12 +3,13 @@ from unittest.mock import patch, Mock
 
 from pytest import mark
 
-from hestia_earth.models.environmentalFootprintV3.environmentalFootprintSingleOverallScore import MODEL, TERM_ID, run, \
-    _should_run
+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}.{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}"
 
 
 def fake_rounded_indicator(value: float):
@@ -17,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(
@@ -52,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",
@@ -63,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 → 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"}

tests/models/environmentalFootprintV3_1/test_soilQualityIndexLandTransformation.py

@@ -0,0 +1,194 @@
+import json
+from unittest.mock import Mock, patch
+
+from pytest import mark
+
+from hestia_earth.models.environmentalFootprintV3_1 import MODEL_FOLDER
+from hestia_earth.models.environmentalFootprintV3_1.soilQualityIndexLandTransformation 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, 7)
+    return indicator
+
+
+crop_land = {"@id": "cropland", "termType": "landCover"}
+sea_land_cover = {"@id": "seaOrOcean", "termType": "landCover"}
+forest = {"@id": "forest", "termType": "landCover"}
+
+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_during_cycle,
+    "previousLandCover": forest,
+    "value": 0.5}
+
+indicator_no_previous_land_cover = {
+    "term": indicator_during_cycle,
+    "landCover": crop_land,
+    "value": 0.5}
+
+indicator_bad_area_value = {
+    "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_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_inputs_production,
+    "value": 0.5,
+    "previousLandCover": forest,
+    "landCover": crop_land}
+
+good_inputs_production_indicator_from_forest_to_forest = {
+    "term": indicator_inputs_production,
+    "value": 0.5,
+    "previousLandCover": forest,
+    "landCover": forest}
+
+good_during_cycle_indicator_from_forest_to_cropland = {
+    "term": indicator_during_cycle,
+    "value": 0.5,
+    "previousLandCover": forest,
+    "landCover": crop_land}
+
+good_during_cycle_indicator_from_forest_to_forest = {
+    "term": indicator_during_cycle,
+    "value": 0.5,
+    "previousLandCover": forest,
+    "landCover": forest}
+
+
+@mark.parametrize(
+    "test_name, resources, expected, num_inputs",
+    [
+        ("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(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)
+
+    impact['emissionsResourceUse'] = resources
+
+    should_run, resources_with_cf = _should_run(impact)
+    assert should_run is expected
+    assert len(resources_with_cf) == num_inputs
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(f"{fixtures_folder}/multipleTransformations/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
+
+    with open(f"{fixtures_folder}/multipleTransformations/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impact)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run_italy(*args):
+    with open(f"{fixtures_folder}/Italy/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
+
+    with open(f"{fixtures_folder}/Italy/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impact)
+    assert value == expected
+
+
+@mark.parametrize(
+    "added_data",
+    [
+        {"country": {}},
+        {"country": {"@id": "region-europe", "@type": "Term", "name": "Europe"}},
+    ],
+    ids=["No country/region => default to region world",
+         "region-europe not in the lookup file => default to region world"]
+)
+@patch(f"{class_path}._indicator", side_effect=fake_rounded_indicator)
+def test_run_with_country_fallback(mocked_indicator: Mock, added_data: dict):
+    """
+    When given valid sub-region or country not in the lookup file, default to country 'region-world' with value 574.56
+    """
+
+    with open(f"{fixtures_folder}/multipleTransformations/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
+
+    impact = impact | added_data
+
+    value = run(impact)
+    assert value['value'] == 574.56

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

@@ -3,12 +3,12 @@ from unittest.mock import patch
 
 from pytest import mark
 
-from hestia_earth.models.environmentalFootprintV3.soilQualityIndexTotalLandUseEffects import MODEL, TERM_ID, run, \
-    _should_run
+from hestia_earth.models.environmentalFootprintV3_1 import MODEL_FOLDER
+from hestia_earth.models.environmentalFootprintV3_1.soilQualityIndexTotalLandUseEffects 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}"
 
 transform_indicator = {'term': {'@id': 'soilQualityIndexLandTransformation'}, 'value': 10}
 occupation_indicator = {'term': {'@id': 'soilQualityIndexLandOccupation'}, 'value': 10}

tests/models/impact_assessment/test_emissions.py

@@ -28,5 +28,4 @@ def test_run(*args):
         expected = json.load(f)
 
     value = run(impact)
-    print(json.dumps(value))
     assert value == expected