hestia-earth-models 0.57.2__py3-none-any.whl → 0.59.0__py3-none-any.whl

tests/models/koble2014/test_residueBurnt.py

@@ -1,11 +1,10 @@
 from unittest.mock import patch
 import json
-from tests.utils import fixtures_path, fake_new_practice
+from tests.utils import RESIDUE_TERMS, fixtures_path, fake_new_practice
 
 from hestia_earth.models.koble2014.residueBurnt import MODEL, TERM_ID, run
 
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-RESIDUE_TERMS = ['residueIncorporated', 'residueRemoved', 'residueBurnt', 'residueLeftOnField']
 
 
 @patch(f"hestia_earth.models.{MODEL}.utils.get_crop_residue_management_terms", return_value=RESIDUE_TERMS)

tests/models/koble2014/test_residueLeftOnField.py

@@ -1,12 +1,11 @@
 from unittest.mock import patch
 import json
-from tests.utils import fixtures_path, fake_new_practice
+from tests.utils import RESIDUE_TERMS, fixtures_path, fake_new_practice
 
 from hestia_earth.models.koble2014 import MODEL
 from hestia_earth.models.koble2014.residueLeftOnField import TERM_ID, run
 
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-RESIDUE_TERMS = ['residueIncorporated', 'residueRemoved', 'residueBurnt', 'residueLeftOnField']
 
 
 @patch(f"hestia_earth.models.{MODEL}.utils.get_crop_residue_management_terms", return_value=RESIDUE_TERMS)

tests/models/koble2014/test_residueRemoved.py

@@ -1,11 +1,10 @@
 from unittest.mock import patch
 import json
-from tests.utils import fixtures_path, fake_new_practice
+from tests.utils import RESIDUE_TERMS, fixtures_path, fake_new_practice
 
 from hestia_earth.models.koble2014.residueRemoved import MODEL, TERM_ID, run
 
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-RESIDUE_TERMS = ['residueIncorporated', 'residueRemoved', 'residueBurnt', 'residueLeftOnField']
 
 
 @patch(f"hestia_earth.models.{MODEL}.utils.get_crop_residue_management_terms", return_value=RESIDUE_TERMS)

tests/models/koble2014/test_utils.py

@@ -0,0 +1,52 @@
+from unittest.mock import patch
+from tests.utils import RESIDUE_TERMS
+
+from hestia_earth.models.koble2014 import MODEL
+from hestia_earth.models.koble2014.utils import _should_run
+
+class_path = '.'.join(['hestia_earth', 'models', MODEL, 'utils'])
+
+
+@patch(f"hestia_earth.models.{MODEL}.utils.get_crop_residue_management_terms", return_value=RESIDUE_TERMS)
+@patch(f"{class_path}.find_primary_product", return_value={})
+def test_should_run(*args):
+    cycle = {'completeness': {'cropResidue': False}}
+
+    # with 100% practices => no run
+    cycle['practices'] = [
+        {
+            'term': {'termType': 'cropResidueManagement', '@id': RESIDUE_TERMS[0]},
+            'value': [100]
+        }
+    ]
+    should_run, *ars = _should_run('', cycle)
+    assert not should_run
+
+    # with below 100% practices => run
+    cycle['practices'] = [
+        {
+            'term': {'termType': 'cropResidueManagement', '@id': RESIDUE_TERMS[0]},
+            'value': [50]
+        }
+    ]
+    should_run, *ars = _should_run('', cycle)
+    assert should_run is True
+
+    # requires country / no country => no run
+    should_run, *ars = _should_run('', cycle, require_country=True)
+    assert not should_run
+
+    # requires country / with country => run
+    cycle['site'] = {'country': {'@id': 'GADM-GBR'}}
+    should_run, *ars = _should_run('', cycle, require_country=True)
+    assert should_run is True
+
+    # with existing product => no run
+    cycle['products'] = [
+        {
+            'term': {'termType': 'cropResidue', '@id': 'aboveGroundCropResidueRemoved'},
+            'value': [50]
+        }
+    ]
+    should_run, *ars = _should_run('', cycle)
+    assert not should_run

tests/models/site/test_management.py

@@ -0,0 +1,117 @@
+import json
+from unittest.mock import patch
+from hestia_earth.schema import TermTermType
+
+from hestia_earth.models.site.management import MODEL, MODEL_KEY, run, should_run
+from tests.utils import fixtures_path
+
+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}
+}
+
+
+@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 => run
+    mock_related_cycles.return_value = [
+        {
+            "products": [
+                {
+                    "term": {
+                        "termType": TermTermType.CROP.value,
+                        "@id": "genericCropProduct"
+                    },
+                    "value": [51],
+                    "startDate": "2001",
+                    "endDate": "2002",
+                    "properties": {"test": "properties"}
+                }
+            ],
+            "startDate": "2021",
+            "endDate": "2022"
+        }
+    ]
+    _should_run, *args = should_run({})
+    assert _should_run is True
+    assert args[0] == [{
+        'term': TERM_BY_ID['genericCropPlant'],
+        'value': 100,
+        'endDate': '2002',
+        'startDate': '2001',
+        'properties': {'test': 'properties'}
+    }]
+
+
+@patch(f"{CLASS_PATH}.download_hestia", side_effect=lambda id, *args: TERM_BY_ID[id])
+@patch(f"{CLASS_PATH}.related_cycles")
+def test_run(mock_related_cycles, *args):
+    with open(f"{fixtures_folder}/cycles.jsonld", encoding='utf-8') as f:
+        cycles = json.load(f)
+    mock_related_cycles.return_value = cycles
+
+    with open(f"{fixtures_folder}/site.jsonld", encoding='utf-8') as f:
+        site = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    result = run(site)
+    assert result == expected

tests/models/site/test_organicCarbonPerHa.py

@@ -5,13 +5,19 @@ from unittest.mock import patch
 from tests.utils import fixtures_path, fake_new_measurement
 
 from hestia_earth.models.site.organicCarbonPerHa import (
-    MODEL, TERM_ID, run, _cdf, _c_to_depth, _get_last_date, _should_run_measurements
+    MODEL, TERM_ID, run, _cdf, _c_to_depth, _get_most_relevant_soc_node, _get_last_date, _should_run_calculation_group
 )
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
-SUBFOLDERS = ["calculate", "rescale", "calculate-and-rescale"]
+SUBFOLDERS = [
+    "calculate-single",
+    "calculate-multiple",
+    "rescale-single",
+    "rescale-multiple",
+    "calculate-and-rescale"
+]
 
 
 @mark.parametrize("depth, expected", [(0, 0), (1, 10.41666666666667)], ids=["0m", "1m"])
@@ -36,21 +42,55 @@ def test_cdf(depth_upper, depth_lower, expected):
         (["2020-01-01", "2020-02-28"], "2020-02-28"),
         ([], None)
     ],
-    ids=["YYYY", "YYYY-MM", "YYYY-MM-DD", "Empty list"]
+    ids=["YYYY", "YYYY-MM", "YYYY-MM-DD", "empty-list"]
 )
 def test_get_node_date(dates, expected):
     assert _get_last_date(dates) == expected
 
 
+@mark.parametrize(
+    "nodes, expected_id",
+    [
+        (
+            [
+                {"@id": "1", "depthUpper": 0, "depthLower": 10},
+                {"@id": "2", "depthUpper": 0, "depthLower": 40},
+                {"@id": "3", "depthUpper": 0, "depthLower": 100}
+            ],
+            "2"
+        ),
+        (
+            [
+                {"@id": "1", "depthUpper": 0, "depthLower": 5},
+                {"@id": "2", "depthUpper": 0, "depthLower": 10},
+                {"@id": "3", "depthUpper": 0, "depthLower": 20}
+            ],
+            "3"
+        ),
+        (
+            [
+                {"@id": "1", "depthUpper": 0, "depthLower": 20},
+                {"@id": "2", "depthUpper": 0, "depthLower": 40},
+                {"@id": "3", "depthUpper": 0, "depthLower": 100}
+            ],
+            "2"
+        )
+    ],
+    ids=["simple", "no-priority", "tie"]
+)
+def test_get_most_relevant_soc_node(nodes, expected_id):
+    assert _get_most_relevant_soc_node(nodes).get("@id") == expected_id
+
+
 @patch(f"{class_path}.find_term_match")
 def test_should_run_measurements(mock_find):
     # no measurement => no run
     mock_find.return_value = {}
-    assert not _should_run_measurements({}, [])
+    assert _should_run_calculation_group([]) is False
 
     # with measurement => run
     mock_find.return_value = {'value': [10], 'depthUpper': 0, 'depthLower': 10}
-    assert _should_run_measurements({}, []) is True
+    assert _should_run_calculation_group([]) is True
 
 
 @mark.parametrize("subfolder", SUBFOLDERS)
@@ -65,3 +105,9 @@ def test_run(_new_measurement_mock, get_source_mock, subfolder):
 
     value = run(site)
     assert value == expected
+
+
+@patch(f"{class_path}.get_source", return_value={})
+@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
+def test_run_empty(_new_measurement_mock, get_source_mock):
+    assert run({}) == []