Fix import order in tests

The upstream dropped this test long ago, and these tests now break on
Django 3.1+, so I don't want to invest into these tests too much.

LICENSE

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2013-2020 Jan-Jelle Kester
+Copyright (c) 2019-2020 Alieh Rymašeuski <alieh.rymasheuski@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

auditlog/admin.py

@@ -1,10 +1,30 @@
+from django.conf import settings
 from django.contrib import admin
+from django.core.paginator import Paginator
+from django.utils.functional import cached_property
 
-from auditlog.filters import ResourceTypeFilter
+from auditlog.count import limit_query_time
+from auditlog.filters import (
+    FieldFilter,
+    ResourceTypeFilter,
+    ShortActorFilter,
+    get_timestamp_filter,
+)
 from auditlog.mixins import LogEntryAdminMixin
 from auditlog.models import LogEntry
 
 
+class TimeLimitedPaginator(Paginator):
+    """A PostgreSQL-specific paginator with a hard time limit for total count of pages."""
+
+    @cached_property
+    @limit_query_time(
+        getattr(settings, "AUDITLOG_PAGINATOR_TIMEOUT", 500), default=100000
+    )
+    def count(self):
+        return super().count
+
+
 class LogEntryAdmin(admin.ModelAdmin, LogEntryAdminMixin):
     list_display = ["created", "resource_url", "action", "msg_short", "user_url"]
     search_fields = [
@@ -14,12 +34,21 @@ class LogEntryAdmin(admin.ModelAdmin, LogEntryAdminMixin):
         "actor__first_name",
         "actor__last_name",
     ]
-    list_filter = ["action", ResourceTypeFilter]
+    list_filter = [
+        "action",
+        ShortActorFilter,
+        ResourceTypeFilter,
+        FieldFilter,
+        ("timestamp", get_timestamp_filter()),
+    ]
     readonly_fields = ["created", "resource_url", "action", "user_url", "msg"]
     fieldsets = [
         (None, {"fields": ["created", "user_url", "resource_url"]}),
         ("Changes", {"fields": ["action", "msg"]}),
     ]
+    list_select_related = ["actor", "content_type"]
+    show_full_result_count = False
+    paginator = TimeLimitedPaginator
 
 
 admin.site.register(LogEntry, LogEntryAdmin)

auditlog/context.py

@@ -0,0 +1,67 @@
+import contextlib
+import threading
+import time
+from functools import partial
+
+from django.contrib.auth import get_user_model
+from django.db.models.signals import pre_save
+
+from auditlog.models import LogEntry
+
+threadlocal = threading.local()
+
+
+@contextlib.contextmanager
+def set_actor(actor, remote_addr=None):
+    """Connect a signal receiver with current user attached."""
+    # Initialize thread local storage
+    threadlocal.auditlog = {
+        "signal_duid": ("set_actor", time.time()),
+        "remote_addr": remote_addr,
+    }
+
+    # Connect signal for automatic logging
+    set_actor = partial(
+        _set_actor, user=actor, signal_duid=threadlocal.auditlog["signal_duid"]
+    )
+    pre_save.connect(
+        set_actor,
+        sender=LogEntry,
+        dispatch_uid=threadlocal.auditlog["signal_duid"],
+        weak=False,
+    )
+
+    try:
+        yield
+
+    finally:
+        try:
+            auditlog = threadlocal.auditlog
+        except AttributeError:
+            pass
+        else:
+            pre_save.disconnect(sender=LogEntry, dispatch_uid=auditlog["signal_duid"])
+            del threadlocal.auditlog
+
+
+def _set_actor(user, sender, instance, signal_duid, **kwargs):
+    """Signal receiver with extra 'user' and 'signal_duid' kwargs.
+
+    This function becomes a valid signal receiver when it is curried with the actor and a dispatch id.
+    """
+    try:
+        auditlog = threadlocal.auditlog
+    except AttributeError:
+        pass
+    else:
+        if signal_duid != auditlog["signal_duid"]:
+            return
+        auth_user_model = get_user_model()
+        if (
+            sender == LogEntry
+            and isinstance(user, auth_user_model)
+            and instance.actor is None
+        ):
+            instance.actor = user
+
+        instance.remote_addr = auditlog["remote_addr"]

auditlog/count.py

@@ -0,0 +1,23 @@
+from django.db import OperationalError, connection, transaction
+
+
+def limit_query_time(timeout, default=None):
+    """A PostgreSQL-specific decorator with a hard time limit and a default return value.
+
+    Timeout in milliseconds.
+
+    Courtesy of https://medium.com/@hakibenita/optimizing-django-admin-paginator-53c4eb6bfca3
+    """
+
+    def decorator(function):
+        def _limit_query_time(*args, **kwargs):
+            with transaction.atomic(), connection.cursor() as cursor:
+                cursor.execute("SET LOCAL statement_timeout TO %s;", (timeout,))
+                try:
+                    return function(*args, **kwargs)
+                except OperationalError:
+                    return default
+
+        return _limit_query_time
+
+    return decorator

auditlog/filters.py

@@ -1,4 +1,29 @@
+from django.apps import apps
 from django.contrib.admin import SimpleListFilter
+from django.contrib.admin.filters import DateFieldListFilter
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.postgres.fields import JSONField
+from django.db import connection
+from django.db.models import Value
+from django.db.models.functions import Cast, Concat
+
+from auditlog.registry import auditlog
+
+
+class ShortActorFilter(SimpleListFilter):
+    title = "Actor"
+    parameter_name = "actor"
+
+    def lookups(self, request, model_admin):
+        return [("null", "System"), ("not_null", "Users")]
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if value is None:
+            return queryset
+        if value == "null":
+            return queryset.filter(actor__isnull=True)
+        return queryset.filter(actor__isnull=False)
 
 
 class ResourceTypeFilter(SimpleListFilter):
@@ -6,11 +31,68 @@ class ResourceTypeFilter(SimpleListFilter):
     parameter_name = "resource_type"
 
     def lookups(self, request, model_admin):
-        qs = model_admin.get_queryset(request)
-        types = qs.values_list("content_type_id", "content_type__model")
-        return list(types.order_by("content_type__model").distinct())
+        tracked_model_names = [
+            "{}.{}".format(m._meta.app_label, m._meta.model_name)
+            for m in auditlog.get_models()
+        ]
+        model_name_concat = Concat("app_label", Value("."), "model")
+        content_types = ContentType.objects.annotate(
+            model_name=model_name_concat,
+        ).filter(
+            model_name__in=tracked_model_names,
+        )
+        return content_types.order_by("model_name").values_list("id", "model_name")
 
     def queryset(self, request, queryset):
         if self.value() is None:
             return queryset
         return queryset.filter(content_type_id=self.value())
