hestia-earth-models 0.64.7__py3-none-any.whl → 0.64.9__py3-none-any.whl

tests/models/environmentalFootprintV3/test_soilQualityIndexLandOccupation.py

@@ -1,71 +1,107 @@
 import json
 from unittest.mock import patch
 
-from hestia_earth.models.environmentalFootprintV3.soilQualityIndexLandOccupation import MODEL, TERM_ID, run, _should_run
+import pytest
+
+from hestia_earth.models.environmentalFootprintV3.soilQualityIndexLandOccupation 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}"
 
-
-with open(f"{fixtures_path}/impact_assessment/emissions/impact-assessment.jsonld", encoding='utf-8') as f:
-    impact = json.load(f)
-
-
-def test_should_run():
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    # a LandCover type with no CF => no run
-    cycle['site']['management'] = [{"endDate": "2024-03-31", "@type": "Management",
-                                    "term": {"termType": "landCover", "@type": "Term", "@id": "ocean"}}]
-
-    should_run, *args = _should_run({'cycle': cycle})
-    assert not should_run
-
-    # no management => no run
-    cycle['site']['management'] = []
-    should_run, *args = _should_run({'cycle': cycle})
-    assert not should_run
+crop_land = {"@id": "cropland", "termType": "landCover"}
+sea_land_cover = {"@id": "seaOrOcean", "termType": "landCover"}
+forest = {"@id": "forest", "termType": "landCover"}
+
+wrong_indicator = {"term": {"@id": "NOT_landOccupationInputsProduction", "termType": "resourceUse", "units": "m2*year"},
+                   "value": 0.5, "landCover": crop_land}
+
+indicator_no_land_cover = {
+    "term": {"@id": "landOccupationInputsProduction", "termType": "resourceUse", "units": "m2*year"},
+    "value": 0.5}
+
+indicator_no_unit = {"term": {"@id": "landOccupationInputsProduction", "termType": "resourceUse"},
+                     "value": 0.5, "landCover": crop_land}
+
+indicator_wrong_unit = {
+    "term": {"@id": "landOccupationInputsProduction", "termType": "resourceUse", "units": "ha*day"}, "value": 0.5,
+    "landCover": crop_land}
+
+indicator_bad_area_time_value = {
+    "term": {"@id": "landOccupationInputsProduction", "termType": "resourceUse", "units": "m2*year"}, "value": 0,
+    "landCover": crop_land}
+
+inputs_production_indicator_no_cf = {
+    "term": {"@id": "landOccupationInputsProduction", "termType": "resourceUse", "units": "m2*year"}, "value": 0.5,
+    "landCover": sea_land_cover}
+
+good_inputs_production_indicator_cropland = {
+    "term": {"@id": "landOccupationInputsProduction", "termType": "resourceUse", "units": "m2*year"}, "value": 0.5,
+    "landCover": crop_land}
+
+good_inputs_production_indicator_forest = {
+    "term": {"@id": "landOccupationInputsProduction", "termType": "resourceUse", "units": "m2*year"}, "value": 0.5,
+    "landCover": forest}
+
+good_during_cycle_indicator_cropland = {
+    "term": {"@id": "landOccupationDuringCycle", "termType": "resourceUse", "units": "m2*year"}, "value": 0.5,
+    "landCover": crop_land}
+
+good_during_cycle_indicator_forest = {
+    "term": {"@id": "landOccupationDuringCycle", "termType": "resourceUse", "units": "m2*year"}, "value": 0.5,
+    "landCover": forest}
+
+
+@pytest.mark.parametrize(
+    "resources, expected, num_inputs",
+    [
+        ([], False, 0),
+        ([wrong_indicator], False, 0),
+        ([indicator_no_land_cover], False, 0),
+        ([indicator_no_unit], False, 0),
+        ([indicator_wrong_unit], False, 0),
+        ([indicator_bad_area_time_value], False, 0),
+        ([inputs_production_indicator_no_cf], True, 0),
+        ([good_during_cycle_indicator_cropland], True, 1),
+        ([good_during_cycle_indicator_cropland, good_inputs_production_indicator_forest], True, 2),
+        ([good_during_cycle_indicator_cropland, inputs_production_indicator_no_cf], True, 1),
+        ([good_during_cycle_indicator_cropland, good_during_cycle_indicator_forest,
+          good_inputs_production_indicator_forest, good_inputs_production_indicator_cropland], True, 4),
+
+    ],
+    ids=["No emissionsResourceUse => no run",
+         "Wrong indicator termid => no run",
+         "Indicator no landcover terms => no run",
+         "Missing unit => no run",
+         "Wrong unit => no run",
+         "Bad area*time value => no run",
+         "Input with no cf => run, empty input",
+         "One good input => run, 1 dict",
+         "Two good input => run, 2 dict",
+         "One good input and One with no CF => run, 2 dict",
+         "Multiple good indicators with same id => run, 4 dict",
+         ]
+)
+def test_should_run(resources, expected, num_inputs):
+    with open(f"{fixtures_folder}/impact-assessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    impactassessment['emissionsResourceUse'] = resources
+
+    should_run, resources_with_cf = _should_run(impactassessment)
+    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}/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
+    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)
 
