hestia-earth-models 0.59.5__py3-none-any.whl → 0.59.7__py3-none-any.whl

tests/models/faostat2018/product/test_price.py

@@ -2,22 +2,12 @@ import json
 from unittest.mock import patch
 from tests.utils import fixtures_path
 
-from hestia_earth.models.faostat2018.product.price import MODEL, MODEL_KEY, run, _should_run, _lookup_data
+from hestia_earth.models.faostat2018.product.price import MODEL, MODEL_KEY, run, _lookup_data
 
 class_path = f"hestia_earth.models.{MODEL}.product.{MODEL_KEY}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/product/{MODEL_KEY}"
 
 
-def test_should_run():
-    cycle = {'endDate': '2020-01'}
-    should_run, *_ = _should_run(cycle)
-    assert not should_run
-
-    cycle['site'] = {'country': {'@id': 'GADM-GBR'}}
-    should_run, *_ = _should_run(cycle)
-    assert should_run is True
-
-
 def test_lookup_data():
     assert _lookup_data('cocoaSeedDehulled', 'Cocoa beans', 'GADM-GHA', 2000, term_type='crop') == 412.9
     # average price per tonne as year value is missing
@@ -37,11 +27,23 @@ def test_run_crop(*args):
 
 
 @patch(f"{class_path}.download_hestia", return_value={})
-def test_run_animalProduct(*args):
-    with open(f"{fixtures_folder}/animalProduct/cycle.jsonld", encoding='utf-8') as f:
+def test_run_animalProduct_kg(*args):
+    with open(f"{fixtures_folder}/animalProduct/kg/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/animalProduct/kg/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}.download_hestia", return_value={})
+def test_run_animalProduct_number(*args):
+    with open(f"{fixtures_folder}/animalProduct/number/cycle.jsonld", encoding='utf-8') as f:
         cycle = json.load(f)
 
-    with open(f"{fixtures_folder}/animalProduct/result.jsonld", encoding='utf-8') as f:
+    with open(f"{fixtures_folder}/animalProduct/number/result.jsonld", encoding='utf-8') as f:
         expected = json.load(f)
 
     value = run(cycle)
@@ -57,24 +59,10 @@ def test_run_liveAnimal_chicken(mock_download_hestia):
         expected = json.load(f)
 
     mock_download_hestia.return_value = {
-        "@id": "meatChickenReadyToCookWeight",
+        "@id": "meatChickenLiveweight",
         "@type": "Term",
-        "units": "kg ready-to-cook weight",
-        "termType": "animalProduct",
-        "defaultProperties": [
-            {
-                "term": {
-                    "@type": "Term",
-                    "name": "Processing conversion, cold carcass weight to ready-to-cook weight",
-                    "termType": "property",
-                    "@id": "processingConversionColdCarcassWeightToReadyToCookWeight",
-                    "units": "%"
-                },
-                "value": 72.45065789473684,
-                "sd": 3.605314180391945,
-                "@type": "Property"
-            }
-        ]
+        "units": "kg liveweight",
+        "termType": "animalProduct"
     }
     value = run(cycle)
     assert value == expected
@@ -89,24 +77,28 @@ def test_run_liveAnimal_pig(mock_download_hestia):
         expected = json.load(f)
 
     mock_download_hestia.return_value = {
-        "@id": "meatPigColdDressedCarcassWeight",
+        "@id": "meatPigLiveweight",
+        "@type": "Term",
+        "units": "kg liveweight",
+        "termType": "animalProduct"
+    }
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}.download_hestia")
+def test_run_liveAnimal_sheepLamb(mock_download_hestia):
+    with open(f"{fixtures_folder}/liveAnimal/sheepLamb/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/liveAnimal/sheepLamb/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    mock_download_hestia.return_value = {
+        "@id": "meatSheepLiveweight",
         "@type": "Term",
-        "units": "kg cold dressed carcass weight",
-        "termType": "animalProduct",
-        "defaultProperties": [
-            {
-                "term": {
-                    "@type": "Term",
-                    "name": "Processing conversion, liveweight to cold carcass weight",
-                    "termType": "property",
-                    "@id": "processingConversionLiveweightToColdCarcassWeight",
-                    "units": "%"
-                },
-                "value": 75.22666597366735,
-                "sd": 2.9377280394802323,
-                "@type": "Property"
-            }
-        ]
+        "units": "kg liveweight",
+        "termType": "animalProduct"
     }
     value = run(cycle)
     assert value == expected

tests/models/faostat2018/test_liveweightPerHead.py

@@ -1,61 +1,125 @@
 from unittest.mock import patch
 import json
 
-from hestia_earth.schema import TermTermType
 from tests.utils import fixtures_path, fake_new_property
 
-from hestia_earth.models.faostat2018.liveweightPerHead import MODEL, TERM_ID, _should_run, run
+from hestia_earth.models.faostat2018.liveweightPerHead import MODEL, TERM_ID, run
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-FAO_TERM = {
-    '@id': 'meatChickenReadyToCookWeight',
-    '@type': 'Term',
-    'units': 'kg ready-to-cook weight',
-    'defaultProperties': [{
-        'term': {'@id': 'processingConversionLiveweightToColdCarcassWeight', 'units': '%'},
-        'value': 72.30401869158878
-    }, {
-        'term': {'@id': 'processingConversionColdCarcassWeightToReadyToCookWeight', 'units': '%'},
-        'value': 72.45065789473684
-    }]
-}
-
-
-def test_should_run():
-    cycle = {}
-
-    # no animal products => no run
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with animal products => no run
-    cycle['products'] = [
-        {
-            'term': {
-                'termType': TermTermType.ANIMALPRODUCT.value,
-                'units': 'kg liveweight'
+
+
+@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+def test_run_animalProduct(*args):
+    with open(f"{fixtures_folder}/animalProduct/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/animalProduct/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+@patch(f"{class_path}.download_hestia")
+def test_run_liveAnimal_chicken(mock_download_hestia, *args):
+    with open(f"{fixtures_folder}/liveAnimal/chicken/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/liveAnimal/chicken/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    mock_download_hestia.return_value = {
+        "@id": "meatChickenReadyToCookWeight",
+        "@type": "Term",
+        "units": "kg ready-to-cook weight",
+        "defaultProperties": [
+            {
+                "term": {
+                    "@type": "Term",
+                    "name": "Processing conversion, liveweight to cold carcass weight",
+                    "termType": "property",
+                    "@id": "processingConversionLiveweightToColdCarcassWeight",
+                    "units": "%"
+                },
+                "value": 72.30401869158878,
+                "@type": "Property"
+            },
+            {
+                "term": {
+                    "@type": "Term",
+                    "name": "Processing conversion, cold carcass weight to ready-to-cook weight",
+                    "termType": "property",
+                    "@id": "processingConversionColdCarcassWeightToReadyToCookWeight",
+                    "units": "%"
+                },
+                "value": 72.45065789473684,
+                "@type": "Property"
             }
-        }
-    ]
-    should_run, *args = _should_run(cycle)
-    assert not should_run
+        ]
+    }
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+@patch(f"{class_path}.download_hestia")
+def test_run_liveAnimal_pig(mock_download_hestia, *args):
+    with open(f"{fixtures_folder}/liveAnimal/pig/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
 
-    # with an endDate and country => run
-    cycle['endDate'] = '2020'
-    cycle['site'] = {'country': {'@id': 'GADM-GBR'}}
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
+    with open(f"{fixtures_folder}/liveAnimal/pig/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    mock_download_hestia.return_value = {
+        "@id": "meatPigColdDressedCarcassWeight",
+        "@type": "Term",
+        "units": "kg cold dressed carcass weight",
+        "defaultProperties": [
+            {
+                "term": {
+                    "@type": "Term",
+                    "name": "Processing conversion, liveweight to cold carcass weight",
+                    "termType": "property",
+                    "@id": "processingConversionLiveweightToColdCarcassWeight",
+                    "units": "%"
+                },
+                "value": 75.22666597366735,
+                "@type": "Property"
+            }
+        ]
+    }
+    value = run(cycle)
+    assert value == expected
 
 
-@patch(f"hestia_earth.models.{MODEL}.utils.download_hestia", return_value=FAO_TERM)
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)
-def test_run(*args):
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+@patch(f"{class_path}.download_hestia")
+def test_run_liveAnimal_sheepLamb(mock_download_hestia, *args):
+    with open(f"{fixtures_folder}/liveAnimal/sheepLamb/cycle.jsonld", encoding='utf-8') as f:
         cycle = json.load(f)
 
-    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+    with open(f"{fixtures_folder}/liveAnimal/sheepLamb/result.jsonld", encoding='utf-8') as f:
         expected = json.load(f)
 
+    mock_download_hestia.return_value = {
+        "@id": "meatSheepColdDressedCarcassWeight",
+        "@type": "Term",
+        "units": "kg cold dressed carcass weight",
+        "defaultProperties": [
+            {
+                "term": {
+                    "@type": "Term",
+                    "name": "Processing conversion, liveweight to cold carcass weight",
+                    "termType": "property",
+                    "@id": "processingConversionLiveweightToColdCarcassWeight",
+                    "units": "%"
+                },
+                "value": 47.301833667687326,
+                "@type": "Property"
+            }
+        ]
+    }
     value = run(cycle)
     assert value == expected

tests/models/ipcc2019/test_organicCarbonPerHa.py

@@ -20,6 +20,7 @@ from hestia_earth.models.ipcc2019.organicCarbonPerHa import (
     _check_cropland_medium_category,
     _get_carbon_input_kwargs,
     _iterate_soc_equilibriums,
+    _should_run,
     IpccCarbonInputCategory,
     IpccLandUseCategory,
     IpccManagementCategory,
@@ -103,36 +104,38 @@ def find_term_property_side_effect(term: dict, property: str, *_):
 # --- TIER 1 & TIER 2 TESTS ---
 
 
-# subfolder, load_cycles
-RUN_SUBFOLDERS = [
-    ("tier-1-and-2/cropland", True),
-    ("tier-2/with-generalised-monthly-measurements", True),  # Closes issue 600
-    ("tier-2/with-incomplete-climate-data", True),  # Closes issue 599
-    ("tier-2/with-initial-soc", True),
-    ("tier-2/with-multi-year-cycles", True),
-    ("tier-2/with-multi-year-cycles-and-missing-properties", True),  # Closes issue 734
-    ("tier-2/without-any-measurements", True),  # Closes issue 594
-    ("tier-2/without-initial-soc", True),
-    ("tier-2/with-irrigation", True),
-    ("tier-2/with-irrigation-dates", True),
-    ("tier-2/with-paddy-rice", True),
-    ("tier-2/with-sand-without-date", True),  # Closes issue 739
-    ("tier-2/with-irrigated-upland-rice", True),
-    ("tier-1/cropland-depth-as-float", False),
-    ("tier-1/cropland-with-measured-soc", False),
-    ("tier-1/cropland-without-measured-soc", False),
-    ("tier-1/permanent-pasture", False),
-    ("tier-1/should-not-run", False),
-    ("tier-1/without-management-with-measured-soc", False),
-    ("tier-1/land-use-change", False),  # Closes issue 755
-    ("tier-1/run-with-site-type", False)  # Closes issue 755
+# subfolder, load_cycles, should_run
+SHOULD_RUN_SUBFOLDERS = [
+    ("tier-1-and-2/cropland", True, True),
+    ("tier-1-and-2/with-zero-carbon-input", True, True),  # Closes issue 777
+    ("tier-2/with-generalised-monthly-measurements", True, False),  # Closes issue 600
+    ("tier-2/with-incomplete-climate-data", True, False),  # Closes issue 599
+    ("tier-2/with-initial-soc", True, True),
+    ("tier-2/with-multi-year-cycles", True, True),
+    ("tier-2/with-multi-year-cycles-and-missing-properties", True, True),  # Closes issue 734
+    ("tier-2/without-any-measurements", True, False),  # Closes issue 594
+    ("tier-2/without-initial-soc", True, True),
+    ("tier-2/with-irrigation", True, True),
+    ("tier-2/with-irrigation-dates", True, True),
+    ("tier-2/with-paddy-rice", True, False),
+    ("tier-2/with-sand-without-date", True, True),  # Closes issue 739
+    ("tier-2/with-irrigated-upland-rice", True, False),
+    ("tier-1/cropland-depth-as-float", False, True),
+    ("tier-1/cropland-with-measured-soc", False, True),
+    ("tier-1/cropland-without-measured-soc", False, True),
+    ("tier-1/permanent-pasture", False, True),
+    ("tier-1/should-not-run", False, False),
+    ("tier-1/without-management-with-measured-soc", False, False),
+    ("tier-1/land-use-change", False, True),  # Closes issue 755
+    ("tier-1/run-with-site-type", False, True),  # Closes issue 755
+    ("tier-1/cropland-polar", False, False)  # Closes issue 794
 ]
 
 
 @mark.parametrize(
-    "subfolder, load_cycles",
-    RUN_SUBFOLDERS,
-    ids=[params[0] for params in RUN_SUBFOLDERS]
+    "subfolder, load_cycles, should_run",
+    SHOULD_RUN_SUBFOLDERS,
+    ids=[params[0] for params in SHOULD_RUN_SUBFOLDERS]
 )
 @patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
 @patch(f"{class_path}.get_cover_crop_property_terms", return_value=COVER_CROP_PROPERTY_TERM_IDS)
@@ -142,8 +145,8 @@ RUN_SUBFOLDERS = [
 @patch(f"{class_path}.get_upland_rice_land_cover_terms", return_value=UPLAND_RICE_LAND_COVER_TERM_IDS)
 @patch(f"{class_path}.get_upland_rice_crop_terms", return_value=UPLAND_RICE_CROP_TERM_IDS)
 @patch(f"{class_path}.related_cycles")
-@patch("hestia_earth.models.utils.property.find_term_property")
-def test_run(
+@patch("hestia_earth.models.utils.property.find_term_property", side_effect=find_term_property_side_effect)
+def test_should_run(
     mock_find_term_property,
     mock_related_cycles,
     _mock_get_upland_rice_crop_terms,
@@ -154,7 +157,8 @@ def test_run(
     _mock_get_cover_crop_property_terms,
     _mock_new_measurement,
     subfolder,
-    load_cycles
+    load_cycles,
+    should_run
 ):
     folder = f"{fixtures_folder}/{subfolder}"
 
@@ -162,20 +166,17 @@ def test_run(
         with open(f"{folder}/cycles.jsonld", encoding='utf-8') as f:
             return json.load(f)
 
-    mock_find_term_property.side_effect = find_term_property_side_effect
     mock_related_cycles.return_value = load_cycles_from_file() if load_cycles else []
 
     with open(f"{folder}/site.jsonld", encoding='utf-8') as f:
         site = json.load(f)
 
-    with open(f"{folder}/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
+    should_run_tier_1, should_run_tier_2, *_ = _should_run(site)
+    should_run_ = should_run_tier_1 or should_run_tier_2
 
-    result = run(site)
-    assert result == expected
+    assert should_run_ == should_run
 
 
-@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
 @patch(f"{class_path}.get_cover_crop_property_terms", return_value=COVER_CROP_PROPERTY_TERM_IDS)
 @patch(f"{class_path}.get_crop_residue_incorporated_or_left_on_field_terms", return_value=CROP_RESIDUE_INCORP_TERM_IDS)
 @patch(f"{class_path}.get_irrigated_terms", return_value=IRRIGATED_TERM_IDS)
@@ -183,11 +184,66 @@ def test_run(
 @patch(f"{class_path}.get_upland_rice_land_cover_terms", return_value=UPLAND_RICE_LAND_COVER_TERM_IDS)
 @patch(f"{class_path}.get_upland_rice_crop_terms", return_value=UPLAND_RICE_CROP_TERM_IDS)
 @patch(f"{class_path}.related_cycles", return_value=[])
-def test_run_no_data(*args):
+@patch("hestia_earth.models.utils.property.find_term_property", side_effect=find_term_property_side_effect)
+def test_should_run_no_data(*args):
     SITE = {}
-    EXPECTED = []
-    result = run(SITE)
-    assert result == EXPECTED
+    EXPECTED = False
+
+    should_run_tier_1, should_run_tier_2, *_ = _should_run(SITE)
+    should_run = should_run_tier_1 or should_run_tier_2
+
+    assert should_run == EXPECTED
+
+
+RUN_SUBFOLDERS = [
+    (subfolder, load_cycles) for subfolder, load_cycles, should_run in SHOULD_RUN_SUBFOLDERS
+    if should_run
+]
+
+
+@mark.parametrize(
+    "subfolder, load_cycles",
+    RUN_SUBFOLDERS,
+    ids=[params[0] for params in RUN_SUBFOLDERS]
+)
+@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
+@patch(f"{class_path}.get_cover_crop_property_terms", return_value=COVER_CROP_PROPERTY_TERM_IDS)
+@patch(f"{class_path}.get_crop_residue_incorporated_or_left_on_field_terms", return_value=CROP_RESIDUE_INCORP_TERM_IDS)
+@patch(f"{class_path}.get_irrigated_terms", return_value=IRRIGATED_TERM_IDS)
+@patch(f"{class_path}.get_residue_removed_or_burnt_terms", return_value=RESIDUE_REMOVED_OR_BURNT_TERM_IDS)
+@patch(f"{class_path}.get_upland_rice_land_cover_terms", return_value=UPLAND_RICE_LAND_COVER_TERM_IDS)
+@patch(f"{class_path}.get_upland_rice_crop_terms", return_value=UPLAND_RICE_CROP_TERM_IDS)
+@patch(f"{class_path}.related_cycles")
+@patch("hestia_earth.models.utils.property.find_term_property", side_effect=find_term_property_side_effect)
+def test_run(
+    mock_find_term_property,
+    mock_related_cycles,
+    _mock_get_upland_rice_crop_terms,
+    _mock_get_upland_rice_land_cover_terms,
+    _mock_get_residue_removed_or_burnt_terms,
+    _mock_get_irrigated_terms,
+    _mock_get_crop_residue_incorporated_or_left_on_field_terms,
+    _mock_get_cover_crop_property_terms,
+    _mock_new_measurement,
+    subfolder,
+    load_cycles
+):
+    folder = f"{fixtures_folder}/{subfolder}"
+
+    def load_cycles_from_file():
+        with open(f"{folder}/cycles.jsonld", encoding='utf-8') as f:
+            return json.load(f)
+
+    mock_related_cycles.return_value = load_cycles_from_file() if load_cycles else []
+
+    with open(f"{folder}/site.jsonld", encoding='utf-8') as f:
+        site = json.load(f)
+
+    with open(f"{folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    result = run(site)
+    assert result == expected
 
 
 # --- TIER 2 TESTS: SUB-MODELS ---
@@ -227,6 +283,13 @@ def test_calc_water_factor():
     assert _calc_water_factor(1, 1) == _calc_water_factor(1000, 1000)
 
 
+def test_calc_water_factor_zero():
+    """
+    Closes issue 771. Function should not raise 0 error and should return the maximum water factor.
+    """
+    assert _calc_water_factor(0, 0) == 1.49961875
+
+
 # --- IPCC SOIL CATEGORY TESTS ---
 
 

tests/models/schmidt2007/test_h2SToAirWasteTreatment.py

@@ -0,0 +1,45 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.schmidt2007.h2SToAirWasteTreatment import MODEL, TERM_ID, run, _should_run
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{class_path}.get_waste_values")
+def test_should_run(mock_get_waste_values):
+    # no fuel values => no run
+    mock_get_waste_values.return_value = []
+    should_run, *args = _should_run({})
+    assert not should_run
+
+    # with fuel values => run
+    mock_get_waste_values.return_value = [0]
+    should_run, *args = _should_run({})
+    assert should_run is True
+
+
+@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:
+        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
+
+
+@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+def test_run_data_complete(*args):
+    with open(f"{fixtures_folder}/no-input-data-complete/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/no-input-data-complete/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/utils/test_blank_node.py

@@ -1,8 +1,10 @@
 from datetime import datetime
 import pytest
+from pytest import mark
 from unittest.mock import patch
 
 from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.tools import parse
 
 from hestia_earth.models.utils.blank_node import (
     _calc_datetime_range_intersection_duration,
@@ -552,13 +554,31 @@ GROUP_NODES_BY_YEAR_SCENARIO_A_CYCLES = [
 ]
 
 
-def test_group_nodes_by_year_scenario_a():
+@mark.parametrize(
+    "system_datetime",
+    [
+        datetime(2024, 5, 1),  # Closes issue 772
+        datetime(2024, 1, 1),  # Jan 1st
+        datetime(2024, 2, 29),  # Leap year
+        datetime(2024, 12, 31),  # Dec 31st
+        # 3 random dates...
+        datetime(2030, 5, 4),
+        datetime(2035, 7, 22),
+        datetime(2047, 8, 14)
+    ],
+    ids=lambda system_datetime: f"system_datetime = {datetime.strftime(system_datetime, r'%Y-%m-%d')}"
+)
+@patch("hestia_earth.utils.tools.parse")
+def test_group_nodes_by_year_scenario_a(mock_parse, system_datetime):
     """
     Datestr in format `YYYY`. Some nodes missing `startDate` field. One multi-year cycle.
 
     Incomplete datestrs are gapfilled by default; with `endDate` datestrs snapping to the end
     of the calendar year, and `startDate` datestrs snapping to the beginning of the calendar
     year.
+
+    A bug used to occur in this function when it was run on the first day of a calendar month (e.g., 2024-04-01). To
+    verify that the bug is fixed we have simulated running the function on a variety of different dates.
     """
 
     EXPECTED = {
@@ -597,6 +617,9 @@ def test_group_nodes_by_year_scenario_a():
         }]
     }
 
+    # As we can't mock builtin method datetime.now(), we have to pass our test system_datetime into the parse function.
+    mock_parse.side_effect = lambda *args, **kwargs: parse(*args, default=system_datetime, **kwargs)
+
     result = group_nodes_by_year(GROUP_NODES_BY_YEAR_SCENARIO_A_CYCLES)
     assert result == EXPECTED
 
@@ -965,7 +988,26 @@ def test_group_nodes_by_year_missing_dates():
     assert result == EXPECTED
 
 
-def test_group_nodes_by_year_multiple_values_and_dates():
+@mark.parametrize(
+    "system_datetime",
+    [
+        datetime(2024, 5, 1),  # Closes issue 772
+        datetime(2024, 1, 1),  # Jan 1st
+        datetime(2024, 2, 29),  # Leap year
+        datetime(2024, 12, 31),  # Dec 31st
+        # 3 random dates...
+        datetime(2026, 5, 14),
+        datetime(2032, 10, 10),
+        datetime(2043, 8, 22)
+    ],
+    ids=lambda system_datetime: f"system_datetime = {datetime.strftime(system_datetime, r'%Y-%m-%d')}"
+)
+@patch("hestia_earth.utils.tools.parse")
+def test_group_nodes_by_year_multiple_values_and_dates(mock_parse, system_datetime):
+    """
+    A bug used to occur in this function when it was run on the first day of a calendar month (e.g., 2024-04-01). To
+    verify that the bug is fixed we have simulated running the function on a variety of different dates.
+    """
 
     NODES = [{
         "value": [1, 2, 3, 4, 5],
@@ -1005,11 +1047,34 @@ def test_group_nodes_by_year_multiple_values_and_dates():
         }]
     }
 
+    # As we can't mock builtin method datetime.now(), we have to pass our test system_datetime into the parse function.
+    mock_parse.side_effect = lambda *args, **kwargs: parse(*args, default=system_datetime, **kwargs)
+
     result = group_nodes_by_year(NODES, mode=GroupNodesByYearMode.DATES)
     assert result == EXPECTED
 
 
-def test_group_nodes_by_year_and_month():
+@mark.parametrize(
+    "system_datetime",
+    [
+        datetime(2024, 5, 1),  # Closes issue 772
+        datetime(2024, 1, 1),  # Jan 1st
+        datetime(2024, 2, 29),  # Leap year
+        datetime(2024, 12, 31),  # Dec 31st
+        # 3 random dates...
+        datetime(2026, 4, 6),
+        datetime(2034, 7, 24),
+        datetime(2049, 10, 10)
+    ],
+    ids=lambda system_datetime: f"system_datetime = {datetime.strftime(system_datetime, r'%Y-%m-%d')}"
+)
+@patch("hestia_earth.utils.tools.parse")
+def test_group_nodes_by_year_and_month(mock_parse, system_datetime):
+    """
+    A bug used to occur in this function when it was run on the first day of a calendar month (e.g., 2024-04-01). To
+    verify that the bug is fixed we have simulated running the function on a variety of different dates.
+    """
+
     MANAGEMENT = [
         {
             "term.@id": "fullTillage",
@@ -1064,5 +1129,8 @@ def test_group_nodes_by_year_and_month():
         }
     }
 
+    # As we can't mock builtin method datetime.now(), we have to pass our test system date into the parse function.
+    mock_parse.side_effect = lambda *args, **kwargs: parse(*args, default=system_datetime, **kwargs)
+
     result = group_nodes_by_year_and_month(MANAGEMENT)
     assert result == EXPECTED