[feature] Implement VPN cache invalidation using _initial pattern

- Use getattr for version-safe _initial_context access
- Add behavioral tests covering all invalidation scenarios

Fixes #1098

Author: Srinath0916

openwisp_controller/config/base/multitenancy.py

@@ -49,7 +49,7 @@ class Meta:
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self._initial_context = self.context
+        self._initial_context = deepcopy(self.context)
 
     def __str__(self):
         return self.organization.name
@@ -62,15 +62,17 @@ def save(
     ):
         context_changed = False
         if not self._state.adding:
-            context_changed = self._initial_context != self.context
+            initial_context = getattr(self, "_initial_context", None)
+            if initial_context is not None:
+                context_changed = initial_context != self.context
         super().save(force_insert, force_update, using, update_fields)
         if context_changed and self.organization.is_active:
             transaction.on_commit(
                 lambda: tasks.invalidate_organization_vpn_cache.delay(
                     str(self.organization_id)
                 )
             )
-        self._initial_context = self.context
+        self._initial_context = deepcopy(self.context)
 
 
 class AbstractOrganizationLimits(models.Model):

openwisp_controller/config/tests/test_handlers.py

@@ -13,12 +13,10 @@ def test_organization_disabled_handler(self, mocked_task):
         with self.subTest("Test task not executed on creating active orgs"):
             org = self._create_org()
             mocked_task.assert_not_called()
-
         with self.subTest("Test task executed on changing active to inactive org"):
             org.is_active = False
             org.save()
             mocked_task.assert_called_once()
-
         with self.subTest("Test task not executed on changing inactive to active org"):
             mocked_task.reset_mock()
             inactive_org = self._create_org(is_active=False)
@@ -37,80 +35,35 @@ def _get_org_config_settings(self, org=None):
         return org.config_settings
 
     @patch.object(tasks.invalidate_organization_vpn_cache, "delay")
-    def test_vpn_cache_invalidation_on_context_change(self, mocked_task):
+    def test_vpn_cache_invalidated_on_context_change(self, mocked_task):
         """Test VPN cache invalidation when context changes"""
         config_settings = self._get_org_config_settings()
+        config_settings.context = {"new": "context"}
+        config_settings.save()
+        mocked_task.assert_called_once_with(str(config_settings.organization_id))
 
-        with self.subTest("Test no invalidation on creation"):
-            mocked_task.assert_not_called()
-
-        with self.subTest("Test invalidation when context changes"):
-            config_settings.context = {"new": "context"}
-            config_settings.save()
-            mocked_task.assert_called_once_with(str(config_settings.organization_id))
-
-        with self.subTest("Test no invalidation when context unchanged"):
-            mocked_task.reset_mock()
-            config_settings.registration_enabled = False
-            config_settings.save()
-            mocked_task.assert_not_called()
+    @patch.object(tasks.invalidate_organization_vpn_cache, "delay")
+    def test_no_cache_invalidation_on_create(self, mocked_task):
+        """Test no VPN cache invalidation on object creation"""
+        self._get_org_config_settings()
+        mocked_task.assert_not_called()
 
     @patch.object(tasks.invalidate_organization_vpn_cache, "delay")
-    def test_no_vpn_cache_invalidation_for_inactive_org(self, mocked_task):
+    def test_no_cache_invalidation_for_inactive_org(self, mocked_task):
         """Test no VPN cache invalidation for inactive organizations"""
         inactive_org = self._create_org(is_active=False)
         config_settings = inactive_org.config_settings
-
-        with self.subTest("Test no invalidation for inactive org context change"):
-            config_settings.context = {"new": "context"}
-            config_settings.save()
-            mocked_task.assert_not_called()
-
-    def test_initial_context_pattern_implementation(self):
-        """Test that _initial_context follows the established pattern"""
-        config_settings = self._get_org_config_settings()
-
-        with self.subTest("Test _initial_context is set on init"):
-            self.assertEqual(config_settings._initial_context, config_settings.context)
-
-        with self.subTest("Test _initial_context updates after save"):
-            new_context = {"updated": "context"}
-            config_settings.context = new_context
-            config_settings.save()
-            self.assertEqual(config_settings._initial_context, new_context)
-
-    @patch.object(tasks.invalidate_organization_vpn_cache, "delay")
-    def test_feature_fails_when_removed(self, mocked_task):
-        """Test that fails with clear error when feature code is removed"""
-        config_settings = self._get_org_config_settings()
-
-        # Simulate removing the _initial_context pattern
-        def broken_init(self, *args, **kwargs):
-            super(type(config_settings), self).__init__(*args, **kwargs)
-            # Missing: self._initial_context = self.context
-
-        with patch.object(type(config_settings), "__init__", broken_init):
-            new_config = type(config_settings)(organization=self._create_org())
-            new_config.context = {"test": "context"}
-            with self.assertRaises(
-                AttributeError, msg="Feature code removed - _initial_context not set"
-            ):
-                new_config.save()
+        config_settings.context = {"new": "context"}
+        config_settings.save()
+        mocked_task.assert_not_called()
 
     @patch.object(tasks.invalidate_organization_vpn_cache, "delay")
-    def test_feature_fails_when_bugged(self, mocked_task):
-        """Test that fails with clear error when feature code is bugged"""
+    def test_no_cache_invalidation_if_context_unchanged(self, mocked_task):
+        """Test no VPN cache invalidation when context is unchanged"""
         config_settings = self._get_org_config_settings()
-
-        # Simulate buggy implementation - always trigger invalidation
-        def buggy_save(self, *args, **kwargs):
-            super(type(config_settings), self).save(*args, **kwargs)
-            # Bug: always invalidate regardless of context change
-            if hasattr(self, "organization") and self.organization.is_active:
-                tasks.invalidate_organization_vpn_cache.delay(str(self.organization_id))
-
-        with patch.object(type(config_settings), "save", buggy_save):
-            # This should not trigger invalidation but buggy code will
-            config_settings.registration_enabled = False
-            config_settings.save()
-            mocked_task.assert_called_once()  # This proves the bug exists
+        original_context = config_settings.context
+        config_settings.registration_enabled = False
+        config_settings.save()
+        mocked_task.assert_not_called()
+        # Verify context actually didn't change
+        self.assertEqual(config_settings.context, original_context)