+
+
+class FieldFilter(SimpleListFilter):
+    title = "Field"
+    parameter_name = "field"
+    parent = ResourceTypeFilter
+
+    def __init__(self, request, *args, **kwargs):
+        self.target_model = self._get_target_model(request)
+        super().__init__(request, *args, **kwargs)
+
+    def _get_target_model(self, request):
+        # the parameters consumed by previous filters aren't passed to subsequent filters,
+        # so we have to look into the request parameters explicitly
+        content_type_id = request.GET.get(self.parent.parameter_name)
+        if not content_type_id:
+            return None
+
+        return ContentType.objects.get(id=content_type_id).model_class()
+
+    def lookups(self, request, model_admin):
+        if connection.vendor != "postgresql":
+            # filtering inside JSON is PostgreSQL-specific for now
+            return []
+        if not self.target_model:
+            return []
+        return sorted(
+            (field.name, field.name) for field in self.target_model._meta.fields
+        )
+
+    def queryset(self, request, queryset):
+        if self.value() is None:
+            return queryset
+        return queryset.annotate(changes_json=Cast("changes", JSONField())).filter(
+            **{"changes_json__{}__isnull".format(self.value()): False}
+        )
+
+
+def get_timestamp_filter():
+    """Returns rangefilter filter class if able or a simple list filter as a fallback."""
+    if apps.is_installed("rangefilter"):
+        try:
+            from rangefilter.filter import DateTimeRangeFilter
+
+            return DateTimeRangeFilter
+        except ImportError:
+            pass
+
+    return DateFieldListFilter

auditlog/middleware.py

@@ -1,97 +1,35 @@
-import threading
-import time
-from functools import partial
+import contextlib
 
-from django.apps import apps
-from django.conf import settings
-from django.db.models.signals import pre_save
-from django.utils.deprecation import MiddlewareMixin
-
-from auditlog.models import LogEntry
-
-threadlocal = threading.local()
+from auditlog.context import set_actor
 
 
-class AuditlogMiddleware(MiddlewareMixin):
+@contextlib.contextmanager
+def nullcontext():
+    """Equivalent to contextlib.nullcontext(None) from Python 3.7."""
+    yield
+
+
+class AuditlogMiddleware(object):
     """
     Middleware to couple the request's user to log items. This is accomplished by currying the signal receiver with the
     user from the request (or None if the user is not authenticated).
     """
 
-    def process_request(self, request):
-        """
-        Gets the current user from the request and prepares and connects a signal receiver with the user already
-        attached to it.
-        """
-        # Initialize thread local storage
-        threadlocal.auditlog = {
-            "signal_duid": (self.__class__, time.time()),
-            "remote_addr": request.META.get("REMOTE_ADDR"),
-        }
+    def __init__(self, get_response=None):
+        self.get_response = get_response
+
+    def __call__(self, request):
 
-        # In case of proxy, set 'original' address
         if request.META.get("HTTP_X_FORWARDED_FOR"):
-            threadlocal.auditlog["remote_addr"] = request.META.get(
-                "HTTP_X_FORWARDED_FOR"
-            ).split(",")[0]
+            # In case of proxy, set 'original' address
+            remote_addr = request.META.get("HTTP_X_FORWARDED_FOR").split(",")[0]
+        else:
+            remote_addr = request.META.get("REMOTE_ADDR")
 
-        # Connect signal for automatic logging
-        if hasattr(request, "user") and getattr(
-            request.user, "is_authenticated", False
-        ):
-            set_actor = partial(
-                self.set_actor,
-                user=request.user,
-                signal_duid=threadlocal.auditlog["signal_duid"],
-            )
-            pre_save.connect(
-                set_actor,
-                sender=LogEntry,
-                dispatch_uid=threadlocal.auditlog["signal_duid"],
-                weak=False,
-            )
+        if hasattr(request, "user") and request.user.is_authenticated:
+            context = set_actor(actor=request.user, remote_addr=remote_addr)
+        else:
+            context = nullcontext()
 
-    def process_response(self, request, response):
-        """
-        Disconnects the signal receiver to prevent it from staying active.
-        """
-        if hasattr(threadlocal, "auditlog"):
-            pre_save.disconnect(
-                sender=LogEntry, dispatch_uid=threadlocal.auditlog["signal_duid"]
-            )
-
-        return response
-
-    def process_exception(self, request, exception):
-        """
-        Disconnects the signal receiver to prevent it from staying active in case of an exception.
-        """
-        if hasattr(threadlocal, "auditlog"):
-            pre_save.disconnect(
-                sender=LogEntry, dispatch_uid=threadlocal.auditlog["signal_duid"]
-            )
-
-        return None
-
-    @staticmethod
-    def set_actor(user, sender, instance, signal_duid, **kwargs):
-        """
-        Signal receiver with an extra, required 'user' kwarg. This method becomes a real (valid) signal receiver when
-        it is curried with the actor.
-        """
-        if hasattr(threadlocal, "auditlog"):
-            if signal_duid != threadlocal.auditlog["signal_duid"]:
-                return
-            try:
-                app_label, model_name = settings.AUTH_USER_MODEL.split(".")
-                auth_user_model = apps.get_model(app_label, model_name)
-            except ValueError:
-                auth_user_model = apps.get_model("auth", "user")
-            if (
-                sender == LogEntry
-                and isinstance(user, auth_user_model)
-                and instance.actor is None
-            ):
-                instance.actor = user
-
-            instance.remote_addr = threadlocal.auditlog["remote_addr"]
+        with context:
+            return self.get_response(request)

auditlog/migrations/0004_logentry_detailed_object_repr.py

@@ -1,5 +1,5 @@
 import jsonfield.fields
-from django.db import migrations, models
+from django.db import migrations
 
 
 class Migration(migrations.Migration):

auditlog/migrations/0005_logentry_additional_data_verbose_name.py

@@ -1,5 +1,5 @@
 import jsonfield.fields
-from django.db import migrations, models
+from django.db import migrations
 
 
 class Migration(migrations.Migration):

auditlog/migrations/0008_timestamp_index.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("auditlog", "0007_object_pk_type"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="logentry",
+            name="timestamp",
+            field=models.DateTimeField(
+                auto_now_add=True, db_index=True, verbose_name="timestamp"
+            ),
+        ),
+    ]

auditlog/migrations/0009_timestamp_id_index.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("auditlog", "0008_timestamp_index"),
+    ]
+
+    operations = [
+        migrations.AlterIndexTogether(
+            name="logentry",
+            index_together={("timestamp", "id")},
+        ),
+        migrations.AlterField(
+            model_name="logentry",
+            name="timestamp",
+            field=models.DateTimeField(auto_now_add=True, verbose_name="timestamp"),
+        ),
+    ]

