hestia-earth-models 0.64.12__py3-none-any.whl → 0.64.13__py3-none-any.whl

{hestia_earth_models-0.64.12.dist-info → hestia_earth_models-0.64.13.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/models/cycle/completeness/test_seed.py

@@ -20,7 +20,7 @@ def test_run_seed(mock_find_term):
 
 @patch(f"{class_path}.is_plantation", return_value=False)
 @patch(f"{class_path}.find_term_match", return_value=None)
-def test_run_saplings(mock_find_term, mock_is_plantation):
+def test_run_saplingsDepreciatedAmountPerCycle(mock_find_term, mock_is_plantation):
     cycle = {}
 
     # on cropland => not complete

tests/models/cycle/test_endDate.py

@@ -1,3 +1,5 @@
+import pytest
+
 from hestia_earth.models.cycle.endDate import _should_run, run
 
 
@@ -18,5 +20,19 @@ def test_should_run():
     assert should_run is True
 
 
-def test_run():
-    assert run({'endDate': '2020-01'}) == '2020-01-14'
+@pytest.mark.parametrize(
+    'test_name,cycle,result',
+    [
+        (
+            'with endDate only', {'endDate': '2020-01'}, '2020-01-14'
+        ),
+        (
+            'with endDate same month as startDate', {'endDate': '2020-02', 'startDate': '2020-02'}, '2020-02-29'
+        ),
+        (
+            'with endDate not same month as startDate', {'endDate': '2020-02', 'startDate': '2020-01'}, '2020-02-14'
+        ),
+    ]
+)
+def test_run(test_name: str, cycle: dict, result: str):
+    assert run(cycle) == result, test_name

tests/models/cycle/test_startDate.py

@@ -1,3 +1,5 @@
+import pytest
+
 from hestia_earth.models.cycle.startDate import _should_run_by_cycleDuration, _should_run_by_startDate, run
 
 
@@ -35,6 +37,22 @@ def test_should_run_by_startDate():
     assert should_run is True
 
 
-def test_run():
-    assert run({'endDate': '2020-01-01', 'cycleDuration': 365}) == '2019-01-01'
-    assert run({'startDate': '2020-01'}) == '2020-01-15'
+@pytest.mark.parametrize(
+    'test_name,cycle,result',
+    [
+        (
+            'with startDate only', {'startDate': '2020-01'}, '2020-01-15'
+        ),
+        (
+            'with endDate and cycleDuration', {'endDate': '2020-01-01', 'cycleDuration': 365}, '2019-01-01'
+        ),
+        (
+            'with endDate same month as startDate', {'endDate': '2020-02', 'startDate': '2020-02'}, '2020-02-01'
+        ),
+        (
+            'with endDate not same month as startDate', {'endDate': '2020-02', 'startDate': '2020-01'}, '2020-01-15'
+        ),
+    ]
+)
+def test_run(test_name: str, cycle: dict, result: str):
+    assert run(cycle) == result, test_name

tests/models/hestia/test_landCover.py

@@ -4,7 +4,7 @@ import numpy as np
 import pytest
 from unittest.mock import patch
 
-from tests.utils import fixtures_path
+from tests.utils import fixtures_path, fake_new_management
 from hestia_earth.models.faostat2018.utils import MODEL as FAOSTAT_MODEL
 from hestia_earth.models.hestia.landCover import (
     MODEL, MODEL_KEY, get_changes, _estimate_maximum_forest_change,
@@ -197,7 +197,8 @@ def test_get_sums_of_crop_expansion():
         "gbr_example"
     ]
 )
-def test_run(subfolder):
+@patch(f"{CLASS_PATH}._new_management", side_effect=fake_new_management)
+def test_run(mock, subfolder):
     folder = f"{fixtures_folder}/{subfolder}"
     with open(f"{folder}/site.jsonld", encoding='utf-8') as f:
         site = json.load(f)

tests/models/ipcc2019/test_aboveGroundBiomass.py

