Fix tests coverage

 - Add tool to find missing files in coverage report.
 - Add packages to coverage source config, to fix the issues with the
   namespace packages.
 - Add missing __init__.py files for the inventory, okta and wsone
   management commands packages to facilitate the coverage discovery.
 - Add missing store test cases
 - Add all missing actions to tests base.json

Author: np5

ee/zentral/contrib/wsone/management/__init__.py

@@ -8,8 +8,10 @@
     "metrics_bearer_token": "CHANGE ME!!!"
   },
   "extra_links": [
-    {"anchor_text": "Prometheus",
-     "url": "https://zentral/prometheus/"}
+    {
+      "anchor_text": "Prometheus",
+      "url": "https://zentral/prometheus/"
+    }
   ],
   "django": {
     "SECRET_KEY": "DJANGO SECRET !!! CHANGE THIS !!! DO NOT USE IN PRODUCTION !!!",
@@ -46,6 +48,70 @@
     "debug": {
       "backend": "zentral.core.actions.backends.json_file",
       "local_dir": "/tmp/zentral_notifications/"
+    },
+    "test_email": {
+      "backend": "zentral.core.actions.backends.email",
+      "smtp_host": "127.0.0.1",
+      "smtp_port": 25,
+      "recipients": [
+        "hi@example.com"
+      ]
+    },
+    "test_freshdesk": {
+      "backend": "zentral.core.actions.backends.freshdesk",
+      "api_key": "123",
+      "password": "456",
+      "subdomain": "test",
+      "default_ticket_email": "hi@example.com",
+      "extra_attributes": {
+        "un": "deux"
+      }
+    },
+    "test_google_chat": {
+      "backend": "zentral.core.actions.backends.google_chat",
+      "webhook": "https://example.com"
+    },
+    "test_http_post": {
+      "backend": "zentral.core.actions.backends.http_post",
+      "url": "https://example.com",
+      "basic_auth": {
+        "login": "user",
+        "password": "123"
+      },
+      "headers": {
+        "X-Custom-Header": "value"
+      }
+    },
+    "test_slack": {
+      "backend": "zentral.core.actions.backends.slack",
+      "webhook": "https://example.com"
+    },
+    "test_github": {
+      "backend": "zentral.core.actions.backends.github",
+      "repository": "example",
+      "user": "user",
+      "access_token": "123",
+      "assignees": [
+        "person1",
+        "person2"
+      ]
+    },
+    "test_trello": {
+      "backend": "zentral.core.actions.backends.trello",
+      "application_key": "123",
+      "token": "456",
+      "default_board": "default_board",
+      "default_list": "default_list"
+    },
+    "test_twilio": {
+      "backend": "zentral.core.actions.backends.twilio",
+      "account_sid": "123",
+      "auth_token": "456",
+      "from_number": "0123456789",
+      "to_numbers": [
+        "1234567890",
+        "2345678901"
+      ]
     }
   },
   "apps": {
@@ -93,19 +159,29 @@
     "zentral.contrib.munki": {
       "metrics": true,
       "principal_user_detection": {
-        "sources": ["company_portal", "google_chrome", "logged_in_user"],
-        "domains": ["zentral.pro"]
+        "sources": [
+          "company_portal",
+          "google_chrome",
+          "logged_in_user"
+        ],
+        "domains": [
+          "zentral.pro"
+        ]
       }
     },
     "zentral.contrib.monolith": {
       "metrics": true,
       "enrollment_package_builders": {
         "zentral.contrib.munki.osx_package.builder.MunkiZentralEnrollPkgBuilder": {
-          "requires": ["munkitools_core"],
+          "requires": [
+            "munkitools_core"
+          ],
           "optional": false
         },
         "zentral.contrib.osquery.osx_package.builder.OsqueryZentralEnrollPkgBuilder": {
-          "requires": ["osquery"],
+          "requires": [
+            "osquery"
+          ],
           "optional": true
         }
       },

ee/zentral/contrib/wsone/management/commands/__init__.py

@@ -0,0 +1,69 @@
+from unittest.mock import Mock
+from django.test import SimpleTestCase
+from django.utils.crypto import get_random_string
+from accounts.events import EventMetadata, LoginEvent
+from zentral.core.stores.backends.datadog import EventStore
+
+
+class DatadogStoreTestCase(SimpleTestCase):
+    def get_store(self, **kwargs):
+        for arg, default in (("store_name", get_random_string(12)),
+                             ("site", "datadoghq.com"),
+                             ("service", None),
+                             ("source", None),
+                             ("api_key", "123"),
+                             ("application_key", "456")):
+            val = kwargs.get(arg)
+            if val is None and default is not None:
+                kwargs[arg] = default
+        return EventStore(kwargs)
+
+    def build_login_event(self, username=None):
+        if username is None:
+            username = get_random_string(12)
+        return LoginEvent(EventMetadata(), {"user": {"username": username}})
+
+    def test_event_serialization(self):
+        username = get_random_string(12)
+        event = self.build_login_event(username)
+        self.assertEqual(
+            self.get_store()._serialize_event(event),
+            {'@timestamp': event.metadata.created_at.isoformat(),
+             'ddsource': 'zentral',
+             'ddtags': 'ztl-tag:zentral',
+             'host': 'Zentral',
+             'id': str(event.metadata.uuid),
+             'index': 0,
+             'logger': {'name': 'zentral_login'},
+             'namespace': 'zentral',
+             'service': 'Zentral',
+             'zentral': {'user': {'username': username}}}
+        )
+
+    def test_dict_event_serialization(self):
+        username = get_random_string(12)
+        event = self.build_login_event(username)
+        self.assertEqual(
+            self.get_store()._serialize_event(event.serialize()),
+            {'@timestamp': event.metadata.created_at.isoformat(),
+             'ddsource': 'zentral',
+             'ddtags': 'ztl-tag:zentral',
+             'host': 'Zentral',
+             'id': str(event.metadata.uuid),
+             'index': 0,
+             'logger': {'name': 'zentral_login'},
+             'namespace': 'zentral',
+             'service': 'Zentral',
+             'zentral': {'user': {'username': username}}}
+        )
+
+    def test_store(self):
+        mock_response = Mock()
+        mock_response.raise_for_status.return_value = None
+        mock_post = Mock(return_value=mock_response)
+        store = self.get_store()
+        store._session.post = mock_post
+        event = self.build_login_event()
+        store.store(event)
+        mock_post.assert_called_once()
+        mock_response.raise_for_status.assert_called_once()

tests/conf/base.json

@@ -0,0 +1,62 @@
+from unittest.mock import Mock
+from django.test import SimpleTestCase
+from django.utils.crypto import get_random_string
+from accounts.events import EventMetadata, LoginEvent
+from zentral.core.stores.backends.http import EventStore
+
+
+class HttpStoreTestCase(SimpleTestCase):
+    def get_store(self, **kwargs):
+        for arg, default in (("store_name", get_random_string(12)),
+                             ("endpoint_url", "https://example.com"),
+                             ("verify_tls", None),
+                             ("headers", None),
+                             ("username", None),
+                             ("password", None)):
+            val = kwargs.get(arg)
+            if val is None and default is not None:
+                kwargs[arg] = default
+        return EventStore(kwargs)
+
+    def build_login_event(self, username=None):
+        if username is None:
+            username = get_random_string(12)
+        return LoginEvent(EventMetadata(), {"user": {"username": username}})
+
+    def test_event_serialization(self):
+        username = get_random_string(12)
+        event = self.build_login_event(username)
+        self.assertEqual(
+            self.get_store().client._serialize_event(event),
+            {'created_at': event.metadata.created_at.isoformat(),
+             'id': str(event.metadata.uuid),
+             'index': 0,
+             'namespace': 'zentral',
+             'tags': ['zentral'],
+             'type': 'zentral_login',
+             'zentral': {'user': {'username': username}}}
+        )
+
+    def test_dict_event_serialization(self):
+        username = get_random_string(12)
+        event = self.build_login_event(username)
+        self.assertEqual(
+            self.get_store().client._serialize_event(event.serialize()),
+            {'created_at': event.metadata.created_at.isoformat(),
+             'id': str(event.metadata.uuid),
+             'index': 0,
+             'namespace': 'zentral',
+             'tags': ['zentral'],
+             'type': 'zentral_login',
+             'zentral': {'user': {'username': username}}}
+        )
+
+    def test_store(self):
+        mock_response = Mock()
+        mock_response.ok = True
+        mock_post = Mock(return_value=mock_response)
+        store = self.get_store()
+        store.client.session.post = mock_post
+        event = self.build_login_event()
+        store.store(event)
+        mock_post.assert_called_once()

tests/stores/test_datadog.py

@@ -0,0 +1,60 @@
+from unittest.mock import Mock
+from django.test import SimpleTestCase
+from django.utils.crypto import get_random_string
+from accounts.events import EventMetadata, LoginEvent
+from zentral.core.stores.backends.humio import EventStore
+
+
+class HumioStoreTestCase(SimpleTestCase):
+    def get_store(self, **kwargs):
+        for arg, default in (("store_name", get_random_string(12)),
+                             ("base_url", "https://example.com"),
+                             ("ingest_token", "123")):
+            val = kwargs.get(arg)
+            if val is None and default is not None:
+                kwargs[arg] = default
+        return EventStore(kwargs)
+
+    def build_login_event(self, username=None):
+        if username is None:
+            username = get_random_string(12)
+        return LoginEvent(EventMetadata(), {"user": {"username": username}})
+
+    def test_event_serialization(self):
+        username = get_random_string(12)
+        event = self.build_login_event(username)
+        self.assertEqual(
+            self.get_store()._serialize_event(event),
+            [{'events': [{'attributes': {'id': str(event.metadata.uuid),
+                                         'index': 0,
+                                         'namespace': 'zentral',
+                                         'tags': ['zentral'],
+                                         'zentral': {'user': {'username': username}}},
+                          'timestamp': event.metadata.created_at.isoformat()[:-3] + "Z"}],
+              'tags': {'event_type': 'zentral_login'}}]
+        )
+
+    def test_dict_event_serialization(self):
+        username = get_random_string(12)
+        event = self.build_login_event(username)
+        self.assertEqual(
+            self.get_store()._serialize_event(event.serialize()),
+            [{'events': [{'attributes': {'id': str(event.metadata.uuid),
+                                         'index': 0,
+                                         'namespace': 'zentral',
+                                         'tags': ['zentral'],
+                                         'zentral': {'user': {'username': username}}},
+                          'timestamp': event.metadata.created_at.isoformat()[:-3] + "Z"}],
+              'tags': {'event_type': 'zentral_login'}}]
+        )
+
+    def test_store(self):
+        mock_response = Mock()
+        mock_response.raise_for_status.return_value = None
+        mock_post = Mock(return_value=mock_response)
+        store = self.get_store()
+        store._session.post = mock_post
+        event = self.build_login_event()
+        store.store(event)
+        mock_post.assert_called_once()
+        mock_response.raise_for_status.assert_called_once()

tests/stores/test_http.py

@@ -0,0 +1,33 @@
+from unittest.mock import Mock
+from django.test import SimpleTestCase
+from django.utils.crypto import get_random_string
+from accounts.events import EventMetadata, LoginEvent
+from zentral.core.stores.backends.kinesis import EventStore
+
+
+class KinesisStoreTestCase(SimpleTestCase):
+    def get_store(self, **kwargs):
+        for arg, default in (("store_name", get_random_string(12)),
+                             ("stream", "123"),
+                             ("region_name", "us-east1"),
+                             ("aws_access_key_id", "123"),
+                             ("aws_secret_access_key", "456")):
+            val = kwargs.get(arg)
+            if val is None and default is not None:
+                kwargs[arg] = default
+        return EventStore(kwargs)
+
+    def build_login_event(self, username=None):
+        if username is None:
+            username = get_random_string(12)
+        return LoginEvent(EventMetadata(), {"user": {"username": username}})
+
+    def test_store(self):
+        store = self.get_store()
+        store.wait_and_configure_if_necessary()
+        mock_client = Mock()
+        mock_client.put_record.return_value = None
+        store.client = mock_client
+        event = self.build_login_event()
+        store.store(event)
+        mock_client.put_record.assert_called_once()

tests/stores/test_humio.py

@@ -0,0 +1,38 @@
+from unittest.mock import Mock, patch
+from django.test import SimpleTestCase
+from django.utils.crypto import get_random_string
+from accounts.events import EventMetadata, LoginEvent
+from zentral.core.stores.backends.syslog import EventStore
+
+
+class SyslogStoreTestCase(SimpleTestCase):
+    def get_store(self, **kwargs):
+        for arg, default in (("store_name", get_random_string(12)),
+                             ("priority", None),
+                             ("facility", None),
+                             ("prepend_ecc", None),
+                             ("protocol", None),
+                             ("host", None),
+                             ("port", None)):
+            val = kwargs.get(arg)
+            if val is None and default is not None:
+                kwargs[arg] = default
+        return EventStore(kwargs)
+
+    def build_login_event(self, username=None):
+        if username is None:
+            username = get_random_string(12)
+        return LoginEvent(EventMetadata(), {"user": {"username": username}})
+
+    @patch("zentral.core.stores.backends.syslog.socket")
+    def test_store(self, syslog_socket):
+        mock_socket = Mock()
+        mock_socket.connect.return_value = None
+        mock_socket.send.return_value = None
+        syslog_socket.socket.return_value = mock_socket
+        store = self.get_store()
+        store.wait_and_configure_if_necessary()
+        event = self.build_login_event()
+        store.store(event)
+        mock_socket.connect.assert_called_once()
+        mock_socket.send.assert_called_once()