Reorganize test folder

mqueue/tests/test_admin.py

@@ -0,0 +1,27 @@
+from django.test import TestCase
+from django.contrib import admin
+from .base import MqueueBaseTest
+from mqueue.models import MEvent
+from mqueue.admin import link_to_object, link_to_object_admin, MEventAdmin
+
+
+class MqueueTestAdmin(MqueueBaseTest):
+
+    def test_admin(self):
+        instance, _ = MEvent.objects.get_or_create(name="Event name",
+                                                   url="http://url",
+                                                   admin_url="http://admin_url")
+        res = link_to_object(instance)
+        link = '<a href="http://url" target="_blank">http://url</a>'
+        self.assertEqual(link, res)
+        res = link_to_object_admin(instance)
+        link = '<a href="http://admin_url" target="_blank">http://admin_url</a>'
+        self.assertEqual(link, res)
+        request = self.factory.get('/')
+
+        class TestAdminSite(admin.AdminSite):
+            pass
+
+        adm = MEventAdmin(MEvent, TestAdminSite)
+        res = adm.get_readonly_fields(request)
+        self.assertEqual(res, ('notes', 'request'))

mqueue/tests/test_apps.py

@@ -0,0 +1,15 @@
+from django.test import TestCase
+from .base import MqueueBaseTest
+from django.apps import apps
+
+
+class MqueueTestApps(MqueueBaseTest):
+
+    def test_apps(self):
+        apps.get_app_config('mqueue')
+
+    def test_apps_import_error(self):
+        req = (('wrong.model.path', ["c", "d", "u"]),)
+        with self.settings(MQUEUE_AUTOREGISTER=req):
+            apps.get_app_config('mqueue')
+            self.assertRaises(ImportError)

mqueue/tests/test_create.py

@@ -0,0 +1,61 @@
+from django.test import TestCase
+from .base import MqueueBaseTest
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.auth.models import User
+from mqueue.models import MEvent
+
+
+class MqueueTestCreate(MqueueBaseTest):
+
+    def create_mevent(self, name="M event", url='/', obj_pk=1, notes='Notes'):
+        self._content_type = ContentType.objects.get_for_model(User)
+        return MEvent.objects.create(name=name, url=url, obj_pk=obj_pk, notes=notes,
+                                     model=User, content_type=self._content_type)
+
+    def test_mevent_creation(self):
+        mevent = self.create_mevent()
+        self.assertTrue(isinstance(mevent, MEvent))
+        self.assertEqual(mevent.content_type, self._content_type)
+        self.assertEqual(mevent.url, "/")
+        self.assertEqual(mevent.name, "M event")
+        self.assertEqual(mevent.obj_pk, 1)
+        self.assertEqual(mevent.notes, "Notes")
+        self.assertEqual(mevent.__unicode__(), mevent.name +
+                         ' - ' + str(mevent.date_posted))
+
+    def test_create_mevent_empty(self):
+        self.assertRaises(ValueError, MEvent.objects.create, 'name')
+
+    def test_mevent_creation_with_user(self):
+        self._content_type = ContentType.objects.get_for_model(User)
+        self.reset()
+        user = self.user
+        mevent = MEvent.objects.create(
+            name='M Event', instance=user, user=user)
+        self.assertTrue(isinstance(mevent, MEvent))
+        self.assertEqual(mevent.content_type, self._content_type)
+        self.assertEqual(mevent.obj_pk, 1)
+        self.assertEqual(mevent.user, user)
+        self.reset()
+
+    def test_event_creation_more(self):
+        request = self.factory.get('/')
+        mevent = MEvent.objects.create(
+            name='123',
+            scope="superuser",
+            bucket="sup",
+            request=request,
+            data={"k": "v"},
+            admin_url="http://admin",
+        )
+        self.assertTrue(isinstance(mevent, MEvent))
+        self.assertEqual(mevent.name, "123")
+        self.assertEqual(mevent.scope, "superuser")
+        self.assertEqual(mevent.bucket, "sup")
+        self.assertEqual(mevent.admin_url, "http://admin")
+        formated_request = ""
+        for key in request.META.keys():
+            formated_request += str(key) + ' : ' + \
+                str(request.META[key]) + '\n'
+        self.assertEqual(mevent.request, formated_request)
+        self.assertEqual(mevent.data, {"k": "v"})

