pyoaev 1.18.20__py3-none-any.whl

test/apis/injector_contract/test_injector_contract.py

@@ -0,0 +1,58 @@
+from unittest import TestCase, main, mock
+from unittest.mock import ANY
+
+from pyoaev import OpenAEV
+from pyoaev.apis.inputs.search import (
+    Filter,
+    FilterGroup,
+    InjectorContractSearchPaginationInput,
+)
+
+
+def mock_response(**kwargs):
+    class MockResponse:
+        def __init__(self, json_data, status_code):
+            self.json_data = json_data
+            self.status_code = status_code
+            self.history = None
+            self.content = None
+            self.headers = {"Content-Type": "application/json"}
+
+        def json(self):
+            return self.json_data
+
+    return MockResponse(None, 200)
+
+
+class TestInjectorContract(TestCase):
+    @mock.patch("requests.Session.request", side_effect=mock_response)
+    def test_search_input_correctly_serialised(self, mock_request):
+        api_client = OpenAEV("url", "token")
+
+        search_input = InjectorContractSearchPaginationInput(
+            0,
+            20,
+            FilterGroup("or", [Filter("prop", "and", "eq", ["titi", "toto"])]),
+            None,
+            None,
+        )
+
+        expected_json = search_input.to_dict()
+        api_client.injector_contract.search(search_input)
+
+        mock_request.assert_called_once_with(
+            method="post",
+            url="url/api/injector_contracts/search",
+            params={},
+            data=None,
+            timeout=None,
+            stream=False,
+            verify=True,
+            json=expected_json,
+            headers=ANY,
+            auth=ANY,
+        )
+
+
+if __name__ == "__main__":
+    main()

test/configuration/test_configuration.py

