hestia-earth-models 0.74.17__py3-none-any.whl → 0.75.1__py3-none-any.whl

tests/models/ipcc2019/test_belowGroundBiomass.py

@@ -1,189 +0,0 @@
-import json
-from numpy.typing import NDArray
-from os.path import isfile
-from pytest import mark
-from unittest.mock import MagicMock, patch
-
-from hestia_earth.models.ipcc2019.belowGroundBiomass import _build_col_name, _should_run, MODEL, run, TERM_ID
-from hestia_earth.models.ipcc2019.biomass_utils import BiomassCategory, sample_constant
-
-from tests.utils import fake_new_measurement, fixtures_path
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-utils_path = f"hestia_earth.models.{MODEL}.biomass_utils"
-term_path = "hestia_earth.models.utils.term"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-_ITERATIONS = 1000
-
-COVER_CROP_PROPERTY_TERM_IDS = [
-    "catchCrop",
-    "coverCrop",
-    "groundCover",
-    "longFallowCrop",
-    "shortFallowCrop"
-]
-
-
-def _load_fixture(path: str, default=None):
-    if isfile(path):
-        with open(path, encoding="utf-8") as f:
-            return json.load(f)
-    return default
-
-
-def _fake_calc_descriptive_stats(arr: NDArray, *_args, **_kwargs):
-    return {"value": [round(row[0], 6) for row in arr]}
-
-
-# subfolder, should_run
-PARAMS_SHOULD_RUN = [
-    ("forest-to-animal-housing", False),
-    ("forest-to-cropland", True),
-    ("forest-to-cropland-greater-than-100", True),
-    ("forest-to-cropland-less-than-100", True),
-    ("forest-to-cropland-lcc-q2", True),
-    ("forest-to-cropland-lcc-q3", True),
-    ("forest-to-cropland-lcc-q4", True),
-    ("forest-to-gohac", False),
-    ("forest-to-orchard", True),
-    ("forest-to-orchard-with-ground-cover", True),                 # Closes 989
-    ("forest-to-orchard-with-in-category-lcc", True),
-    ("historical-land-cover-mix", True),
-    ("historical-argentina-pasture", True),
-    ("historical-brazil-maize", True),
-    ("perennial-to-grassland-with-pasture-condition", True),
-    ("with-gapfilled-start-date-end-date", False),                 # Closes #972
-    ("forest-to-cropland-with-missing-equilibrium-year-a", True),  # Closes #1076
-    ("forest-to-cropland-with-missing-equilibrium-year-b", True)   # Closes #1076
-]
-IDS_SHOULD_RUN = [p[0] for p in PARAMS_SHOULD_RUN]
-
-
-@mark.parametrize("subfolder, should_run", PARAMS_SHOULD_RUN, ids=IDS_SHOULD_RUN)
-@patch(f"{utils_path}.get_cover_crop_property_terms", return_value=COVER_CROP_PROPERTY_TERM_IDS)
-@patch(f"{term_path}.search")
-def test_should_run(
-    search_mock: MagicMock,
-    get_cover_crop_property_terms_mock: MagicMock,
-    subfolder: str,
-    should_run: bool
-):
-    folder = f"{fixtures_folder}/{subfolder}"
-
-    site = _load_fixture(f"{folder}/site.jsonld", {})
-
-    result, *_ = _should_run(site)
-    assert result == should_run
-
-    assert get_cover_crop_property_terms_mock.call_count <= 1  # assert the API call is only requested once
-    search_mock.assert_not_called()                            # assert the API call is properly mocked
-
-
-@patch(f"{utils_path}.get_cover_crop_property_terms", return_value=COVER_CROP_PROPERTY_TERM_IDS)
-@patch(f"{term_path}.search")
-def test_should_run_no_data(search_mock: MagicMock, get_cover_crop_property_terms_mock: MagicMock):
-    SITE = {}
-    EXPECTED = False
-
-    result, *_ = _should_run(SITE)
-    assert result == EXPECTED
-
-    assert get_cover_crop_property_terms_mock.call_count <= 1  # assert the API call is only requested once
-    search_mock.assert_not_called()                            # assert the API call is properly mocked
-
-
-PARAMS_RUN = [subfolder for subfolder, should_run in PARAMS_SHOULD_RUN if should_run]
-
-
-@mark.parametrize("subfolder", PARAMS_RUN)
-@patch(f"{class_path}.get_source", return_value={})
-@patch(f"{class_path}.calc_descriptive_stats", side_effect=_fake_calc_descriptive_stats)
-@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
-@patch(f"{utils_path}._get_sample_func", return_value=sample_constant)
-@patch(f"{utils_path}.get_cover_crop_property_terms", return_value=COVER_CROP_PROPERTY_TERM_IDS)
-@patch(f"{term_path}.search")
-def test_run(
-    search_mock: MagicMock,
-    get_cover_crop_property_terms_mock: MagicMock,
-    _get_sample_func_mock: MagicMock,
-    _new_measurement_mock: MagicMock,
-    _calc_descriptive_stats_mock: MagicMock,
-    _mock_source: MagicMock,
-    subfolder: str
-):
-    folder = f"{fixtures_folder}/{subfolder}"
-
-    site = _load_fixture(f"{folder}/site.jsonld", {})
-    expected = _load_fixture(f"{folder}/result.jsonld", [])
-
-    with patch(f"{class_path}._ITERATIONS", _ITERATIONS):
-        result = run(site)
-
-    assert result == expected
-
-    assert get_cover_crop_property_terms_mock.call_count <= 1  # assert the API call is only requested once
-    search_mock.assert_not_called()                            # assert the API call is properly mocked
-
-
-# subfolder
-PARAMS_RUN_WITH_STATS = [
-    "forest-to-cropland-with-stats",
-    "forest-to-orchard-with-in-category-lcc-with-stats",
-    "historical-land-cover-mix-with-stats"
-]
-
-
-@mark.parametrize("subfolder", PARAMS_RUN_WITH_STATS)
-@patch(f"{class_path}.get_source", return_value={})
-@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
-@patch(f"{utils_path}.get_cover_crop_property_terms", return_value=COVER_CROP_PROPERTY_TERM_IDS)
-@patch(f"{term_path}.search")
-def test_run_with_stats(
-    search_mock: MagicMock,
-    get_cover_crop_property_terms_mock: MagicMock,
-    _new_measurement_mock: MagicMock,
-    _mock_source: MagicMock,
-    subfolder: str
-):
-    folder = f"{fixtures_folder}/{subfolder}"
-
-    site = _load_fixture(f"{folder}/site.jsonld", {})
-    expected = _load_fixture(f"{folder}/result.jsonld", [])
-
-    with patch(f"{class_path}._ITERATIONS", _ITERATIONS):
-        result = run(site)
-
-    assert result == expected
-
-    assert get_cover_crop_property_terms_mock.call_count <= 1  # assert the API call is only requested once
-    search_mock.assert_not_called()                            # assert the API call is properly mocked
-
-
-# input, expected
-PARAMS_BUILD_COLUMN_NAME = [
-    (BiomassCategory.ANNUAL_CROPS, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.COCONUT, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.FOREST, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_FOREST"),
-    (BiomassCategory.GRASSLAND, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.JATROPHA, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.JOJOBA, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.NATURAL_FOREST, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_NATURAL_FOREST"),
-    (BiomassCategory.OIL_PALM, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.OLIVE, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.ORCHARD, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.OTHER, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.PLANTATION_FOREST, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_PLANTATION_FOREST"),
-    (BiomassCategory.RUBBER, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.SHORT_ROTATION_COPPICE, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.TEA, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.VINE, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    (BiomassCategory.WOODY_PERENNIAL, "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
-    ("Miscellaneous value", "BG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER")
-]
-IDS_BUILD_COLUMN_NAME = [p[0] for p in PARAMS_BUILD_COLUMN_NAME]
-
-
-@mark.parametrize("input, expected", PARAMS_BUILD_COLUMN_NAME, ids=IDS_BUILD_COLUMN_NAME)
-def test_build_col_name(input: BiomassCategory, expected: str):
-    assert _build_col_name(input) == expected

tests/models/ipcc2019/test_belowGroundCropResidue.py

@@ -1,77 +0,0 @@
-from unittest.mock import patch
-import json
-
-from hestia_earth.schema import TermTermType
-from tests.utils import fixtures_path, fake_new_product
-
-from hestia_earth.models.ipcc2019.belowGroundCropResidue import (
-    MODEL, TERM_ID, run, _should_run, _should_run_product
-)
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-CROP_RESIDUE_TERM = {
-    'termType': TermTermType.CROPRESIDUE.value
-}
-
-
-@patch('hestia_earth.models.utils.completeness.download_term', return_value=CROP_RESIDUE_TERM)
-@patch(f"{class_path}._should_run_product", return_value=True)
-def test_should_run(*args):
-    crop_product = {'term': {'termType': TermTermType.CROP.value}}
-    cycle = {'products': []}
-
-    # no crops => no run
-    cycle['products'] = []
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with a crop => run
-    cycle['products'] = [crop_product]
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
-
-
-@patch('hestia_earth.models.utils.completeness.download_term', return_value=CROP_RESIDUE_TERM)
-@patch(f"{class_path}.get_yield_dm", return_value=None)
-def test_should_run_product(mock_get_yield_dm, *args):
-    product = {'term': {'@id': 'maizeGrain'}}
-
-    # with a dryMatter property => no run
-    product['properties'] = [{'term': {'@id': 'dryMatter'}, 'value': 10}]
-    assert not _should_run_product(product)
-
-    # with a value => no run
-    product['value'] = [10]
-    assert not _should_run_product(product)
-
-    # with a lookup value => run
-    mock_get_yield_dm.return_value = 10
-    assert _should_run_product(product) is True
-
-
-@patch('hestia_earth.models.utils.completeness.download_term', return_value=CROP_RESIDUE_TERM)
-@patch(f"{class_path}._new_product", side_effect=fake_new_product)
-def test_run_crop(*args):
-    with open(f"{fixtures_folder}/crop/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/crop/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected
-
-
-@patch('hestia_earth.models.utils.completeness.download_term', return_value=CROP_RESIDUE_TERM)
-@patch(f"{class_path}._new_product", side_effect=fake_new_product)
-def test_run_forage(*args):
-    with open(f"{fixtures_folder}/forage/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/forage/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected

tests/models/ipcc2019/test_biocharOrganicCarbonPerHa.py

@@ -1,132 +0,0 @@
-import json
-from os.path import isfile
-from pytest import mark
-from unittest.mock import MagicMock, patch
-
-from hestia_earth.models.ipcc2019.biocharOrganicCarbonPerHa import _should_run, MODEL, run, TERM_ID
-
-from tests.utils import fake_new_measurement, fixtures_path
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-property_path = "hestia_earth.models.utils.property"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-_DEFAULT_PROPERTIES = {
-    "biocharManureGasification": {
-        "organicCarbonContent": {
-            "value": 9,
-            "sd": 2.4,
-            "min": 0,
-            "max": 100
-        }
-    },
-    "biocharBambooLowTemperaturePyrolysis": {
-        "organicCarbonContent": {
-            "value": 77,
-            "sd": 16.5,
-            "min": 0,
-            "max": 100
-        }
-    },
-    "biocharStrawHighTemperaturePyrolysis": {
-        "organicCarbonContent": {
-            "value": 65,
-            "sd": 14.9,
-            "min": 0,
-            "max": 100
-        }
-    },
-    "biocharPaperSludgeMediumTemperaturePyrolysis": {
-        "organicCarbonContent": {
-            "value": 35,
-            "sd": 7.1,
-            "min": 0,
-            "max": 100
-        }
-    },
-    "biocharUnspecifiedFeedstockUnspecifiedProductionMethod": {
-        "organicCarbonContent": {
-            "value": 40.6,
-            "sd": 10.5,
-            "min": 0,
-            "max": 100
-        }
-    }
-}
-
-
-def fake_find_term_property(term: dict, property: str, *_):
-    term_id = term.get('@id', None)
-    return _DEFAULT_PROPERTIES.get(term_id, {}).get(property, {})
-
-
-def _load_fixture(path: str, default=None):
-    if isfile(path):
-        with open(path, encoding="utf-8") as f:
-            return json.load(f)
-    return default
-
-
-# subfolder, should_run
-PARAMS_SHOULD_RUN = [
-    ("with-stats", True),
-    ("no-biochar", True),
-    ("no-cycles", False),
-    ("with-organic-soils", False),
-    ("with-relative-func-unit", False),
-    ("with-site-type-forest", False),
-    ("with-missing-start-dates", True)
-]
-IDS_SHOULD_RUN = [p[0] for p in PARAMS_SHOULD_RUN]
-
-
-@mark.parametrize("subfolder, should_run", PARAMS_SHOULD_RUN, ids=IDS_SHOULD_RUN)
-@patch(f"{property_path}.find_term_property", side_effect=fake_find_term_property)
-@patch(f"{property_path}.download_term")
-@patch(f"{class_path}.related_cycles")
-def test_should_run(
-    related_cycles_mock: MagicMock,
-    download_term_mock: MagicMock,
-    _find_term_property_mock: MagicMock,
-    subfolder: str,
-    should_run: bool
-):
-    folder = f"{fixtures_folder}/{subfolder}"
-
-    site = _load_fixture(f"{folder}/site.jsonld", {})
-    related_cycles_mock.return_value = _load_fixture(f"{folder}/cycles.jsonld", [])
-
-    result, *_ = _should_run(site)
-    assert result == should_run
-
-    # Ensure that the property utils are properly mocked.
-    download_term_mock.assert_not_called()
-
-
-PARAMS_RUN = [subfolder for subfolder, should_run in PARAMS_SHOULD_RUN if should_run]
-
-
-@mark.parametrize("subfolder", PARAMS_RUN)
-@patch(f"{property_path}.find_term_property", side_effect=fake_find_term_property)
-@patch(f"{property_path}.download_term")
-@patch(f"{class_path}.related_cycles")
-@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
-def test_run(
-    _new_measurement_mock: MagicMock,
-    related_cycles_mock: MagicMock,
-    download_term_mock: MagicMock,
-    _find_term_property_mock: MagicMock,
-    subfolder: str
-):
-    folder = f"{fixtures_folder}/{subfolder}"
-
-    site = _load_fixture(f"{folder}/site.jsonld", {})
-    related_cycles_mock.return_value = _load_fixture(f"{folder}/cycles.jsonld", [])
-
-    expected = _load_fixture(f"{folder}/result.jsonld", [])
-
-    result = run(site)
-    assert result == expected
-
-    # Ensure that the property utils are properly mocked.
-    download_term_mock.assert_not_called()

tests/models/ipcc2019/test_biomass_utils.py

@@ -1,115 +0,0 @@
-from pytest import mark
-
-from hestia_earth.models.ipcc2019.biomass_utils import (
-    _assign_biomass_category, _get_sample_func, _rescale_category_cover, BiomassCategory, detect_land_cover_change,
-    sample_constant, sample_plus_minus_error
-)
-
-_ITERATIONS = 1000
-
-
-# input, expected
-PARAMS_RESCALE_CATEGORY_COVER = [
-    (
-        {BiomassCategory.ANNUAL_CROPS: 90},
-        {BiomassCategory.ANNUAL_CROPS: 90, BiomassCategory.OTHER: 10}
-    ),
-    (
-        {BiomassCategory.OTHER: 90},
-        {BiomassCategory.OTHER: 100}
-    ),
-    (
-        {BiomassCategory.ANNUAL_CROPS: 60, BiomassCategory.VINE: 60},
-        {BiomassCategory.ANNUAL_CROPS: 50, BiomassCategory.VINE: 50}
-    ),
-    (
-        {BiomassCategory.NATURAL_FOREST: 100},
-        {BiomassCategory.NATURAL_FOREST: 100}
-    )
-]
-IDS_RESCALE_CATEGORY_COVER = ["fill", "fill w/ other", "squash", "do nothing"]
-
-
-@mark.parametrize("input, expected", PARAMS_RESCALE_CATEGORY_COVER, ids=IDS_RESCALE_CATEGORY_COVER)
-def test_rescale_category_cover(input: dict, expected: dict):
-    assert _rescale_category_cover(input) == expected
-
-
-# a, b, expected
-PARAMS_IS_LCC_EVENT = [
-    (
-        {
-            "appleTree": 33.333,
-            "pearTree": 33.333,
-            BiomassCategory.ANNUAL_CROPS: 33.334,
-        },
-        {
-            "appleTree": 33.33333,
-            "pearTree": 33.33333,
-            BiomassCategory.ANNUAL_CROPS: 33.33334,
-        },
-        True
-    ),
-    (
-        {
-            "appleTree": 33.3333,
-            "pearTree": 33.3333,
-            BiomassCategory.ANNUAL_CROPS: 33.3334,
-        },
-        {
-            "appleTree": 33.33333,
-            "pearTree": 33.33333,
-            BiomassCategory.ANNUAL_CROPS: 33.33334,
-        },
-        False
-    )
-]
-IDS_IS_LCC_EVENT = ["True", "False"]
-
-
-@mark.parametrize("a, b, expected", PARAMS_IS_LCC_EVENT, ids=IDS_IS_LCC_EVENT)
-def test_detect_land_cover_change(a: dict, b: dict, expected: bool):
-    assert detect_land_cover_change(a, b) is expected
-
-
-# kwargs, sample_func, expected_shape
-PARAMS_GET_SAMPLE_FUNC = [
-    ({"value": 1}, sample_constant),
-    ({"value": 1, "error": 10}, sample_plus_minus_error),
-]
-IDS_GET_SAMPLE_FUNC = ["constant", "+/- error"]
-
-
-@mark.parametrize("kwargs, sample_func", PARAMS_GET_SAMPLE_FUNC, ids=IDS_GET_SAMPLE_FUNC)
-def test_get_sample_func(kwargs, sample_func):
-    result = _get_sample_func(kwargs)
-    assert result == sample_func
-
-
-# input, expected
-PARAMS_ASSIGN_BIOMASS_CATEGORY = [
-    ("Annual crops", BiomassCategory.ANNUAL_CROPS),
-    ("Coconut", BiomassCategory.COCONUT),
-    ("Forest", BiomassCategory.FOREST),
-    ("Grassland", BiomassCategory.GRASSLAND),
-    ("Jatropha", BiomassCategory.JATROPHA),
-    ("Jojoba", BiomassCategory.JOJOBA),
-    ("Natural forest", BiomassCategory.NATURAL_FOREST),
-    ("Oil palm", BiomassCategory.OIL_PALM),
-    ("Olive", BiomassCategory.OLIVE),
-    ("Orchard", BiomassCategory.ORCHARD),
-    ("Other", BiomassCategory.OTHER),
-    ("Plantation forest", BiomassCategory.PLANTATION_FOREST),
-    ("Rubber", BiomassCategory.RUBBER),
-    ("Short rotation coppice", BiomassCategory.SHORT_ROTATION_COPPICE),
-    ("Tea", BiomassCategory.TEA),
-    ("Vine", BiomassCategory.VINE),
-    ("Woody perennial", BiomassCategory.WOODY_PERENNIAL),
-    ("Miscellaneous value", None)
-]
-IDS_ASSIGN_BIOMASS_CATEGORY = [p[0] for p in PARAMS_ASSIGN_BIOMASS_CATEGORY]
-
-
-@mark.parametrize("input, expected", PARAMS_ASSIGN_BIOMASS_CATEGORY, ids=IDS_ASSIGN_BIOMASS_CATEGORY)
-def test_assign_biomass_category(input: str, expected: BiomassCategory):
-    assert _assign_biomass_category(input) == expected

tests/models/ipcc2019/test_carbonContent.py

@@ -1,119 +0,0 @@
-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.ipcc2019.carbonContent import (
-    MODEL, TERM_ID, run, _should_run, _should_run_product, _should_run_multiple_products
-)
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@patch(f"{class_path}._should_run_product", return_value=True)
-@patch(f"{class_path}._should_run_single_product", return_value=False)
-@patch(f"{class_path}._should_run_multiple_products", return_value=False)
-def test_should_run(mock_should_run_multiple, mock_should_run_single, *args):
-    crop_residue_product = {'term': {'termType': TermTermType.CROPRESIDUE.value}}
-    crop_product = {'term': {'termType': TermTermType.CROP.value}}
-    cycle = {'products': []}
-
-    # with a single crop => no run
-    cycle['products'] = [crop_residue_product, crop_product]
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # allowing single product => run
-    mock_should_run_single.return_value = True
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
-
-    # with multiple crops => no run
-    cycle['products'] = [crop_residue_product, crop_product, crop_product]
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # allowing multiple products => run
-    mock_should_run_multiple.return_value = True
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
-
-
-def test_should_run_product():
-    product = {}
-
-    # not a crop residue product => no run
-    product['term'] = {'@id': 'random id'}
-    assert not _should_run_product(product)
-
-    # with a crop residue product => run
-    product['term']['@id'] = 'aboveGroundCropResidueTotal'
-    assert _should_run_product(product) is True
-
-
-@patch(f"{class_path}.get_yield_dm", return_value=10)
-@patch(f"{class_path}._get_lookup_value", return_value=None)
-def test_should_run_multiple_products(mock_get_crop_value, *args):
-    product = {'term': {'@id': 'maizeGrain'}}
-
-    # with a dryMatter property => no run
-    product['properties'] = [{'term': {'@id': 'dryMatter'}, 'value': 10}]
-    assert not _should_run_multiple_products(product)
-
-    # with a value => no run
-    product['value'] = [10]
-    assert not _should_run_multiple_products(product)
-
-    # with a lookup value => run
-    mock_get_crop_value.return_value = 10
-    assert _should_run_multiple_products(product) is True
-
-
-@patch(f"{class_path}._new_property", side_effect=fake_new_property)
-def test_run_single_crop(*args):
-    with open(f"{fixtures_folder}/single-crop/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/single-crop/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)
-def test_run_single_forage(*args):
-    with open(f"{fixtures_folder}/single-forage/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/single-forage/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)
-def test_run_multiple_crops(*args):
-    with open(f"{fixtures_folder}/multiple-crops/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/multiple-crops/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)
-def test_run_multiple_crops_single_residue(*args):
-    with open(f"{fixtures_folder}/multiple-crops-single-residue/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/multiple-crops-single-residue/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected

tests/models/ipcc2019/test_ch4ToAirAquacultureSystems.py

@@ -1,60 +0,0 @@
-import json
-import pytest
-from unittest.mock import patch
-from tests.utils import fixtures_path, fake_new_emission
-
-from hestia_earth.models.ipcc2019.ch4ToAirAquacultureSystems import MODEL, TERM_ID, run, _should_run
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@pytest.mark.parametrize(
-    'test_name,cycle,expected_should_run',
-    [
-        (
-            'no cycleDuration => no run',
-            {},
-            False
-        ),
-        (
-            'with cycleDuration not relative unit => no run',
-            {'cycleDuration': 150, 'functionalUnit': '1 ha'},
-            False
-        ),
-        (
-            'with cycleDuration, relative unit, no area => no run',
-            {'cycleDuration': 150, 'functionalUnit': 'relative'},
-            False
-        ),
-        (
-            'with cycleDuration, relative unit, with area, no measurement => no run',
-            {'cycleDuration': 150, 'functionalUnit': 'relative', 'site': {'area': 1000}},
-            False
-        ),
-        (
-            'with cycleDuration, relative unit, with area, and measurement => run',
-            {
-                'cycleDuration': 150,
-                'functionalUnit': 'relative',
-                'site': {'area': 1000, 'measurements': [{'term': {'@id': 'salineWater', 'termType': 'measurement'}}]}
-            },
-            True
-        )
-    ]
-)
-def test_should_run(test_name, cycle, expected_should_run):
-    should_run, *args = _should_run(cycle)
-    assert should_run == expected_should_run, test_name
-
-
-@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