mqueue/tests/test_graphql_api.py

@@ -0,0 +1,29 @@
+from django.test import TestCase
+from .base import MqueueBaseTest
+from graphene.test import Client
+from mqueue.schema import schema
+from mqueue.models import MEvent
+
+
+client = Client(schema)
+
+
+class MqueueTestGraphqlApi(MqueueBaseTest):
+
+    """
+    # TOFIX
+    def test_graphql_query(self):
+        self.reset()
+        MEvent.objects.create(name="Test public event", scope="public")
+        query = '''query publicEvents(first:10) {
+                edges {
+                    node {
+                        name
+                        event_class
+                    }
+                }
+            }
+        '''
+        res = [{"name": "Test public event"}]
+        self.assertEqual(client.execute(query), res)
+        """

mqueue/tests/test_logging.py

@@ -0,0 +1,22 @@
+import logging
+from unittest.mock import patch
+from django.test import TestCase
+from .base import MqueueBaseTest
+from mqueue.models import MEvent
+
+
+class MqueueTestLogging(MqueueBaseTest):
+
+    """
+
+    # TOFIX
+
+    @patch('mqueue.logging.DEV_LOGGING')
+    def test_mqueue_logging(self, mock_logging):
+        from mqueue.logging import DEV_LOGGING, LOGGING_WARNING
+        logger = logging.getLogger('mqueue.logging.DEV_LOGGING')
+        logger.debug('debug logged')
+        logger.info('info logged')
+        logger.warning('warning logged')
+        logger.critical('critical logged')
+        self.assertTrue(mock_logging.warn.called)"""

mqueue/tests/test_managers.py

@@ -0,0 +1,45 @@
+from django.test import TestCase
+from .base import MqueueBaseTest
+from django.contrib.auth.models import User
+from mqueue.models import MEvent
+
+
+class MqueueTestManagers(MqueueBaseTest):
+
+    def test_managers(self):
+        self.reset()
+        user = self.user
+        mevent1 = MEvent.objects.create(name="event1", model=User)
+        mevent2 = MEvent.objects.create(name="event2", instance=user)
+        self.assertEqual(
+            list(
+                MEvent.objects.events_for_model(User)), [
+                mevent2, mevent1])
+        self.assertEqual(MEvent.objects.count_for_model(User), 2)
+        self.assertEqual(
+            list(
+                MEvent.objects.events_for_object(user)),
+            [mevent2])
+        return
+
+    def test_managers_with_event_class(self):
+        self.reset()
+        user = self.user
+        mevent1 = MEvent.objects.create(
+            name="event1", model=User, event_class="class1")
+        mevent2 = MEvent.objects.create(
+            name="event2", instance=user, event_class="class2")
+        self.assertEqual(
+            list(
+                MEvent.objects.events_for_model(
+                    User,
+                    event_classes=["class1"])),
+            [mevent1])
+        self.assertEqual(
+            MEvent.objects.count_for_model(
+                User, event_classes=["class2"]), 1)
+        self.assertEqual(
+            list(
+                MEvent.objects.events_for_object(user)),
+            [mevent2])
+        return

mqueue/tests/test_signals.py