@@ -0,0 +1,257 @@
+import os
+import unittest
+from unittest.mock import patch
+
+from pyoaev.configuration import Configuration
+
+TEST_CONFIG_HINTS = {
+    "string_config_direct": {"data": "this is string_config_direct"},
+    "string_config_no_default": {
+        "env": "PYOAEV_TEST_CONFIGURATION_STRING_CONFIG_NO_DEFAULT",
+        "file_path": ["pyoaev_test_configuration", "string_config_no_default"],
+    },
+    "int_config_no_default": {
+        "env": "PYOAEV_TEST_CONFIGURATION_INT_CONFIG_NO_DEFAULT",
+        "file_path": ["pyoaev_test_configuration", "int_config_no_default"],
+        "is_number": True,
+    },
+    "int_config_no_default_not_marked_number": {
+        "env": "PYOAEV_TEST_CONFIGURATION_INT_CONFIG_NO_DEFAULT",
+        "file_path": [
+            "pyoaev_test_configuration",
+            "int_config_no_default_not_marked_number",
+        ],
+    },
+    "string_config_with_default": {
+        "env": "PYOAEV_TEST_CONFIGURATION_STRING_CONFIG_WITH_DEFAULT",
+        "file_path": ["pyoaev_test_configuration", "string_config_with_default"],
+        "default": "default string config",
+    },
+    "int_config_with_default": {
+        "env": "PYOAEV_TEST_CONFIGURATION_INT_CONFIG_WITH_DEFAULT",
+        "file_path": ["pyoaev_test_configuration", "int_config_with_default"],
+        "is_number": True,
+        "default": 777_777,
+    },
+    "bool_config_with_default": {
+        "env": "PYOAEV_TEST_CONFIGURATION_BOOL_CONFIG_WITH_DEFAULT",
+        "file_path": ["pyoaev_test_configuration", "bool_config_with_default"],
+        "default": True,
+    },
+}
+
+
+class TestConfiguration(unittest.TestCase):
+    def test_when_string_config_has_no_default_when_key_not_found_return_None(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("string_config_no_default")
+
+        self.assertIsNone(value)
+
+    def test_when_config_has_no_default_when_key_is_set_as_bool_return_bool(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+        config_obj.set("string_config_no_default", True)
+
+        value = config_obj.get("string_config_no_default")
+
+        self.assertEqual(value, True)
+
+    def test_when_config_has_no_default_when_key_is_set_as_string_bool_return_bool(
+        self,
+    ):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+        config_obj.set("string_config_no_default", "yes")
+
+        value = config_obj.get("string_config_no_default")
+
+        self.assertEqual(value, True)
+
+    def test_when_string_config_has_default_when_key_not_found_return_default(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("string_config_with_default")
+
+        self.assertEqual(value, "default string config")
+
+    @patch.dict(
+        os.environ,
+        values={"PYOAEV_TEST_CONFIGURATION_STRING_CONFIG_NO_DEFAULT": "actual value"},
+        clear=True,
+    )
+    def test_when_string_config_has_no_default_when_key_is_in_env_return_env_value(
+        self,
+    ):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("string_config_no_default")
+
+        self.assertEqual(value, "actual value")
+
+    @patch.dict(
+        os.environ,
+        values={"PYOAEV_TEST_CONFIGURATION_STRING_CONFIG_WITH_DEFAULT": "actual value"},
+        clear=True,
+    )
+    def test_when_string_config_has_default_when_key_is_in_env_return_env_value(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("string_config_with_default")
+
+        self.assertEqual(value, "actual value")
+
+    @patch.dict(
+        os.environ,
+        values={"PYOAEV_TEST_CONFIGURATION_STRING_CONFIG_NO_DEFAULT": "actual value"},
+        clear=True,
+    )
+    def test_when_key_is_in_both_env_and_file_return_env_value(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+            config_values={
+                "pyoaev_test_configuration": {
+                    "string_config_no_default": "another value"
+                }
+            },
+        )
+
+        value = config_obj.get("string_config_no_default")
+
+        self.assertEqual(value, "actual value")
+
+    @patch.dict(
+        os.environ,
+        values={"PYOAEV_TEST_CONFIGURATION_STRING_CONFIG_NO_DEFAULT": "env value"},
+        clear=True,
+    )
+    def test_when_key_is_in_both_env_and_file_when_value_is_set_return_set_value(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+            config_values={
+                "pyoaev_test_configuration": {"string_config_no_default": "file value"}
+            },
+        )
+        config_obj.set("string_config_no_default", "set value")
+
+        value = config_obj.get("string_config_no_default")
+
+        self.assertEqual(value, "set value")
+
+    def test_when_string_config_has_no_default_when_key_is_in_file_return_file_value(
+        self,
+    ):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+            config_values={
+                "pyoaev_test_configuration": {
+                    "string_config_no_default": "another value"
+                }
+            },
+        )
+
+        value = config_obj.get("string_config_no_default")
+
+        self.assertEqual(value, "another value")
+
+    def test_when_int_config_has_no_default_when_key_is_not_found_return_None(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("int_config_no_default")
+
+        self.assertIsNone(value)
+
+    def test_when_int_config_has_default_when_key_is_not_found_return_default(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("int_config_with_default")
+
+        self.assertEqual(value, 777_777)
+
+    @patch.dict(
+        os.environ,
+        values={"PYOAEV_TEST_CONFIGURATION_INT_CONFIG_NO_DEFAULT": "1234"},
+        clear=True,
+    )
+    def test_when_int_config_has_no_default_when_key_is_in_env_return_env_value(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("int_config_no_default")
+
+        self.assertEqual(value, 1234)
+
+    def test_when_int_config_has_no_default_when_key_is_passed_as_int_return_int_value(
+        self,
+    ):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+            config_values={
+                "pyoaev_test_configuration": {"int_config_no_default": 456_123}
+            },
+        )
+
+        value = config_obj.get("int_config_no_default")
+
+        self.assertEqual(value, 456_123)
+
+    def test_when_int_config_has_no_default_when_key_is_passed_as_int_when_config_is_not_marked_as_number_return_int_value(
+        self,
+    ):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+            config_values={
+                "pyoaev_test_configuration": {
+                    "int_config_no_default_not_marked_number": 842_204
+                }
+            },
+        )
+
+        value = config_obj.get("int_config_no_default_not_marked_number")
+
+        self.assertEqual(value, 842_204)
+
+    @patch.dict(
+        os.environ,
+        values={"PYOAEV_TEST_CONFIGURATION_STRING_CONFIG_NO_DEFAULT": "yes"},
+        clear=True,
+    )
+    def test_when_string_config_has_no_default_when_string_is_boolean_when_key_is_in_env_return_env_value(
+        self,
+    ):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("string_config_no_default")
+
+        self.assertEqual(value, True)
+
+    def test_when_bool_config_has_default_when_key_is_not_found_return_default(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+        )
+
+        value = config_obj.get("bool_config_with_default")
+
+        self.assertEqual(value, True)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/configuration/test_sources.py

@@ -0,0 +1,69 @@
+import os
+import unittest
+from unittest.mock import patch
+
+from pyoaev.configuration.sources import DictionarySource, EnvironmentSource
+
+TEST_ENV_VAR: str = "PYOAEV_TEST_ENV_VAR"
+
+
+class TestEnvironmentSource(unittest.TestCase):
+    @patch.dict(os.environ, clear=True)
+    def test_when_env_var_not_set_return_none(self):
+        result = EnvironmentSource.get(TEST_ENV_VAR)
+
+        self.assertIsNone(result)
+
+    @patch.dict(os.environ, values={TEST_ENV_VAR: "some_value"}, clear=True)
+    def test_when_env_var_is_set_return_value(self):
+        result = EnvironmentSource.get(TEST_ENV_VAR)
+
+        self.assertEqual(result, "some_value")
+
+
+class TestDictionarySource(unittest.TestCase):
+    def test_when_config_key_path_is_not_list_it_throws(self):
+        string_key_path = "some string"
+        with self.assertRaises(AssertionError):
+            DictionarySource.get(string_key_path, {})
+
+    def test_when_config_key_path_has_not_2_elements_it_throws(self):
+        key_path = ["element 1"]
+        with self.assertRaises(AssertionError):
+            DictionarySource.get(key_path, {})
+
+    def test_when_config_key_path_has_empty_elements_it_throws(self):
+        key_path = ["element 1", ""]
+        with self.assertRaises(AssertionError):
+            DictionarySource.get(key_path, {})
+
+    def test_when_config_missing_first_path_part_return_None(self):
+        expected_value = None
+        key_path = ["element 1", "element 2"]
+        values = {"not element 1": None}
+
+        result = DictionarySource.get(key_path, values)
+
+        self.assertEqual(result, expected_value)
+
+    def test_when_config_missing_second_path_part_return_None(self):
+        expected_value = None
+        key_path = ["element 1", "element 2"]
+        values = {"element 1": {"not element 2": "some value"}}
+
+        result = DictionarySource.get(key_path, values)
+
+        self.assertEqual(result, expected_value)
+
+    def test_when_config_found_return_value(self):
+        expected_value = "expected!"
+        key_path = ["element 1", "element 2"]
+        values = {"element 1": {"element 2": expected_value}}
+
+        result = DictionarySource.get(key_path, values)
+
+        self.assertEqual(result, expected_value)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/daemons/test_base_daemon.py

@@ -0,0 +1,109 @@
+import unittest
+import unittest.mock
+
+from pyoaev.configuration import Configuration
+from pyoaev.daemons import BaseDaemon
+from pyoaev.exceptions import OpenAEVError
+
+TEST_DAEMON_CONFIG_HINTS = {
+    "openaev_url": {"data": "http://example.com"},
+    "openaev_token": {"data": "test"},
+    "log_level": {"data": "info"},
+    "name": {"data": "my test daemon"},
+}
+
+TEST_DAEMON_CONFIGURATION = Configuration(config_hints=TEST_DAEMON_CONFIG_HINTS)
+
+
+class DaemonForTest(BaseDaemon):
+    def _setup(self):
+        pass
+
+    def _start_loop(self):
+        pass
+
+
+def create_mock_daemon(callback: callable = None):
+    mock_setup = unittest.mock.MagicMock()
+    mock_start_loop = unittest.mock.MagicMock()
+    inner_mock_func = unittest.mock.MagicMock()
+
+    class MockDaemon(BaseDaemon):
+        def _setup(self):
+            mock_setup()
+
+        def _start_loop(self):
+            mock_start_loop()
+
+        def bound_method(self):
+            inner_mock_func()
+
+    return (
+        MockDaemon(
+            configuration=TEST_DAEMON_CONFIGURATION,
+            callback=callback,
+            # silence logging in tests
+            logger=unittest.mock.MagicMock(),
+        ),
+        mock_setup,
+        mock_start_loop,
+        inner_mock_func,
+    )
+
+
+class TestBaseDaemon(unittest.TestCase):
+    def test_when_no_callback_when_complete_config_ctor_ok(self):
+        daemon = DaemonForTest(configuration=TEST_DAEMON_CONFIGURATION)
+
+        self.assertIsInstance(daemon, BaseDaemon)
+
+    def test_when_no_callback_when_lacking_config_key_ctor_throws(self):
+        with self.assertRaises(Exception):
+            DaemonForTest(configuration=Configuration(config_hints={}))
+
+    def test_when_no_callback_daemon_cant_start(self):
+        daemon, mock_setup, mock_start_loop, _ = create_mock_daemon()
+
+        with self.assertRaises(OpenAEVError):
+            daemon.start()
+
+        mock_setup.assert_not_called()
+        mock_start_loop.assert_not_called()
+
+    def test_when_callback_daemon_can_start(self):
+        daemon, mock_setup, mock_start_loop, _ = create_mock_daemon(lambda: None)
+
+        daemon.start()
+
+        mock_setup.assert_called_once()
+        mock_start_loop.assert_called_once()
+
+    def test_when_callback_is_bound_method_daemon_can_call(self):
+        daemon, mock_setup, mock_start_loop, inner_mock_func = create_mock_daemon()
+        daemon.set_callback(daemon.bound_method)
+
+        daemon._try_callback()
+
+        inner_mock_func.assert_called_once()
+
+    def test_when_callback_is_func_with_collector_parameter_daemon_can_call(self):
+        daemon, mock_setup, mock_start_loop, _ = create_mock_daemon()
+        inner_mock_func = unittest.mock.MagicMock()
+        daemon.set_callback(lambda collector: inner_mock_func())
+
+        daemon._try_callback()
+
+        inner_mock_func.assert_called_once()
+
+    def test_when_callback_is_func_with_other_parameter_daemon_cant_call(self):
+        daemon, mock_setup, mock_start_loop, _ = create_mock_daemon()
+        inner_mock_func = unittest.mock.MagicMock()
+        daemon.set_callback(lambda other_parameter: inner_mock_func())
+
+        daemon._try_callback()
+
+        inner_mock_func.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

test/daemons/test_collector_daemon.py

@@ -0,0 +1,39 @@
+import unittest
+from unittest.mock import mock_open, patch
+
+from pyoaev.configuration import Configuration
+from pyoaev.daemons import CollectorDaemon
+from pyoaev.daemons.collector_daemon import DEFAULT_PERIOD_SECONDS
+
+
+class TestCollectorDaemon(unittest.TestCase):
+    @patch("pyoaev.apis.DocumentManager.upsert")
+    @patch("pyoaev.apis.CollectorManager.create")
+    @patch("builtins.open", new_callable=mock_open, read_data="data")
+    @patch("pyoaev.utils.PingAlive.start")
+    def test_when_no_period_config_provided_set_default_period(
+        self,
+        mock_ping_alive,
+        mock_open_local,
+        mock_collector_create,
+        mock_document_upsert,
+    ):
+        mock_ping_alive.return_value = None
+        mock_collector_create.return_value = {}
+        mock_document_upsert.return_value = {}
+        config = Configuration(
+            config_hints={
+                "openaev_url": {"data": "fake"},
+                "openaev_token": {"data": "fake"},
+                "collector_id": {"data": "fake id"},
+            }
+        )
+        collector = CollectorDaemon(configuration=config, collector_type="test")
+
+        collector._setup()
+
+        self.assertEqual(config.get("collector_period"), DEFAULT_PERIOD_SECONDS)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/signatures/test_signature_match.py

@@ -0,0 +1,25 @@
+import unittest
+
+from pyoaev.exceptions import OpenAEVError
+from pyoaev.signatures.signature_match import SignatureMatch
+from pyoaev.signatures.types import MatchTypes
+
+
+class TestSignatureMatch(unittest.TestCase):
+    def test_non_simple_match_with_non_null_score_throws(self):
+        score = None
+        self.assertRaises(
+            OpenAEVError, SignatureMatch, MatchTypes.MATCH_TYPE_FUZZY, score
+        )
+
+    def test_simple_match_with_null_score_does_not_throw(self):
+        score = None
+        SignatureMatch(match_type=MatchTypes.MATCH_TYPE_SIMPLE, match_score=score)
+
+    def test_fuzzy_match_with_0_score_does_not_throw(self):
+        score = 0
+        SignatureMatch(match_type=MatchTypes.MATCH_TYPE_FUZZY, match_score=score)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/signatures/test_signature_type.py

@@ -0,0 +1,57 @@
+import unittest
+
+from pyoaev.signatures.signature_type import SignatureType
+from pyoaev.signatures.types import MatchTypes, SignatureTypes
+
+
+class TestSignatureType(unittest.TestCase):
+    def test_make_struct_create_expected_struct_for_simple_sig_type(self):
+        simple_signature_type_label = SignatureTypes.SIG_TYPE_TARGET_HOSTNAME_ADDRESS
+        simple_signature_type = SignatureType(
+            label=simple_signature_type_label, match_type=MatchTypes.MATCH_TYPE_SIMPLE
+        )
+
+        data = "just a simple string"
+        simple_struct = simple_signature_type.make_struct_for_matching(data=data)
+
+        self.assertEqual(simple_struct.get("type"), MatchTypes.MATCH_TYPE_SIMPLE.value)
+        self.assertEqual(simple_struct.get("data"), data)
+        self.assertFalse("score" in simple_struct.keys())
+
+    def test_make_struct_create_expected_struct_for_fuzzy_sig_type(self):
+        fuzzy_signature_type_label = SignatureTypes.SIG_TYPE_TARGET_HOSTNAME_ADDRESS
+        fuzzy_signature_type_score = 50
+        fuzzy_signature_type = SignatureType(
+            label=fuzzy_signature_type_label,
+            match_type=MatchTypes.MATCH_TYPE_FUZZY,
+            match_score=fuzzy_signature_type_score,
+        )
+
+        data = "just another simple string"
+        simple_struct = fuzzy_signature_type.make_struct_for_matching(data=data)
+
+        self.assertEqual(simple_struct.get("type"), MatchTypes.MATCH_TYPE_FUZZY.value)
+        self.assertEqual(simple_struct.get("data"), data)
+        self.assertEqual(simple_struct.get("score"), fuzzy_signature_type_score)
+
+    def test_make_struct_create_expected_struct_for_fuzzy_sig_type_when_score_is_0(
+        self,
+    ):
+        fuzzy_signature_type_label = SignatureTypes.SIG_TYPE_TARGET_HOSTNAME_ADDRESS
+        fuzzy_signature_type_score = 0
+        fuzzy_signature_type = SignatureType(
+            label=fuzzy_signature_type_label,
+            match_type=MatchTypes.MATCH_TYPE_FUZZY,
+            match_score=fuzzy_signature_type_score,
+        )
+
+        data = "just another simple string"
+        simple_struct = fuzzy_signature_type.make_struct_for_matching(data=data)
+
+        self.assertEqual(simple_struct.get("type"), MatchTypes.MATCH_TYPE_FUZZY.value)
+        self.assertEqual(simple_struct.get("data"), data)
+        self.assertEqual(simple_struct.get("score"), fuzzy_signature_type_score)
+
+
+if __name__ == "__main__":
+    unittest.main()