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

tests/models/cycle/test_coldCarcassWeightPerHead.py

@@ -31,7 +31,7 @@ def test_should_run():
         }
     ]
     should_run, *args = _should_run(cycle)
-    assert should_run
+    assert should_run is True
 
 
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)

tests/models/cycle/test_coldDressedCarcassWeightPerHead.py

@@ -31,7 +31,7 @@ def test_should_run():
         }
     ]
     should_run, *args = _should_run(cycle)
-    assert should_run
+    assert should_run is True
 
 
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)

tests/models/cycle/{test_irrigated.py → test_irrigatedTypeUnspecified.py}

@@ -2,7 +2,7 @@ from unittest.mock import patch
 import json
 from tests.utils import fixtures_path, fake_new_practice
 
-from hestia_earth.models.cycle.irrigated import MODEL, TERM_ID, run
+from hestia_earth.models.cycle.irrigatedTypeUnspecified import MODEL, TERM_ID, run
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"

tests/models/cycle/test_milkYield.py

@@ -0,0 +1,58 @@
+from unittest.mock import patch
+import json
+from hestia_earth.schema import TermTermType
+
+from tests.utils import fixtures_path, fake_new_practice
+from hestia_earth.models.cycle.milkYield import MODEL, MODEL_KEY, run, _should_run
+
+class_path = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{MODEL_KEY}"
+
+
+@patch(f"{class_path}._get_liveAnimal_term_id", return_value='chicken')
+@patch(f"{class_path}.get_lookup_value", return_value='id')
+@patch(f"{class_path}.valid_site_type", return_value=False)
+def test_should_run(mock_valid_site_type, *args):
+    cycle = {'cycleDuration': 365}
+
+    # with valid siteType => not run
+    mock_valid_site_type.return_value = True
+    should_run, *args = _should_run(cycle)
+    assert not should_run
+
+    # no animal product => no run
+    cycle['products'] = []
+    should_run, *args = _should_run(cycle)
+    assert not should_run
+
+    # with animal product => not run
+    cycle['products'] = [
+        {
+            'term': {'termType': TermTermType.ANIMALPRODUCT.value},
+            'value': [2]
+        }
+    ]
+    should_run, *args = _should_run(cycle)
+    assert not should_run
+
+    # with matching animal => run
+    cycle['animals'] = [
+        {
+            'term': {'termType': TermTermType.LIVEANIMAL.value, '@id': 'chicken'},
+            'value': 2
+        }
+    ]
+    should_run, *args = _should_run(cycle)
+    assert should_run is True
+
+
+@patch(f"{class_path}._new_practice", side_effect=fake_new_practice)
+def test_run(*argsm):
+    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/cycle/test_readyToCookWeightPerHead.py

@@ -31,7 +31,7 @@ def test_should_run():
         }
     ]
     should_run, *args = _should_run(cycle)
-    assert should_run
+    assert should_run is True
 
 
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)

tests/models/emepEea2019/test_nh3ToAirInorganicFertiliser.py

@@ -24,7 +24,7 @@ def test_should_run(mock_measurement, *args):
     # with country @id => run
     cycle['site'] = {'country': {'@id': 'GADM-AUS'}}
     should_run, *args = _should_run(cycle)
-    assert should_run
+    assert should_run is True
 
 
 @patch(f"{class_path}._new_emission", side_effect=fake_new_emission)

tests/models/geospatialDatabase/test_clayContent.py

@@ -11,11 +11,17 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 @patch(f"{class_path}.should_download", return_value=True)
 @patch(f"{class_path}.has_geospatial_data")
 def test_should_run(mock_has_geospatial_data, *args):
-    mock_has_geospatial_data.return_value = True
-    assert _should_run({}) is True
+    site = {}
 
     mock_has_geospatial_data.return_value = False
-    assert not _should_run({})
+    assert not _should_run(site)
+
+    mock_has_geospatial_data.return_value = True
+    assert _should_run(site) is True
+
+    # with other texture measurements => not run
+    site['measurements'] = [{'term': {'@id': 'clayContent'}}]
+    assert not _should_run(site)
 
 
 @patch(f"{class_path}.get_source", return_value={})

tests/models/geospatialDatabase/test_sandContent.py

@@ -11,11 +11,17 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 @patch(f"{class_path}.should_download", return_value=True)
 @patch(f"{class_path}.has_geospatial_data")
 def test_should_run(mock_has_geospatial_data, *args):
-    mock_has_geospatial_data.return_value = True
-    assert _should_run({}) is True
+    site = {}
 
     mock_has_geospatial_data.return_value = False
