Feature/unit tests/tags parser (#257)

* eventtype_parser unit tests

* eventtype_parser no config file update

* review remarks #1

* conftest parametrization

* wrapped pytest arguments

* test_tags_parser

* build_parsed_output

* fixture scope

* typo change

* review remarks #1

* review remarks #2

Author: kkania-splunk

tests/unit/conftest.py

@@ -1,29 +1,47 @@
 import pytest
 from unittest.mock import Mock
-from pytest_splunk_addon.standard_lib.addon_parser.eventtype_parser import (
-    EventTypeParser,
-)
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def parser():
-    class FakeConfigurationFile:
-        def __init__(self):
-            self.headers = []
-            self.sects = {
-                "fake_splunkd": {
-                    "name": "fake_splunkd",
-                    "options": "index=_internal sourcetype=splunkd",
-                },
-                "fake_for_tags_positive": {
-                    "name": "fake_for_tags_positive",
-                    "options": "sourcetype=splunkd",
-                },
-            }
-            self.errors = []
+    def create_parser(parser_class, func_to_be_mocked, parsed_output):
+        class FakeConfigurationFile:
+            def __init__(self, sects):
+                self.headers = []
+                self.sects = sects
+                self.errors = []
 
-    FakeApp = Mock()
-    FakeApp.eventtypes = FakeConfigurationFile()
-    FakeApp.eventtypes_conf.return_value = FakeConfigurationFile()
+        FakeApp = Mock()
+        attrs = {
+            "{}.return_value".format(func_to_be_mocked): FakeConfigurationFile(
+                parsed_output
+            )
+        }
+        FakeApp.configure_mock(**attrs)
+        return parser_class("fake_path", FakeApp)
 
-    return EventTypeParser("fake_path", FakeApp)
+    return create_parser
+
+
+@pytest.fixture(scope="session")
+def build_parsed_output():
+    def parsed_output(output_elements):
+        """
+        builds expected parser output from provided dict
+        :param output_elements: dictionary with {stanza: {option: value, ...}, ...}
+        :return: parsed_output
+        """
+        parsed_output = {}
+        for stanza, stanza_value in output_elements.items():
+            fake_section = Mock()
+            fake_section.options = {}
+            fake_section.name = stanza
+            parsed_output.update({stanza: fake_section})
+            for option, value in stanza_value.items():
+                fake_setting = Mock()
+                fake_setting.name = option
+                fake_setting.value = value
+                parsed_output[stanza].options.update({option: fake_setting})
+        return parsed_output
+
+    return parsed_output

tests/unit/test_eventtype_parser.py

@@ -1,26 +1,61 @@
-def test_eventtypes_can_be_parsed_and_extracted(parser):
-    assert hasattr(
-        parser.eventtypes, "sects"
-    ), "eventypes can not be called or does have sects attribute"
+import pytest
+from unittest.mock import patch, PropertyMock
+from pytest_splunk_addon.standard_lib.addon_parser.eventtype_parser import (
+    EventTypeParser,
+)
 
 
-def test_eventtypes_can_be_parsed_and_returned(parser):
-    expected_outputs = [
-        {"stanza": x} for x in ["fake_splunkd", "fake_for_tags_positive"]
-    ]
-    for i, event in enumerate(parser.get_eventtypes()):
+output_to_build = {
+    "fiction_is_splunkd": {"search": "index=_internal sourcetype=splunkd"},
+    "fiction_for_tags_positive": {"search": "sourcetype=splunkd"},
+    "fiction_is_splunkd-%host%": {"search": "index=_internal sourcetype=splunkd"},
+}
+
+
+def test_eventtypes_can_be_parsed_and_extracted(parser_instance):
+    assert list(parser_instance.eventtypes.sects.keys()) == [
+        "fiction_is_splunkd",
+        "fiction_for_tags_positive",
+        "fiction_is_splunkd-%host%",
+    ], "eventypes can not be called or does not have sects attribute"
+
+
+def test_eventtypes_can_be_parsed_and_returned(parsed_output, parser_instance):
+    expected_outputs = [{"stanza": x} for x in parsed_output.keys()]
+    for i, event in enumerate(parser_instance.get_eventtypes()):
         assert event == expected_outputs[i], "expeceted event {} not found".format(
             expected_outputs[i]
         )
 
 
-def test_get_eventtypes_calls_app_get_config(parser):
-    for _ in parser.get_eventtypes():
+def test_get_eventtypes_calls_app_get_config(parser_instance):
+    for _ in parser_instance.get_eventtypes():
         pass
-    parser.app.eventtypes_conf.assert_called_once()
+    parser_instance.app.eventtypes_conf.assert_called_once()
+
+
+def test_no_eventtype_config_file(parser_instance):
+    parser_instance.app.eventtypes_conf.side_effect = OSError
+    assert (
+        parser_instance.eventtypes is None
+    ), "eventtypes created when no config file exists"
+
+
+def test_nothing_returned_when_no_tags_config_file(parser):
+    with patch.object(
+        EventTypeParser, "eventtypes", new_callable=PropertyMock
+    ) as eventtypes_mock:
+        eventtypes_mock.return_value = None
+        parser_instance = parser(EventTypeParser, "eventtypes_conf", {})
+        output = [tag for tag in parser_instance.get_eventtypes() if tag]
+        assert output == [], "eventtypes returned when no config file exists"
+
+
+@pytest.fixture(scope="module")
+def parsed_output(build_parsed_output):
+    return build_parsed_output(output_to_build)
 
 
-def test_no_eventtype_config_file(parser):
-    parser.app.eventtypes_conf.side_effect = OSError
-    output = [eventtype for eventtype in parser.get_eventtypes() if eventtype]
-    assert output == [], "eventtypes created when no config file exists"
+@pytest.fixture()
+def parser_instance(parsed_output, parser):
+    return parser(EventTypeParser, "eventtypes_conf", parsed_output)

tests/unit/test_tags_parser.py

@@ -0,0 +1,82 @@
+import pytest
+from unittest.mock import patch, PropertyMock
+from pytest_splunk_addon.standard_lib.addon_parser.tags_parser import (
+    TagsParser,
+)
+
+
+output_to_build = {
+    "eventtype=fiction_for_tags_positive": {
+        "tags_positive_event": "enabled",
+        "tags_disabled_event": "disabled",
+    },
+    "source=%2Fopt%2Fsplunk%2Fvar%2Flog%2Fsplunk%2Fsplunkd.log": {
+        "tags_positive_event": "enabled",
+        "tags_disabled_event": "disabled",
+    },
+}
+
+
+def test_tags_can_be_parsed_and_extracted(parser_instance):
+    assert list(parser_instance.tags.sects.keys()) == [
+        "eventtype=fiction_for_tags_positive",
+        "source=%2Fopt%2Fsplunk%2Fvar%2Flog%2Fsplunk%2Fsplunkd.log",
+    ], "tags can not be called or does not have sects attribute"
+
+
+def test_tags_can_be_parsed_and_returned(parser_instance):
+    expected_outputs = [
+        {
+            "stanza": 'eventtype="fiction_for_tags_positive"',
+            "tag": "tags_positive_event",
+            "enabled": True,
+        },
+        {
+            "stanza": 'eventtype="fiction_for_tags_positive"',
+            "tag": "tags_disabled_event",
+            "enabled": False,
+        },
+        {
+            "stanza": 'source="/opt/splunk/var/log/splunk/splunkd.log"',
+            "tag": "tags_positive_event",
+            "enabled": True,
+        },
+        {
+            "stanza": 'source="/opt/splunk/var/log/splunk/splunkd.log"',
+            "tag": "tags_disabled_event",
+            "enabled": False,
+        },
+    ]
+    for i, event in enumerate(parser_instance.get_tags()):
+        assert event == expected_outputs[i], "expeceted event {} not found".format(
+            expected_outputs[i]
+        )
+
+
+def test_get_tags_calls_app_get_config(parser_instance):
+    for _ in parser_instance.get_tags():
+        pass
+    parser_instance.app.get_config.assert_called_once()
+
+
+def test_no_tags_config_file(parser_instance):
+    parser_instance.app.get_config.side_effect = OSError
+    assert parser_instance.tags is None, "tags created when no config file exists"
+
+
+def test_nothing_returned_when_no_tags_config_file(parser):
+    with patch.object(TagsParser, "tags", new_callable=PropertyMock) as tags_mock:
+        tags_mock.return_value = None
+        parser_instance = parser(TagsParser, "get_config", {})
+        output = [tag for tag in parser_instance.get_tags() if tag]
+        assert output == [], "tags returned when no config file exists"
+
+
+@pytest.fixture(scope="module")
+def parsed_output(build_parsed_output):
+    return build_parsed_output(output_to_build)
+
+
+@pytest.fixture()
+def parser_instance(parsed_output, parser):
+    return parser(TagsParser, "get_config", parsed_output)