hestia-earth-models 0.65.6__py3-none-any.whl → 0.65.7__py3-none-any.whl

tests/orchestrator/strategies/merge/test_merge_list.py

@@ -0,0 +1,327 @@
+from unittest.mock import patch
+import pydash
+
+from hestia_earth.orchestrator.strategies.merge.merge_list import merge
+
+class_path = 'hestia_earth.orchestrator.strategies.merge.merge_list'
+version = '1'
+
+
+def _default_merge(a, b, *args): return pydash.objects.merge({}, a, b)
+
+
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_new_node(*args):
+    old_node = {
+        'term': {'@id': 'old-term'},
+        'value': 1
+    }
+    new_node = {
+        'term': {'@id': 'new-term'},
+        'value': 2
+    }
+    result = merge([old_node], [new_node], version)
+    assert result == [old_node, new_node]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_existing_node(*args):
+    term = {'@id': 'term'}
+
+    node_type = 'Site'
+    model = {'key': 'measurements'}
+
+    # with different value => should merge
+    old_node = {
+        'term': term,
+        'value': 1
+    }
+    new_node = {
+        'term': term,
+        'value': 2
+    }
+    result = merge([old_node], [new_node], version, model=model, node_type=node_type)
+    assert len(result) == 1
+
+    # with different depths => should not merge
+    result = merge([{
+        **old_node,
+        'depthUpper': 100
+    }, {
+        **old_node,
+        'depthUpper': 150
+    }], [{
+        **new_node,
+        'depthUpper': 50
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 3
+
+    node_type = 'Cycle'
+    model = {'key': 'emissions'}
+
+    # with same inputs => should merge
+    result = merge([{
+        **old_node,
+        'inputs': [{'@id': 'input-1'}]
+    }], [{
+        **new_node,
+        'inputs': [{'@id': 'input-1'}]
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 1
+
+    # with different inputs => should not merge
+    result = merge([{
+        **old_node,
+        'inputs': [{'@id': 'input-1'}]
+    }], [{
+        **new_node,
+        'inputs': [{'@id': 'input-2'}]
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 2
+
+    result = merge([{
+        **old_node,
+        'inputs': [{'@id': 'input-1'}]
+    }], [{
+        **new_node,
+        'inputs': [{'@id': 'input-1'}, {'@id': 'input-2'}]
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 2
+
+    # with no inputs => should not merge
+    result = merge([old_node], [{
+        **new_node,
+        'inputs': [{'@id': 'input-2'}]
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 2
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_existing_node_skip_same_term(*args):
+    term = {'@id': 'term'}
+    node_type = 'Site'
+    model = {'key': 'measurements'}
+
+    old_node = {
+        'term': term,
+        'value': 1
+    }
+    new_node = {
+        'term': term,
+        'value': 2
+    }
+    result = merge([old_node], [new_node], version, model, {'skipSameTerm': True}, node_type)
+    assert len(result) == 1
+    assert result[0]['value'] == 1
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_existing_node_new_unique_key(*args):
+    term = {'@id': 'term'}
+    node_type = 'Cycle'
+    model = {'key': 'inputs'}
+
+    old_node = {
+        'term': term,
+        'value': 1
+    }
+    new_node = {
+        'term': term,
+        'value': 1,
+        'impactAssessment': {'@id': 'ia-1'}
+    }
+    result = merge([old_node], [new_node], version, model, {}, node_type)
+    assert len(result) == 1
+    assert result[0]['impactAssessment'] == {'@id': 'ia-1'}
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_authors(*args):
+    node_type = 'Bibliography'
+    model = {'key': 'authors'}
+
+    old_node = {
+        'lastName': 'name 1'
+    }
+    new_node = {
+        'lastName': 'name 2'
+    }
+    result = merge([old_node], [new_node], version, model, {}, node_type)
+    # no unique keys, should just append data
+    assert result == [old_node, new_node]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_different_terms_same_unique_properties(*args):
+    method = {'@id': 'method1'}
+    operation = {'@id': 'operation1'}
+    inputs = [{'@id': 'input1'}, {'@id': 'input2'}]
+    node_type = 'ImpactAssessment'
+    model = {'key': 'emissionsResourceUse'}
+
+    node1 = {
+        'term': {'@id': 'term1'},
+        'value': 1,
+        'methodModel': method,
+        'operation': operation,
+        'inputs': inputs
+    }
+    node2 = {
+        'term': {'@id': 'term2'},
+        'value': 2,
+        'methodModel': method,
+        'operation': operation,
+        'inputs': inputs
+    }
+    node3 = {
+        'term': {'@id': 'term3'},
+        'value': 3,
+        'inputs': inputs
+    }
+    node4 = {
+        'term': {'@id': 'term1'},
+        'value': 2,
+        'methodModel': method,
+        'operation': operation,
+        'inputs': inputs
+    }
+    # different term should not merge
+    assert merge([node1], [node2], version, model, {'sameMethodModel': True}, node_type) == [node1, node2]
+    assert merge([node1, node2], [node3], version, model, {'sameMethodModel': True}, node_type) == [node1, node2, node3]
+    assert merge([node1], [node2, node3], version, model, {}, node_type) == [node1, node2, node3]
+    # same term, methodModel, operation and inputs should merge
+    assert merge([node1], [node4], version, model, {}, node_type) == [node4]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_multiple_identical_terms(*args):
+    term1 = {'@id': 'term1'}
+    node_type = 'Cycle'
+    model = {'key': 'inputs'}
+
+    node1 = {
+        'term': term1,
+        'value': 1
+    }
+    node2 = {
+        'term': term1,
+        'value': 2,
+        'impactAssessment': {'id': 'ia-1'}
+    }
+    # merging the same unique nodes should make no changes
+    result = merge([node1, node2], [node1, node2], version, model, {}, node_type)
+    assert result == [node1, node2]
+
+    # adding the same first node with a new unique key
+    node3 = {
+        'term': term1,
+        'value': 3,
+        'impactAssessment': {'@id': 'ia-1'}
+    }
+    result = merge([node1, node2], [node3], version, model, {}, node_type)
+    assert result == [node3, node2]
+
+    node4 = {
+        'term': term1,
+        'value': 4,
+        'impactAssessment': {'id': 'ia-1'}
+    }
+    result = merge([node1, node2], [node4], version, model, {}, node_type)
+    assert result == [node1, node4]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_animals(*args):
+    term1 = {'@id': 'term1'}
+    node_type = 'Cycle'
+    model = {'key': 'animals'}
+
+    node1 = {
+        'animalId': 'animal-1',
+        'term': term1,
+        'value': 1,
+        'properties': [
+            {
+                'term': {"@id": "liveweightPerHead"},
+                'value': 40
+            }
+        ]
+    }
+    node2 = {
+        'animalId': 'animal-2',
+        'term': term1,
+        'value': 1,
+        'properties': [
+            {
+                'term': {"@id": "liveweightPerHead"},
+                'value': 40
+            },
+            {
+                'term': {"@id": "age"},
+                'value': 10
+            }
+        ]
+    }
+    result = merge([node1], [node2], version, model, {}, node_type)
+    # can not merge as properties is used to determine uniqueness
+    assert result == [node1, node2]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_with_properties(*args):
+    node_type = 'Cycle'
+    model = {'key': 'inputs'}
+
+    node1 = {
+      "term": {
+        "@type": "Term",
+        "@id": "concentrateFeedBlend"
+      },
+      "isAnimalFeed": True,
+      "value": [
+        100
+      ],
+      "impactAssessment": {
+        "@id": "_djxbkdk2wnx",
+        "@type": "ImpactAssessment"
+      },
+      "impactAssessmentIsProxy": False,
+      "@type": "Input"
+    }
+
+    node2 = {
+      "term": {
+        "@type": "Term",
+        "@id": "concentrateFeedBlend"
+      },
+      "isAnimalFeed": True,
+      "value": [
+        200
+      ],
+      "impactAssessment": {
+        "@id": "uug7pcaas6aa",
+        "@type": "ImpactAssessment"
+      },
+      "impactAssessmentIsProxy": False,
+      "@type": "Input"
+    }
+
+    properties = [
+        {
+            'term': {'@id': 'property-1'},
+            'value': 100
+        }
+    ]
+    node3 = node2 | {'properties': properties}
+
+    result = merge([node1, node2], [node3], version, model, {}, node_type)
+    # can not merge as properties is used to determine uniqueness
+    assert result == [node1, node3]

tests/orchestrator/strategies/merge/test_merge_node.py

@@ -0,0 +1,95 @@
+from unittest.mock import patch
+from hestia_earth.schema import EmissionMethodTier
+
+from hestia_earth.orchestrator.strategies.merge.merge_node import merge, _has_threshold_diff, _should_merge_lower_tier
+
+class_path = 'hestia_earth.orchestrator.strategies.merge.merge_node'
+
+
+def test_has_threshold_diff():
+    key = 'key'
+    threshold = 0.1  # 10%
+    source = {}
+    dest = {}
+
+    # key not in source => merge
+    assert _has_threshold_diff(source, dest, key, threshold) is True
+
+    # key not in dest => no merge
+    source[key] = [100]
+    assert not _has_threshold_diff(source, dest, key, threshold)
+
+    dest[key] = [90]
+    assert not _has_threshold_diff(source, dest, key, threshold)
+
+    dest[key] = [89]
+    assert _has_threshold_diff(source, dest, key, threshold) is True
+
+    # edge cases
+    source[key] = [0]
+    dest[key] = [1]
+    assert _has_threshold_diff(source, dest, key, threshold) is True
+
+    source[key] = [0]
+    dest[key] = [0]
+    assert not _has_threshold_diff(source, dest, key, threshold)
+
+    source[key] = [1]
+    dest[key] = [0]
+    assert _has_threshold_diff(source, dest, key, threshold)
+
+
+def test_should_merge_lower_tier():
+    source = {}
+    dest = {}
+
+    # always merge if replacing lower tier
+    assert _should_merge_lower_tier(source, dest, {'replaceLowerTier': True}) is True
+
+    # new value has lower tier
+    source['methodTier'] = EmissionMethodTier.TIER_3.value
+    dest['methodTier'] = EmissionMethodTier.TIER_1.value
+    assert not _should_merge_lower_tier(source, dest, {'replaceLowerTier': False})
+
+    source['methodTier'] = EmissionMethodTier.TIER_1.value
+    dest['methodTier'] = EmissionMethodTier.NOT_RELEVANT.value
+    assert not _should_merge_lower_tier(source, dest, {'replaceLowerTier': False})
+
+    # new value has identical tier
+    source['methodTier'] = EmissionMethodTier.TIER_1.value
+    dest['methodTier'] = EmissionMethodTier.TIER_1.value
+    assert _should_merge_lower_tier(source, dest, {'replaceLowerTier': False}) is True
+
+    # new value has higher tier
+    source['methodTier'] = EmissionMethodTier.TIER_1.value
+    dest['methodTier'] = EmissionMethodTier.TIER_3.value
+    assert _should_merge_lower_tier(source, dest, {'replaceLowerTier': False}) is True
+
+
+@patch(f"{class_path}._has_threshold_diff", return_value=False)
+def test_merge_no_merge(*args):
+    source = {'value': [100]}
+    dest = {'value': [50]}
+    args = {'replaceThreshold': ['value', 50]}
+    # simply return the source
+    assert merge(source, dest, '0', {}, args) == source
+
+
+@patch(f"{class_path}._has_threshold_diff", return_value=True)
+@patch(f"{class_path}.update_node_version", return_value={})
+def test_merge_no_threshold(mock_update, *args):
+    source = {'value': [100]}
+    dest = {'value': [50]}
+    args = {}
+    merge(source, dest, '0', {}, args)
+    mock_update.assert_called_once()
+
+
+@patch(f"{class_path}._has_threshold_diff", return_value=True)
+@patch(f"{class_path}.update_node_version", return_value={})
+def test_merge_with_threshold(mock_update, *args):
+    source = {'value': [100]}
+    dest = {'value': [50]}
+    args = {'replaceThreshold': ['value', 50]}
+    merge(source, dest, '0', {}, args)
+    mock_update.assert_called_once()

tests/orchestrator/strategies/run/test_add_blank_node_if_missing.py

@@ -0,0 +1,114 @@
+from unittest.mock import patch
+
+from hestia_earth.orchestrator.strategies.run.add_blank_node_if_missing import should_run
+
+class_path = 'hestia_earth.orchestrator.strategies.run.add_blank_node_if_missing'
+FAKE_EMISSION = {'@id': 'n2OToAirExcretaDirect', 'termType': 'emission'}
+
+
+@patch(f"{class_path}.get_required_model_param", return_value='')
+@patch(f"{class_path}.find_term_match")
+def test_should_run(mock_node_exists, *args):
+    data = {}
+    model = {}
+
+    # node does not exists => run
+    mock_node_exists.return_value = None
+    assert should_run(data, model) is True
+
+    # node exists but no value => run
+    mock_node_exists.return_value = {}
+    assert should_run(data, model) is True
+
+    # node exists with value + no params => no run
+    node = {'value': 10}
+    mock_node_exists.return_value = node
+    assert not should_run(data, model)
+
+    # node exists with added value `0` and `Emission` => run
+    node = {'@type': 'Emission', 'value': [0], 'added': ['value']}
+    mock_node_exists.return_value = node
+    assert should_run(data, model) is True
+
+
+@patch(f"{class_path}.get_required_model_param", return_value='')
+@patch(f"{class_path}.find_term_match")
+def test_should_run_skipEmptyValue(mock_node_exists, *args):
+    data = {}
+
+    # no value and not skip => run
+    mock_node_exists.return_value = {}
+    model = {'runArgs': {'skipEmptyValue': False}}
+    assert should_run(data, model) is True
+
+    # no value and skip => no run
+    mock_node_exists.return_value = {}
+    model = {'runArgs': {'skipEmptyValue': True}}
+    assert not should_run(data, model)
+
+
+@patch(f"{class_path}.get_required_model_param", return_value='')
+def test_should_run_skipAggregated(*args):
+    data = {}
+    model = {'runArgs': {'skipAggregated': True}}
+
+    # not aggregated => run
+    data = {'aggregated': False}
+    assert should_run(data, model) is True
+
+    # aggregated => no run
+    data = {'aggregated': True}
+    assert not should_run(data, model)
+
+
+@patch(f"{class_path}.get_required_model_param", return_value='')
+@patch(f"{class_path}.find_term_match")
+def test_should_run_runNonAddedTerm(mock_node_exists, *args):
+    data = {}
+    node = {'value': 10}
+    mock_node_exists.return_value = node
+    model = {'runArgs': {'runNonAddedTerm': True}}
+
+    # term has been added => no run
+    node['added'] = ['term']
+    assert not should_run(data, model)
+
+    # term has not been added => run
+    node['added'] = []
+    assert should_run(data, model) is True
+
+
+@patch(f"{class_path}.get_required_model_param", return_value='')
+@patch(f"{class_path}.find_term_match")
+def test_should_run_runNonMeasured(mock_node_exists, *args):
+    data = {}
+    node = {'value': 10}
+    mock_node_exists.return_value = node
+    model = {'runArgs': {'runNonMeasured': True}}
+
+    # term measured => no run
+    node['methodTier'] = 'measured'
+    assert not should_run(data, model)
+
+    # term not measured => run
+    node['methodTier'] = 'background'
+    assert should_run(data, model) is True
+
+
+@patch(f"{class_path}.get_table_value", return_value='Cycle')
+@patch(f"{class_path}.download_hestia", return_value=FAKE_EMISSION)
+@patch(f"{class_path}.get_required_model_param", return_value='')
+@patch(f"{class_path}.find_term_match")
+def test_should_run_check_typeAllowed(mock_node_exists, *args):
+    data = {}
+    node = {'term': FAKE_EMISSION}
+    mock_node_exists.return_value = node
+    model = {}
+
+    # type is not allowed => no run
+    data['@type'] = 'Transformation'
+    assert not should_run(data, model)
+
+    # type is allowed => run
+    data['@type'] = 'Cycle'
+    assert should_run(data, model) is True

tests/orchestrator/strategies/run/test_add_key_if_missing.py

@@ -0,0 +1,14 @@
+from hestia_earth.orchestrator.strategies.run.add_key_if_missing import should_run
+
+
+def test_should_run():
+    data = {}
+    key = 'model-key'
+    model = {'key': key}
+
+    # key not in data => run
+    assert should_run(data, model) is True
+
+    # key in data => no run
+    data[key] = 10
+    assert not should_run(data, model)

tests/orchestrator/strategies/run/test_always.py

@@ -0,0 +1,5 @@
+from hestia_earth.orchestrator.strategies.run.always import should_run
+
+
+def test_should_run():
+    assert should_run({}, {}) is True

tests/orchestrator/test_models.py

@@ -0,0 +1,69 @@
+from unittest.mock import patch
+import pytest
+import json
+import os
+
+from tests.utils import fixtures_path
+from hestia_earth.orchestrator.models import run, _run_parallel, _filter_models_stage
+
+class_path = 'hestia_earth.orchestrator.models'
+folder_path = os.path.join(fixtures_path, 'orchestrator', 'cycle')
+
+
+@patch('hestia_earth.orchestrator.strategies.merge._merge_version', return_value='0.0.0')
+def test_run(*args):
+    with open(os.path.join(folder_path, 'config.json'), encoding='utf-8') as f:
+        config = json.load(f)
+    with open(os.path.join(folder_path, 'cycle.jsonld'), encoding='utf-8') as f:
+        cycle = json.load(f)
+    with open(os.path.join(folder_path, 'result.jsonld'), encoding='utf-8') as f:
+        expected = json.load(f)
+
+    result = run(cycle, config.get('models'))
+    assert result == expected
+
+
+@patch(f"{class_path}._run_model", side_effect=Exception('error'))
+def test_run_parallel_with_errors(*args):
+    data = {
+        '@type': 'Cycle',
+        '@id': 'cycle'
+    }
+    model = [{'key': 'model1'}, {'key': 'model2'}]
+
+    with pytest.raises(Exception):
+        _run_parallel(data, model, [])
+
+
+def test_filter_models_stage():
+    models = json.load(open(os.path.join(fixtures_path, 'orchestrator', 'stages', 'config.json'))).get('models')
+    assert _filter_models_stage(models) == models
+    assert _filter_models_stage(models, 1) == [
+        {
+            "key": "model1",
+            "stage": 1
+        },
+        {
+            "key": "model2",
+            "stage": 1
+        }
+    ]
+    assert _filter_models_stage(models, 2) == [
+        [
+            {
+                "key": "model3",
+                "stage": 2
+            },
+            {
+                "key": "model4",
+                "stage": 2
+            }
+        ]
+    ]
+    assert _filter_models_stage(models, 3) == [
+        {
+            "key": "model5",
+            "stage": 3
+        }
+    ]
+    assert _filter_models_stage(models, [1, 2, 3]) == models

tests/orchestrator/test_orchestrator.py

@@ -0,0 +1,27 @@
+from unittest.mock import patch
+import pytest
+
+from hestia_earth.orchestrator import run
+
+config = {'models': []}
+
+
+@patch('hestia_earth.orchestrator.run_models', return_value={})
+def test_run(mock_run_models, *args):
+    run({'@type': 'Cycle'}, config)
+    mock_run_models.assert_called_once()
+
+
+def test_run_missing_type():
+    with pytest.raises(Exception, match='Please provide an "@type" key in your data.'):
+        run({}, config)
+
+
+def test_run_missing_config():
+    with pytest.raises(Exception, match='Please provide a valid configuration.'):
+        run({'@type': 'Cycle'}, None)
+
+
+def test_run_missing_models():
+    with pytest.raises(Exception, match='Please provide a valid configuration.'):
+        run({'@type': 'Cycle'}, {})