hestia-earth-models 0.59.1__py3-none-any.whl → 0.59.2__py3-none-any.whl

tests/models/ipcc2019/test_n2OToAirOrganicFertiliserIndirect.py

@@ -2,26 +2,49 @@ from unittest.mock import patch
 import json
 from tests.utils import fixtures_path, fake_new_emission
 
-from hestia_earth.models.ipcc2019.n2OToAirOrganicFertiliserIndirect import MODEL, TERM_ID, run, _should_run
+from hestia_earth.models.ipcc2019.n2OToAirOrganicFertiliserIndirect import (
+    MODEL, TERM_ID, run, _should_run, NH3_TERM_ID, NO3_TERM_ID, NOX_TERM_ID
+)
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
-@patch(f"{class_path}.get_ecoClimateZone", return_value=2)
-@patch(f"{class_path}._is_term_type_complete", return_value=False)
-@patch(f"{class_path}.get_organic_fertiliser_N_total", return_value=0)
-def test_should_run(mock_N_total, mock_complete, *args):
-    # no N => no run
-    assert not _should_run({})
+def test_should_run():
+    # no emissions => no run
+    cycle = {'completeness': {'fertiliser': True}, 'emissions': []}
+    should_run, *args = _should_run(cycle)
+    assert not should_run
 
-    # with N => no run
-    mock_N_total.return_value = 10
-    assert not _should_run({})
+    # with no3 emission => run
+    cycle['emissions'] = [
+        {
+            'term': {'@id': NO3_TERM_ID},
+            'value': [100]
+        },
+        {
+            'term': {'@id': NH3_TERM_ID},
+            'value': [100]
+        },
+        {
+            'term': {'@id': NOX_TERM_ID},
+            'value': [100]
+        }
+    ]
+    should_run, *args = _should_run(cycle)
+    assert should_run is True
 
-    # is complete => run
-    mock_complete.return_value = True
-    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)

tests/models/ipcc2019/test_nh3ToAirOrganicFertiliser.py

@@ -0,0 +1,35 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.ipcc2019.nh3ToAirOrganicFertiliser 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}._is_term_type_complete", return_value=False)
+@patch(f"{class_path}.get_organic_fertiliser_N_total", return_value=0)
+def test_should_run(mock_N_total, mock_complete, *args):
+    # no N => no run
+    assert not _should_run({})
+
+    # with N => no run
+    mock_N_total.return_value = 10
+    assert not _should_run({})
+
+    # is complete => run
+    mock_complete.return_value = True
+    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

tests/models/ipcc2019/test_noxToAirOrganicFertiliser.py

@@ -0,0 +1,35 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.ipcc2019.noxToAirOrganicFertiliser 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}._is_term_type_complete", return_value=False)
+@patch(f"{class_path}.get_organic_fertiliser_N_total", return_value=0)
+def test_should_run(mock_N_total, mock_complete, *args):
+    # no N => no run
+    assert not _should_run({})
+
+    # with N => no run
+    mock_N_total.return_value = 10
+    assert not _should_run({})
+
+    # is complete => run
+    mock_complete.return_value = True
+    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

tests/models/ipcc2019/test_organicCarbonPerHa.py

@@ -16,6 +16,7 @@ from hestia_earth.models.ipcc2019.organicCarbonPerHa import (
     _calc_temperature_factor,
     _calc_tier_1_soc_stocks,
     _calc_water_factor,
+    _calculated_cycles,
     _check_cropland_low_category,
     _check_cropland_medium_category,
     _get_carbon_input_kwargs,
@@ -85,6 +86,25 @@ UPLAND_RICE_CROP_TERM_IDS = [
     "riceGrainInHuskUpland"
 ]
 
+DEFAULT_PROPERTIES = {
+    "manureDryKgMass": {
+        "carbonContent": {
+            "value": 38.4
+        },
+        "nitrogenContent": {
+            "value": 2.65
+        },
+        "ligninContent": {
+            "value": 9.67
+        }
+    }
+}
+
+
+def find_term_property_side_effect(term: dict, property: str, *_):
+    term_id = term.get('@id', None)
+    return DEFAULT_PROPERTIES.get(term_id, {}).get(property, {})
+
 
 # --- TIER 1 & TIER 2 TESTS ---
 
@@ -96,11 +116,13 @@ RUN_SUBFOLDERS = [
     ("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),
@@ -124,9 +146,11 @@ RUN_SUBFOLDERS = [
 @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(f"{class_path}._calculated_cycles")
+@patch("hestia_earth.models.utils.property.find_term_property")
 def test_run(
-    mock_related_cycles,
+    mock_find_term_property,
+    mock_calculated_cycles,
     _mock_get_upland_rice_crop_terms,
     _mock_get_upland_rice_land_cover_terms,
     _mock_get_residue_removed_or_burnt_terms,
@@ -144,7 +168,8 @@ def test_run(
         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 []
+    mock_find_term_property.side_effect = find_term_property_side_effect
+    mock_calculated_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)
@@ -164,7 +189,7 @@ def test_run(
 @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", return_value=[])
+@patch(f"{class_path}._calculated_cycles", return_value=[])
 def test_run_no_data(*args):
     SITE = {}
     EXPECTED = []
@@ -209,6 +234,22 @@ def test_calc_water_factor():
     assert _calc_water_factor(1, 1) == _calc_water_factor(1000, 1000)
 
 
+@patch(f"{class_path}.find_related")
+@patch("hestia_earth.models.utils.download_hestia")
+def test_calculated_cycles(mock_download_hestia, mock_find_related):
+    CYCLES = [{"@id": "cycle"}]
+    EXPECTED = [{"@id": "cycle", "@type": "Cycle"}]
+
+    mock_download_hestia.side_effect = lambda node_id, node_type, **_: {
+        "@type": node_type.value,
+        "@id": node_id
+    }
+    mock_find_related.return_value = CYCLES
+
+    result = _calculated_cycles({})
+    assert EXPECTED == result
+
+
 # --- IPCC SOIL CATEGORY TESTS ---
 
 

tests/models/site/test_soilMeasurement.py

@@ -0,0 +1,159 @@
+from unittest.mock import patch
+import json
+import pytest
+
+from tests.utils import fixtures_path, fake_new_measurement
+
+from hestia_earth.models.site.soilMeasurement import (
+    MODEL,
+    MODEL_KEY,
+    _get_overlap,
+    _harmonise_measurements,
+    _should_run, run
+)
+
+class_path = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
+fixtures_folder = f"{fixtures_path}/site/soilMeasurement"
+
+
+@pytest.mark.parametrize(
+    "data,expected",
+    [
+        ((1, 10, 2, 150), 8),
+        ((1, 10, 5, 15), 5),
+        ((1, 10, 10, 15), 0),
+        ((10, 10, 0, 150), 0),
+        ((150, 155, 1, 150), 0),
+        ((20, 40, 0, 30), 10),
+        ((0, 20, 0, 50), 20),
+        ((20, 60, 0, 50), 30),
+        ((10, 20, 40, 50), 0),
+        ((10, 20, 19, 50), 1),
+    ]
+)
+def test_get_overlap(data, expected):
+    result = _get_overlap(
+        data[0], data[1], data[2], data[3]
+    )
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "measurements_list,returns_dict,expected_value",
+    [
+        (
+            [
+                {"value": [7.5], "depthUpper": 0, "depthLower": 20},
+                {"value": [6], "depthUpper": 20, "depthLower": 40},
+            ],
+            {"depthUpper": 0, "depthLower": 30},
+            7
+        ),
+        (
+            [
+                {"value": [7.5], "depthUpper": 0, "depthLower": 20},
+                {"value": [6], "depthUpper": 20, "depthLower": 40},
+            ],
+            {"depthUpper": 0, "depthLower": 50},
+            6.75
+        ),
+    ]
+)
+def test_harmonise_measurements(measurements_list, returns_dict, expected_value):
+    actual_value = _harmonise_measurements(
+        measurements_list=measurements_list,
+        standard_depth_upper=returns_dict["depthUpper"],
+        standard_depth_lower=returns_dict["depthLower"],
+    )
+    assert actual_value == expected_value
+
+
+@pytest.mark.parametrize(
+    "test_name,site,expected_should_run",
+    [
+        (
+            "no measurement => no run",
+            {"measurements": []},
+            False
+        ),
+        (
+            "missing dates => run",
+            {
+                "measurements":
+                [
+                    {
+                        "term": {"@id": "clayContent"},
+                        "depthUpper": 0,
+                        "depthLower": 20
+                    }
+                ]
+            },
+            True
+        ),
+        (
+            "no depthUpper => no run",
+            {
+                "measurements":
+                    [
+                        {
+                            "term": {"@id": "clayContent"},
+                            "dates": ["2022-01-02"],
+                            "depthLower": 20
+                        }
+                    ]
+            },
+            False
+        ),
+        (
+            "all fields => run",
+            {
+                "measurements":
+                    [
+                        {
+                            "term": {"@id": "clayContent"},
+                            "dates": ["2022-01-02"],
+                            "depthUpper": 0,
+                            "depthLower": 20
+                        }
+                    ]
+            },
+            True
+        )
+    ]
+)
+@patch(f"{class_path}.get_lookup_value")
+def test_should_run(mock_get_lookup, test_name, site, expected_should_run):
+    mock_get_lookup.return_value = True
+    model_key = "clayContent"
+    should_run, *args = _should_run(site=site, model_key=model_key)
+    assert should_run == expected_should_run, test_name
+
+
+def lookup_side_effect(*args, **kwargs):
+    _ = kwargs
+    if args[0]["@id"] == "soilPh" and args[1] == "depthSensitive":
+        return False
+    elif args[0]["@id"] in {"baseSaturation", "soilDepth", "rainfallHourly"}:
+        return False
+    return True
+
+
+@pytest.mark.parametrize(
+    "test_name",
+    [
+        "missingDepth", "simpleSoilPh", "clayContent", "missingDepth", "nonUniqueMeasurements", "arrays"
+    ]
+)
+@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
+@patch(f"{class_path}.get_lookup_value")
+def test_run(mock_lookup, mock_new_measurement, test_name):
+    mock_lookup.side_effect = lookup_side_effect
+
+    with open(f"{fixtures_folder}/{test_name}/site.jsonld", encoding='utf-8') as f:
+        site = json.load(f)
+
+    with open(f"{fixtures_folder}/{test_name}/result.jsonld", encoding='utf-8') as f:
+        result = json.load(f)
+
+    value = run(site)
+    assert value == result