auditlog/mixins.py

@@ -5,6 +5,7 @@ from django.conf import settings
 from django.urls.exceptions import NoReverseMatch
 from django.utils.html import format_html
 from django.utils.safestring import mark_safe
+from django.utils.timezone import localtime
 
 from auditlog.models import LogEntry
 
@@ -13,7 +14,7 @@ MAX = 75
 
 class LogEntryAdminMixin(object):
     def created(self, obj):
-        return obj.timestamp.strftime("%Y-%m-%d %H:%M:%S")
+        return localtime(obj.timestamp).strftime("%Y-%m-%d %H:%M:%S")
 
     created.short_description = "Created"
 

auditlog/models.py

@@ -8,10 +8,10 @@ from django.contrib.contenttypes.fields import GenericRelation
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import FieldDoesNotExist
 from django.db import DEFAULT_DB_ALIAS, models
-from django.db.models import Field, Q, QuerySet
+from django.db.models import Q, QuerySet
 from django.utils import formats, timezone
 from django.utils.encoding import smart_str
-from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import gettext_lazy as _
 from jsonfield.fields import JSONField
 
 
@@ -239,6 +239,7 @@ class LogEntry(models.Model):
         ordering = ["-timestamp"]
         verbose_name = _("log entry")
         verbose_name_plural = _("log entries")
+        index_together = ("timestamp", "id")
 
     def __str__(self):
         if self.action == self.Action.CREATE:
@@ -310,14 +311,9 @@ class LogEntry(models.Model):
             values_display = []
             # handle choices fields and Postgres ArrayField to get human readable version
             choices_dict = None
-            if getattr(field, "choices") and len(field.choices) > 0:
+            if getattr(field, "choices", []):
                 choices_dict = dict(field.choices)
-            if (
-                hasattr(field, "base_field")
-                and isinstance(field.base_field, Field)
-                and getattr(field.base_field, "choices")
-                and len(field.base_field.choices) > 0
-            ):
+            if getattr(getattr(field, "base_field", None), "choices", []):
                 choices_dict = dict(field.base_field.choices)
 
             if choices_dict:
@@ -332,9 +328,7 @@ class LogEntry(models.Model):
                             )
                         else:
                             values_display.append(choices_dict.get(value, "None"))
-                    except ValueError:
-                        values_display.append(choices_dict.get(value, "None"))
-                    except:
+                    except Exception:
                         values_display.append(choices_dict.get(value, "None"))
             else:
                 try:

auditlog/registry.py

@@ -107,6 +107,7 @@ class AuditlogModelRegistry(object):
             self._disconnect_signals(model)
 
     def get_models(self) -> List[ModelBase]:
+        """Get a list of all registered models."""
         return list(self._registry.keys())
 
     def get_model_fields(self, model: ModelBase):

auditlog_tests/test_settings.py

@@ -18,18 +18,20 @@ INSTALLED_APPS = [
     "auditlog_tests",
 ]
 
