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

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'}, {})

tests/orchestrator/test_utils.py

@@ -0,0 +1,109 @@
+from hestia_earth.orchestrator.utils import update_node_version
+
+version = '2'
+
+
+def test_update_node_version():
+    current_data = {
+        'key1': 50,
+        'key2': 100
+    }
+    new_data = {
+        'key2': 200,
+        'key3': 300,
+        'key4': {}
+    }
+    assert update_node_version(version, new_data, current_data) == {
+        **new_data,
+        'added': ['key3', 'key4'],
+        'addedVersion': [version, version],
+        'updated': ['key2'],
+        'updatedVersion': [version]
+    }
+
+
+def test_update_node_version_deep():
+    current_data = {
+        'object': {
+            'first': True
+        },
+        'values': [
+            {
+                'term': {'@type': 'Term'},
+                'value': [500],
+                'properties': [
+                    {
+                        'term': {'@type': 'Term', '@id': 'Prop1'},
+                        'value': 100
+                    }
+                ]
+            }
+        ]
+    }
+    new_data = {
+        'object': {
+            'first': True,
+            'second': False
+        },
+        'values': [
+            {
+                'term': {'@type': 'Term'},
+                'value': [500],
+                'min': [100],
+                'properties': [
+                    {
+                        'term': {'@type': 'Term', '@id': 'Prop1'},
+                        'value': 10
+                    },
+                    {
+                        'term': {'@type': 'Term', '@id': 'Prop2'},
+                        'value': 20
+                    }
+                ]
+            },
+            {
+                'term': {'@type': 'Term', '@id': 'Test2'}
+            }
+        ]
+    }
+    result = update_node_version(version, new_data, current_data)
+    assert result == {
+        'object': {
+            'first': True,
+            'second': False,
+            'added': ['second'],
+            'addedVersion': [version]
+        },
+        'values': [
+            {
+                'term': {'@type': 'Term'},
+                'value': [500],
+                'min': [100],
+                'properties': [
+                    {
+                        'term': {'@type': 'Term', '@id': 'Prop1'},
+                        'value': 10,
+                        'updated': ['value'],
+                        'updatedVersion': [version]
+                    },
+                    {
+                        'term': {'@type': 'Term', '@id': 'Prop2'},
+                        'value': 20,
+                        'added': ['term', 'value'],
+                        'addedVersion': [version, version]
+                    }
+                ],
+                'added': ['min'],
+                'addedVersion': [version],
+                'updated': ['properties'],
+                'updatedVersion': [version]
+            },
+            {
+                'term': {'@type': 'Term', '@id': 'Test2'},
+                'added': ['term'],
+                'addedVersion': [version]
+            }
+        ],
+        'updated': ['object', 'values'],
+        'updatedVersion': [version, version]
+    }