-    assert not _should_run({})
+    assert not _should_run(site)
+
+    mock_has_geospatial_data.return_value = True
+    assert _should_run(site) is True
+
+    # with other texture measurements => not run
+    site['measurements'] = [{'term': {'@id': 'clayContent'}}]
+    assert not _should_run(site)
 
 
 @patch(f"{class_path}.get_source", return_value={})

tests/models/ipcc2006/test_n2OToAirExcretaDirect.py

@@ -10,11 +10,16 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
 def test_should_run():
-    # no inputs => no run
-    cycle = {'completeness': {'excreta': True}, 'inputs': []}
+    # no inputs not complete => no run
+    cycle = {'completeness': {'excreta': False}, 'inputs': []}
     should_run, *args = _should_run(cycle)
     assert not should_run
 
+    # complete => run
+    cycle['completeness'] = {'excreta': True}
+    should_run, *args = _should_run(cycle)
+    assert should_run is True
+
     # with kg N inputs => run
     cycle['inputs'] = [{
         'term': {

tests/models/ipcc2006/test_n2OToAirExcretaIndirect.py

@@ -10,7 +10,7 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 def test_should_run():
     # no emissions => no run
-    cycle = {'emissions': []}
+    cycle = {'completeness': {'excreta': True}, 'emissions': []}
     should_run, *args = _should_run(cycle)
     assert not should_run
 

tests/models/ipcc2006/test_n2OToAirInorganicFertiliserDirect.py

@@ -9,11 +9,16 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
 def test_should_run():
-    # no inputs => no run
-    cycle = {'completeness': {'fertiliser': True}, 'inputs': []}
+    # no inputs not complete => no run
+    cycle = {'completeness': {'fertiliser': False}, 'inputs': []}
     should_run, *args = _should_run(cycle)
     assert not should_run
 
+    # complete => run
+    cycle['completeness'] = {'fertiliser': True}
+    should_run, *args = _should_run(cycle)
+    assert should_run is True
+
     # with kg N inputs => no run
     cycle['inputs'] = [{
         'term': {

tests/models/ipcc2006/test_n2OToAirInorganicFertiliserIndirect.py

@@ -9,11 +9,16 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
 def test_should_run():
-    # no inputs => no run
-    cycle = {'completeness': {'fertiliser': True}, 'inputs': []}
+    # no inputs not complete => no run
+    cycle = {'completeness': {'fertiliser': False}, 'inputs': []}
     should_run, *args = _should_run(cycle)
     assert not should_run
 
+    # complete => run
+    cycle['completeness'] = {'fertiliser': True}
+    should_run, *args = _should_run(cycle)
+    assert should_run is True
+
     # with kg N inputs => run
     cycle['inputs'] = [{
         'term': {

tests/models/ipcc2006/test_n2OToAirOrganicFertiliserDirect.py

@@ -9,11 +9,16 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
 def test_should_run():
-    # no inputs => no run
-    cycle = {'completeness': {'fertiliser': True}, 'inputs': []}
+    # no inputs not complete => no run
+    cycle = {'completeness': {'fertiliser': False}, 'inputs': []}
     should_run, *args = _should_run(cycle)
     assert not should_run
 
+    # complete => run
+    cycle['completeness'] = {'fertiliser': True}
+    should_run, *args = _should_run(cycle)
+    assert should_run is True
+
     # with kg N inputs => no run
     cycle['inputs'] = [{
         'term': {

tests/models/ipcc2006/test_n2OToAirOrganicFertiliserIndirect.py

@@ -9,11 +9,16 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
 def test_should_run():
-    # no inputs => no run
-    cycle = {'completeness': {'fertiliser': True}, 'inputs': []}
+    # no inputs not complete => no run
+    cycle = {'completeness': {'fertiliser': False}, 'inputs': []}
     should_run, *args = _should_run(cycle)
     assert not should_run
 
+    # complete => run
+    cycle['completeness'] = {'fertiliser': True}
+    should_run, *args = _should_run(cycle)
+    assert should_run is True
+
     # with kg N inputs => run
     cycle['inputs'] = [{
         'term': {

tests/models/ipcc2019/test_ch4ToAirEntericFermentation.py

@@ -14,7 +14,7 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 @patch(f"{class_path}.get_total_value_converted_with_min_ratio", return_value=0)
 def test_should_run(mock_feed, mock_lookup_value, *args):
     cycle = {
-        "completeness": {"animalFeed": True, "grazedForage": True},
+        "completeness": {"animalFeed": True, "freshForage": True},
         "inputs": [
             {
                 "term": {

tests/models/ipcc2019/test_co2ToAirSoilCarbonStockChangeManagementChange.py

@@ -0,0 +1,228 @@
+from functools import reduce
+import json
+from pytest import mark
+from unittest.mock import patch
+
+from hestia_earth.schema import MeasurementMethodClassification
+
+from hestia_earth.models.ipcc2019.co2ToAirSoilCarbonStockChangeManagementChange import (
+    _calc_soc_stock_change,
+    _convert_c_to_co2,
+    _get_max_measurement_method,
+    _get_min_measurement_method,
+    _linear_interpolate_soc_stock,
+    _nodes_to_soc_stock,
+    MODEL,
+    run,
+    SocStock,
+    TERM_ID
+)
+
+from tests.utils import (
+    fake_new_emission,
+    fixtures_path
+)
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+RUN_SCENARIOS = [
+    ("no-overlapping-cycles", 3),
+    ("overlapping-cycles", 4),
+    ("complex-overlapping-cycles", 5),
+    ("missing-measurement-dates", 3),
+    ("no-organic-carbon-measurements", 1)  # Closes issue #700
+]
+"""List of (subfolder: str, num_cycles: int)."""
+
+RUN_PARAMS = reduce(
+    lambda params, scenario: params + [(scenario[0], scenario[1], i) for i in range(scenario[1])],
+    RUN_SCENARIOS,
+    list()
+)
+"""List of (subfolder: str, num_cycles: int, cycle_index: int)."""
+
+RUN_IDS = [f"{param[0]}, cycle{param[2]}" for param in RUN_PARAMS]
+
+
+def _load_fixture(path: str):
+    with open(path, encoding="utf-8") as f:
+        fixture = json.load(f)
+    return fixture
+
+
+def _get_site_path(subfolder: str) -> str:
+    return f"{fixtures_folder}/{subfolder}/site.jsonld"
+
+
+def _get_cycle_path(subfolder: str, index: int) -> str:
+    return f"{fixtures_folder}/{subfolder}/cycle{index}.jsonld"
+
+
+def _get_result_path(subfolder: str, index: int) -> str:
+    return f"{fixtures_folder}/{subfolder}/result{index}.jsonld"
+
+
+def test_calc_soc_stock_change():
+    START_SOC_STOCK = SocStock(20000, MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
+    END_SOC_STOCK = SocStock(21000, MeasurementMethodClassification.TIER_1_MODEL)
+    EXPECTED = SocStock(1000, MeasurementMethodClassification.TIER_1_MODEL)
+
+    result = _calc_soc_stock_change(START_SOC_STOCK, END_SOC_STOCK)
+    assert result == EXPECTED
+
+
+def test_convert_c_to_co2():
+    KG_C = 1000
+    EXPECTED = 3663.836163836164
+
+    assert _convert_c_to_co2(KG_C) == EXPECTED
+
+
+def test_get_max_measurement_method():
+    EXPECTED = MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT
+    result = _get_max_measurement_method(
+        MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+        MeasurementMethodClassification.TIER_2_MODEL,
+        MeasurementMethodClassification.TIER_1_MODEL
+    )
+    assert result == EXPECTED
+
+
+def test_get_max_measurement_method_list():
+    EXPECTED = MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT
+    METHODS = [
+        MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+        MeasurementMethodClassification.TIER_2_MODEL,
+        MeasurementMethodClassification.TIER_1_MODEL
+    ]
+    result = _get_max_measurement_method(METHODS)
+    assert result == EXPECTED
+
+
+def test_get_max_measurement_method_no_methods():
+    EXPECTED = MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT
+    result = _get_max_measurement_method()
+    assert result == EXPECTED
+
+
+def test_get_min_measurement_method():
+    EXPECTED = MeasurementMethodClassification.TIER_1_MODEL
+    result = _get_min_measurement_method(
+        MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+        MeasurementMethodClassification.TIER_2_MODEL,
+        MeasurementMethodClassification.TIER_1_MODEL
+    )
+    assert result == EXPECTED
+
+
+def test_get_min_measurement_method_list():
+    EXPECTED = MeasurementMethodClassification.TIER_1_MODEL
+    METHODS = [
+        MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+        MeasurementMethodClassification.TIER_2_MODEL,
+        MeasurementMethodClassification.TIER_1_MODEL
+    ]
+    result = _get_min_measurement_method(METHODS)
+    assert result == EXPECTED
+
+
+def test_get_min_measurement_method_no_methods():
+    EXPECTED = MeasurementMethodClassification.UNSOURCED_ASSUMPTION
+    result = _get_min_measurement_method()
+    assert result == EXPECTED
+
+
+def test_linear_interpolate_soc_stock():
+    START_YEAR = 2000
+    END_YEAR = 2002
+    START_SOC_STOCK = SocStock(20000, MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
+    END_SOC_STOCK = SocStock(22000, MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
+    TARGET_YEAR = 2001
+    EXPECTED = SocStock(21000, MeasurementMethodClassification.TIER_1_MODEL)
+
+    result = _linear_interpolate_soc_stock(
+        START_YEAR, END_YEAR, START_SOC_STOCK, END_SOC_STOCK, TARGET_YEAR
+    )
+    assert result == EXPECTED
+
+
+def test_nodes_to_soc_stock_diff_dates():
+    NODES = [
+        {
+            "value": [1000],
+            "dates": ["2020"],
+            "methodClassification": "modelled using other measurements"
+        },
+        {
+            "value": [12000],
+            "dates": ["2020-12-31"],
+            "methodClassification": "tier 1 model"
+        }
+    ]
+    EXPECTED = SocStock(12000, MeasurementMethodClassification.TIER_1_MODEL)
+
+    assert _nodes_to_soc_stock(2020, NODES) == EXPECTED
+
+
+def test_nodes_to_soc_stock_same_dates():
+    NODES = [
+        {
+            "value": [10000],
+            "dates": ["2020-12-31"],
+            "methodClassification": "modelled using other measurements"
+        },
+        {
+            "value": [12000],
+            "dates": ["2020-12-31"],
+            "methodClassification": "tier 1 model"
+        },
+        {
+            "value": [11000],
+            "dates": ["2020-06-01"],
+            "methodClassification": "on-site physical measurement"
+        }
+    ]
+    EXPECTED = SocStock(10000, MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS)
+
+    assert _nodes_to_soc_stock(2020, NODES) == EXPECTED
+
+
+@mark.parametrize("subfolder, num_cycles, cycle_index", RUN_PARAMS, ids=RUN_IDS)
+@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+@patch(f"{class_path}.related_cycles")
+@patch(f"{class_path}.get_site")
+def test_run(_get_site_mock, related_cycles_mock, _new_emission_mock, subfolder, num_cycles, cycle_index):
+    """
+    Test `run` function for each cycle in each scenario.
+    """
+    site = _load_fixture(_get_site_path(subfolder))
+    cycle = _load_fixture(_get_cycle_path(subfolder, cycle_index))
+    expected = _load_fixture(_get_result_path(subfolder, cycle_index))
+
+    cycles = [
+        _load_fixture(_get_cycle_path(subfolder, i)) for i in range(num_cycles)
+    ]
+
+    _get_site_mock.return_value = site
+    related_cycles_mock.return_value = cycles
+
+    result = run(cycle)
+    assert result == expected
+
+
+@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+@patch(f"{class_path}.related_cycles")
+@patch(f"{class_path}.get_site")
+def test_run_empty(_get_site_mock, related_cycles_mock, _new_emission_mock):
+    """
+    Test `run` function for each cycle in each scenario.
+    """
+    CYCLE = {}
+    EXPECTED = []
+
+    _get_site_mock.return_value = {}
+    related_cycles_mock.return_value = [CYCLE]
+
+    result = run(CYCLE)
+    assert result == EXPECTED

tests/models/ipcc2019/test_n2OToAirInorganicFertiliserDirect.py

@@ -0,0 +1,74 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.ipcc2019.n2OToAirInorganicFertiliserDirect 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_inorganic_fertiliser_N_total", return_value=0)
+def test_should_run(mock_N_total, mock_complete):
+    # no N => no run
+    should_run, *args = _should_run({})
+    assert not should_run
+
+    # with N => no run
+    mock_N_total.return_value = 10
+    should_run, *args = _should_run({})
+    assert not should_run
+
+    # is complete => run
+    mock_complete.return_value = True
+    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_wet(*args):
+    with open(f"{fixtures_folder}/ecoClimateZone-wet/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/ecoClimateZone-wet/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_dry(*args):
+    with open(f"{fixtures_folder}/ecoClimateZone-dry/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/ecoClimateZone-dry/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_flooded_rice(*args):
+    with open(f"{fixtures_folder}/with-flooded-rice/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/with-flooded-rice/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/ipcc2019/test_n2OToAirOrganicFertiliserDirect.py

@@ -0,0 +1,74 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.ipcc2019.n2OToAirOrganicFertiliserDirect 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):
+    # no N => no run
+    should_run, *args = _should_run({})
+    assert not should_run
+
+    # with N => no run
+    mock_N_total.return_value = 10
+    should_run, *args = _should_run({})
+    assert not should_run
+
+    # is complete => run
+    mock_complete.return_value = True
+    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_wet(*args):
+    with open(f"{fixtures_folder}/ecoClimateZone-wet/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/ecoClimateZone-wet/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_dry(*args):
+    with open(f"{fixtures_folder}/ecoClimateZone-dry/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/ecoClimateZone-dry/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_flooded_rice(*args):
+    with open(f"{fixtures_folder}/with-flooded-rice/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/with-flooded-rice/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected