django-field-audit 1.2.8__tar.gz → 1.2.9__tar.gz

{django-field-audit-1.2.8 → django_field_audit-1.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: django-field-audit
-Version: 1.2.8
+Version: 1.2.9
 Summary: Audit Field Changes on Django Models
 Home-page: https://github.com/dimagi/django-field-audit
 Maintainer: Joel Miller
@@ -26,6 +26,14 @@ Classifier: Framework :: Django :: 4.2
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: summary
 
 # Audit Field Changes on Django Models
 

{django-field-audit-1.2.8 → django_field_audit-1.2.9}/django_field_audit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: django-field-audit
-Version: 1.2.8
+Version: 1.2.9
 Summary: Audit Field Changes on Django Models
 Home-page: https://github.com/dimagi/django-field-audit
 Maintainer: Joel Miller
@@ -26,6 +26,14 @@ Classifier: Framework :: Django :: 4.2
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: summary
 
 # Audit Field Changes on Django Models
 

{django-field-audit-1.2.8 → django_field_audit-1.2.9}/django_field_audit.egg-info/SOURCES.txt

@@ -19,4 +19,12 @@ field_audit/management/commands/__init__.py
 field_audit/management/commands/bootstrap_field_audit_events.py
 field_audit/migrations/0001_initial.py
 field_audit/migrations/0002_add_is_bootstrap_column.py
-field_audit/migrations/__init__.py
+field_audit/migrations/__init__.py
+tests/test_apps.py
+tests/test_auditors.py
+tests/test_bootstrap_field_audit_events.py
+tests/test_django_compat.py
+tests/test_field_audit.py
+tests/test_middleware.py
+tests/test_models.py
+tests/test_utils.py

{django-field-audit-1.2.8 → django_field_audit-1.2.9}/field_audit/__init__.py

@@ -1,3 +1,3 @@
 from .field_audit import audit_fields  # noqa: F401
 
-__version__ = "1.2.8"
+__version__ = "1.2.9"

{django-field-audit-1.2.8 → django_field_audit-1.2.9}/field_audit/auditors.py

@@ -107,7 +107,7 @@ class SystemUserAuditor(BaseAuditor):
             try:
                 # get owner of STDIN file on login sessions (e.g. SSH)
                 output = check_output(["who", "-m"], stderr=DEVNULL)
-            except CalledProcessError:
+            except (FileNotFoundError, CalledProcessError):
                 self.has_who_bin = False
             else:
                 if output:

{django-field-audit-1.2.8 → django_field_audit-1.2.9}/setup.cfg

@@ -6,7 +6,9 @@ license_file = LICENSE
 
 [flake8]
 max-line-length = 80
-exclude = ./build
+exclude = 
+	./build
+	.venv
 
 [egg_info]
 tag_build = 

django_field_audit-1.2.9/tests/test_apps.py

@@ -0,0 +1,18 @@
+from django.apps import apps
+from django.test import TestCase
+
+from field_audit.auditors import audit_dispatcher
+
+
+class TestFieldAuditConfig(TestCase):
+
+    def test_config_ready_sets_auditors(self):
+        # ensure it's not empty already
+        self.assertNotEqual([], audit_dispatcher.auditors)
+        try:
+            audit_dispatcher.auditors = []
+            apps.get_app_config("field_audit").ready()
+            self.assertNotEqual([], audit_dispatcher.auditors)
+        finally:
+            # reset to defaults
+            audit_dispatcher.setup_auditors()

django_field_audit-1.2.9/tests/test_auditors.py

@@ -0,0 +1,238 @@
+from subprocess import CalledProcessError
+from unittest.mock import patch
+
+from django.conf import settings
+from django.test import TestCase
+from django.test.utils import override_settings
+
+from field_audit.auditors import (
+    BaseAuditor,
+    RequestAuditor,
+    SystemUserAuditor,
+    audit_dispatcher,
+)
+from field_audit.models import (
+    USER_TYPE_PROCESS,
+    USER_TYPE_REQUEST,
+    USER_TYPE_TTY,
+)
+
+
+class TestAuditDispatcher(TestCase):
+
+    def setUp(self):
+        # reset the auditor chain to default values
+        audit_dispatcher.setup_auditors()
+
+    def test_audit_dispatcher_default_auditor_chain(self):
+        with self.assertRaises(AttributeError):
+            getattr(settings, "FIELD_AUDIT_AUDITORS")
+        request_auditor, sysuser_auditor = audit_dispatcher.auditors
+        self.assertIsInstance(request_auditor, RequestAuditor)
+        self.assertIsInstance(sysuser_auditor, SystemUserAuditor)
+
+    @override_settings(
+        FIELD_AUDIT_AUDITORS=[
+            "tests.test_auditors.CustomAuditor1",
+            "tests.test_auditors.CustomAuditor2",
+            "tests.test_auditors.CustomAuditor3",
+        ],
+    )
+    def test_audit_dispatcher_auditor_chain_is_configurable(self):
+        audit_dispatcher.setup_auditors()
+        one, two, three = audit_dispatcher.auditors
+        self.assertIsInstance(one, CustomAuditor1)
+        self.assertIsInstance(two, CustomAuditor2)
+        self.assertIsInstance(three, CustomAuditor3)
+
+    @override_settings(FIELD_AUDIT_AUDITORS=[])
+    def test_audit_dispatcher_setting_empty_auditor_chain_clears_auditors(self):
+        audit_dispatcher.setup_auditors()
+        self.assertEqual([], audit_dispatcher.auditors)
+
+    @override_settings(FIELD_AUDIT_AUDITORS=["tests.models.Flight"])
+    def test_audit_dispatcher_custom_auditors_must_subclass_baseauditor(self):
+        from .models import Flight
+        self.assertFalse(issubclass(Flight, BaseAuditor))
+        with self.assertRaises(ValueError):
+            audit_dispatcher.setup_auditors()
+
+    def test_audit_dispatcher_chain(self):
+        aud1 = MockAuditor(True)
+        aud2 = MockAuditor(True)
+        chain = [aud1, aud2]
+
+        # aud1 hits, aud2 never called
+        with patch.object(audit_dispatcher, "auditors", chain):
+            change_context = audit_dispatcher.dispatch(object())
+        self.assertIs(change_context, aud1)
+        self.assertEqual(aud1.dispatched, 1)
+        self.assertEqual(aud2.dispatched, 0)
+
+        # aud1 misses, aud2 hits
+        aud1.reset(False)
+        with patch.object(audit_dispatcher, "auditors", chain):
+            change_context = audit_dispatcher.dispatch(object())
+        self.assertIs(change_context, aud2)
+        self.assertEqual(aud1.dispatched, 1)
+        self.assertEqual(aud2.dispatched, 1)
+
+        # both miss
+        aud1.reset(False)
+        aud2.reset(False)
+        with patch.object(audit_dispatcher, "auditors", chain):
+            change_context = audit_dispatcher.dispatch(object())
+        self.assertIsNone(change_context)
+        self.assertEqual(aud1.dispatched, 1)
+        self.assertEqual(aud2.dispatched, 1)
+
+
+class CustomAuditor1(BaseAuditor):
+    pass
+
+
+class CustomAuditor2(BaseAuditor):
+    pass
+
+
+class CustomAuditor3(BaseAuditor):
+    pass
+
+
+class MockAuditor:
+
+    def __init__(self, enabled):
+        self.reset(enabled)
+
+    def reset(self, enabled):
+        self.dispatched = 0
+        self.enabled = enabled
+
+    def change_context(self, request):
+        self.dispatched += 1
+        return self if self.enabled else None
+
+
+class TestBaseAuditor(TestCase):
+
+    def test_baseauditor_change_context_raises_notimplementederror(self):
+        with self.assertRaises(NotImplementedError):
+            BaseAuditor().change_context(object())
+
+
+class TestSystemUserAuditor(TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.auditor = SystemUserAuditor()
+
+    def test_systemuserauditor_change_context_returns_sys_value_for_request(self):  # noqa: E501
+        def user(*args, **kw):
+            return b"test ..."
+        with patch("field_audit.auditors.check_output", side_effect=user):
+            self.assertEqual(
+                {"user_type": USER_TYPE_TTY, "username": "test"},
+                self.auditor.change_context(object()),
+            )
+
+    def _patch_system_getters_and_validate(self, fake_output, change_context):
+        kwargs = {"side_effect": fake_output}
+        user = None if change_context is None else change_context["username"]
+        with (
+            patch("field_audit.auditors.check_output", **kwargs) as chk_out,
+            patch("field_audit.auditors.getuser", return_value=user) as getuser,
+        ):
+            audit_info = self.auditor.change_context(None)
+            if isinstance(audit_info, dict):
+                self.assertEqual(change_context, audit_info)
+            else:
+                self.assertIsNone(audit_info)
+            return chk_out, getuser
+
+    def test_systemuserauditor_change_context_tolerates_invalid_who_output(self):  # noqa: E501
+        def bogus(*args, **kw):
+            return b"\xb4"
+        ch_by = {"user_type": USER_TYPE_PROCESS, "username": "alice"}
+        chk_out, getuser = self._patch_system_getters_and_validate(bogus, ch_by)
+        chk_out.assert_called_once()
+        getuser.assert_called_once()
+
+    def test_systemuserauditor_change_context_tolerates_empty_who_output(self):
+        def empty(*args, **kw):
+            return b""
+        ch_by = {"user_type": USER_TYPE_PROCESS, "username": "bob"}
+        chk_out, getuser = self._patch_system_getters_and_validate(empty, ch_by)
+        chk_out.assert_called_once()
+        getuser.assert_called_once()
+
+    def test_systemuserauditor_remembers_who_error(self):
+        def fail(*args, **kw):
+            raise CalledProcessError(1, [], "")
+        ch_by = {"user_type": USER_TYPE_PROCESS, "username": "carlos"}
+        # round 1
+        chk_out, getuser = self._patch_system_getters_and_validate(fail, ch_by)
+        chk_out.assert_called_once()
+        getuser.assert_called_once()
+        # round 2
+        chk_out, getuser = self._patch_system_getters_and_validate(fail, ch_by)
+        chk_out.assert_not_called()
+        getuser.assert_called_once()
+
+    def test_systemuserauditor_handles_missing_who_bin(self):
+        def fail(*args, **kw):
+            raise FileNotFoundError()
+        ch_by = {"user_type": USER_TYPE_PROCESS, "username": "carlos"}
+        chk_out, getuser = self._patch_system_getters_and_validate(fail, ch_by)
+        chk_out.assert_called_once()
+        getuser.assert_called_once()
+
+    def test_systemuserauditor_change_context_returns_tty_user_on_who_output(self):  # noqa: E501
+        def mock(*args, **kw):
+            return b"eve  ttys000  May 8 17:04  (localhost)"
+        ch_by = {"user_type": USER_TYPE_TTY, "username": "eve"}
+        chk_out, getuser = self._patch_system_getters_and_validate(mock, ch_by)
+        chk_out.assert_called_once()
+        getuser.assert_not_called()
+
+    def test_systemuserauditor_change_context_returns_none_if_all_else_fails(self):  # noqa: E501
+        def empty(*args, **kw):
+            return b""
+        chk_out, getuser = self._patch_system_getters_and_validate(empty, None)
+        chk_out.assert_called_once()
+        getuser.assert_called_once()
+
+
+class TestRequestAuditor(TestCase):
+
+    def setUp(self):
+        self.request = AuthedRequest()
+        self.auditor = RequestAuditor()
+
+    def test_requestauditor_change_context(self):
+        self.assertEqual(
+            {
+                "user_type": USER_TYPE_REQUEST,
+                "username": self.request.user.username,
+            },
+            self.auditor.change_context(self.request),
+        )
+
+    def test_requestauditor_change_context_returns_none_without_request(self):
+        self.assertIsNone(self.auditor.change_context(None))
+
+    def test_requestauditor_change_context_returns_value_for_unauthorized_req(self):  # noqa: E501
+        self.request.deauth()
+        self.assertEqual({}, self.auditor.change_context(self.request))
+
+
+class AuthedRequest:
+
+    class User:
+        username = "test@example.com"
+        is_authenticated = True
+
+    def __init__(self):
+        self.user = self.User()
+
+    def deauth(self):
+        self.user.is_authenticated = False

django_field_audit-1.2.9/tests/test_bootstrap_field_audit_events.py

@@ -0,0 +1,144 @@
+from contextlib import contextmanager
+from io import StringIO
+from unittest.mock import ANY, patch
+
+from django.core.management import CommandError, call_command
+from django.db import models
+from django.test import TestCase
+
+from field_audit.const import BOOTSTRAP_BATCH_SIZE
+from field_audit.field_audit import get_audited_models
+from field_audit.management.commands import (
+    bootstrap_field_audit_events as bootstrap,
+)
+from field_audit.models import AuditEvent
+from tests.models import PkAuto
+
+
+@contextmanager
+def restore_command_models(command_class):
+    backup = command_class.models
+    yield
+    command_class.models = backup
+
+
+class TestCommand(TestCase):
+
+    command = "bootstrap_field_audit_events"
+
+    def setUp(self):
+        super().setUp()
+        # create some records for bootstrapping
+        for _ in range(2):
+            PkAuto.objects.create()
+        # clear the "create" audit events
+        AuditEvent.objects.all().delete()
+
+    def test_setup_models_populates_models_dict(self):
+        with restore_command_models(bootstrap.Command):
+            bootstrap.Command.models = {}
+            bootstrap.Command.setup_models()
+            self.assertEqual(
+                set(get_audited_models()),
+                set(bootstrap.Command.models.values()),
+            )
+
+    def test_setup_models_uses_model_name(self):
+        with restore_command_models(bootstrap.Command):
+            bootstrap.Command.models = {}
+            bootstrap.Command.setup_models()
+            self.assertIs(PkAuto, bootstrap.Command.models["PkAuto"])
+
+    def test_setup_models_uses_app_name_to_prevent_model_name_collisions(self):
+        with restore_command_models(bootstrap.Command):
+            class ModelX(models.Model):
+                pass
+            bootstrap.Command.models = {"PkAuto": ModelX}
+            patch_kw = {"return_value": {PkAuto: "cls"}}
+            with patch.object(bootstrap, "get_audited_models", **patch_kw):
+                bootstrap.Command.setup_models()
+            self.assertEqual(
+                {"tests.ModelX": ModelX, "tests.PkAuto": PkAuto},
+                bootstrap.Command.models,
+            )
+
+    def test_setup_models_crashes_on_verbose_model_name_collision(self):
+
+        class ModelY(models.Model):
+            pass
+
+        class ModelZ(models.Model):
+            pass
+
+        ModelZ.__name__ = ModelY.__name__
+        with restore_command_models(bootstrap.Command):
+            patch_kw = {"return_value": {ModelY: "y", ModelZ: "z"}}
+            with (
+                patch.object(bootstrap, "get_audited_models", **patch_kw),
+                self.assertRaises(bootstrap.InvalidModelState),
+            ):
+                bootstrap.Command.setup_models()
+
+    def test_bootstrap_uses_default_batch_size(self):
+        with patch.object(AuditEvent, "bootstrap_top_up") as mock:
+            self.quiet_command("top-up", "PkAuto")
+            mock.assert_called_once_with(
+                PkAuto, ANY, batch_size=BOOTSTRAP_BATCH_SIZE,
+            )
+
+    def test_bootstrap_allows_custom_batch_size(self):
+        with patch.object(AuditEvent, "bootstrap_top_up") as mock:
+            self.quiet_command("top-up", "--batch-size", "1", "PkAuto")
+            mock.assert_called_once_with(PkAuto, ANY, batch_size=1)
+
+    def test_bootstrap_disables_batching_for_batch_size_zero(self):
+        with patch.object(AuditEvent, "bootstrap_top_up") as mock:
+            self.quiet_command("top-up", "--batch-size", "0", "PkAuto")
+            mock.assert_called_once_with(PkAuto, ANY, batch_size=None)
+
+    def test_bootstrap_crashes_for_negative_batch_size(self):
+        with self.assertRaises(CommandError):
+            self.quiet_command("top-up", "--batch-size", "-1", "PkAuto")
+
+    def test_bootstrap_crashes_early_if_model_has_invalid_fields(self):
+        with (
+            patch.object(PkAuto, AuditEvent.ATTACH_FIELD_NAMES_AT, []),
+            self.assertRaises(CommandError),
+        ):
+            self.quiet_command("init", "PkAuto")
+
+    def test_bootstrap_init_creates_audit_events_for_all_model_records(self):
+        self.quiet_command("init", "PkAuto")
+        self.assertEqual(
+            set(PkAuto.objects.all().values_list("pk", flat=True)),
+            set(
+                AuditEvent.objects.by_model(PkAuto)
+                .filter(is_bootstrap=True)
+                .values_list("object_pk", flat=True)
+            ),
+        )
+
+    def test_bootstrap_top_up_creates_audit_events_for_some_model_records(self):
+        need_bootstrap = set(PkAuto.objects.all().values_list("pk", flat=True))
+        # generate two more models (generates two "create" audit events)
+        for _ in range(2):
+            PkAuto.objects.create()
+        # convert one of them to a bootstrap event
+        event = AuditEvent.objects.first()
+        event.is_create = False
+        event.is_bootstrap = True
+        event.save()
+        pre_top_up_event_ids = set(
+            AuditEvent.objects.all().values_list("id", flat=True)
+        )
+        self.quiet_command("top-up", "PkAuto")
+        self.assertEqual(
+            need_bootstrap,
+            set(
+                AuditEvent.objects.exclude(id__in=pre_top_up_event_ids)
+                .values_list("object_pk", flat=True)
+            ),
+        )
+
+    def quiet_command(self, *args, **kw):
+        return call_command(self.command, *args, stdout=StringIO(), **kw)

django_field_audit-1.2.9/tests/test_django_compat.py

@@ -0,0 +1,148 @@
+import django
+from django.test import TestCase
+
+from field_audit.models import AuditEvent
+
+from .models import ModelWithValueOnSave, SimpleModel
+
+
+class TestAuditedDbWrites(TestCase):
+
+    def test_model_delete_is_audited(self):
+        self.assertNoAuditEvents()
+        instance = SimpleModel.objects.create(id=0, value='test')
+        AuditEvent.objects.all().delete()  # delete the create audit event
+        instance.delete()
+        self.assertAuditEvent(
+            is_delete=True,
+            delta={"id": {"old": 0}, "value": {"old": 'test'}},
+        )
+
+    def test_model_delete_with_value_on_save_is_audited(self):
+        self.assertNoAuditEvents()
+        instance = ModelWithValueOnSave.objects.create(id=0)
+        AuditEvent.objects.all().delete()  # delete the create audit event
+        instance.delete()
+        self.assertAuditEvent(
+            is_delete=True,
+            delta={'id': {'old': 0}, 'save_count': {'old': 1}},
+        )
+
+    def test_model_save_is_audited(self):
+        self.assertNoAuditEvents()
+        SimpleModel(id=0).save()
+        self.assertAuditEvent(
+            is_create=True,
+            delta={"id": {"new": 0}, "value": {"new": None}},
+        )
+
+    def test_model_save_with_value_on_save_is_audited(self):
+        self.assertNoAuditEvents()
+        ModelWithValueOnSave.objects.create(id=0)
+        self.assertAuditEvent(
+            is_create=True,
+            delta={'id': {'new': 0}, 'save_count': {'new': 1}},
+        )
+
+    def test_model_multiple_saves_with_value_on_save_is_audited(self):
+        self.assertNoAuditEvents()
+        instance = ModelWithValueOnSave.objects.create(id=0)
+        AuditEvent.objects.all().delete()  # delete the create audit event
+        instance.value = 'update'
+        instance.save()
+        self.assertAuditEvent(
+            is_create=False,
+            delta={'save_count': {'old': 1, 'new': 2}},
+        )
+
+    def test_queryset_bulk_create_is_not_audited(self):
+        self.assertNoAuditEvents()
+        instance, = SimpleModel.objects.bulk_create([SimpleModel(id=1)])
+        instance.refresh_from_db()
+        self.assertIsNotNone(instance.id)
+        self.assertNoAuditEvents()
+
+    def test_queryset_bulk_update_is_not_audited(self):
+        instance = SimpleModel.objects.create(id=1)
+        AuditEvent.objects.all().delete()  # delete the create audit event
+        self.assertIsNone(instance.value)
+        instance.value = "test"
+        updates = SimpleModel.objects.bulk_update([instance], ["value"])
+        if django.VERSION[0] < 4:
+            expected_updates = None
+        else:
+            expected_updates = 1
+        self.assertEqual(expected_updates, updates)
+        instance.refresh_from_db()
+        self.assertEqual("test", instance.value)
+        self.assertNoAuditEvents()
+
+    def test_queryset_create_is_audited(self):
+        self.assertNoAuditEvents()
+        instance = SimpleModel.objects.create()
+        self.assertAuditEvent(
+            is_create=True,
+            delta={"id": {"new": instance.id}, "value": {"new": None}},
+        )
+
+    def test_queryset_delete_is_not_audited(self):
+        self.assertNoAuditEvents()
+        instance = SimpleModel.objects.create()
+        AuditEvent.objects.all().delete()  # delete the create audit event
+        instance.refresh_from_db()
+        self.assertIsNotNone(instance.id)
+        SimpleModel.objects.all().delete()
+        self.assertNoAuditEvents()
+
+    def test_queryset_get_or_create_is_audited(self):
+        self.assertNoAuditEvents()
+        self.assertEqual([], list(SimpleModel.objects.all()))
+        SimpleModel.objects.get_or_create(id=0)
+        self.assertAuditEvent(
+            is_create=True,
+            delta={"id": {"new": 0}, "value": {"new": None}},
+        )
+
+    def test_queryset_update_is_not_audited(self):
+        self.assertNoAuditEvents()
+        instance = SimpleModel.objects.create()
+        AuditEvent.objects.all().delete()  # delete the create audit event
+        SimpleModel.objects.all().update(value="test")
+        instance.refresh_from_db()
+        self.assertEqual("test", instance.value)
+        self.assertNoAuditEvents()
+
+    def test_queryset_update_or_create_is_audited_on_create(self):
+        self.assertNoAuditEvents()
+        self.assertEqual([], list(SimpleModel.objects.all()))
+        response = SimpleModel.objects.update_or_create({"value": "test"}, id=0)
+        instance, x = response
+        self.assertEqual(0, instance.id)
+        self.assertEqual("test", instance.value)
+        self.assertAuditEvent(
+            is_create=True,
+            delta={"id": {"new": 0}, "value": {"new": "test"}},
+        )
+
+    def test_queryset_update_or_create_is_audited_on_update(self):
+        self.assertNoAuditEvents()
+        instance = SimpleModel.objects.create()
+        AuditEvent.objects.all().delete()  # delete the create audit event
+        self.assertEqual([instance], list(SimpleModel.objects.all()))
+        self.assertIsNone(instance.value)
+        SimpleModel.objects.update_or_create({"value": "test"}, id=instance.id)
+        instance.refresh_from_db()
+        self.assertEqual("test", instance.value)
+        self.assertAuditEvent(
+            is_create=False,
+            is_delete=False,
+            delta={"value": {"old": None, "new": "test"}},
+        )
+
+    def assertNoAuditEvents(self):
+        self.assertEqual([], list(AuditEvent.objects.all()))
+
+    def assertAuditEvent(self, **kwargs):
+        event, = AuditEvent.objects.all()
+        for name, value in kwargs.items():
+            self.assertEqual(value, getattr(event, name))