@@ -45,7 +45,8 @@ PARAMS_SHOULD_RUN = [
     ("historical-land-cover-mix", True),
     ("historical-argentina-pasture", True),
     ("historical-brazil-maize", True),
-    ("perennial-to-grassland-with-pasture-condition", True)
+    ("perennial-to-grassland-with-pasture-condition", True),
+    ("with-gapfilled-start-date-end-date", False)  # Closes #972
 ]
 IDS_SHOULD_RUN = [p[0] for p in PARAMS_SHOULD_RUN]
 

tests/models/ipcc2019/test_belowGroundBiomass.py

@@ -45,7 +45,8 @@ PARAMS_SHOULD_RUN = [
     ("historical-land-cover-mix", True),
     ("historical-argentina-pasture", True),
     ("historical-brazil-maize", True),
-    ("perennial-to-grassland-with-pasture-condition", True)
+    ("perennial-to-grassland-with-pasture-condition", True),
+    ("with-gapfilled-start-date-end-date", False)  # Closes #972
 ]
 IDS_SHOULD_RUN = [p[0] for p in PARAMS_SHOULD_RUN]
 

tests/models/ipcc2019/test_co2ToAirAboveGroundBiomassStockChange.py

@@ -19,9 +19,10 @@ RUN_SCENARIOS = [
     ("missing-measurement-dates", 3),
     ("no-biomass-measurements", 1),               # Closes issue #700
     ("non-consecutive-biomass-measurements", 1),  # Closes issue #827
-    ("multiple-method-classifications", 5),              # Closes issue #764
-    ("non-soil-based-gohac-system", 3),                  # Closes issue #848
-    ("soil-based-gohac-system", 3)                       # Closes issue #848
+    ("multiple-method-classifications", 5),       # Closes issue #764
+    ("non-soil-based-gohac-system", 3),           # Closes issue #848
+    ("soil-based-gohac-system", 3),               # Closes issue #848
+    ("with-gapfilled-start-date-end-date", 1)     # Closes issue #972
 ]
 """List of (subfolder: str, num_cycles: int)."""
 

tests/models/ipcc2019/test_co2ToAirBelowGroundBiomassStockChange.py

@@ -19,9 +19,9 @@ RUN_SCENARIOS = [
     ("missing-measurement-dates", 3),
     ("no-biomass-measurements", 1),               # Closes issue #700
     ("non-consecutive-biomass-measurements", 1),  # Closes issue #827
-    ("multiple-method-classifications", 5),              # Closes issue #764
-    ("non-soil-based-gohac-system", 3),                  # Closes issue #848
-    ("soil-based-gohac-system", 3)                       # Closes issue #848
+    ("multiple-method-classifications", 5),       # Closes issue #764
+    ("non-soil-based-gohac-system", 3),           # Closes issue #848
+    ("with-gapfilled-start-date-end-date", 1)     # Closes issue #972
 ]
 """List of (subfolder: str, num_cycles: int)."""
 

tests/models/ipcc2019/test_co2ToAirSoilOrganicCarbonStockChange.py

@@ -47,7 +47,7 @@ RUN_SCENARIOS = [
     ("non-consecutive-organic-carbon-measurements", 1),  # Closes issue #827
     ("multiple-method-classifications", 5),              # Closes issue #764
     ("non-soil-based-gohac-system", 3),                  # Closes issue #848
-    ("soil-based-gohac-system", 3)                       # Closes issue #848
+    ("with-gapfilled-start-date-end-date", 1)            # Closes issue #972
 ]
 """List of (subfolder: str, num_cycles: int)."""
 

tests/models/ipcc2019/test_n2OToAirExcretaDirect.py

@@ -36,3 +36,15 @@ def test_run(*args):
 
     value = run(cycle)
     assert value == expected
