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

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_soilQualityIndexLandTransformation.py

@@ -100,8 +100,7 @@ good_during_cycle_indicator_from_forest_to_forest = {
          "Multiple good indicators => run, 2 dict",
          ]
 )
-@patch(f"{class_path}.download_all_land_cover_terms",
-       return_value=[{'@id': 'cropland'}, {'@id': 'seaOrOcean'}, {'@id': 'forest'}])
+@patch(f"{class_path}.get_land_cover_terms", return_value=['cropland', 'seaOrOcean', '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)

tests/models/impact_assessment/test_emissions.py

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

tests/models/ipcc2019/test_aboveGroundBiomass.py

@@ -4,15 +4,13 @@ from os.path import isfile
 from pytest import mark
 from unittest.mock import MagicMock, patch
 
-from hestia_earth.models.ipcc2019.aboveGroundBiomass import (
-    _is_lcc_event, _rescale_category_cover, _should_run, MODEL, run, TERM_ID
-)
-from hestia_earth.models.ipcc2019.aboveGroundBiomass_utils import BiomassCategory, sample_constant
+from hestia_earth.models.ipcc2019.aboveGroundBiomass import _build_col_name, _should_run, MODEL, run, TERM_ID
+from hestia_earth.models.ipcc2019.biomass_utils import BiomassCategory, sample_constant
 
 from tests.utils import fake_new_measurement, fixtures_path
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-utils_path = f"hestia_earth.models.{MODEL}.{TERM_ID}_utils"
+utils_path = f"hestia_earth.models.{MODEL}.biomass_utils"
 term_path = "hestia_earth.models.utils.term"
 property_path = "hestia_earth.models.utils.property"
 
@@ -40,6 +38,7 @@ PARAMS_SHOULD_RUN = [
     ("forest-to-cropland-lcc-q2", True),
     ("forest-to-cropland-lcc-q3", True),
     ("forest-to-cropland-lcc-q4", True),
+    ("forest-to-gohac", False),
     ("forest-to-orchard", True),
     ("forest-to-orchard-with-backup-factors", True),
     ("forest-to-orchard-with-in-category-lcc", True),
@@ -119,64 +118,29 @@ def test_run_with_stats(
 
 
 # input, expected
-PARAMS_RESCALE_CATEGORY_COVER = [
-    (
-        {BiomassCategory.ANNUAL_CROPS: 90},
-        {BiomassCategory.ANNUAL_CROPS: 90, BiomassCategory.OTHER: 10}
-    ),
-    (
-        {BiomassCategory.OTHER: 90},
-        {BiomassCategory.OTHER: 100}
-    ),
-    (
-        {BiomassCategory.ANNUAL_CROPS: 60, BiomassCategory.VINE: 60},
-        {BiomassCategory.ANNUAL_CROPS: 50, BiomassCategory.VINE: 50}
-    ),
-    (
-        {BiomassCategory.NATURAL_FOREST: 100},
-        {BiomassCategory.NATURAL_FOREST: 100}
-    )
+PARAMS_BUILD_COLUMN_NAME = [
+    (BiomassCategory.ANNUAL_CROPS, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_ANNUAL_CROPS"),
+    (BiomassCategory.COCONUT, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_COCONUT"),
+    (BiomassCategory.FOREST, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_FOREST"),
+    (BiomassCategory.GRASSLAND, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_GRASSLAND"),
+    (BiomassCategory.JATROPHA, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_JATROPHA"),
+    (BiomassCategory.JOJOBA, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_JOJOBA"),
+    (BiomassCategory.NATURAL_FOREST, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_NATURAL_FOREST"),
+    (BiomassCategory.OIL_PALM, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OIL_PALM"),
+    (BiomassCategory.OLIVE, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OLIVE"),
+    (BiomassCategory.ORCHARD, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_ORCHARD"),
+    (BiomassCategory.OTHER, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.PLANTATION_FOREST, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_PLANTATION_FOREST"),
+    (BiomassCategory.RUBBER, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_RUBBER"),
+    (BiomassCategory.SHORT_ROTATION_COPPICE, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_SHORT_ROTATION_COPPICE"),
+    (BiomassCategory.TEA, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_TEA"),
+    (BiomassCategory.VINE, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_VINE"),
+    (BiomassCategory.WOODY_PERENNIAL, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_WOODY_PERENNIAL"),
+    ("Miscellaneous value", "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER")
 ]
-IDS_RESCALE_CATEGORY_COVER = ["fill", "fill w/ other", "squash", "do nothing"]
-
-
-@mark.parametrize("input, expected", PARAMS_RESCALE_CATEGORY_COVER, ids=IDS_RESCALE_CATEGORY_COVER)
-def test_rescale_category_cover(input: dict, expected: dict):
-    assert _rescale_category_cover(input) == expected
-
-
-# a, b, expected
-PARAMS_IS_LCC_EVENT = [
-    (
-        {
-            "appleTree": 33.333,
-            "pearTree": 33.333,
-            BiomassCategory.ANNUAL_CROPS: 33.334,
-        },
-        {
-            "appleTree": 33.33333,
-            "pearTree": 33.33333,
-            BiomassCategory.ANNUAL_CROPS: 33.33334,
-        },
-        True
-    ),
-    (
-        {
-            "appleTree": 33.3333,
-            "pearTree": 33.3333,
-            BiomassCategory.ANNUAL_CROPS: 33.3334,
-        },
-        {
-            "appleTree": 33.33333,
-            "pearTree": 33.33333,
-            BiomassCategory.ANNUAL_CROPS: 33.33334,
-        },
-        False
-    )
-]
-IDS_IS_LCC_EVENT = ["True", "False"]
+IDS_BUILD_COLUMN_NAME = [p[0] for p in PARAMS_BUILD_COLUMN_NAME]
 
 
-@mark.parametrize("a, b, expected", PARAMS_IS_LCC_EVENT, ids=IDS_IS_LCC_EVENT)
-def test_is_lcc_event(a: dict, b: dict, expected: bool):
-    assert _is_lcc_event(a, b) is expected
+@mark.parametrize("input, expected", PARAMS_BUILD_COLUMN_NAME, ids=IDS_BUILD_COLUMN_NAME)
+def test_build_col_name(input: BiomassCategory, expected: str):
+    assert _build_col_name(input) == expected

tests/models/ipcc2019/test_belowGroundBiomass.py

@@ -0,0 +1,146 @@
+import json
+from numpy.typing import NDArray
+from os.path import isfile
+from pytest import mark
+from unittest.mock import MagicMock, patch
+
+from hestia_earth.models.ipcc2019.belowGroundBiomass import _build_col_name, _should_run, MODEL, run, TERM_ID
+from hestia_earth.models.ipcc2019.biomass_utils import BiomassCategory, sample_constant
+
+from tests.utils import fake_new_measurement, fixtures_path
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+utils_path = f"hestia_earth.models.{MODEL}.biomass_utils"
+term_path = "hestia_earth.models.utils.term"
+property_path = "hestia_earth.models.utils.property"
+
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+_ITERATIONS = 1000
+
+
+def _load_fixture(path: str, default=None):
+    if isfile(path):
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    return default
+
+
+def _fake_calc_descriptive_stats(arr: NDArray, *_args, **_kwargs):
+    return {"value": [round(row[0], 6) for row in arr]}
+
+
+# subfolder, should_run
+PARAMS_SHOULD_RUN = [
+    ("forest-to-animal-housing", False),
+    ("forest-to-cropland", True),
+    ("forest-to-cropland-greater-than-100", True),
+    ("forest-to-cropland-less-than-100", True),
+    ("forest-to-cropland-lcc-q2", True),
+    ("forest-to-cropland-lcc-q3", True),
+    ("forest-to-cropland-lcc-q4", True),
+    ("forest-to-gohac", False),
+    ("forest-to-orchard", True),
+    ("forest-to-orchard-with-in-category-lcc", True),
+    ("historical-land-cover-mix", True),
+    ("historical-argentina-pasture", True),
+    ("historical-brazil-maize", True),
+    ("perennial-to-grassland-with-pasture-condition", True)
+]
+IDS_SHOULD_RUN = [p[0] for p in PARAMS_SHOULD_RUN]
+
+
+@mark.parametrize("subfolder, should_run", PARAMS_SHOULD_RUN, ids=IDS_SHOULD_RUN)
+def test_should_run(subfolder: str, should_run: bool):
+    folder = f"{fixtures_folder}/{subfolder}"
+
+    site = _load_fixture(f"{folder}/site.jsonld", {})
+
+    result, *_ = _should_run(site)
+    assert result == should_run
+
+
+def test_should_run_no_data():
+    SITE = {}
+    EXPECTED = False
+
+    result, *_ = _should_run(SITE)
+    assert result == EXPECTED
+
+
+PARAMS_RUN = [subfolder for subfolder, should_run in PARAMS_SHOULD_RUN if should_run]
+
+
+@mark.parametrize("subfolder", PARAMS_RUN)
+@patch(f"{class_path}.calc_descriptive_stats", side_effect=_fake_calc_descriptive_stats)
+@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
+@patch(f"{utils_path}._get_sample_func", return_value=sample_constant)
+def test_run(
+    _get_sample_func_mock: MagicMock,
+    _new_measurement_mock: MagicMock,
+    _calc_descriptive_stats_mock: MagicMock,
+    subfolder: str
+):
+    folder = f"{fixtures_folder}/{subfolder}"
+
+    site = _load_fixture(f"{folder}/site.jsonld", {})
+    expected = _load_fixture(f"{folder}/result.jsonld", [])
+
+    with patch(f"{class_path}._ITERATIONS", _ITERATIONS):
+        result = run(site)
+
+    assert result == expected
+
+
+# subfolder
+PARAMS_RUN_WITH_STATS = [
+    "forest-to-cropland-with-stats",
+    "forest-to-orchard-with-in-category-lcc-with-stats",
+    "historical-land-cover-mix-with-stats"
+]
+
+
+@mark.parametrize("subfolder", PARAMS_RUN_WITH_STATS)
+@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
+def test_run_with_stats(
+    _new_measurement_mock: MagicMock,
+    subfolder: str
+):
+    folder = f"{fixtures_folder}/{subfolder}"
+
+    site = _load_fixture(f"{folder}/site.jsonld", {})
+    expected = _load_fixture(f"{folder}/result.jsonld", [])
+
+    with patch(f"{class_path}._ITERATIONS", _ITERATIONS):
+        result = run(site)
+
+    assert result == expected
+
+
+# input, expected
+PARAMS_BUILD_COLUMN_NAME = [
+    (BiomassCategory.ANNUAL_CROPS, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.COCONUT, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.FOREST, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_FOREST"),
+    (BiomassCategory.GRASSLAND, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.JATROPHA, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.JOJOBA, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.NATURAL_FOREST, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_NATURAL_FOREST"),
+    (BiomassCategory.OIL_PALM, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.OLIVE, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.ORCHARD, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.OTHER, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.PLANTATION_FOREST, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_PLANTATION_FOREST"),
+    (BiomassCategory.RUBBER, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.SHORT_ROTATION_COPPICE, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.TEA, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.VINE, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.WOODY_PERENNIAL, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    ("Miscellaneous value", "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER")
+]
+IDS_BUILD_COLUMN_NAME = [p[0] for p in PARAMS_BUILD_COLUMN_NAME]
+
+
+@mark.parametrize("input, expected", PARAMS_BUILD_COLUMN_NAME, ids=IDS_BUILD_COLUMN_NAME)
+def test_build_col_name(input: BiomassCategory, expected: str):
+    assert _build_col_name(input) == expected

tests/models/ipcc2019/test_biomass_utils.py

@@ -0,0 +1,115 @@
+from pytest import mark
+
+from hestia_earth.models.ipcc2019.biomass_utils import (
+    _assign_biomass_category, _get_sample_func, _rescale_category_cover, BiomassCategory, detect_land_cover_change,
+    sample_constant, sample_plus_minus_error
+)
+
+_ITERATIONS = 1000
+
+
+# input, expected
+PARAMS_RESCALE_CATEGORY_COVER = [
+    (
+        {BiomassCategory.ANNUAL_CROPS: 90},
+        {BiomassCategory.ANNUAL_CROPS: 90, BiomassCategory.OTHER: 10}
+    ),
+    (
+        {BiomassCategory.OTHER: 90},
+        {BiomassCategory.OTHER: 100}
+    ),
+    (
+        {BiomassCategory.ANNUAL_CROPS: 60, BiomassCategory.VINE: 60},
+        {BiomassCategory.ANNUAL_CROPS: 50, BiomassCategory.VINE: 50}
+    ),
+    (
+        {BiomassCategory.NATURAL_FOREST: 100},
+        {BiomassCategory.NATURAL_FOREST: 100}
+    )
+]
+IDS_RESCALE_CATEGORY_COVER = ["fill", "fill w/ other", "squash", "do nothing"]
+
+
+@mark.parametrize("input, expected", PARAMS_RESCALE_CATEGORY_COVER, ids=IDS_RESCALE_CATEGORY_COVER)
+def test_rescale_category_cover(input: dict, expected: dict):
+    assert _rescale_category_cover(input) == expected
+
+
+# a, b, expected
+PARAMS_IS_LCC_EVENT = [
+    (
+        {
+            "appleTree": 33.333,
+            "pearTree": 33.333,
+            BiomassCategory.ANNUAL_CROPS: 33.334,
+        },
+        {
+            "appleTree": 33.33333,
+            "pearTree": 33.33333,
+            BiomassCategory.ANNUAL_CROPS: 33.33334,
+        },
+        True
+    ),
+    (
+        {
+            "appleTree": 33.3333,
+            "pearTree": 33.3333,
+            BiomassCategory.ANNUAL_CROPS: 33.3334,
+        },
+        {
+            "appleTree": 33.33333,
+            "pearTree": 33.33333,
+            BiomassCategory.ANNUAL_CROPS: 33.33334,
+        },
+        False
+    )
+]
+IDS_IS_LCC_EVENT = ["True", "False"]
+
+
+@mark.parametrize("a, b, expected", PARAMS_IS_LCC_EVENT, ids=IDS_IS_LCC_EVENT)
+def test_detect_land_cover_change(a: dict, b: dict, expected: bool):
+    assert detect_land_cover_change(a, b) is expected
+
+
+# kwargs, sample_func, expected_shape
+PARAMS_GET_SAMPLE_FUNC = [
+    ({"value": 1}, sample_constant),
+    ({"value": 1, "error": 10}, sample_plus_minus_error),
+]
+IDS_GET_SAMPLE_FUNC = ["constant", "+/- error"]
+
+
+@mark.parametrize("kwargs, sample_func", PARAMS_GET_SAMPLE_FUNC, ids=IDS_GET_SAMPLE_FUNC)
+def test_get_sample_func(kwargs, sample_func):
+    result = _get_sample_func(kwargs)
+    assert result == sample_func
+
+
+# input, expected
+PARAMS_ASSIGN_BIOMASS_CATEGORY = [
+    ("Annual crops", BiomassCategory.ANNUAL_CROPS),
+    ("Coconut", BiomassCategory.COCONUT),
+    ("Forest", BiomassCategory.FOREST),
+    ("Grassland", BiomassCategory.GRASSLAND),
+    ("Jatropha", BiomassCategory.JATROPHA),
+    ("Jojoba", BiomassCategory.JOJOBA),
+    ("Natural forest", BiomassCategory.NATURAL_FOREST),
+    ("Oil palm", BiomassCategory.OIL_PALM),
+    ("Olive", BiomassCategory.OLIVE),
+    ("Orchard", BiomassCategory.ORCHARD),
+    ("Other", BiomassCategory.OTHER),
+    ("Plantation forest", BiomassCategory.PLANTATION_FOREST),
+    ("Rubber", BiomassCategory.RUBBER),
+    ("Short rotation coppice", BiomassCategory.SHORT_ROTATION_COPPICE),
+    ("Tea", BiomassCategory.TEA),
+    ("Vine", BiomassCategory.VINE),
+    ("Woody perennial", BiomassCategory.WOODY_PERENNIAL),
+    ("Miscellaneous value", None)
+]
+IDS_ASSIGN_BIOMASS_CATEGORY = [p[0] for p in PARAMS_ASSIGN_BIOMASS_CATEGORY]
+
+
+@mark.parametrize("input, expected", PARAMS_ASSIGN_BIOMASS_CATEGORY, ids=IDS_ASSIGN_BIOMASS_CATEGORY)
+def test_assign_biomass_category(input: str, expected: BiomassCategory):
+    assert _assign_biomass_category(input) == expected

tests/models/ipcc2019/{test_co2ToAirAboveGroundBiomassStockChangeLandUseChange.py → test_co2ToAirAboveGroundBiomassStockChange.py}

@@ -4,13 +4,13 @@ from os.path import isfile
 from pytest import mark
 from unittest.mock import patch
 
-from hestia_earth.models.ipcc2019.co2ToAirAboveGroundBiomassStockChangeLandUseChange import MODEL, run, TERM_ID
+from hestia_earth.models.ipcc2019.co2ToAirAboveGroundBiomassStockChange import MODEL, run
 
-from tests.utils import fake_new_emission, fixtures_path
+from tests.utils import fake_new_emission, fixtures_path, order_list
 
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+class_path = f"hestia_earth.models.{MODEL}.co2ToAirAboveGroundBiomassStockChange"
 utils_path = f"hestia_earth.models.{MODEL}.co2ToAirCarbonStockChange_utils"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/co2ToAirAboveGroundBiomassStockChange"
 
 RUN_SCENARIOS = [
     ("no-overlapping-cycles", 3),
@@ -63,7 +63,7 @@ def test_run(_get_site_mock, related_cycles_mock, _new_emission_mock, subfolder,
     related_cycles_mock.return_value = cycles
 
     result = run(cycle)
-    assert result == expected
+    assert order_list(result) == order_list(expected)
 
 
 @patch(f"{class_path}._new_emission", side_effect=fake_new_emission)

tests/models/ipcc2019/{test_co2ToAirBelowGroundBiomassStockChangeLandUseChange.py → test_co2ToAirBelowGroundBiomassStockChange.py}

@@ -4,13 +4,13 @@ from os.path import isfile
 from pytest import mark
 from unittest.mock import patch
 
-from hestia_earth.models.ipcc2019.co2ToAirBelowGroundBiomassStockChangeLandUseChange import MODEL, run, TERM_ID
+from hestia_earth.models.ipcc2019.co2ToAirBelowGroundBiomassStockChange import MODEL, run
 
-from tests.utils import fake_new_emission, fixtures_path
+from tests.utils import fake_new_emission, fixtures_path, order_list
 
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+class_path = f"hestia_earth.models.{MODEL}.co2ToAirBelowGroundBiomassStockChange"
 utils_path = f"hestia_earth.models.{MODEL}.co2ToAirCarbonStockChange_utils"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/co2ToAirBelowGroundBiomassStockChange"
 
 RUN_SCENARIOS = [
     ("no-overlapping-cycles", 3),
@@ -63,7 +63,7 @@ def test_run(_get_site_mock, related_cycles_mock, _new_emission_mock, subfolder,
     related_cycles_mock.return_value = cycles
 
     result = run(cycle)
-    assert result == expected
+    assert order_list(result) == order_list(expected)
 
 
 @patch(f"{class_path}._new_emission", side_effect=fake_new_emission)

tests/models/ipcc2019/{test_co2ToAirSoilOrganicCarbonStockChangeManagementChange.py → test_co2ToAirSoilOrganicCarbonStockChange.py}

@@ -4,13 +4,13 @@ from os.path import isfile
 from pytest import mark
 from unittest.mock import patch
 
-from hestia_earth.models.ipcc2019.co2ToAirSoilOrganicCarbonStockChangeManagementChange import MODEL, run, TERM_ID
+from hestia_earth.models.ipcc2019.co2ToAirSoilOrganicCarbonStockChange import MODEL, run
 
-from tests.utils import fake_new_emission, fixtures_path
+from tests.utils import fake_new_emission, fixtures_path, order_list
 
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+class_path = f"hestia_earth.models.{MODEL}.co2ToAirSoilOrganicCarbonStockChange"
 utils_path = f"hestia_earth.models.{MODEL}.co2ToAirCarbonStockChange_utils"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/co2ToAirSoilOrganicCarbonStockChange"
 
 RUN_SCENARIOS = [
     ("no-overlapping-cycles", 3),
@@ -63,7 +63,7 @@ def test_run(_get_site_mock, related_cycles_mock, _new_emission_mock, subfolder,
     related_cycles_mock.return_value = cycles
 
     result = run(cycle)
-    assert result == expected
+    assert order_list(result) == order_list(expected)
 
 
 @patch(f"{class_path}._new_emission", side_effect=fake_new_emission)

tests/models/ipcc2021/test_gwp100.py

@@ -13,8 +13,8 @@ def test_run_no_emissions():
         impact = json.load(f)
 
     impact['emissionsResourceUse'] = []
-    value = run(impact)
-    assert value is None
+    indicator = run(impact)
+    assert indicator.get('value') == 0
 
 
 @patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)