hestia-earth-models 0.62.3__py3-none-any.whl → 0.62.5__py3-none-any.whl

tests/models/emepEea2019/test_so2ToAirFuelCombustion.py

@@ -5,6 +5,7 @@ from tests.utils import fixtures_path, fake_new_emission
 from hestia_earth.models.emepEea2019.so2ToAirFuelCombustion import MODEL, TERM_ID, run, _should_run
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+model_utils_path = f"hestia_earth.models.{MODEL}.utils"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
@@ -21,7 +22,7 @@ def test_should_run(mock_get_fuel_values):
     assert should_run is True
 
 
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+@patch(f"{model_utils_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)
@@ -33,7 +34,7 @@ def test_run(*args):
     assert value == expected
 
 
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+@patch(f"{model_utils_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)

tests/models/emepEea2019/test_tspToAirAnimalHousing.py

@@ -0,0 +1,21 @@
+from unittest.mock import patch
+import json
+
+from tests.utils import fixtures_path, fake_new_emission
+from hestia_earth.models.emepEea2019.tspToAirAnimalHousing import MODEL, TERM_ID, run
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+model_utils_path = f"hestia_earth.models.{MODEL}.utils"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{model_utils_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/emepEea2019/test_utils.py

@@ -1,6 +1,8 @@
 from unittest.mock import patch
 
-from hestia_earth.models.emepEea2019.utils import get_fuel_values
+import pytest
+
+from hestia_earth.models.emepEea2019.utils import get_fuel_values, should_run_animal, _duration_in_housing
 
 class_path = 'hestia_earth.models.emepEea2019.utils'
 TERMS = [
@@ -53,3 +55,198 @@ def test_get_fuel_values(*args):
     }
     result = get_fuel_values('co2ToAirFuelCombustion', cycle, 'co2ToAirFuelCombustionEmepEea2019')
     assert result == [317.0, 632.0, 475.5, 158.5]
+
+
+@pytest.mark.parametrize(
+    "test_name,cycle,expected_duration",
+    [
+        (
+            "no sites => 0",
+            {"completeness": {"@type": "Completeness", "animalPopulation": False}},
+            0
+        ),
+        (
+            "site and other sites have wrong type => 0",
+            {
+                "site": {"@type": "Site", "siteType": "permanent pasture"},
+                "siteDuration": 15,
+                "otherSites": [
+                    {"@type": "Site", "siteType": "pond"},
+                    {"@type": "Site", "siteType": "pond"},
+                    {"@type": "Site", "siteType": "pond"},
+                ],
+                "otherSitesDuration": [20, 21, 22],
+            },
+            0
+        ),
+        (
+            "only second other site is animal housing => 12",
+            {
+                "site": {"@type": "Site", "siteType": "pond"},
+                "siteDuration": 20,
+                "otherSites": [
+                    {"@type": "Site", "siteType": "pond"},
+                    {"@type": "Site", "siteType": "animal housing"},
+                    {"@type": "Site", "siteType": "pond"},
+                ],
+                "otherSitesDuration": [11, 12, 13],
+            },
+            12
+        ),
+        (
+            "only site is animal housing => 20",
+            {
+                "site": {"@type": "Site", "siteType": "animal housing"},
+                "otherSites": [
+                    {"@type": "Site", "siteType": "forest"},
+                    {"@type": "Site", "siteType": "forest"},
+                    {"@type": "Site", "siteType": "forest"},
+                ],
+                "siteDuration": 20,
+                "otherSitesDuration": [12, 13, 14],
+            },
+            20
+        ),
+        (
+            "site and otherSites are animal housing, sum all values => 59",
+            {
+                "site": {"@type": "Site", "siteType": "animal housing"},
+                "otherSites": [
+                    {"@type": "Site", "siteType": "animal housing"},
+                    {"@type": "Site", "siteType": "animal housing"},
+                    {"@type": "Site", "siteType": "animal housing"},
+                ],
+                "siteDuration": 20,
+                "otherSitesDuration": [12, 13, 14],
+            },
+            59
+        )
+
+    ]
+)
+def test_duration_in_housing(test_name, cycle, expected_duration):
+    assert _duration_in_housing(cycle) == expected_duration
+
+
+@pytest.mark.parametrize(
+    "test_name,cycle,expected_should_run",
+    [
+        (
+            "not complete => no run",
+            {"completeness": {"@type": "Completeness", "animalPopulation": False}},
+            False
+        ),
+        (
+            "no site or other sites => no run",
+            {"completeness": {"@type": "Completeness", "animalPopulation": True}},
+            False
+        ),
+        (
+            "no site or other sites with 'animal housing' type => no run",
+            {
+                "completeness": {"@type": "Completeness", "animalPopulation": True},
+                "site": {"@type": "Site", "siteType": "permanent pasture"},
+                "otherSites": [{"@type": "Site", "siteType": "pond"}]
+            },
+            False
+        ),
+        (
+            "no site or other sites with 'animal housing' type and duration => no run",
+            {
+                "completeness": {"@type": "Completeness", "animalPopulation": True},
+                "site": {"@type": "Site", "siteType": "animal housing"},
+                "otherSites": [{"@type": "Site", "siteType": "pond"}],
+                "siteDuration": ""
+            },
+            False
+        ),
+        (
+            "no animal values => no run",
+            {
+                "completeness": {"@type": "Completeness", "animalPopulation": True},
+                "site": {"@type": "Site", "siteType": "animal housing"},
+                "otherSites": [{"@type": "Site", "siteType": "pond"}],
+                "siteDuration": 150,
+                "animals": [
+                    {"value": ""}
+                ]
+            },
+            False
+        ),
+        (
+            "animal values reference period is not 'average' => no run",
+            {
+                "completeness": {"@type": "Completeness", "animalPopulation": True},
+                "site": {"@type": "Site", "siteType": "animal housing"},
+                "otherSites": [{"@type": "Site", "siteType": "pond"}],
+                "siteDuration": 150,
+                "animals": [
+                    {
+                        "@type": "Animal",
+                        "value": 1
+                    },
+                    {
+                        "@type": "Animal",
+                        "value": 2,
+                        "referencePeriod": ""
+                    },
+                    {
+                        "@type": "Animal",
+                        "value": 3,
+                        "referencePeriod": "start of Cycle"
+                    },
+                ]
+            },
+            False
+        ),
+        (
+            "missing otherSitesDuration => no run",
+            {
+                "completeness": {"@type": "Completeness", "animalPopulation": True},
+                "site": {"@type": "Site", "siteType": "animal housing"},
+                "otherSites": [{"@type": "Site", "siteType": "pond"}],
+                "siteDuration": 150,
+                "animals": [
+                    {
+                        "@type": "Animal",
+                        "value": 2,
+                        "referencePeriod": ""
+                    },
+                    {
+                        "@type": "Animal",
+                        "value": 3,
+                        "referencePeriod": "average"
+                    },
+                ]
+            },
+            False
+        ),
+        (
+            "all requirements met with otherSites => run",
+            {
+                "completeness": {"@type": "Completeness", "animalPopulation": True},
+                "site": {"@type": "Site", "siteType": "pond"},
+                "siteDuration": "",
+                "otherSites": [{"@type": "Site", "siteType": "animal housing"}],
+                "otherSitesDuration": [200],
+                "animals": [
+                    {
+                        "@type": "Animal",
+                        "value": 2,
+                        "referencePeriod": ""
+                    },
+                    {
+                        "@type": "Animal",
+                        "value": 3,
+                        "referencePeriod": "average"
+                    },
+                ]
+            },
+            True
+        ),
+
+    ]
+)
+def test_should_run_animal(test_name, cycle, expected_should_run):
+    should_run, *args = should_run_animal(cycle, 'model', 'term', 'tier')
+    assert should_run == expected_should_run, test_name

tests/models/faostat2018/test_liveweightPerHead.py

@@ -123,3 +123,12 @@ def test_run_liveAnimal_sheepLamb(mock_download_hestia, *args):
     }
     value = run(cycle)
     assert value == expected
+
+
+@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+def test_run_liveAninal_missing_term_id(*args):
+    with open(f"{fixtures_folder}/liveAnimal/missing-fao-term-id/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    value = run(cycle)
+    assert value == []

tests/models/site/test_management.py

@@ -2,7 +2,7 @@ import json
 from unittest.mock import patch
 
 import pytest
-from hestia_earth.schema import TermTermType
+from hestia_earth.schema import TermTermType, SiteSiteType
 
 from hestia_earth.models.site.management import MODEL, MODEL_KEY, run, _should_run
 from hestia_earth.models.utils.blank_node import condense_nodes
@@ -17,8 +17,17 @@ TERM_BY_ID = {
     '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 = {SiteSiteType.ANIMAL_HOUSING.value: "animalHousing"}
+
 
 def lookup_side_effect(*args, **kwargs):
     # Values taken from real lookups.
@@ -233,7 +242,7 @@ def test_should_run(mock_related_cycles, *args):
     should_run, *args = _should_run({})
     assert should_run is True
 
-    # with relevant product => run
+    # with relevant product, blank site_type => no run
     mock_related_cycles.return_value = [
         {
             "products": [
@@ -253,6 +262,28 @@ def test_should_run(mock_related_cycles, *args):
         }
     ]
     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",
+                    "properties": {"test": "properties"}
+                }
+            ],
+            "startDate": "2021",
+            "endDate": "2022"
+        }
+    ]
+    should_run, *args = _should_run({"siteType": "cropland"})
     assert should_run is True
     assert args[0] == [{
         'term': TERM_BY_ID['genericCropPlant'],
@@ -266,11 +297,12 @@ def test_should_run(mock_related_cycles, *args):
 @pytest.mark.parametrize(
     "test_name,fixture_path",
     [
+        ("Products and practices", f"{fixtures_folder}"),
         ("Example 1", f"{fixtures_folder}/inputs/example1"),
         ("Example 2", f"{fixtures_folder}/inputs/example2"),
         ("Example 3", f"{fixtures_folder}/inputs/example3"),
         ("Example 4", f"{fixtures_folder}/inputs/example4"),
-        ("Condense Nodes", f"{fixtures_folder}/inputs/condense_nodes")
+        ("Condense Nodes", f"{fixtures_folder}/inputs/condense_nodes"),
         # Expected:
         #   - appleTree (81) x 3 condenses 2020-03-01 to 2021-02-15
         #   - animalManureUsed (true) x 2 condenses 2001-04-01 to 2001-12-31
@@ -282,18 +314,34 @@ 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")
     ]
 )
-@patch(f"{CLASS_PATH}.download_hestia", side_effect=lambda id, *args: TERM_BY_ID[id])
+@patch(
+    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)
-def test_run(mock_get_lookup_with_debug, mock_related_cycles, mock_download, test_name, fixture_path):
+def test_run(
+        mock_get_lookup_with_debug,
+        mock_related_cycles,
+        mock_download,
+        mock_land_cover_lookup,
+        test_name,
+        fixture_path
+):
     with open(f"{fixture_path}/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)
+    try:
+        with open(f"{fixture_path}/site.jsonld", encoding='utf-8') as f:
+            site = json.load(f)
+    except FileNotFoundError:
+        with open(f"{fixtures_folder}/site.jsonld", encoding='utf-8') as f:
+            site = json.load(f)
 
     with open(f"{fixture_path}/result.jsonld", encoding='utf-8') as f:
         expected = json.load(f)