+
+
+@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+def test_run_complete_no_inputs(*args):
+    with open(f"{fixtures_folder}/complete-no-inputs/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/complete-no-inputs/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/ipcc2019/test_organicCarbonPerHa.py

@@ -108,6 +108,7 @@ PARAMS_SHOULD_RUN = [
     ("tier-1/run-with-site-type", True),                             # Closes issue 755
     ("tier-1/cropland-polar", False),                                # Closes issue 794
     ("tier-1/cropland-with-system-increasing-c-input", True),        # Closes issue 851
+    ("tier-1/with-gapfilled-start-date-end-date", False),            # Closes issue 972
     ("tier-2/with-generalised-monthly-measurements", False),         # Closes issue 600
     ("tier-2/with-incomplete-climate-data", False),                  # Closes issue 599
     ("tier-2/with-initial-soc", True),

tests/models/koble2014/test_aboveGroundCropResidue.py

@@ -47,3 +47,16 @@ def test_run_no_total(*args):
 
     value = run(cycle)
     assert value == expected
+
+
+@patch(f"{class_path}._is_term_type_incomplete", return_value=True)
+@patch(f"{class_path}._new_product", side_effect=fake_new_product)
+def test_run_with_leftOnField(*args):
+    with open(f"{fixtures_folder}/with-left-on-field-value/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/with-left-on-field-value/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/pooreNemecek2018/test_no3ToGroundwaterCropResidueDecomposition.py

@@ -6,10 +6,11 @@ from hestia_earth.models.pooreNemecek2018.no3ToGroundwaterCropResidueDecompositi
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+utils_class_path = f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux_utils"
 
 
-@patch(f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux.get_max_rooting_depth", return_value=0.9)
+@patch(f"{utils_class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
+@patch(f"{utils_class_path}.get_max_rooting_depth", return_value=0.9)
 @patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/pooreNemecek2018/test_no3ToGroundwaterExcreta.py

@@ -6,10 +6,11 @@ from hestia_earth.models.pooreNemecek2018.no3ToGroundwaterExcreta import MODEL,
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+utils_class_path = f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux_utils"
 
 
-@patch(f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux.get_max_rooting_depth", return_value=0.9)
+@patch(f"{utils_class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
+@patch(f"{utils_class_path}.get_max_rooting_depth", return_value=0.9)
 @patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/pooreNemecek2018/test_no3ToGroundwaterInorganicFertiliser.py

@@ -6,10 +6,11 @@ from hestia_earth.models.pooreNemecek2018.no3ToGroundwaterInorganicFertiliser im
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+utils_class_path = f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux_utils"
 
 
-@patch(f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux.get_max_rooting_depth", return_value=0.9)
+@patch(f"{utils_class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
+@patch(f"{utils_class_path}.get_max_rooting_depth", return_value=0.9)
 @patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/pooreNemecek2018/test_no3ToGroundwaterOrganicFertiliser.py

@@ -6,10 +6,11 @@ from hestia_earth.models.pooreNemecek2018.no3ToGroundwaterOrganicFertiliser impo
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+utils_class_path = f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux_utils"
 
 
-@patch(f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"hestia_earth.models.{MODEL}.no3ToGroundwaterSoilFlux.get_max_rooting_depth", return_value=0.9)
+@patch(f"{utils_class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
+@patch(f"{utils_class_path}.get_max_rooting_depth", return_value=0.9)
 @patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
 def test_run(*args):
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:

tests/models/pooreNemecek2018/{test_saplings.py → test_saplingsDepreciatedAmountPerCycle.py}

@@ -2,7 +2,7 @@ from unittest.mock import patch
 import json
 from tests.utils import fixtures_path, fake_new_input
 
-from hestia_earth.models.pooreNemecek2018.saplings import MODEL, TERM_ID, run, _should_run
+from hestia_earth.models.pooreNemecek2018.saplingsDepreciatedAmountPerCycle import MODEL, TERM_ID, run, _should_run
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"

tests/models/site/test_management.py

@@ -1,152 +1,20 @@
 import json
-from unittest.mock import patch
-
+from unittest.mock import Mock, patch
 import pytest
-from hestia_earth.schema import TermTermType, SiteSiteType
+from hestia_earth.schema import SiteSiteType
 
-from hestia_earth.models.site.management import MODEL, MODEL_KEY, run, _should_run
-from tests.utils import fixtures_path
+from tests.utils import fixtures_path, fake_new_management
+from hestia_earth.models.site.management import MODEL, MODEL_KEY, run
 
-CLASS_PATH = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
+class_path = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{MODEL_KEY}"
 
-TERM_BY_ID = {
-    'genericCropPlant': {'@type': 'Term', '@id': 'genericCropPlant', 'termType': TermTermType.LANDCOVER.value},
-    'wheatPlant': {'@type': 'Term', '@id': 'wheatPlant', 'termType': TermTermType.LANDCOVER.value},
-    'oatPlant': {'@type': 'Term', '@id': 'oatPlant', 'termType': TermTermType.LANDCOVER.value},
-    'agatiTree': {'@type': 'Term', '@id': 'agatiTree', 'termType': TermTermType.LANDCOVER.value},
-    'wildGarlicPlant': {'@type': 'Term', '@id': 'wildGarlicPlant', 'termType': TermTermType.LANDCOVER.value},
-    'animalHousing': {
-        "@type": "Term",
-        "@id": "animalHousing",
-        "name": "Animal housing",
-        "termType": TermTermType.LANDCOVER.value,
-        "units": "% area"
-    }
-}
-
-LAND_COVER_TERM_BY_SITE_TYPE = {
+_LAND_COVER_TERM_BY_SITE_TYPE = {
     SiteSiteType.ANIMAL_HOUSING.value: "animalHousing",
     SiteSiteType.CROPLAND.value: "cropland"
 }
 
 
-def lookup_side_effect(*args, **kwargs):
-    # Values taken from real lookups.
-    _ = kwargs
-    if args[0]["@id"] == "ureaKgN" and args[1] == "nitrogenContent":
-        return 45.5
-    if args[0]["@id"] == "compostKgMass" and args[1] == "ANIMAL_MANURE":
-        return False
-    return True
-
-
-@patch(f"{CLASS_PATH}.download_hestia", side_effect=lambda id, *args: TERM_BY_ID[id])
-@patch(f"{CLASS_PATH}.related_cycles")
-def test_should_run(mock_related_cycles, *args):
-    # no cycles => do not run
-    mock_related_cycles.return_value = []
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # no products => do not run
-    mock_related_cycles.return_value = [{"products": []}]
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # with irrelevant termType => do not run
-    mock_related_cycles.return_value = [
-        {
-            "products": [
-                {"term": {"termType": TermTermType.BUILDING.value}},
-                {"term": {"termType": TermTermType.EXCRETA.value}}
-            ],
-            "startDate": "2021",
-            "endDate": "2022"
-        }
-    ]
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # products and practices but no relevant terms/termTypes => do not run
-    mock_related_cycles.return_value = [
-        {
-            "practices": [
-                {"term": {"@id": "soilAssociationOrganicStandard"}},
-                {"term": {"@id": "noTillage"}}
-            ],
-            "products": [
-                {"term": {"termType": TermTermType.BUILDING.value}},
-                {"term": {"termType": TermTermType.EXCRETA.value}}
-            ]
-        }
-    ]
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # # practices with relevant termType => run
-    mock_related_cycles.return_value = [
-        {
-            "practices": [
-                {"term": {"termType": TermTermType.WATERREGIME.value}},
-                {"term": {"termType": TermTermType.MACHINERY.value}}
-            ],
-            "startDate": "2021",
-            "endDate": "2022"
-        }
-    ]
-    should_run, *args = _should_run({})
-    assert should_run is True
-
-    # with relevant product, blank site_type => no run
-    mock_related_cycles.return_value = [
-        {
-            "products": [
-                {
-                    "term": {
-                        "termType": TermTermType.CROP.value,
-                        "@id": "genericCropProduct"
-                    },
-                    "value": [51],
-                    "startDate": "2001",
-                    "endDate": "2002"
-                }
-            ],
-            "startDate": "2021",
-            "endDate": "2022"
-        }
-    ]
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # with relevant product and site_type => run
-    mock_related_cycles.return_value = [
-        {
-            "products": [
-                {
-                    "term": {
-                        "termType": TermTermType.CROP.value,
-                        "@id": "genericCropProduct"
-                    },
-                    "value": [51],
-                    "startDate": "2001",
-                    "endDate": "2002"
-                }
-            ],
-            "startDate": "2021",
-            "endDate": "2022"
-        }
-    ]
-    should_run, *args = _should_run({"siteType": "cropland"})
-    assert should_run is True
-    assert args[0] == [{
-        'term': TERM_BY_ID['genericCropPlant'],
-        'value': 100,
-        'endDate': '2022',
-        'startDate': '2021'
-    }]
-
-
 @pytest.mark.parametrize(
     "test_name,fixture_path",
     [
@@ -167,23 +35,22 @@ def test_should_run(mock_related_cycles, *args):
         #   - sassafrasTree (86) x 2 condenses 2001-01-01 to 2004-12-31
         #   - bananaPlant (87) does not condense [non-consecutive years]
         #   - durianTree (89) does not condense [dates overwritten See 808]
-        ("Site Type", f"{fixtures_folder}/inputs/site_type")
+        ("Site Type", f"{fixtures_folder}/inputs/site_type"),
+        ("Multiple products but only 1 with landCover id", f"{fixtures_folder}/multiple-products"),
     ]
 )
 @patch(
-    f"{CLASS_PATH}.get_landCover_term_id_from_site_type",
-    side_effect=lambda site_type: LAND_COVER_TERM_BY_SITE_TYPE[site_type]
+    f"{class_path}.get_landCover_term_id_from_site_type",
+    side_effect=lambda site_type: _LAND_COVER_TERM_BY_SITE_TYPE[site_type]
 )
-@patch(f"{CLASS_PATH}.download_hestia", side_effect=lambda term_id, *args: TERM_BY_ID[term_id])
-@patch(f"{CLASS_PATH}.related_cycles")
-@patch(f"{CLASS_PATH}._get_lookup_with_debug", side_effect=lookup_side_effect)
+@patch(f"{class_path}._new_management", side_effect=fake_new_management)
+@patch(f"{class_path}.related_cycles")
 def test_run(
-        mock_get_lookup_with_debug,
-        mock_related_cycles,
-        mock_download,
-        mock_land_cover_lookup,
-        test_name,
-        fixture_path
+        mock_related_cycles: Mock,
+        mock_new_management: Mock,
+        mock_land_cover_lookup: Mock,
+        test_name: str,
+        fixture_path: str
 ):
     with open(f"{fixture_path}/cycles.jsonld", encoding='utf-8') as f:
         cycles = json.load(f)
@@ -200,4 +67,4 @@ def test_run(
         expected = json.load(f)
 
     result = run(site)
-    assert result == expected
+    assert result == expected, test_name

tests/models/utils/test_blank_node.py

@@ -24,7 +24,8 @@ from hestia_earth.models.utils.blank_node import (
     GroupNodesByYearMode,
     split_node_by_dates,
     _most_recent_nodes,
-    _shallowest_node
+    _shallowest_node,
+    validate_start_date_end_date
 )
 
 
@@ -184,6 +185,19 @@ def test_condense_nodes():
                  "value": [7]}
             ],
         ),
+        (
+            "same-blank-nodes-sum",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [50]},
+                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [50]}
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [100]}
+            ]
+        )
     ]
 )
 def test_condense_nodes_(test_name, input_nodes, expected_output_nodes):
@@ -872,6 +886,18 @@ def test_group_nodes_by_year_missing_dates():
     assert result == EXPECTED
 
 
+def test_group_nodes_by_year_incorrect_dates():
+
+    NODES = [
+        {"value": [0], "endDate": "2000-09-14", "startDate": "2000-09-15"},
+    ]
+
+    EXPECTED = {}
+
+    result = group_nodes_by_year(NODES, mode=GroupNodesByYearMode.START_AND_END_DATE)
+    assert result == EXPECTED
+
+
 @mark.parametrize(
     "system_datetime",
     [
@@ -1176,3 +1202,33 @@ def test_shallowest_measurement():
         expected = json.load(f)
 
     assert _shallowest_node(measurements) == expected
+
+
+@mark.parametrize(
+    "node, expected",
+    [
+        (
+            {"startDate": "2000", "endDate": "2001"},
+            True
+        ),
+        (
+            {"startDate": "2001", "endDate": "2000"},
+            False
+        ),
+        (
+            {"startDate": "2000-01-01T00:00:00", "endDate": "2000-01-01T00:00:00"},
+            False
+        ),
+        (
+            {"endDate": "2000"},
+            True
+        ),
+        (
+            {},
+            True
+        ),
+    ],
+    ids=["correct", "reversed", "equal", "no start date", "no start date, no end date"])
+def test_validate_start_date_end_date(node: dict, expected: bool):
+    # Closes #972
+    assert validate_start_date_end_date(node) == expected

tests/models/utils/test_emission.py

@@ -4,7 +4,7 @@ from unittest.mock import patch
 from hestia_earth.schema import EmissionMethodTier
 
 from tests.utils import TERM
-from hestia_earth.models.utils.emission import _new_emission, is_in_system_boundary, min_emission_method_tier
+from hestia_earth.models.utils.emission import _new_emission, min_emission_method_tier
 
 class_path = 'hestia_earth.models.utils.emission'
 
@@ -27,11 +27,6 @@ def test_new_emission(*args):
     }
 
 
-def test_is_in_system_boundary():
-    assert is_in_system_boundary('ch4ToAirCropResidueBurning') is True
-    assert is_in_system_boundary('codToWaterInputsProduction') is False
-
-
 @mark.parametrize(
     "input, expected",
     [

tests/models/utils/test_site.py

@@ -1,7 +1,8 @@
-from unittest.mock import patch
+import pytest
+from unittest.mock import Mock, patch
 from hestia_earth.schema import SiteSiteType
 
-from hestia_earth.models.utils.site import region_level_1_id, related_cycles, valid_site_type
+from hestia_earth.models.utils.site import region_level_1_id, related_cycles, valid_site_type, get_land_cover_term_id
 
 class_path = 'hestia_earth.models.utils.site'
 CYCLE = {'@id': 'id'}
@@ -30,3 +31,33 @@ def test_valid_site_type():
 
     site = {'siteType': SiteSiteType.CROPLAND.value}
     assert not valid_site_type(site, [SiteSiteType.OTHER_NATURAL_VEGETATION.value])
+
+
+_LAND_COVER_TERMS = [
+    {'@type': 'Term', 'name': 'Glass or high accessible cover', '@id': 'glassOrHighAccessibleCover'},
+    {'@type': 'Term', 'name': 'Sea or ocean', '@id': 'seaOrOcean'},
+    {'@type': 'Term', 'name': 'River or stream', '@id': 'riverOrStream'},
+    {'@type': 'Term', 'name': 'Other natural vegetation', '@id': 'otherNaturalVegetation'},
+    {'@type': 'Term', 'name': 'Food retailer', '@id': 'foodRetailer'},
+    {'@type': 'Term', 'name': 'Agri-food processor', '@id': 'agriFoodProcessor'},
+    {'@type': 'Term', 'name': 'Permanent pasture', '@id': 'permanentPasture'},
+    {'@type': 'Term', 'name': 'Animal housing', '@id': 'animalHousing'},
+    {'@type': 'Term', 'name': 'Forest', '@id': 'forest'},
+    {'@type': 'Term', 'name': 'Lake', '@id': 'lake'},
+    {'@type': 'Term', 'name': 'Pond', '@id': 'pond'},
+    {'@type': 'Term', 'name': 'Cropland', '@id': 'cropland'},
+]
+
+
+@pytest.mark.parametrize(
+    'site_type,expected_landCover_id',
+    [
+        (SiteSiteType.CROPLAND.value, 'cropland'),
+        (SiteSiteType.SEA_OR_OCEAN.value, 'seaOrOcean'),
+        (SiteSiteType.AGRI_FOOD_PROCESSOR.value, 'agriFoodProcessor'),
+        (SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value, 'glassOrHighAccessibleCover'),
+    ]
+)
+@patch(f"{class_path}.get_land_cover_siteTypes", return_value=_LAND_COVER_TERMS)
+def test_get_land_cover_term_id(mock_terms: Mock, site_type: str, expected_landCover_id: str):
+    assert get_land_cover_term_id(site_type) == expected_landCover_id, site_type