hestia-earth-models 0.64.8__py3-none-any.whl → 0.64.10__py3-none-any.whl

tests/models/cml2001Baseline/test_abioticResourceDepletionFossilFuels.py

@@ -0,0 +1,196 @@
+import json
+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
+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
+
+
+def fake_download_hestia(filename):
+    data = {
+        'fuel.csv': ["lignite", "conventionalCrudeOil", "naturalGas", "coalTar"],
+        'electricity.csv': ['electricityGridMarketMix', 'electricityGridHardCoal', 'electricityProducedOnSiteHardCoal',
+                            'electricityGridNaturalGas', 'electricityProducedOnSiteNaturalGas', 'electricityGridOil',
+                            'electricityProducedOnSiteOil', 'electricityGridNuclear']}
+    return data[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"},
+                   "value": 5,
+                   "inputs": [input_lignite_mj]}
+
+indicator_no_inputs = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+                       "value": 5,
+                       "inputs": []}
+
+indicator_2_inputs = {"term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+                      "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"},
+                        "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]}
+
+good_indicator_inputs_production_mj = {
+    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+    "value": 5,
+    "inputs": [input_lignite_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"},
+    "value": 5,
+    "inputs": [input_crude_oil_kg_property]
+}
+
+good_indicator_inputs_production_with_no_property = {
+    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+    "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]}
+
+bad_fuel_indicator_no_property_lookup = {
+    "term": {"@id": "resourceUseEnergyDepletionInputsProduction", "termType": "resourceUse"},
+    "value": 5,
+    "inputs": [input_coal_tar_kg]}
+
+
+@mark.parametrize(
+    "resources, expected, num_inputs",
+    [
+        ([], True, 0),
+        ([wrong_indicator], True, 0),
+        ([indicator_no_inputs], False, 0),
+        ([indicator_2_inputs], False, 2),
+        ([indicator_no_unit], False, 0),
+        ([indicator_wrong_unit], False, 0),
+        ([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"]
+)
+@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):
+    with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    impactassessment['emissionsResourceUse'] = resources
+
+    should_run, resources = _should_run(impactassessment)
+    assert should_run is expected
+    assert len(resources) == num_inputs
+
+
+@patch(f"{class_path}.download_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:
+        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
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run_no_emissions(*args):
+    """
+    Impact assessment with no emissions should return a indicator of 0
+    """
+    with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    del impactassessment['emissionsResourceUse']
+
+    value = run(impactassessment)
+    assert value['value'] == 0
+
+
+def test_download_all_non_renewable_terms(*args):
+    """
+    make sure download_all_non_renewable_terms() only returns terms we want
+    """
+    electricity_terms = download_all_non_renewable_terms("electricity.csv")
+
+    assert "electricityGridHardCoal" in electricity_terms
+    assert "electricityGridWind" not in electricity_terms
+
+    fuel_terms = download_all_non_renewable_terms("fuel.csv")
+
+    assert "coalTar" in fuel_terms
+    assert "sodPeat" not in fuel_terms

tests/models/cml2001Baseline/test_abioticResourceDepletionMineralsAndMetals.py

@@ -0,0 +1,124 @@
+import json
+from unittest.mock import patch
+
+from pytest import mark
+
+from hestia_earth.models.cml2001Baseline.abioticResourceDepletionMineralsAndMetals 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
+
+
+iodine_input = {"@id": "iodineMaterial", "termType": "material", "units": "kg"}
+boron_input = {"@id": "boron", "termType": "soilAmendment", "units": "kg B"}
+tellurium_input = {"@id": "CAS-13494-80-9", "termType": "otherInorganicChemical", "units": "kg"}
+input_no_cf_material = {"@id": "cork", "termType": "material", "units": "kg"}
+
+wrong_indicator = {'value': [1],
+                   'term': {'@id': 'landTransformationFromCropland20YearAverageDuringCycle', 'termType': 'resourceUse'},
+                   'inputs': [iodine_input]}
+
+indicator_no_inputs = {'value': 3,
+                       'term': {'@id': 'resourceUseMineralsAndMetalsInputsProduction', 'termType': 'resourceUse'},
+                       'inputs': []}
+indicator_2_inputs = {
+    'value': 3, 'term': {'@id': 'resourceUseMineralsAndMetalsInputsProduction', 'termType': 'resourceUse'},
+    'inputs': [boron_input, iodine_input]
+}
+
+indicator_no_unit = {
+    'value': 3, 'term': {'@id': 'resourceUseMineralsAndMetalsInputsProduction', 'termType': 'resourceUse'},
+    'inputs': [{"@id": "iodineMaterial", "termType": "material", }],
+}
+
+indicator_wrong_unit = {
+    'value': 3, 'term': {'@id': 'resourceUseMineralsAndMetalsInputsProduction', 'termType': 'resourceUse'},
+    'inputs': [{"@id": "iodineMaterial", "termType": "material", "units": "Mj"}],
+}
+
+indicator_no_cf_material = {
+    'value': 3, 'term': {'@id': 'resourceUseMineralsAndMetalsInputsProduction', 'termType': 'resourceUse'},
+    'inputs': [input_no_cf_material]
+}
+
+indicator_iodine = {
+    'value': [1],
+    'term': {'@id': 'resourceUseMineralsAndMetalsInputsProduction', 'termType': 'resourceUse'},
+    'inputs': [iodine_input]
+}
+
+indicator_boron = {
+    'value': 2,
+    'term': {'@id': 'resourceUseMineralsAndMetalsInputsProduction', 'termType': 'resourceUse'},
+    'inputs': [boron_input]
+}
+
+indicator_tellurium = {
+    'value': 2,
+    'term': {'@id': 'resourceUseMineralsAndMetalsInputsProduction', 'termType': 'resourceUse'},
+    'inputs': [tellurium_input]
+}
+
+
+@mark.parametrize(
+    "resources, expected, num_inputs",
+    [
+        ([], 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_material], True, 0),
+        ([indicator_iodine], True, 1),
+        ([indicator_boron], True, 1),
+        ([indicator_tellurium], True, 1),
+        ([indicator_iodine, indicator_no_cf_material], True, 1),
+    ],
+    ids=["No indicators", "wrong indicator", "indicator no inputs", "indicator 2 inputs", "missing unit", "wrong unit",
+         "material with no cf", "good input material", "good input soilAmendment", "good input otherInorganicChemical",
+         "one good input"]
+)
+def test_should_run(resources, expected, num_inputs):
+    with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    impactassessment['emissionsResourceUse'] = resources
+
+    should_run, grouped_inputs = _should_run(impactassessment)
+    assert should_run is expected
+    assert len(grouped_inputs) == num_inputs
+
+
+@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:
+        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
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run_no_emissions(*args):
+    """
+    Impact assessment with no emissions should return a indicator of 0
+    """
+    with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    del impactassessment['emissionsResourceUse']
+
+    value = run(impactassessment)
+    assert value['value'] == 0

tests/models/edip2003/test_ozoneDepletionPotential.py

@@ -1,7 +1,6 @@
 from unittest.mock import patch
 import json
 
-from hestia_earth.models.utils.lookup import factor_value
 from tests.utils import fixtures_path, fake_new_indicator
 
 from hestia_earth.models.edip2003.ozoneDepletionPotential import MODEL, TERM_ID, run
@@ -32,15 +31,4 @@ def test_run_empty_input(*args):
         impactassessment = json.load(f)
 
     result = run(impactassessment)
-    assert result['value'] is None
-
-
-def test_known_ozone_depletion_lookup_value(*args):
-    lookup_result = factor_value(
-        'edip2003', 'ozoneDepletionPotential', 'emission.csv', 'ozoneDepletionPotential')(
-        data={
-            '@type': 'Emission',
-            'term': {'@type': 'Term', '@id': '112TrichlorotrifluoroethaneToAirInputsProduction'},
-            'value': [1],
-        })
-    assert lookup_result == 0.81
+    assert result['value'] == 0

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