-    impact['cycle'] = cycle
-    value = run(impact)
-    assert value == expected
-
-
-@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
-def test_run_other_sites(*args):
-    """
-    This test case contains 2 sites:
-    One is a crop in france, with value:
-    CF_METHOD_factor_france_permanent_crops * ( siteArea_france_crop * time_in_years )
-    = 87.631 * ( 1.0082662E-7 * 1 )
-    = 8.835537537220001e-06
-
-    And one a forest in italy, with value:
-    CF_METHOD_factor_italy_forest * ( siteArea_italy_forest * time_in_years )
-    = 43.198 * ( 1.3573373E-9 * 1 )
-    = 5.86342566854E-08
-
-    We expect the model to return 8.835537537220001e-06 + 5.86342566854E-08 = 8.894171793905402e-06
-
-    """
-    with open(f"{fixtures_folder}/otherSites/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/otherSites/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    impact['cycle'] = cycle
     value = run(impact)
     assert value == expected
 
@@ -75,21 +111,18 @@ def test_run_with_subclass_landcover(*args):
     """
     Example data:
     Country: Italy
-    Quantity in m^2: 1.3573373E-9
-    CF METHOD factor: 4.3198E+01
-    "Charact Result [soil quality index]" result also in result.jsonld : 5.86342566854E-08
-    siteArea in test file in ha:    1.3573373E-9 / 10 000 = 1.3573373e-13
+    Quantity in m2*year: 1
+    CF METHOD factor: 50.438
 
     landCover field "plantationForest" should map to
     Name Flow: "forest, intensive Land occupation"
     """
-    with open(f"{fixtures_folder}/plantationForest/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
 
+    with open(f"{fixtures_folder}/plantationForest/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
     with open(f"{fixtures_folder}/plantationForest/result.jsonld", encoding='utf-8') as f:
         expected = json.load(f)
 
-    impact['cycle'] = cycle
     value = run(impact)
     assert value == expected
 
@@ -99,13 +132,12 @@ def test_run_with_region_missing_data(*args):
     """
     When given valid sub-region or country not in the lookup file should default to 'region-world'
     """
-    with open(f"{fixtures_folder}/default-region-world/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
+    with open(f"{fixtures_folder}/default-region-world/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
 
     with open(f"{fixtures_folder}/default-region-world/result.jsonld", encoding='utf-8') as f:
         expected = json.load(f)
 
-    impact['cycle'] = cycle
     value = run(impact)
     assert value == expected
 
@@ -115,14 +147,13 @@ def test_run_with_no_region(*args):
     """
     When no location is specified, defaults to region world.
     """
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
+    with open(f"{fixtures_folder}/default-region-world/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
 
-    del cycle['site']['country']
+    del impact['country']
 
     with open(f"{fixtures_folder}/default-region-world/result.jsonld", encoding='utf-8') as f:
         expected = json.load(f)
 
-    impact['cycle'] = cycle
     value = run(impact)
     assert value == expected

tests/models/environmentalFootprintV3/test_soilQualityIndexLandTransformation.py

@@ -0,0 +1,176 @@
+import json
+from unittest.mock import patch
+
+from pytest import mark
+
+from hestia_earth.models.environmentalFootprintV3.soilQualityIndexLandTransformation 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}"
+
+
+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"}
+
+wrong_indicator = {"term": {"@id": "NOT_VALID_INDICATOR_ID", "termType": "resourceUse", "units": "m2 / year"},
+                   "value": 0.5, "landCover": crop_land}
+
+indicator_no_land_cover = {
+    "term": {"@id": "landTransformationFromForest20YearAverageInputsProduction", "termType": "resourceUse",
+             "units": "m2 / year"},
+    "value": 0.5}
+
+indicator_no_unit = {
+    "term": {"@id": "landTransformationFromForest20YearAverageInputsProduction", "termType": "resourceUse"},
+    "value": 0.5, "landCover": crop_land}
+
+indicator_wrong_unit = {
+    "term": {"@id": "landTransformationFromForest20YearAverageInputsProduction", "termType": "resourceUse",
+             "units": "ha*day"}, "value": 0.5,
+    "landCover": crop_land}
+
+indicator_bad_area_value = {
+    "term": {"@id": "landTransformationFromForest20YearAverageInputsProduction", "termType": "resourceUse",
+             "units": "m2 / year"}, "value": -10,
+    "landCover": crop_land}
+
+inputs_production_indicator_from_forest_to_no_cf = {
+    "term": {"@id": "landTransformationFromForest20YearAverageInputsProduction", "termType": "resourceUse",
+             "units": "m2 / year"}, "value": 0.5,
+    "landCover": sea_land_cover}
+
+good_inputs_production_indicator_from_forest_to_cropland = {
+    "term": {"@id": "landTransformationFromForest20YearAverageInputsProduction", "termType": "resourceUse",
+             "units": "m2 / year"}, "value": 0.5,
+    "landCover": crop_land}
+
+good_inputs_production_indicator_from_forest_to_forest = {
+    "term": {"@id": "landTransformationFromForest20YearAverageInputsProduction", "termType": "resourceUse",
+             "units": "m2 / year"}, "value": 0.5,
+    "landCover": forest}
+
+good_during_cycle_indicator_from_forest_to_cropland = {
+    "term": {"@id": "landTransformationFromForest20YearAverageDuringCycle", "termType": "resourceUse",
+             "units": "m2 / year"}, "value": 0.5,
+    "landCover": crop_land}
+
+good_during_cycle_indicator_from_forest_to_forest = {
+    "term": {"@id": "landTransformationFromForest20YearAverageDuringCycle", "termType": "resourceUse",
+             "units": "m2 / year"}, "value": 0.5,
+    "landCover": forest}
+
+
+@mark.parametrize(
+    "resources, expected, num_inputs",
+    [
+        ([], True, 0),
+        ([wrong_indicator], True, 0),
+        ([indicator_no_land_cover], False, 0),
+        ([indicator_no_unit], False, 0),
+        ([indicator_wrong_unit], 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 => run, 0 dict",
+         "Wrong indicator termid => run, 0 dict",
+         "Indicator no landcover terms => no run",
+         "Missing unit => no run",
+         "Wrong unit => 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",
+         ]
+)
+@patch(f"{class_path}.download_all_land_cover_terms",
+       return_value=[{'@id': 'cropland'}, {'@id': 'seaOrOcean'}, {'@id': 'forest'}])
+def test_should_run(mock_download, resources, expected, num_inputs):
+    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, added_data):
+    """
+    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
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run_no_transformation(*args):
+    """
+    Impact assessment with no transformations should return a indicator of 0
+    """
+    with open(f"{fixtures_folder}/multipleTransformations/impact-assessment.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
+
+    impact['emissionsResourceUse'] = []
+
+    value = run(impact)
+
+    assert value['value'] == 0

tests/models/environmentalFootprintV3/test_soilQualityIndexTotalLandUseEffects.py

@@ -0,0 +1,55 @@
+import json
+from unittest.mock import patch
+
+from pytest import mark
+
+from hestia_earth.models.environmentalFootprintV3.soilQualityIndexTotalLandUseEffects 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}"
+
+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"}
+
+
+@mark.parametrize(
+    "emissions_resource_use, expected, num_expected",
+    [
+        ([], False, 0),
+        ([transform_indicator], False, 1),
+        ([transform_indicator, transform_indicator], False, 2),
+        ([transform_indicator, missing_value_indicator], False, 2),
+        ([transform_indicator, bad_value_indicator], False, 2),
+        ([transform_indicator, occupation_indicator], True, 2),
+        ([occupation_indicator], False, 1),
+        ([occupation_indicator, occupation_indicator, occupation_indicator,
+          transform_indicator, transform_indicator], True, 5),
+    ],
+    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):
+    with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    impactassessment['emissionsResourceUse'] = emissions_resource_use
+
+    should_run, indicators = _should_run(impactassessment)
+    assert should_run is expected
+    assert len(indicators) is num_expected
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*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/frischknechtEtAl2000/test_ionisingRadiationKbqU235Eq.py

@@ -8,54 +8,77 @@ from hestia_earth.models.frischknechtEtAl2000.ionisingRadiationKbqU235Eq import
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
+hydrogen3_input = {"@id": "hydrogen3", "termType": "waste", "units": "kg"}
+cesium134_input = {"@id": "cesium134", "termType": "waste", "units": "kg"}
+cesium137_input = {"@id": "cesium137", "termType": "waste", "units": "kg"}
+uranium234_input = {"@id": "uranium234", "termType": "waste", "units": "kg"}
+iodine129_input = {"@id": "iodine129", "termType": "waste", "units": "kg"}
+no_cf_input = {"@id": "oilPalmMillEffluentWaste", "termType": "waste", "units": "kg"}
+
+wrong_indicator = {"term": {"@id": "co2ToAirSoilOrganicCarbonStockChangeManagementChange", "termType": "emission"},
+                   "value": 3, "inputs": [hydrogen3_input]}
+
+indicator_no_inputs = {"term": {"@id": "ionisingCompoundsToAirInputsProduction", "termType": "emission"},
+                       "value": 3, "inputs": []}
+
+indicator_2_inputs = {"term": {"@id": "ionisingCompoundsToWaterInputsProduction", "termType": "emission"},
+                      "value": 3, "inputs": [cesium134_input, cesium137_input]}
+
+indicator_no_unit = {"term": {"@id": "ionisingCompoundsToAirInputsProduction", "termType": "emission"},
+                     "value": 3, "inputs": [{"@id": "hydrogen3", "termType": "waste"}]}
+
+indicator_wrong_unit = {"term": {"@id": "ionisingCompoundsToAirInputsProduction", "termType": "emission"},
+                        "value": 3, "inputs": [{"@id": "hydrogen3", "termType": "waste", "units": "not_a_unit"}]}
+
+indicator_no_cf_input = {"term": {"@id": "ionisingCompoundsToAirInputsProduction", "termType": "emission"},
+                         "value": 3, "inputs": [no_cf_input]}
+
+indicator_hydrogen3_input = {"term": {"@id": "ionisingCompoundsToAirInputsProduction", "termType": "emission"},
+                             "value": 3, "inputs": [hydrogen3_input]}
+
+indicator_cesium137_input = {"term": {"@id": "ionisingCompoundsToWaterInputsProduction", "termType": "emission"},
+                             "value": 3, "inputs": [cesium137_input]}
+
+indicator_uranium234_input = {"term": {"@id": "ionisingCompoundsToSaltwaterInputsProduction", "termType": "emission"},
+                              "value": 3, "inputs": [uranium234_input]}
+
 
 @pytest.mark.parametrize(
-    'test_name,impact,expected_should_run',
+    "resources, expected, num_inputs",
     [
-        (
-            'no emissionsResourceUse => no run',
-            {},
-            False
-        ),
-        (
-            'no emissions in the lookups list => no run',
-            {
-                'emissionsResourceUse': [
-                    {
-                        'term': {'@id': 'co2ToAirInputsProduction'}
-                    }
-                ]
-            },
-            False
-        ),
-        (
-            'with emissions in the lookup list but no waste inputs => no run',
-            {
-                'emissionsResourceUse': [
-                    {
-                        'term': {'@id': 'ionisingCompoundsToAirInputsProduction'}
-                    }
-                ]
-            },
-            False
-        ),
-        (
-            'with emissions in the lookup list and waste inputs => run',
-            {
-                'emissionsResourceUse': [
-                    {
-                        'term': {'@id': 'ionisingCompoundsToAirInputsProduction'},
-                        'inputs': [{'termType': 'waste'}]
-                    }
-                ]
-            },
-            True
-        )
-    ]
+        ([], True, 0),
+        ([wrong_indicator], True, 0),
+        ([indicator_no_inputs], False, 0),
+        ([indicator_2_inputs], False, 0),
+        ([indicator_no_unit], False, 0),
+        ([indicator_wrong_unit], False, 0),
+        ([indicator_no_cf_input], True, 0),
+        ([indicator_hydrogen3_input], True, 1),
+        ([indicator_cesium137_input], True, 1),
+        ([indicator_uranium234_input], True, 1),
+        ([indicator_cesium137_input, indicator_no_cf_input], True, 1),
+    ],
+    ids=["No emissionsResourceUse => run, empty input",
+         "Wrong indicator termid => run, empty input",
+         "Indicator no inputs => no run",
+         "Indicator 2 inputs => no run",
+         "Missing unit => no run",
+         "Wrong unit => no run",
+         "Input with no cf => run, empty input",
+         "Good input ionisingCompoundsToAirInputsProduction => run, 1 input",
+         "Good input ionisingCompoundsToWaterInputsProduction => run, 1 input",
+         "Good input ionisingCompoundsToSaltwaterInputsProduction => run, 1 input",
+         "One good input => run, 1 input"]
 )
-def test_should_run(test_name, impact, expected_should_run):
-    should_run, *args = _should_run(impact)
-    assert should_run == expected_should_run, test_name
+def test_should_run(resources, expected, num_inputs):
+    with open(f"{fixtures_folder}/impact-assessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    impactassessment['emissionsResourceUse'] = resources
+
+    should_run, resources_with_cf = _should_run(impactassessment)
+    assert should_run is expected
+    assert len(resources_with_cf) == num_inputs
 
 
 @patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)

tests/models/ipcc2019/animal/test_fatContent.py

@@ -0,0 +1,22 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_property
+
+from hestia_earth.models.ipcc2019 import MODEL
+from hestia_earth.models.ipcc2019.animal.fatContent import TERM_ID, run
+
+utils_path = '.'.join(['hestia_earth', 'models', MODEL, 'animal', 'utils'])
+class_path = f"hestia_earth.models.{MODEL}.animal.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/animal/{TERM_ID}"
+
+
+@patch(f"{utils_path}._new_property", side_effect=fake_new_property)
+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/ipcc2019/animal/test_liveweightGain.py

@@ -2,13 +2,15 @@ from unittest.mock import patch
 import json
 from tests.utils import fixtures_path, fake_new_property
 
-from hestia_earth.models.ipcc2019.animal.liveweightGain import MODEL, TERM_ID, run
+from hestia_earth.models.ipcc2019 import MODEL
+from hestia_earth.models.ipcc2019.animal.liveweightGain import TERM_ID, run
 
+utils_path = '.'.join(['hestia_earth', 'models', MODEL, 'animal', 'utils'])
 class_path = f"hestia_earth.models.{MODEL}.animal.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/animal/{TERM_ID}"
 
 
-@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+@patch(f"{utils_path}._new_property", side_effect=fake_new_property)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
         cycle = json.load(f)

tests/models/ipcc2019/animal/test_liveweightPerHead.py

@@ -2,13 +2,15 @@ from unittest.mock import patch
 import json
 from tests.utils import fixtures_path, fake_new_property
 
-from hestia_earth.models.ipcc2019.animal.liveweightPerHead import MODEL, TERM_ID, run
+from hestia_earth.models.ipcc2019 import MODEL
+from hestia_earth.models.ipcc2019.animal.liveweightPerHead import TERM_ID, run
 
+utils_path = '.'.join(['hestia_earth', 'models', MODEL, 'animal', 'utils'])
 class_path = f"hestia_earth.models.{MODEL}.animal.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/animal/{TERM_ID}"
 
 
-@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+@patch(f"{utils_path}._new_property", side_effect=fake_new_property)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
         cycle = json.load(f)

tests/models/ipcc2019/animal/test_pregnancyRateTotal.py

@@ -0,0 +1,22 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_property
+
+from hestia_earth.models.ipcc2019 import MODEL
+from hestia_earth.models.ipcc2019.animal.pregnancyRateTotal import TERM_ID, run
+
+utils_path = '.'.join(['hestia_earth', 'models', MODEL, 'animal', 'utils'])
+class_path = f"hestia_earth.models.{MODEL}.animal.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/animal/{TERM_ID}"
+
+
+@patch(f"{utils_path}._new_property", side_effect=fake_new_property)
+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