openwisp-controller 1.2.2__tar.gz → 1.2.3__tar.gz

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/CHANGES.rst

@@ -1,6 +1,18 @@
 Changelog
 =========
 
+Version 1.2.3 [2026-04-09]
+--------------------------
+
+Bugfixes
+~~~~~~~~
+
+- Corrected initial field value assignment in ``AbstractDevice`` class
+- Fixed duplicate template entries in Device admin
+- Invalidate Config checksum after subnet provisioning
+- Fixed concurrent ``update_config`` detection `#1204
+  <https://github.com/openwisp/openwisp-controller/issues/1204>`_
+
 Version 1.2.2 [2026-03-06]
 --------------------------
 

{openwisp_controller-1.2.2/openwisp_controller.egg-info → openwisp_controller-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openwisp-controller
-Version: 1.2.2
+Version: 1.2.3
 Summary: OpenWISP Controller
 Home-page: http://openwisp.org
 Download-URL: https://github.com/openwisp/openwisp-controller/releases

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/__init__.py

@@ -1,4 +1,4 @@
-VERSION = (1, 2, 2, "final")
+VERSION = (1, 2, 3, "final")
 __version__ = VERSION  # alias
 
 

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/config/base/device.py

@@ -325,9 +325,9 @@ class AbstractDevice(OrgMixin, BaseModel):
         if not present_values:
             return
         self.refresh_from_db(fields=present_values.keys())
-        for field in self._changed_checked_fields:
-            setattr(self, f"_initial_{field}", field)
-            setattr(self, field, present_values[field])
+        for field, value in present_values.items():
+            setattr(self, f"_initial_{field}", getattr(self, field))
+            setattr(self, field, value)
 
     def _check_name_changed(self):
         if self._initial_name == models.DEFERRED:

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/config/static/config/js/relevant_templates.js

@@ -138,7 +138,7 @@ django.jQuery(function ($) {
         resetTemplateOptions();
         var enabledTemplates = [],
           sortedm2mUl = $("ul.sortedm2m-items:first"),
-          sortedm2mPrefixUl = $("ul.sortedm2m-items:last");
+          sortedm2mPrefixUl = $("#config-empty ul.sortedm2m-items");
 
         // Adds "li" elements for templates
         Object.keys(data).forEach(function (templateId, index) {

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/config/tests/test_device.py

@@ -529,6 +529,20 @@ class TestDevice(
             with self.assertNumQueries(3):
                 device._check_changed_fields()
 
+    def test_deferred_fields_populated_correctly(self):
+        device = self._create_device(
+            name="deferred-test",
+            management_ip="10.0.0.1",
+        )
+        # Load the instance with deferred fields omitted
+        device = Device.objects.only("id").get(pk=device.pk)
+        device.management_ip = "10.0.0.55"
+        # Saving the device object will populate the deferred fields
+        device.save()
+        # Ensure `_initial_<field>` contains the actual value, not the field name
+        self.assertEqual(getattr(device, "_initial_management_ip"), "10.0.0.55")
+        self.assertNotEqual(getattr(device, "_initial_management_ip"), "management_ip")
+
     def test_exceed_organization_device_limit(self):
         org = self._get_org()
         org.config_limits.device_limit = 1

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/config/tests/test_selenium.py

@@ -1,5 +1,6 @@
 import time
 
+from django.contrib.auth.models import Group, Permission
 from django.contrib.staticfiles.testing import StaticLiveServerTestCase
 from django.test import tag
 from django.urls.base import reverse
@@ -40,9 +41,17 @@ class SeleniumTestMixin(BaseSeleniumTestMixin):
         hidden = hidden or []
         visible = visible or []
         for template in hidden:
-            self.wait_for_invisibility(By.XPATH, f'//*[@value="{template.id}"]')
+            self.wait_for_invisibility(
+                By.XPATH,
+                f'//ul[contains(@class,"sortedm2m-items")]'
+                f'//input[@value="{template.id}"]',
+            )
         for template in visible:
-            self.wait_for_visibility(By.XPATH, f'//*[@value="{template.id}"]')
+            self.wait_for_visibility(
+                By.XPATH,
+                f'//ul[contains(@class,"sortedm2m-items")]'
+                f'//input[@value="{template.id}"]',
+            )
 
 
 @tag("selenium_tests")
@@ -373,6 +382,93 @@ class TestDeviceAdmin(
             self.assertEqual(config.templates.count(), 0)
             self.assertEqual(config.status, "modified")
 
+    def test_relevant_templates_duplicates(self):
+        """
+        Test that a user with specific permissions can see shared templates
+        properly. Verifies that:
+        1. User with custom group permissions can access the admin
+        2. Multiple shared templates are displayed correctly
+        3. Each template appears only once in the sortedm2m list
+        """
+        # Define permission codenames for the custom group
+        permission_codenames = [
+            "view_group",
+            "change_config",
+            "view_config",
+            "add_device",
+            "change_device",
+            "delete_device",
+            "view_device",
+            "view_devicegroup",
+            "view_template",
+        ]
+        # Create a custom group with the specified permissions
+        permissions = Permission.objects.filter(codename__in=permission_codenames)
+        custom_group, _ = Group.objects.get_or_create(name="Custom Operator")
+        custom_group.permissions.set(permissions)
+        # Create a user and assign the custom group
+        user = self._create_user(
+            username="limited_user",
+            password="testpass123",
+            email="limited@test.com",
+            is_staff=True,
+        )
+        user.groups.add(custom_group)
+        org = self._get_org()
+        self._create_org_user(user=user, organization=org, is_admin=True)
+        # Create multiple shared templates (organization=None)
+        template1 = self._create_template(
+            name="Shared Template 1", organization=None, default=True
+        )
+        template2 = self._create_template(name="Shared Template 2", organization=None)
+        device = self._create_config(organization=org).device
+        # Login as the limited user
+        self.login(username="limited_user", password="testpass123")
+        # Navigate using Selenium
+        self.open(
+            reverse("admin:config_device_change", args=[device.id]) + "#config-group"
+        )
+        self.hide_loading_overlay()
+        with self.subTest(
+            "Regression precondition: empty Config inline is not rendered"
+        ):
+            self.assertFalse(self.web_driver.find_elements(By.ID, "config-empty"))
+
+        with self.subTest("All shared templates should be visible"):
+            self._verify_templates_visibility(visible=[template1, template2])
+
+        with self.subTest("Verify sortedm2m list has exactly 2 template items"):
+            # Check that ul.sortedm2m-items.sortedm2m.ui-sortable has exactly 2 children
+            # with .sortedm2m-item class
+            sortedm2m_items = self.find_elements(
+                by=By.CSS_SELECTOR,
+                value="ul.sortedm2m-items.sortedm2m.ui-sortable > li.sortedm2m-item",
+            )
+            self.assertEqual(
+                len(sortedm2m_items),
+                2,
+                (
+                    "Expected exactly 2 template items in sortedm2m list,"
+                    f" found {len(sortedm2m_items)}"
+                ),
+            )
+
+        with self.subTest(
+            "Verify checkbox inputs are rendered with expected attributes"
+        ):
+            for idx, template_id in enumerate([template1.id, template2.id]):
+                checkbox = self.find_element(
+                    by=By.ID, value=f"id_config-templates_{idx}"
+                )
+                self.assertEqual(checkbox.get_attribute("value"), str(template_id))
+                self.assertEqual(checkbox.get_attribute("data-required"), "false")
+
+        with self.subTest("Save operation completes successfully"):
+            # Scroll to the top of the page to ensure the save button is visible
+            self.web_driver.execute_script("window.scrollTo(0, 0);")
+            self.find_element(by=By.NAME, value="_save").click()
+            self.wait_for_presence(By.CSS_SELECTOR, ".messagelist .success", timeout=5)
+
 
 @tag("selenium_tests")
 class TestDeviceGroupAdmin(

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/connection/tasks.py

@@ -16,20 +16,25 @@ logger = logging.getLogger(__name__)
 _TASK_NAME = "openwisp_controller.connection.tasks.update_config"
 
 
-def _is_update_in_progress(device_id):
+def _is_update_in_progress(device_id, current_task_id=None):
     active = current_app.control.inspect().active()
     if not active:
         return False
     # check if there's any other running task before adding it
+    # exclude the current task by comparing task IDs
     for task_list in active.values():
         for task in task_list:
-            if task["name"] == _TASK_NAME and str(device_id) in task["args"]:
+            if (
+                task["name"] == _TASK_NAME
+                and str(device_id) in task["args"]
+                and task["id"] != current_task_id
+            ):
                 return True
     return False
 
 
-@shared_task
-def update_config(device_id):
+@shared_task(bind=True)
+def update_config(self, device_id):
     """
     Launches the ``update_config()`` operation
     of a specific device in the background
@@ -48,7 +53,7 @@ def update_config(device_id):
     except ObjectDoesNotExist as e:
         logger.warning(f'update_config("{device_id}") failed: {e}')
         return
-    if _is_update_in_progress(device_id):
+    if _is_update_in_progress(device_id, current_task_id=self.request.id):
         return
     try:
         device_conn = DeviceConnection.get_working_connection(device)

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/connection/tests/test_models.py

@@ -1,6 +1,7 @@
 import socket
 from unittest import mock
 from unittest.mock import PropertyMock
+from uuid import uuid4
 
 import paramiko
 from django.contrib.auth.models import ContentType
@@ -1026,20 +1027,56 @@ class TestModelsTransaction(BaseTestModels, TransactionTestCase):
     @mock.patch.object(DeviceConnection, "update_config")
     @mock.patch.object(DeviceConnection, "get_working_connection")
     def test_device_update_config_in_progress(
-        self, mocked_get_working_connection, update_config, mocked_sleep
+        self, mocked_get_working_connection, mocked_update_config, mocked_sleep
     ):
         conf = self._prepare_conf_object()
 
-        with mock.patch("celery.app.control.Inspect.active") as mocked_active:
-            mocked_active.return_value = {
-                "task": [{"name": _TASK_NAME, "args": [str(conf.device.pk)]}]
-            }
-            conf.config = {"general": {"timezone": "UTC"}}
-            conf.full_clean()
-            conf.save()
-            mocked_active.assert_called_once()
-            mocked_get_working_connection.assert_not_called()
-            update_config.assert_not_called()
+        with self.subTest("More than one update_config task active for the device"):
+            with mock.patch("celery.app.control.Inspect.active") as mocked_active:
+                mocked_active.return_value = {
+                    "task": [
+                        {
+                            "name": _TASK_NAME,
+                            "args": [str(conf.device.pk)],
+                            "id": str(uuid4()),
+                        }
+                    ]
+                }
+                conf.config = {"general": {"timezone": "UTC"}}
+                conf.full_clean()
+                conf.save()
+                mocked_active.assert_called_once()
+                mocked_get_working_connection.assert_not_called()
+                mocked_update_config.assert_not_called()
+
+        Config.objects.update(status="applied")
+        mocked_get_working_connection.return_value = (
+            conf.device.deviceconnection_set.first()
+        )
+        with self.subTest("Only one task is active for the device"):
+            task_id = str(uuid4())
+            with mock.patch(
+                "celery.app.control.Inspect.active"
+            ) as mocked_active, mock.patch(
+                "celery.app.task.Context.id",
+                new_callable=mock.PropertyMock,
+                return_value=task_id,
+            ):
+                mocked_active.return_value = {
+                    "task": [
+                        {
+                            "name": _TASK_NAME,
+                            "args": [str(conf.device.pk)],
+                            "id": task_id,
+                        }
+                    ]
+                }
+                conf.config = {"general": {"timezone": "Asia/Kolkata"}}
+                conf.full_clean()
+                conf.save()
+                mocked_active.assert_called_once()
+                mocked_get_working_connection.assert_called_once()
+                mocked_update_config.assert_called_once()
 
     @mock.patch("time.sleep")
     @mock.patch.object(DeviceConnection, "update_config")
@@ -1053,8 +1090,15 @@ class TestModelsTransaction(BaseTestModels, TransactionTestCase):
         )
 
         with mock.patch("celery.app.control.Inspect.active") as mocked_active:
+            # Mock a task running for a different device (args is different)
             mocked_active.return_value = {
-                "task": [{"name": _TASK_NAME, "args": ["..."]}]
+                "task": [
+                    {
+                        "name": _TASK_NAME,
+                        "args": ["another-device-id"],  # Different device
+                        "id": "different-task-id",
+                    }
+                ]
             }
             conf.config = {"general": {"timezone": "UTC"}}
             conf.full_clean()

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/connection/tests/test_tasks.py

@@ -19,6 +19,56 @@ class TestTasks(CreateConnectionsMixin, TestCase):
         "openwisp_controller.connection.base.models.AbstractDeviceConnection.connect"
     )
 
+    def _get_mocked_celery_active(self, device_id, task_id=None):
+        return {
+            "worker1": [
+                {
+                    "name": tasks._TASK_NAME,
+                    "args": [device_id],
+                    "id": task_id or str(uuid.uuid4()),
+                }
+            ]
+        }
+
+    def test_is_update_in_progress_same_task(self):
+        device_id = str(uuid.uuid4())
+        task_id = str(uuid.uuid4())
+        with mock.patch(
+            "celery.app.control.Inspect.active",
+            return_value=self._get_mocked_celery_active(device_id, task_id),
+        ):
+            result = tasks._is_update_in_progress(device_id, current_task_id=task_id)
+            self.assertEqual(result, False)
+
+    def test_is_update_in_progress_different_task(self):
+        device_id = str(uuid.uuid4())
+        current_task_id = str(uuid.uuid4())
+        other_task_id = str(uuid.uuid4())
+        with mock.patch(
+            "celery.app.control.Inspect.active",
+            return_value=self._get_mocked_celery_active(device_id, other_task_id),
+        ):
+            result = tasks._is_update_in_progress(
+                device_id, current_task_id=current_task_id
+            )
+            self.assertEqual(result, True)
+
+    def test_is_update_in_progress_no_tasks(self):
+        device_id = str(uuid.uuid4())
+        with mock.patch("celery.app.control.Inspect.active", return_value={}):
+            result = tasks._is_update_in_progress(device_id)
+            self.assertEqual(result, False)
+
+    def test_is_update_in_progress_different_device(self):
+        device_id = str(uuid.uuid4())
+        other_device_id = str(uuid.uuid4())
+        with mock.patch(
+            "celery.app.control.Inspect.active",
+            return_value=self._get_mocked_celery_active(other_device_id),
+        ):
+            result = tasks._is_update_in_progress(device_id)
+            self.assertEqual(result, False)
+
     @mock.patch("logging.Logger.warning")
     @mock.patch("time.sleep")
     def test_update_config_missing_config(self, mocked_sleep, mocked_warning):

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/geo/tests/test_admin.py

@@ -29,6 +29,12 @@ class TestAdmin(TestAdminMixin, TestGeoMixin, BaseTestAdmin, TestCase):
         """override TestAdminMixin.setUp"""
         pass
 
+    def _get_location_add_params(self, **kwargs):
+        params = super()._get_location_add_params(**kwargs)
+        if "organization" not in kwargs:
+            params["organization"] = self._get_org().id
+        return params
+
     def _create_multitenancy_test_env(self, vpn=False):
         org1 = self._create_organization(name="test1org")
         org2 = self._create_organization(name="test2org")

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/geo/tests/test_selenium.py

@@ -91,7 +91,11 @@ class TestDeviceAdminReadonly(
     def test_unsaved_changes_readonly(self):
         self.login()
         ol = self._create_object_location()
-        path = reverse("admin:config_device_change", args=[ol.device.id])
+        path = reverse(
+            f"admin:{self.object_model._meta.app_label}_"
+            f"{self.object_model._meta.model_name}_change",
+            args=[ol.device.id],
+        )
 
         with self.subTest("Alert should not be displayed without any change"):
             self.open(path)

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/subnet_division/rule_types/base.py

@@ -79,16 +79,36 @@ class BaseSubnetDivisionRuleType(object):
     def destroyer_receiver(cls, instance, **kwargs):
         cls.destroy_provisioned_subnets_ips(instance, **kwargs)
 
-    @staticmethod
-    def post_provision_handler(instance, provisioned, **kwargs):
+    @classmethod
+    def post_provision_handler(cls, instance, provisioned, **kwargs):
         """
-        This method should be overridden in inherited rule types to
-        perform any operation on provisioned subnets and IP addresses.
-        :param instance: object that triggered provisioning
-        :param provisioned: dictionary containing subnets and IP addresses
-            provisioned, None if nothing is provisioned
+        Hook for post-provisioning actions on subnets and IP addresses.
+
+        This method is intended to be extended by subclasses of rule types
+        to perform custom operations after subnets and IPs are provisioned.
+
+        Subnet provisioning is executed asynchronously in Celery workers.
+        If the device configuration references variables provided by the
+        subnet division rule, the current checksum may have been computed
+        using variable names instead of their provisioned values. In such cases,
+        `Config.checksum_db` (which tracks persisted configuration changes)
+        must be updated to reflect the actual provisioned values, and the
+        checksum cache invalidated to avoid stale data.
+
+        :param instance: The object that triggered the provisioning.
+        :param provisioned: Dictionary containing provisioned subnets and IPs,
+            or None if no provisioning occurred.
         """
-        pass
+        if not provisioned:
+            return
+        config = cls.get_config(instance)
+        config._invalidate_backend_instance_cache()
+        current_checksum = config.checksum
+        if current_checksum != config.checksum_db:
+            # Update checksum using the UPDATE query to avoid sending
+            # unnecessary signals that may be triggered by `save()` method.
+            config._update_checksum_db(current_checksum)
+            config.invalidate_checksum_cache()
 
     @staticmethod
     def subnet_provisioned_signal_emitter(instance, provisioned):

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/subnet_division/rule_types/vpn.py

@@ -41,8 +41,9 @@ class VpnSubnetDivisionRuleType(BaseSubnetDivisionRuleType):
         for vpn_client in qs:
             cls.provision_receiver(instance=vpn_client, created=True)
 
-    @staticmethod
-    def post_provision_handler(instance, provisioned, **kwargs):
+    @classmethod
+    def post_provision_handler(cls, instance, provisioned, **kwargs):
+        super().post_provision_handler(instance, provisioned, **kwargs)
         # Assign the first provisioned IP address to the VPNClient
         # only when subnets and IPs have been provisioned
         if provisioned and provisioned["ip_addresses"]:

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3}/openwisp_controller/subnet_division/tests/test_admin.py

@@ -1,16 +1,21 @@
 from unittest.mock import patch
 
-from django.test import TestCase
+from django.test import TestCase, TransactionTestCase
 from django.urls import reverse
 from swapper import load_model
 
-from openwisp_controller.config.tests.utils import TestWireguardVpnMixin
+from openwisp_controller.config.tests.test_admin import TestDeviceAdminMixin
+from openwisp_controller.config.tests.utils import (
+    TestVpnX509Mixin,
+    TestWireguardVpnMixin,
+)
 from openwisp_users.tests.utils import TestMultitenantAdminMixin
 
-from .helpers import SubnetDivisionAdminTestMixin
+from .helpers import SubnetDivisionAdminTestMixin, SubnetDivisionTestMixin
 
 Subnet = load_model("openwisp_ipam", "Subnet")
 Device = load_model("config", "Device")
+Config = load_model("config", "Config")
 
 
 class TestSubnetAdmin(
@@ -257,3 +262,132 @@ class TestDeviceAdmin(
         )
         self.assertEqual(subnet_response.status_code, 200)
         self.assertContains(subnet_response, self.config.device.name, 1)
+
+
+class TestTransactionDeviceAdmin(
+    SubnetDivisionTestMixin,
+    TestVpnX509Mixin,
+    TestDeviceAdminMixin,
+    TransactionTestCase,
+):
+    ipam_label = "openwisp_ipam"
+    config_label = "config"
+
+    def test_vpn_template_switch_checksum_db(self):
+        admin = self._create_admin()
+        self.client.force_login(admin)
+        org = self._get_org()
+        vpn1_subnet = self._get_master_subnet(organization=org, subnet="10.0.0.0/24")
+        self._get_vpn_subdivision_rule(
+            number_of_ips=1,
+            number_of_subnets=1,
+            organization=org,
+            master_subnet=vpn1_subnet,
+            label="VPN1",
+        )
+        vpn1 = self._create_vpn(name="vpn1", organization=org, subnet=vpn1_subnet)
+        vpn2_subnet = self._get_master_subnet(organization=org, subnet="10.0.1.0/24")
+        self._get_vpn_subdivision_rule(
+            number_of_ips=1,
+            number_of_subnets=1,
+            organization=org,
+            master_subnet=vpn2_subnet,
+            label="VPN2",
+        )
+        vpn2 = self._create_vpn(name="vpn2", organization=org, subnet=vpn2_subnet)
+        vpn1_template = self._create_template(
+            organization=org,
+            name="vpn1-template",
+            type="vpn",
+            vpn=vpn1,
+            default_values={
+                "VPN1_subnet1_ip1": "10.0.0.1",
+                "VPN1_prefix": "24",
+                "ifname": "tun0",
+            },
+            auto_cert=True,
+            config={},
+        )
+        vpn1_template.config["openvpn"][0]["dev"] = "{{ ifname }}"
+        vpn1_template.config.update(
+            {
+                "network": [
+                    {
+                        "config_name": "interface",
+                        "config_value": "lan",
+                        "ipaddr": "{{ VPN1_subnet1_ip1 }}",
+                        "netmask": "255.255.255.240",
+                    }
+                ],
+            }
+        )
+        vpn1_template.full_clean()
+        vpn1_template.save()
+        vpn2_template = self._create_template(
+            organization=org,
+            name="vpn2-template",
+            type="vpn",
+            vpn=vpn2,
+            default_values={
+                "VPN2_subnet1_ip1": "10.0.1.1",
+                "VPN2_prefix": "32",
+                "ifname": "tun1",
+            },
+            auto_cert=True,
+            config={},
+        )
+        vpn2_template.config["openvpn"][0]["dev"] = "{{ ifname }}"
+        vpn2_template.config.update(
+            {
+                "network": [
+                    {
+                        "config_name": "interface",
+                        "config_value": "lan",
+                        "ipaddr": "{{ VPN2_subnet1_ip1 }}",
+                        "netmask": "255.255.255.240",
+                    }
+                ],
+            }
+        )
+        vpn2_template.full_clean()
+        vpn2_template.save()
+        default_template = self._create_template(
+            name="default-template",
+            default=True,
+        )
+        path = reverse(f"admin:{self.config_label}_device_add")
+        params = self._get_device_params(org=org)
+        params.update(
+            {"config-0-templates": f"{default_template.pk},{vpn1_template.pk}"}
+        )
+        response = self.client.post(path, data=params, follow=True)
+        self.assertEqual(response.status_code, 200)
+        config = Config.objects.get(device__name=params["name"])
+        config.refresh_from_db()
+        config._invalidate_backend_instance_cache()
+        initial_checksum = config.checksum
+        self.assertEqual(config.checksum_db, initial_checksum)
+        self.assertEqual(config.vpnclient_set.count(), 1)
+        self.assertEqual(config.vpnclient_set.first().vpn, vpn1)
+
+        path = reverse(
+            f"admin:{self.config_label}_device_change", args=[config.device_id]
+        )
+        params.update(
+            {
+                "config-0-templates": f"{default_template.pk},{vpn2_template.pk}",
+                "config-0-id": str(config.pk),
+                "config-0-device": str(config.device_id),
+                "config-INITIAL_FORMS": 1,
+                "_continue": True,
+            }
+        )
+        response = self.client.post(path, data=params, follow=True)
+        self.assertEqual(response.status_code, 200)
+        config.refresh_from_db()
+        config._invalidate_backend_instance_cache()
+        self.assertEqual(config.status, "modified")
+        self.assertEqual(config.vpnclient_set.count(), 1)
+        self.assertEqual(config.vpnclient_set.first().vpn, vpn2)
+        self.assertNotEqual(config.checksum, initial_checksum)
+        self.assertEqual(config.checksum, config.checksum_db)

{openwisp_controller-1.2.2 → openwisp_controller-1.2.3/openwisp_controller.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openwisp-controller
-Version: 1.2.2
+Version: 1.2.3
 Summary: OpenWISP Controller
 Home-page: http://openwisp.org
 Download-URL: https://github.com/openwisp/openwisp-controller/releases