@@ -0,0 +1,28 @@
+from unittest.mock import patch
+from django.test import TestCase
+from .base import MqueueBaseTest
+from django.contrib.auth.models import User
+from mqueue.models import MEvent
+from mqueue.tracking import mqueue_tracker
+from mqueue.signals import mmessage_create
+
+
+class MqueueTestSignals(MqueueBaseTest):
+
+    def test_register(self):
+        mqueue_tracker.register(User, ["c"])
+        mqueue_tracker.register(User, ["u"])
+        mqueue_tracker.register(User, ["d"])
+
+    """
+    TOFIX
+
+    @patch('mqueue.signals.mmessage_create')
+    def test_signal_create(self, mock):
+        mqueue_tracker.register(User, ["c", "u", "d"])
+        User.objects.create_user(
+            'myuser2', 'myemail2@test.com', 'super_password')
+        self.assertTrue(mock.called)
+        self.assertEqual(mock.call_count, 1)
+
+    """

mqueue/tests/test_utils.py

@@ -0,0 +1,159 @@
+from django.test import TestCase
+from .base import MqueueBaseTest
+from mqueue.models import MEvent
+from mqueue.utils import get_event_class_str, get_object_name, get_url, format_event_class
+from mqueue.conf import EVENT_CLASSES, EVENT_ICONS_HTML
+
+
+class MqueueTestUtils(MqueueBaseTest):
+
+    def test_utils_get_event_class_str(self):
+        event_class = "Obj created"
+        self.assertEqual(get_event_class_str(event_class), "Object created")
+        event_class = "Obj edited"
+        self.assertEqual(get_event_class_str(event_class), "Object edited")
+        event_class = "Obj deleted"
+        self.assertEqual(get_event_class_str(event_class), "Object deleted")
+        event_class = None
+        self.assertEqual(get_event_class_str(event_class), "Default")
+
+    def test_utils_get_object_name(self):
+        self.reset()
+        # test unicode method
+        instance, _ = MEvent.objects.get_or_create(name="Event name")
+        user = self.user
+        object_name = get_object_name(instance, user)
+        res = instance.__class__.__name__ + ' - ' + \
+            str(instance.date_posted) + ' (' + user.username + ')'
+        self.assertEqual(object_name, res)
+        # test name
+        MEvent.objects.create(name='123')
+        instance = MEvent.objects.get(name='123')
+        res = instance.__class__.__name__ + ' - ' + \
+            str(instance.date_posted) + ' (' + user.username + ')'
+        object_name = get_object_name(instance, user)
+        self.assertEqual(object_name, res)
+        self.reset()
+
+        #app = MqueueConfig("mqueue", mqueue)
+        # app.ready()
+
+    """def test_utils_get_url(self):
+        # test from absolute url
+        instance, created = MEvent.objects.get_or_create(name='123')
+        url = get_url(instance)
+        self.assertEqual(url, "http://absoluteurl")
+        # test from custom method
+        instance, created = MEvent.objects.get_or_create(title='123')
+        url = get_url(instance)
+        self.assertEqual(url, "http://eventurl")"""
+
+    def test_utils_format_event_class(self):
+        # test with obj
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class="Default")
+        event_class_formated = format_event_class(instance)
+        icon = EVENT_ICONS_HTML[instance.event_class] + ' '
+        html = '<span class="' + \
+            EVENT_CLASSES[instance.event_class] + '">' + \
+            icon + instance.event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        # test with event_class
+        event_class = "Default"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        icon = EVENT_ICONS_HTML[event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[event_class] + '">' + icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Myobj created"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Object created'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Myobj edited"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Object edited'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Myobj deleted"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Object deleted'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Random event class"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Default'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Some error event"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Error'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Some debug event"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Debug'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Some warning event"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Warning'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Some info event"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Info'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)
+        event_class = "Some important event"
+        instance, created = MEvent.objects.get_or_create(
+            name="Event name", event_class=event_class)
+        event_class_formated = format_event_class(event_class=event_class)
+        res_event_class = 'Important'
+        icon = EVENT_ICONS_HTML[res_event_class] + '&nbsp;'
+        html = '<span class="' + \
+            EVENT_CLASSES[res_event_class] + '">' + \
+            icon + event_class + '</span>'
+        self.assertEqual(event_class_formated, html)