-MIDDLEWARE = (
+MIDDLEWARE = [
     "django.middleware.common.CommonMiddleware",
     "django.contrib.sessions.middleware.SessionMiddleware",
     "django.contrib.auth.middleware.AuthenticationMiddleware",
     "django.contrib.messages.middleware.MessageMiddleware",
     "auditlog.middleware.AuditlogMiddleware",
-)
+]
 
 DATABASES = {
     "default": {
         "ENGINE": "django.db.backends.postgresql",
-        "NAME": os.getenv("TEST_DB_NAME", "auditlog_tests_db"),
+        "NAME": os.getenv(
+            "TEST_DB_NAME", "auditlog" + os.environ.get("TOX_PARALLEL_ENV", "")
+        ),
         "USER": os.getenv("TEST_DB_USER", "postgres"),
         "PASSWORD": os.getenv("TEST_DB_PASS", ""),
         "HOST": os.getenv("TEST_DB_HOST", "127.0.0.1"),

auditlog_tests/tests.py

@@ -1,17 +1,19 @@
 import datetime
+import itertools
 import json
 
 import django
+import mock
 from dateutil.tz import gettz
 from django.conf import settings
-from django.contrib import auth
+from django.contrib.auth import get_user_model
 from django.contrib.auth.models import AnonymousUser, User
-from django.core.exceptions import ValidationError
+from django.contrib.contenttypes.models import ContentType
 from django.db.models.signals import pre_save
-from django.http import HttpResponse
 from django.test import RequestFactory, TestCase
 from django.utils import dateformat, formats, timezone
 
+from auditlog.context import set_actor
 from auditlog.middleware import AuditlogMiddleware
 from auditlog.models import LogEntry
 from auditlog.registry import auditlog
@@ -36,7 +38,11 @@ from auditlog_tests.models import (
 
 class SimpleModelTest(TestCase):
     def setUp(self):
-        self.obj = SimpleModel.objects.create(text="I am not difficult.")
+        self.obj = self.make_object()
+        super().setUp()
+
+    def make_object(self):
+        return SimpleModel.objects.create(text="I am not difficult.")
 
     def test_create(self):
         """Creation is logged correctly."""
@@ -44,19 +50,16 @@ class SimpleModelTest(TestCase):
         obj = self.obj
 
         # Check for log entries
-        self.assertTrue(obj.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(obj.history.count(), 1, msg="There is one log entry")
 
-        try:
-            history = obj.history.get()
-        except obj.history.DoesNotExist:
-            self.assertTrue(False, "Log entry exists")
-        else:
-            self.assertEqual(
-                history.action, LogEntry.Action.CREATE, msg="Action is 'CREATE'"
-            )
-            self.assertEqual(
-                history.object_repr, str(obj), msg="Representation is equal"
-            )
+        history = obj.history.get()
+        self.check_create_log_entry(obj, history)
+
+    def check_create_log_entry(self, obj, history):
+        self.assertEqual(
+            history.action, LogEntry.Action.CREATE, msg="Action is 'CREATE'"
+        )
+        self.assertEqual(history.object_repr, str(obj), msg="Representation is equal")
 
     def test_update(self):
         """Updates are logged correctly."""
@@ -64,17 +67,23 @@ class SimpleModelTest(TestCase):
         obj = self.obj
 
         # Change something
-        obj.boolean = True
-        obj.save()
+        self.update(obj)
 
         # Check for log entries
-        self.assertTrue(
-            obj.history.filter(action=LogEntry.Action.UPDATE).count() == 1,
+        self.assertEqual(
+            obj.history.filter(action=LogEntry.Action.UPDATE).count(),
+            1,
             msg="There is one log entry for 'UPDATE'",
         )
 
         history = obj.history.get(action=LogEntry.Action.UPDATE)
+        self.check_update_log_entry(obj, history)
 
+    def update(self, obj):
+        obj.boolean = True
+        obj.save()
+
+    def check_update_log_entry(self, obj, history):
         self.assertJSONEqual(
             history.changes,
             '{"boolean": ["False", "True"]}',
@@ -85,39 +94,104 @@ class SimpleModelTest(TestCase):
         """Deletion is logged correctly."""
         # Get the object to work with
         obj = self.obj
-
-        history = obj.history.latest()
+        content_type = ContentType.objects.get_for_model(obj.__class__)
+        pk = obj.pk
 
         # Delete the object
-        obj.delete()
+        self.delete(obj)
 
         # Check for log entries
-        self.assertTrue(
-            LogEntry.objects.filter(
-                content_type=history.content_type,
-                object_pk=history.object_pk,
-                action=LogEntry.Action.DELETE,
-            ).count()
-            == 1,
-            msg="There is one log entry for 'DELETE'",
-        )
+        qs = LogEntry.objects.filter(content_type=content_type, object_pk=pk)
+        self.assertEqual(qs.count(), 1, msg="There is one log entry for 'DELETE'")
+
+        history = qs.get()
+        self.check_delete_log_entry(obj, history)
+
+    def delete(self, obj):
+        obj.delete()
+
+    def check_delete_log_entry(self, obj, history):
+        pass
 
     def test_recreate(self):
-        SimpleModel.objects.all().delete()
+        self.obj.delete()
         self.setUp()
         self.test_create()
 
 
-class AltPrimaryKeyModelTest(SimpleModelTest):
+class NoActorMixin:
+    def check_create_log_entry(self, obj, log_entry):
+        super().check_create_log_entry(obj, log_entry)
+        self.assertIsNone(log_entry.actor)
+
+    def check_update_log_entry(self, obj, log_entry):
+        super().check_update_log_entry(obj, log_entry)
+        self.assertIsNone(log_entry.actor)
+
+    def check_delete_log_entry(self, obj, log_entry):
+        super().check_delete_log_entry(obj, log_entry)
+        self.assertIsNone(log_entry.actor)
+
+
+class WithActorMixin:
+    sequence = itertools.count()
+
     def setUp(self):
-        self.obj = AltPrimaryKeyModel.objects.create(
+        username = "actor_{}".format(next(self.sequence))
+        self.user = get_user_model().objects.create(
+            username=username,
+            email="{}@example.com".format(username),
+            password="secret",
+        )
+        super().setUp()
+
+    def tearDown(self):
+        self.user.delete()
+        super().tearDown()
+
+    def make_object(self):
+        with set_actor(self.user):
+            return super().make_object()
+
+    def check_create_log_entry(self, obj, log_entry):
+        super().check_create_log_entry(obj, log_entry)
+        self.assertEqual(log_entry.actor, self.user)
+
+    def update(self, obj):
+        with set_actor(self.user):
+            return super().update(obj)
+
+    def check_update_log_entry(self, obj, log_entry):
+        super().check_update_log_entry(obj, log_entry)
+        self.assertEqual(log_entry.actor, self.user)
+
+    def delete(self, obj):
+        with set_actor(self.user):
+            return super().delete(obj)
+
+    def check_delete_log_entry(self, obj, log_entry):
+        super().check_delete_log_entry(obj, log_entry)
+        self.assertEqual(log_entry.actor, self.user)
+
+
+class AltPrimaryKeyModelBase(SimpleModelTest):
+    def make_object(self):
+        return AltPrimaryKeyModel.objects.create(
             key=str(datetime.datetime.now()), text="I am strange."
         )
 
 
-class UUIDPrimaryKeyModelModelTest(SimpleModelTest):
-    def setUp(self):
-        self.obj = UUIDPrimaryKeyModel.objects.create(text="I am strange.")
+class AltPrimaryKeyModelTest(NoActorMixin, AltPrimaryKeyModelBase):
+    pass
+
+
+class AltPrimaryKeyModelWithActorTest(WithActorMixin, AltPrimaryKeyModelBase):
+    pass
+
+
+class UUIDPrimaryKeyModelModelBase(SimpleModelTest):
+    def make_object(self):
+        return UUIDPrimaryKeyModel.objects.create(text="I am strange.")
 
     def test_get_for_object(self):
         self.obj.boolean = True
@@ -135,9 +209,27 @@ class UUIDPrimaryKeyModelModelTest(SimpleModelTest):
         )
 
 
-class ProxyModelTest(SimpleModelTest):
-    def setUp(self):
-        self.obj = ProxyModel.objects.create(text="I am not what you think.")
+class UUIDPrimaryKeyModelModelTest(NoActorMixin, UUIDPrimaryKeyModelModelBase):
+    pass
+
+
+class UUIDPrimaryKeyModelModelWithActorTest(
+    WithActorMixin, UUIDPrimaryKeyModelModelBase
+):
+    pass
+
+
+class ProxyModelBase(SimpleModelTest):
+    def make_object(self):
+        return ProxyModel.objects.create(text="I am not what you think.")
+
+
+class ProxyModelTest(NoActorMixin, ProxyModelBase):
+    pass
+
+
+class ProxyModelWithActorTest(WithActorMixin, ProxyModelBase):
+    pass
 
 
 class ManyRelatedModelTest(TestCase):
@@ -167,72 +259,66 @@ class MiddlewareTest(TestCase):
     """
 
     def setUp(self):
-        self.middleware = AuditlogMiddleware()
+        self.get_response_mock = mock.Mock()
+        self.response_mock = mock.Mock()
+        self.middleware = AuditlogMiddleware(get_response=self.get_response_mock)
         self.factory = RequestFactory()
         self.user = User.objects.create_user(
             username="test", email="test@example.com", password="top_secret"
         )
 
+    def side_effect(self, assertion):
+        def inner(request):
+            assertion()
+            return self.response_mock
+
+        return inner
+
+    def assert_has_listeners(self):
+        self.assertTrue(pre_save.has_listeners(LogEntry))
+
+    def assert_no_listeners(self):
+        self.assertFalse(pre_save.has_listeners(LogEntry))
+
     def test_request_anonymous(self):
         """No actor will be logged when a user is not logged in."""
-        # Create a request
         request = self.factory.get("/")
         request.user = AnonymousUser()
 
-        # Run middleware
-        self.middleware.process_request(request)
+        self.get_response_mock.side_effect = self.side_effect(self.assert_no_listeners)
 
-        # Validate result
-        self.assertFalse(pre_save.has_listeners(LogEntry))
+        response = self.middleware(request)
 
-        # Finalize transaction
-        self.middleware.process_exception(request, None)
+        self.assertIs(response, self.response_mock)
+        self.get_response_mock.assert_called_once_with(request)
+        self.assert_no_listeners()
 
     def test_request(self):
         """The actor will be logged when a user is logged in."""
-        # Create a request
-        request = self.factory.get("/")
-        request.user = self.user
-        # Run middleware
-        self.middleware.process_request(request)
-
-        # Validate result
-        self.assertTrue(pre_save.has_listeners(LogEntry))
-
-        # Finalize transaction
-        self.middleware.process_exception(request, None)
-
-    def test_response(self):
-        """The signal will be disconnected when the request is processed."""
-        # Create a request
         request = self.factory.get("/")
         request.user = self.user
 
-        # Run middleware
-        self.middleware.process_request(request)
-        self.assertTrue(
-            pre_save.has_listeners(LogEntry)
-        )  # The signal should be present before trying to disconnect it.
-        self.middleware.process_response(request, HttpResponse())
+        self.get_response_mock.side_effect = self.side_effect(self.assert_has_listeners)
 
-        # Validate result
-        self.assertFalse(pre_save.has_listeners(LogEntry))
+        response = self.middleware(request)
+
+        self.assertIs(response, self.response_mock)
+        self.get_response_mock.assert_called_once_with(request)
+        self.assert_no_listeners()
 
     def test_exception(self):
         """The signal will be disconnected when an exception is raised."""
-        # Create a request
         request = self.factory.get("/")
         request.user = self.user
 
-        # Run middleware
-        self.middleware.process_request(request)
-        self.assertTrue(
-            pre_save.has_listeners(LogEntry)
-        )  # The signal should be present before trying to disconnect it.
-        self.middleware.process_exception(request, ValidationError("Test"))
+        SomeException = type("SomeException", (Exception,), {})
 
-        # Validate result
-        self.assertFalse(pre_save.has_listeners(LogEntry))
+        self.get_response_mock.side_effect = SomeException
+
+        with self.assertRaises(SomeException):
+            self.middleware(request)
+
+        self.assert_no_listeners()
 
 
 class SimpeIncludeModelTest(TestCase):
@@ -241,17 +327,17 @@ class SimpeIncludeModelTest(TestCase):
     def test_register_include_fields(self):
         sim = SimpleIncludeModel(label="Include model", text="Looong text")
         sim.save()
-        self.assertTrue(sim.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(sim.history.count(), 1, msg="There is one log entry")
 
         # Change label, record
         sim.label = "Changed label"
         sim.save()
-        self.assertTrue(sim.history.count() == 2, msg="There are two log entries")
+        self.assertEqual(sim.history.count(), 2, msg="There are two log entries")
 
         # Change text, ignore
         sim.text = "Short text"
         sim.save()
-        self.assertTrue(sim.history.count() == 2, msg="There are two log entries")
+        self.assertEqual(sim.history.count(), 2, msg="There are two log entries")
 
 
 class SimpeExcludeModelTest(TestCase):
@@ -260,17 +346,17 @@ class SimpeExcludeModelTest(TestCase):
     def test_register_exclude_fields(self):
         sem = SimpleExcludeModel(label="Exclude model", text="Looong text")
         sem.save()
-        self.assertTrue(sem.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(sem.history.count(), 1, msg="There is one log entry")
 
         # Change label, ignore
         sem.label = "Changed label"
         sem.save()
-        self.assertTrue(sem.history.count() == 2, msg="There are two log entries")
+        self.assertEqual(sem.history.count(), 2, msg="There are two log entries")
 
         # Change text, record
         sem.text = "Short text"
         sem.save()
-        self.assertTrue(sem.history.count() == 2, msg="There are two log entries")
+        self.assertEqual(sem.history.count(), 2, msg="There are two log entries")
 
 
 class SimpleMappingModelTest(TestCase):
@@ -281,28 +367,32 @@ class SimpleMappingModelTest(TestCase):
             sku="ASD301301A6", vtxt="2.1.5", not_mapped="Not mapped"
         )
         smm.save()
-        self.assertTrue(
-            smm.history.latest().changes_dict["sku"][1] == "ASD301301A6",
+        self.assertEqual(
+            smm.history.latest().changes_dict["sku"][1],
+            "ASD301301A6",
             msg="The diff function retains 'sku' and can be retrieved.",
         )
-        self.assertTrue(
-            smm.history.latest().changes_dict["not_mapped"][1] == "Not mapped",
+        self.assertEqual(
+            smm.history.latest().changes_dict["not_mapped"][1],
+            "Not mapped",
             msg="The diff function does not map 'not_mapped' and can be retrieved.",
         )
-        self.assertTrue(
-            smm.history.latest().changes_display_dict["Product No."][1]
-            == "ASD301301A6",
+        self.assertEqual(
+            smm.history.latest().changes_display_dict["Product No."][1],
+            "ASD301301A6",
             msg="The diff function maps 'sku' as 'Product No.' and can be retrieved.",
         )
-        self.assertTrue(
-            smm.history.latest().changes_display_dict["Version"][1] == "2.1.5",
+        self.assertEqual(
+            smm.history.latest().changes_display_dict["Version"][1],
+            "2.1.5",
             msg=(
                 "The diff function maps 'vtxt' as 'Version' through verbose_name"
                 " setting on the model field and can be retrieved."
             ),
         )
-        self.assertTrue(
-            smm.history.latest().changes_display_dict["not mapped"][1] == "Not mapped",
+        self.assertEqual(
+            smm.history.latest().changes_display_dict["not mapped"][1],
+            "Not mapped",
             msg=(
                 "The diff function uses the django default verbose name for 'not_mapped'"
                 " and can be retrieved."
@@ -326,8 +416,8 @@ class AdditionalDataModelTest(TestCase):
             label="Additional data to log entries", related=related_model
         )
         obj_with_additional_data.save()
-        self.assertTrue(
-            obj_with_additional_data.history.count() == 1, msg="There is 1 log entry"
+        self.assertEqual(
+            obj_with_additional_data.history.count(), 1, msg="There is 1 log entry"
         )
         log_entry = obj_with_additional_data.history.get()
         # FIXME: Work-around for the fact that additional_data isn't working
@@ -337,12 +427,14 @@ class AdditionalDataModelTest(TestCase):
         else:
             extra_data = log_entry.additional_data
         self.assertIsNotNone(extra_data)
-        self.assertTrue(
-            extra_data["related_model_text"] == related_model.text,
+        self.assertEqual(
+            extra_data["related_model_text"],
+            related_model.text,
             msg="Related model's text is logged",
         )
-        self.assertTrue(
-            extra_data["related_model_id"] == related_model.id,
+        self.assertEqual(
+            extra_data["related_model_id"],
+            related_model.id,
             msg="Related model's id is logged",
         )
 
@@ -365,7 +457,7 @@ class DateTimeFieldModelTest(TestCase):
             naive_dt=self.now,
         )
         dtm.save()
-        self.assertTrue(dtm.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(dtm.history.count(), 1, msg="There is one log entry")
 
         # Change timestamp to same datetime and timezone
         timestamp = datetime.datetime(2017, 1, 10, 12, 0, tzinfo=timezone.utc)
@@ -375,7 +467,7 @@ class DateTimeFieldModelTest(TestCase):
         dtm.save()
 
         # Nothing should have changed
-        self.assertTrue(dtm.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(dtm.history.count(), 1, msg="There is one log entry")
 
     def test_model_with_different_timezone(self):
         timestamp = datetime.datetime(2017, 1, 10, 12, 0, tzinfo=timezone.utc)
@@ -389,7 +481,7 @@ class DateTimeFieldModelTest(TestCase):
             naive_dt=self.now,
         )
         dtm.save()
-        self.assertTrue(dtm.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(dtm.history.count(), 1, msg="There is one log entry")
 
         # Change timestamp to same datetime in another timezone
         timestamp = datetime.datetime(2017, 1, 10, 13, 0, tzinfo=self.utc_plus_one)
@@ -397,7 +489,7 @@ class DateTimeFieldModelTest(TestCase):
         dtm.save()
 
         # Nothing should have changed
-        self.assertTrue(dtm.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(dtm.history.count(), 1, msg="There is one log entry")
 
     def test_model_with_different_datetime(self):
         timestamp = datetime.datetime(2017, 1, 10, 12, 0, tzinfo=timezone.utc)
@@ -411,7 +503,7 @@ class DateTimeFieldModelTest(TestCase):
             naive_dt=self.now,
         )
         dtm.save()
-        self.assertTrue(dtm.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(dtm.history.count(), 1, msg="There is one log entry")
 
         # Change timestamp to another datetime in the same timezone
         timestamp = datetime.datetime(2017, 1, 10, 13, 0, tzinfo=timezone.utc)
@@ -419,7 +511,7 @@ class DateTimeFieldModelTest(TestCase):
         dtm.save()
 
         # The time should have changed.
-        self.assertTrue(dtm.history.count() == 2, msg="There are two log entries")
+        self.assertEqual(dtm.history.count(), 2, msg="There are two log entries")
 
     def test_model_with_different_date(self):
         timestamp = datetime.datetime(2017, 1, 10, 12, 0, tzinfo=timezone.utc)
@@ -433,7 +525,7 @@ class DateTimeFieldModelTest(TestCase):
             naive_dt=self.now,
         )
         dtm.save()
-        self.assertTrue(dtm.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(dtm.history.count(), 1, msg="There is one log entry")
 
         # Change timestamp to another datetime in the same timezone
         date = datetime.datetime(2017, 1, 11)
@@ -441,7 +533,7 @@ class DateTimeFieldModelTest(TestCase):
         dtm.save()
 
         # The time should have changed.
-        self.assertTrue(dtm.history.count() == 2, msg="There are two log entries")
+        self.assertEqual(dtm.history.count(), 2, msg="There are two log entries")
 
     def test_model_with_different_time(self):
         timestamp = datetime.datetime(2017, 1, 10, 12, 0, tzinfo=timezone.utc)
@@ -455,7 +547,7 @@ class DateTimeFieldModelTest(TestCase):
             naive_dt=self.now,
         )
         dtm.save()
-        self.assertTrue(dtm.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(dtm.history.count(), 1, msg="There is one log entry")
 
         # Change timestamp to another datetime in the same timezone
         time = datetime.time(6, 0)
@@ -463,7 +555,7 @@ class DateTimeFieldModelTest(TestCase):
         dtm.save()
 
         # The time should have changed.
-        self.assertTrue(dtm.history.count() == 2, msg="There are two log entries")
+        self.assertEqual(dtm.history.count(), 2, msg="There are two log entries")
 
     def test_model_with_different_time_and_timezone(self):
         timestamp = datetime.datetime(2017, 1, 10, 12, 0, tzinfo=timezone.utc)
@@ -477,7 +569,7 @@ class DateTimeFieldModelTest(TestCase):
             naive_dt=self.now,
         )
         dtm.save()
-        self.assertTrue(dtm.history.count() == 1, msg="There is one log entry")
+        self.assertEqual(dtm.history.count(), 1, msg="There is one log entry")
 
         # Change timestamp to another datetime and another timezone
         timestamp = datetime.datetime(2017, 1, 10, 14, 0, tzinfo=self.utc_plus_one)
@@ -485,7 +577,7 @@ class DateTimeFieldModelTest(TestCase):
         dtm.save()
 
         # The time should have changed.
-        self.assertTrue(dtm.history.count() == 2, msg="There are two log entries")
+        self.assertEqual(dtm.history.count(), 2, msg="There are two log entries")
 
     def test_changes_display_dict_datetime(self):
         timestamp = datetime.datetime(2017, 1, 10, 15, 0, tzinfo=timezone.utc)
@@ -500,9 +592,9 @@ class DateTimeFieldModelTest(TestCase):
         )
         dtm.save()
         localized_timestamp = timestamp.astimezone(gettz(settings.TIME_ZONE))
-        self.assertTrue(
-            dtm.history.latest().changes_display_dict["timestamp"][1]
-            == dateformat.format(localized_timestamp, settings.DATETIME_FORMAT),
+        self.assertEqual(
+            dtm.history.latest().changes_display_dict["timestamp"][1],
+            dateformat.format(localized_timestamp, settings.DATETIME_FORMAT),
             msg=(
                 "The datetime should be formatted according to Django's settings for"
                 " DATETIME_FORMAT"
@@ -512,9 +604,9 @@ class DateTimeFieldModelTest(TestCase):
         dtm.timestamp = timestamp
         dtm.save()
         localized_timestamp = timestamp.astimezone(gettz(settings.TIME_ZONE))
-        self.assertTrue(
-            dtm.history.latest().changes_display_dict["timestamp"][1]
-            == dateformat.format(localized_timestamp, settings.DATETIME_FORMAT),
+        self.assertEqual(
+            dtm.history.latest().changes_display_dict["timestamp"][1],
+            dateformat.format(localized_timestamp, settings.DATETIME_FORMAT),
             msg=(
                 "The datetime should be formatted according to Django's settings for"
                 " DATETIME_FORMAT"
@@ -523,9 +615,9 @@ class DateTimeFieldModelTest(TestCase):
 
         # Change USE_L10N = True
         with self.settings(USE_L10N=True, LANGUAGE_CODE="en-GB"):
-            self.assertTrue(
-                dtm.history.latest().changes_display_dict["timestamp"][1]
-                == formats.localize(localized_timestamp),
+            self.assertEqual(
+                dtm.history.latest().changes_display_dict["timestamp"][1],
+                formats.localize(localized_timestamp),
                 msg=(
                     "The datetime should be formatted according to Django's settings for"
                     " USE_L10N is True with a different LANGUAGE_CODE."
@@ -544,9 +636,9 @@ class DateTimeFieldModelTest(TestCase):
             naive_dt=self.now,
         )
         dtm.save()
-        self.assertTrue(
-            dtm.history.latest().changes_display_dict["date"][1]
-            == dateformat.format(date, settings.DATE_FORMAT),
+        self.assertEqual(
+            dtm.history.latest().changes_display_dict["date"][1],
+            dateformat.format(date, settings.DATE_FORMAT),
             msg=(
                 "The date should be formatted according to Django's settings for"
                 " DATE_FORMAT unless USE_L10N is True."
@@ -555,9 +647,9 @@ class DateTimeFieldModelTest(TestCase):
         date = datetime.date(2017, 1, 11)
         dtm.date = date
         dtm.save()
-        self.assertTrue(
-            dtm.history.latest().changes_display_dict["date"][1]
-            == dateformat.format(date, settings.DATE_FORMAT),
+        self.assertEqual(
+            dtm.history.latest().changes_display_dict["date"][1],
+            dateformat.format(date, settings.DATE_FORMAT),
             msg=(
                 "The date should be formatted according to Django's settings for"
                 " DATE_FORMAT unless USE_L10N is True."
@@ -566,9 +658,9 @@ class DateTimeFieldModelTest(TestCase):
 
         # Change USE_L10N = True
         with self.settings(USE_L10N=True, LANGUAGE_CODE="en-GB"):
-            self.assertTrue(
-                dtm.history.latest().changes_display_dict["date"][1]
-                == formats.localize(date),
+            self.assertEqual(
+                dtm.history.latest().changes_display_dict["date"][1],
+                formats.localize(date),
                 msg=(
                     "The date should be formatted according to Django's settings for"
                     " USE_L10N is True with a different LANGUAGE_CODE."
@@ -587,9 +679,9 @@ class DateTimeFieldModelTest(TestCase):
             naive_dt=self.now,
         )
         dtm.save()
-        self.assertTrue(
-            dtm.history.latest().changes_display_dict["time"][1]
-            == dateformat.format(time, settings.TIME_FORMAT),
+        self.assertEqual(
+            dtm.history.latest().changes_display_dict["time"][1],
+            dateformat.format(time, settings.TIME_FORMAT),
             msg=(
                 "The time should be formatted according to Django's settings for"
                 " TIME_FORMAT unless USE_L10N is True."
@@ -598,9 +690,9 @@ class DateTimeFieldModelTest(TestCase):
         time = datetime.time(6, 0)
         dtm.time = time
         dtm.save()
-        self.assertTrue(
-            dtm.history.latest().changes_display_dict["time"][1]
-            == dateformat.format(time, settings.TIME_FORMAT),
+        self.assertEqual(
+            dtm.history.latest().changes_display_dict["time"][1],
+            dateformat.format(time, settings.TIME_FORMAT),
             msg=(
                 "The time should be formatted according to Django's settings for"
                 " TIME_FORMAT unless USE_L10N is True."
@@ -609,9 +701,9 @@ class DateTimeFieldModelTest(TestCase):
 
         # Change USE_L10N = True
         with self.settings(USE_L10N=True, LANGUAGE_CODE="en-GB"):
-            self.assertTrue(
-                dtm.history.latest().changes_display_dict["time"][1]
-                == formats.localize(time),
+            self.assertEqual(
+                dtm.history.latest().changes_display_dict["time"][1],
+                formats.localize(time),
                 msg=(
                     "The time should be formatted according to Django's settings for"
                     " USE_L10N is True with a different LANGUAGE_CODE."
@@ -651,7 +743,7 @@ class UnregisterTest(TestCase):
         obj = self.obj
 
         # Check for log entries
-        self.assertTrue(obj.history.count() == 0, msg="There are no log entries")
+        self.assertEqual(obj.history.count(), 0, msg="There are no log entries")
 
     def test_unregister_update(self):
         """Updates are not logged after unregistering."""
@@ -663,7 +755,7 @@ class UnregisterTest(TestCase):
         obj.save()
 
         # Check for log entries
-        self.assertTrue(obj.history.count() == 0, msg="There are no log entries")
+        self.assertEqual(obj.history.count(), 0, msg="There are no log entries")
 
     def test_unregister_delete(self):
         """Deletion is not logged after unregistering."""
@@ -674,7 +766,7 @@ class UnregisterTest(TestCase):
         obj.delete()
 
         # Check for log entries
-        self.assertTrue(LogEntry.objects.count() == 0, msg="There are no log entries")
+        self.assertEqual(LogEntry.objects.count(), 0, msg="There are no log entries")
 
 
 class ChoicesFieldModelTest(TestCase):
@@ -690,28 +782,30 @@ class ChoicesFieldModelTest(TestCase):
 
     def test_changes_display_dict_single_choice(self):
 
-        self.assertTrue(
-            self.obj.history.latest().changes_display_dict["status"][1] == "Red",
+        self.assertEqual(
+            self.obj.history.latest().changes_display_dict["status"][1],
+            "Red",
             msg="The human readable text 'Red' is displayed.",
         )
         self.obj.status = ChoicesFieldModel.GREEN
         self.obj.save()
-        self.assertTrue(
-            self.obj.history.latest().changes_display_dict["status"][1] == "Green",
+        self.assertEqual(
+            self.obj.history.latest().changes_display_dict["status"][1],
+            "Green",
             msg="The human readable text 'Green' is displayed.",
         )
 
     def test_changes_display_dict_multiplechoice(self):
-        self.assertTrue(
-            self.obj.history.latest().changes_display_dict["multiplechoice"][1]
-            == "Red, Yellow, Green",
+        self.assertEqual(
+            self.obj.history.latest().changes_display_dict["multiplechoice"][1],
+            "Red, Yellow, Green",
             msg="The human readable text 'Red, Yellow, Green' is displayed.",
         )
         self.obj.multiplechoice = ChoicesFieldModel.RED
         self.obj.save()
-        self.assertTrue(
-            self.obj.history.latest().changes_display_dict["multiplechoice"][1]
-            == "Red",
+        self.assertEqual(
+            self.obj.history.latest().changes_display_dict["multiplechoice"][1],
+            "Red",
             msg="The human readable text 'Red' is displayed.",
         )
 
@@ -726,32 +820,32 @@ class CharfieldTextfieldModelTest(TestCase):
         )
 
     def test_changes_display_dict_longchar(self):
-        self.assertTrue(
-            self.obj.history.latest().changes_display_dict["longchar"][1]
-            == "{}...".format(self.PLACEHOLDER_LONGCHAR[:140]),
+        self.assertEqual(
+            self.obj.history.latest().changes_display_dict["longchar"][1],
+            "{}...".format(self.PLACEHOLDER_LONGCHAR[:140]),
             msg="The string should be truncated at 140 characters with an ellipsis at the end.",
         )
         SHORTENED_PLACEHOLDER = self.PLACEHOLDER_LONGCHAR[:139]
         self.obj.longchar = SHORTENED_PLACEHOLDER
         self.obj.save()
-        self.assertTrue(
-            self.obj.history.latest().changes_display_dict["longchar"][1]
-            == SHORTENED_PLACEHOLDER,
+        self.assertEqual(
+            self.obj.history.latest().changes_display_dict["longchar"][1],
+            SHORTENED_PLACEHOLDER,
             msg="The field should display the entire string because it is less than 140 characters",
         )
 
     def test_changes_display_dict_longtextfield(self):
-        self.assertTrue(
-            self.obj.history.latest().changes_display_dict["longtextfield"][1]
-            == "{}...".format(self.PLACEHOLDER_LONGTEXTFIELD[:140]),
+        self.assertEqual(
+            self.obj.history.latest().changes_display_dict["longtextfield"][1],
+            "{}...".format(self.PLACEHOLDER_LONGTEXTFIELD[:140]),
             msg="The string should be truncated at 140 characters with an ellipsis at the end.",
         )
         SHORTENED_PLACEHOLDER = self.PLACEHOLDER_LONGTEXTFIELD[:139]
         self.obj.longtextfield = SHORTENED_PLACEHOLDER
         self.obj.save()
-        self.assertTrue(
-            self.obj.history.latest().changes_display_dict["longtextfield"][1]
-            == SHORTENED_PLACEHOLDER,
+        self.assertEqual(
+            self.obj.history.latest().changes_display_dict["longtextfield"][1],
+            SHORTENED_PLACEHOLDER,
             msg="The field should display the entire string because it is less than 140 characters",
         )
 
@@ -769,26 +863,28 @@ class PostgresArrayFieldModelTest(TestCase):
         return self.obj.history.latest().changes_display_dict["arrayfield"][1]
 
     def test_changes_display_dict_arrayfield(self):
-        self.assertTrue(
-            self.latest_array_change == "Red, Green",
+        self.assertEqual(
+            self.latest_array_change,
+            "Red, Green",
             msg="The human readable text for the two choices, 'Red, Green' is displayed.",
         )
         self.obj.arrayfield = [PostgresArrayFieldModel.GREEN]
         self.obj.save()
-        self.assertTrue(
-            self.latest_array_change == "Green",
+        self.assertEqual(
+            self.latest_array_change,
+            "Green",
             msg="The human readable text 'Green' is displayed.",
         )
         self.obj.arrayfield = []
         self.obj.save()
-        self.assertTrue(
-            self.latest_array_change == "",
-            msg="The human readable text '' is displayed.",
+        self.assertEqual(
+            self.latest_array_change, "", msg="The human readable text '' is displayed."
         )
         self.obj.arrayfield = [PostgresArrayFieldModel.GREEN]
         self.obj.save()
-        self.assertTrue(
-            self.latest_array_change == "Green",
+        self.assertEqual(
+            self.latest_array_change,
+            "Green",
             msg="The human readable text 'Green' is displayed.",
         )
 

docs/source/conf.py

@@ -9,6 +9,7 @@
 import os
 import sys
 from datetime import date
+
 from pkg_resources import get_distribution
 
 # -- Path setup --------------------------------------------------------------
@@ -18,22 +19,23 @@ from pkg_resources import get_distribution
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 
 # Add sources folder
-sys.path.insert(0, os.path.abspath('../../'))
+sys.path.insert(0, os.path.abspath("../../"))
 
 # Setup Django for autodoc
-os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'auditlog_tests.test_settings')
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "auditlog_tests.test_settings")
 import django
+
 django.setup()
 
 # -- Project information -----------------------------------------------------
 
-project = 'django-auditlog'
-author = 'Jan-Jelle Kester and contributors'
-copyright = f'2013-{date.today().year}, {author}'
+project = "django-auditlog"
+author = "Jan-Jelle Kester and contributors"
+copyright = f"2013-{date.today().year}, {author}"
 
-release = get_distribution('django-auditlog').version
+release = get_distribution("django-auditlog").version
 # for example take major/minor
-version = '.'.join(release.split('.')[:2])
+version = ".".join(release.split(".")[:2])
 
 # -- General configuration ---------------------------------------------------
 
@@ -41,27 +43,27 @@ version = '.'.join(release.split('.')[:2])
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.viewcode',
+    "sphinx.ext.autodoc",
+    "sphinx.ext.viewcode",
 ]
 
 # Master document that contains the root table of contents
-master_doc = 'index'
+master_doc = "index"
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 
 # -- Options for HTML output -------------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'sphinx_rtd_theme'
+html_theme = "sphinx_rtd_theme"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.black]
 target-version = ["py36"]
 
-# black compatible isort
 [tool.isort]
 profile = "black"
+known_first_party = "auditlog"

setup.py

@@ -16,13 +16,18 @@ setup(
         "auditlog.management",
         "auditlog.management.commands",
     ],
-    url="https://github.com/jazzband/django-auditlog",
+    url="https://github.com/MacmillanPlatform/django-auditlog/",
     license="MIT",
     author="Jan-Jelle Kester",
+    maintainer="Alieh Rymašeŭski",
     description="Audit log app for Django",
     long_description=long_description,
     long_description_content_type="text/markdown",
-    install_requires=["django-jsonfield>=1.0.0", "python-dateutil>=2.6.0"],
+    install_requires=[
+        "django-admin-rangefilter>=0.5.0",
+        "django-jsonfield>=1.0.0",
+        "python-dateutil>=2.6.0",
+    ],
     zip_safe=False,
     classifiers=[
         "Programming Language :: Python :: 3",

tox.ini

@@ -5,6 +5,8 @@ envlist =
     py38-qa
 
 [testenv]
+setenv =
+  COVERAGE_FILE={toxworkdir}/.coverage.{envname}
 commands =
     coverage run --source auditlog runtests.py
     coverage xml
@@ -15,7 +17,9 @@ deps =
     # Test requirements
     coverage
     codecov
-    psycopg2-binary
+    django-multiselectfield
+    mock
+    psycopg2-binary>=2.8,<2.9
 passenv=
     TEST_DB_HOST
     TEST_DB_USER