nautobot 3.0.0a2__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/vpn/tests/test_forms.py

@@ -0,0 +1,294 @@
+"""Test vpn forms."""
+
+from django.contrib.contenttypes.models import ContentType
+
+from nautobot.apps.testing import FormTestCases
+from nautobot.dcim.models import Interface
+from nautobot.extras.models import DynamicGroup, Role, SecretsGroup, Status
+from nautobot.ipam.models import Prefix
+from nautobot.tenancy.models import Tenant
+from nautobot.vpn import choices, forms, models
+
+
+class VPNProfileFormTest(FormTestCases.BaseFormTestCase):
+    """Test the VPNProfile form."""
+
+    form_class = forms.VPNProfileForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+        profile_role, _ = Role.objects.get_or_create(name="Default")
+        profile_role.content_types.add(ContentType.objects.get_for_model(models.VPNProfile))
+
+        data = {
+            "name": "test 1",
+            "description": "test value",
+            "role": profile_role,
+            "secrets_group": SecretsGroup.objects.first(),
+            "keepalive_enabled": True,
+            "keepalive_interval": 3,
+            "keepalive_retries": 5,
+            "nat_traversal": False,
+            "extra_options": {"option": "value"},
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {
+            "name": "test value",
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_validate_name_is_required(self):
+        """Test that the name field is required."""
+
+        data = {
+            "description": "test value",
+            "keepalive_enabled": True,
+            "keepalive_interval": 3,
+            "keepalive_retries": 5,
+            "nat_traversal": False,
+            "extra_options": None,
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["name"])
+
+
+class VPNPhase1PolicyFormTest(FormTestCases.BaseFormTestCase):
+    """Test the VPNPhase1Policy form."""
+
+    form_class = forms.VPNPhase1PolicyForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+
+        data = {
+            "name": "test 1",
+            "description": "test value",
+            "ike_version": choices.IkeVersionChoices.ike_v2,
+            "aggressive_mode": False,
+            "encryption_algorithm": [choices.EncryptionAlgorithmChoices.aes_128_cbc],
+            "integrity_algorithm": [choices.IntegrityAlgorithmChoices.sha1],
+            "dh_group": [choices.DhGroupChoices.group5],
+            "lifetime_seconds": 10,
+            "lifetime_kb": 1024,
+            "authentication_method": choices.AuthenticationMethodChoices.rsa,
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {
+            "name": "test value",
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_validate_name_is_required(self):
+        """Test that the name field is required."""
+
+        data = {
+            "description": "test value",
+            "ike_version": choices.IkeVersionChoices.ike_v2,
+            "aggressive_mode": False,
+            "encryption_algorithm": [choices.EncryptionAlgorithmChoices.aes_128_cbc],
+            "integrity_algorithm": [choices.IntegrityAlgorithmChoices.sha1],
+            "dh_group": [choices.DhGroupChoices.group5],
+            "lifetime_seconds": 10,
+            "lifetime_kb": 1024,
+            "authentication_method": choices.AuthenticationMethodChoices.rsa,
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["name"])
+
+
+class VPNPhase2PolicyFormTest(FormTestCases.BaseFormTestCase):
+    """Test the VPNPhase2Policy form."""
+
+    form_class = forms.VPNPhase2PolicyForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+
+        data = {
+            "name": "test 1",
+            "description": "test value",
+            "encryption_algorithm": [choices.EncryptionAlgorithmChoices.aes_128_cbc],
+            "integrity_algorithm": [choices.IntegrityAlgorithmChoices.sha1],
+            "pfs_group": [choices.DhGroupChoices.group5],
+            "lifetime": 10,
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {
+            "name": "test value",
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_validate_name_is_required(self):
+        """Test that the name field is required."""
+
+        data = {
+            "description": "test value",
+            "encryption_algorithm": [choices.EncryptionAlgorithmChoices.aes_128_cbc],
+            "integrity_algorithm": [choices.IntegrityAlgorithmChoices.sha1],
+            "pfs_group": [choices.DhGroupChoices.group5],
+            "lifetime": 10,
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["name"])
+
+
+class VPNFormTest(FormTestCases.BaseFormTestCase):
+    """Test the VPN form."""
+
+    form_class = forms.VPNForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+        vpn_role, _ = Role.objects.get_or_create(name="Default")
+        vpn_role.content_types.add(ContentType.objects.get_for_model(models.VPN))
+
+        data = {
+            "name": "test 1",
+            "description": "test value",
+            "vpn_id": "test value",
+            "role": vpn_role,
+            "vpn_profile": models.VPNProfile.objects.first(),
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {
+            "name": "test value",
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_validate_name_is_required(self):
+        """Test that the name field is required."""
+
+        data = {
+            "description": "test value",
+            "vpn_id": "test value",
+            "vpn_profile": models.VPNProfile.objects.first(),
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["name"])
+
+
+class VPNTunnelFormTest(FormTestCases.BaseFormTestCase):
+    """Test the VPNTunnel form."""
+
+    form_class = forms.VPNTunnelForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+        endpoints = models.VPNTunnelEndpoint.objects.all()
+        tunnel_role, _ = Role.objects.get_or_create(name="Default")
+        tunnel_role.content_types.add(ContentType.objects.get_for_model(models.VPNTunnel))
+        data = {
+            "name": "test 1",
+            "description": "test value",
+            "vpn_profile": models.VPNProfile.objects.first(),
+            "vpn": models.VPN.objects.first(),
+            "tunnel_id": "test value",
+            "status": Status.objects.get(name="Active"),
+            "role": tunnel_role,
+            "encapsulation": choices.EncapsulationChoices.ipsec_tunnel,
+            "endpoint_a": endpoints[1],
+            "endpoint_z": endpoints[2],
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {
+            "name": "test value",
+            "status": Status.objects.get(name="Active"),
+            "encapsulation": choices.EncapsulationChoices.ipsec_tunnel,
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_validate_name_is_required(self):
+        """Test that the name field is required."""
+
+        data = {
+            "description": "test value",
+            "vpn_profile": models.VPNProfile.objects.first(),
+            "vpn": models.VPN.objects.first(),
+            "tunnel_id": "test value",
+            "status": Status.objects.get(name="Active"),
+            "encapsulation": choices.EncapsulationChoices.ipsec_tunnel,
+            "tenant": Tenant.objects.first(),
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["name"])
+
+
+class VPNTunnelEndpointFormTest(FormTestCases.BaseFormTestCase):
+    """Test the VPNTunnelEndpoint form."""
+
+    form_class = forms.VPNTunnelEndpointForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+        interfaces = Interface.objects.filter(device__isnull=False, vpn_tunnel_endpoints_src_int__isnull=True)
+        data = {
+            "device": interfaces[0].device,
+            "source_interface": interfaces[0],
+            "vpn_profile": models.VPNProfile.objects.first(),
+            "protected_prefixes": [Prefix.objects.first()],
+            "protected_prefixes_dg": [DynamicGroup.objects.first()],
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {"source_fqdn": "To Cloud"}
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())

nautobot/vpn/tests/test_models.py

@@ -0,0 +1,97 @@
+"""Test vpn models."""
+
+from django.core.exceptions import ValidationError
+
+from nautobot.apps.testing import ModelTestCases
+from nautobot.dcim.models import Interface
+from nautobot.vpn import models
+
+
+class TestVPNProfileModel(ModelTestCases.BaseModelTestCase):
+    """Test VPNProfile model."""
+
+    model = models.VPNProfile
+
+
+class TestVPNPhase1PolicyModel(ModelTestCases.BaseModelTestCase):
+    """Test VPNPhase1Policy model."""
+
+    model = models.VPNPhase1Policy
+
+
+class TestVPNPhase2PolicyModel(ModelTestCases.BaseModelTestCase):
+    """Test VPNPhase2Policy model."""
+
+    model = models.VPNPhase2Policy
+
+
+class VPNProfilePhase1PolicyAssignmentModel(ModelTestCases.BaseModelTestCase):
+    """Test VPNPhase1Policy model."""
+
+    model = models.VPNProfilePhase1PolicyAssignment
+
+
+class VPNProfilePhase2PolicyAssignmentModel(ModelTestCases.BaseModelTestCase):
+    """Test VPNPhase1Policy model."""
+
+    model = models.VPNProfilePhase2PolicyAssignment
+
+
+class TestVPNModel(ModelTestCases.BaseModelTestCase):
+    """Test VPN model."""
+
+    model = models.VPN
+
+
+class TestVPNTunnelModel(ModelTestCases.BaseModelTestCase):
+    """Test VPNTunnel model."""
+
+    model = models.VPNTunnel
+
+    def test_clean(self):
+        """Test custom clean method."""
+        endpoint = models.VPNTunnelEndpoint.objects.first()
+        tunnel = models.VPNTunnel(
+            endpoint_a=endpoint,
+            endpoint_z=endpoint,
+        )
+        with self.assertRaises(ValidationError):
+            tunnel.clean()
+
+
+class TestVPNTunnelEndpointModel(ModelTestCases.BaseModelTestCase):
+    """Test VPNTunnelEndpoint model."""
+
+    model = models.VPNTunnelEndpoint
+
+    def test_name(self):
+        """Test dynamic name property."""
+        with self.subTest("Test name contains interface name and device name."):
+            endpoint = models.VPNTunnelEndpoint.objects.filter(source_interface__isnull=False).first()
+            self.assertIn(endpoint.source_interface.name, endpoint.name)
+            self.assertIn(endpoint.source_interface.device.name, endpoint.name)
+
+        with self.subTest("Test name contains interface name, device name and IP address."):
+            endpoint = models.VPNTunnelEndpoint.objects.filter(
+                source_interface__isnull=False, source_ipaddress__isnull=False
+            ).first()
+            self.assertIn(endpoint.source_interface.name, endpoint.name)
+            self.assertIn(endpoint.source_interface.device.name, endpoint.name)
+            self.assertIn(endpoint.source_ipaddress.host, endpoint.name)
+
+        with self.subTest("Test name is fqdn"):
+            endpoint = (
+                models.VPNTunnelEndpoint.objects.filter(source_fqdn__isnull=False).exclude(source_fqdn="").first()
+            )
+            self.assertEqual(endpoint.source_fqdn, endpoint.name)
+
+    def test_save(self):
+        """Test save adds dynamic fields."""
+        interface = Interface.objects.filter(vpn_tunnel_endpoints_src_int__isnull=True).first()
+        new_endpoint = models.VPNTunnelEndpoint.objects.create(source_interface=interface)
+
+        with self.subTest("Test device field is saved"):
+            self.assertEqual(new_endpoint.device, interface.device)
+
+        with self.subTest("Test name field is saved"):
+            self.assertEqual(new_endpoint.name, new_endpoint._name())

nautobot/vpn/tests/test_views.py

@@ -0,0 +1,281 @@
+"""Unit tests for vpn views."""
+
+from django.test import override_settings
+from django.urls import reverse
+
+from nautobot.apps.testing import ViewTestCases
+from nautobot.dcim.models import Interface
+from nautobot.extras.models import Status
+from nautobot.ipam.models import Prefix
+from nautobot.vpn import choices, models
+
+
+class VPNProfileViewTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    # pylint: disable=too-many-ancestors
+    """Test the VPNProfile views."""
+
+    model = models.VPNProfile
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "test value",
+            "description": "test value",
+            "keepalive_enabled": True,
+            "keepalive_interval": 10,
+            "keepalive_retries": 3,
+            "nat_traversal": False,
+            "extra_options": None,
+            # Management form fields required for the dynamic formset
+            "vpn_profile_phase1_policy_assignments-TOTAL_FORMS": "0",
+            "vpn_profile_phase1_policy_assignments-INITIAL_FORMS": "1",
+            "vpn_profile_phase1_policy_assignments-MIN_NUM_FORMS": "0",
+            "vpn_profile_phase1_policy_assignments-MAX_NUM_FORMS": "1000",
+            "vpn_profile_phase2_policy_assignments-TOTAL_FORMS": "0",
+            "vpn_profile_phase2_policy_assignments-INITIAL_FORMS": "1",
+            "vpn_profile_phase2_policy_assignments-MIN_NUM_FORMS": "0",
+            "vpn_profile_phase2_policy_assignments-MAX_NUM_FORMS": "1000",
+        }
+
+        cls.update_data = {
+            "name": "updated value",
+            "description": "updated value",
+            "keepalive_enabled": True,
+            "keepalive_interval": 15,
+            "keepalive_retries": 5,
+            "nat_traversal": False,
+            # Management form fields required for the dynamic formset
+            "vpn_profile_phase1_policy_assignments-TOTAL_FORMS": "0",
+            "vpn_profile_phase1_policy_assignments-INITIAL_FORMS": "1",
+            "vpn_profile_phase1_policy_assignments-MIN_NUM_FORMS": "0",
+            "vpn_profile_phase1_policy_assignments-MAX_NUM_FORMS": "1000",
+            "vpn_profile_phase2_policy_assignments-TOTAL_FORMS": "0",
+            "vpn_profile_phase2_policy_assignments-INITIAL_FORMS": "1",
+            "vpn_profile_phase2_policy_assignments-MIN_NUM_FORMS": "0",
+            "vpn_profile_phase2_policy_assignments-MAX_NUM_FORMS": "1000",
+        }
+
+        cls.bulk_edit_data = {
+            "description": "bulk updated value",
+            "keepalive_enabled": True,
+            "keepalive_interval": 30,
+            "keepalive_retries": 10,
+            "nat_traversal": True,
+        }
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_profile_vpns(self):
+        self.add_permissions("vpn.view_vpn")
+        profile = models.VPNProfile.objects.filter(vpns__isnull=False).first()
+
+        url = reverse("vpn:vpnprofile_vpns", kwargs={"pk": profile.pk})
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_profile_vpntunnels(self):
+        self.add_permissions("vpn.view_vpntunnel")
+        profile = models.VPNProfile.objects.filter(vpn_tunnels__isnull=False).first()
+
+        url = reverse("vpn:vpnprofile_vpntunnels", kwargs={"pk": profile.pk})
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_profile_vpnendpoints(self):
+        self.add_permissions("vpn.view_vpntunnelendpoint")
+        profile = models.VPNProfile.objects.filter(vpn_tunnel_endpoints__isnull=False).first()
+
+        url = reverse("vpn:vpnprofile_vpnendpoints", kwargs={"pk": profile.pk})
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+
+
+class VPNPhase1PolicyViewTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    # pylint: disable=too-many-ancestors
+    """Test the VPNPhase1Policy views."""
+
+    model = models.VPNPhase1Policy
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "test value",
+            "description": "test value",
+            "ike_version": choices.IkeVersionChoices.ike_v2,
+            "aggressive_mode": False,
+            "encryption_algorithm": choices.EncryptionAlgorithmChoices.aes_128_cbc,
+            "integrity_algorithm": choices.IntegrityAlgorithmChoices.sha256,
+            "dh_group": choices.DhGroupChoices.group14,
+            "lifetime_seconds": 10,
+            "lifetime_kb": None,
+            "authentication_method": choices.AuthenticationMethodChoices.rsa,
+        }
+
+        cls.update_data = {
+            "name": "updated value",
+            "description": "updated value",
+            "ike_version": choices.IkeVersionChoices.ike_v2,
+            "aggressive_mode": False,
+            "encryption_algorithm": choices.EncryptionAlgorithmChoices.aes_192_cbc,
+            "integrity_algorithm": choices.IntegrityAlgorithmChoices.sha512,
+            "dh_group": choices.DhGroupChoices.group21,
+            "lifetime_seconds": 5,
+            "lifetime_kb": None,
+            "authentication_method": choices.AuthenticationMethodChoices.certificate,
+        }
+
+        cls.bulk_edit_data = {
+            "description": "bulk updated value",
+            "ike_version": choices.IkeVersionChoices.ike_v2,
+            "aggressive_mode": False,
+            "encryption_algorithm": choices.EncryptionAlgorithmChoices.aes_256_gcm,
+            "integrity_algorithm": choices.IntegrityAlgorithmChoices.sha1,
+            "dh_group": choices.DhGroupChoices.group5,
+            "lifetime_seconds": 15,
+            "lifetime_kb": None,
+            "authentication_method": choices.AuthenticationMethodChoices.ecdsa,
+        }
+
+
+class VPNPhase2PolicyViewTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    # pylint: disable=too-many-ancestors
+    """Test the VPNPhase2Policy views."""
+
+    model = models.VPNPhase2Policy
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "test value",
+            "description": "test value",
+            "encryption_algorithm": choices.EncryptionAlgorithmChoices.aes_128_cbc,
+            "integrity_algorithm": choices.IntegrityAlgorithmChoices.sha256,
+            "pfs_group": choices.DhGroupChoices.group14,
+            "lifetime": 10,
+        }
+
+        cls.update_data = {
+            "name": "updated value",
+            "description": "updated value",
+            "encryption_algorithm": choices.EncryptionAlgorithmChoices.aes_192_cbc,
+            "integrity_algorithm": choices.IntegrityAlgorithmChoices.sha512,
+            "pfs_group": choices.DhGroupChoices.group21,
+            "lifetime": 5,
+        }
+
+        cls.bulk_edit_data = {
+            "description": "bulk updated value",
+            "encryption_algorithm": choices.EncryptionAlgorithmChoices.aes_256_gcm,
+            "integrity_algorithm": choices.IntegrityAlgorithmChoices.sha1,
+            "pfs_group": choices.DhGroupChoices.group5,
+            "lifetime": 15,
+        }
+
+
+class VPNViewTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    # pylint: disable=too-many-ancestors
+    """Test the VPN views."""
+
+    model = models.VPN
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "test value",
+            "description": "test value",
+            "vpn_id": "test value",
+            "vpn_profile": models.VPNProfile.objects.first().pk,
+        }
+
+        cls.update_data = {
+            "name": "updated value",
+            "description": "updated value",
+            "vpn_id": "updated value",
+            "vpn_profile": models.VPNProfile.objects.last().pk,
+        }
+
+        cls.bulk_edit_data = {
+            "description": "bulk updated value",
+        }
+
+
+class VPNTunnelViewTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    # pylint: disable=too-many-ancestors
+    """Test the VPNTunnel views."""
+
+    model = models.VPNTunnel
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "test value",
+            "description": "test value",
+            "vpn_profile": models.VPNProfile.objects.first().pk,
+            "vpn": models.VPN.objects.first().pk,
+            "tunnel_id": "test value",
+            "status": Status.objects.get(name="Active").pk,
+            "encapsulation": choices.EncapsulationChoices.ipsec_tunnel,
+            "endpoint_a": models.VPNTunnelEndpoint.objects.first().pk,
+            "endpoint_z": models.VPNTunnelEndpoint.objects.last().pk,
+        }
+
+        cls.update_data = {
+            "name": "test value",
+            "description": "updated value",
+            "vpn_profile": models.VPNProfile.objects.last().pk,
+            "vpn": models.VPN.objects.last().pk,
+            "tunnel_id": "updated value",
+            "status": Status.objects.get(name="Active").pk,
+            "encapsulation": choices.EncapsulationChoices.l2tp,
+            "endpoint_a": models.VPNTunnelEndpoint.objects.last().pk,
+            "endpoint_z": models.VPNTunnelEndpoint.objects.first().pk,
+        }
+
+        cls.bulk_edit_data = {
+            "description": "bulk updated value",
+        }
+
+
+class VPNTunnelEndpointViewTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    # pylint: disable=too-many-ancestors
+    """Test the VPNTunnelEndpoint views."""
+
+    model = models.VPNTunnelEndpoint
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        interfaces = Interface.objects.filter(device__isnull=False, vpn_tunnel_endpoints_src_int__isnull=True)
+
+        cls.form_data = {
+            "device": interfaces.first().device.pk,
+            "source_interface": interfaces.first().pk,
+            "vpn_profile": models.VPNProfile.objects.first().pk,
+            "protected_prefixes": [Prefix.objects.first().pk],
+        }
+
+        cls.update_data = {
+            "device": interfaces.last().device.pk,
+            "source_interface": interfaces.last().pk,
+            "protected_prefixes": [Prefix.objects.last().pk],
+        }
+
+        cls.bulk_edit_data = {"vpn_profile": models.VPNProfile.objects.last().pk}

nautobot/vpn/urls.py

@@ -0,0 +1,16 @@
+from nautobot.core.views.routers import NautobotUIViewSetRouter
+
+from . import views
+
+app_name = "vpn"
+router = NautobotUIViewSetRouter()
+
+router.register("vpn-profiles", views.VPNProfileUIViewSet)
+router.register("vpn-phase-1-policies", views.VPNPhase1PolicyUIViewSet)
+router.register("vpn-phase-2-policies", views.VPNPhase2PolicyUIViewSet)
+router.register("vpns", views.VPNUIViewSet)
+router.register("vpn-tunnels", views.VPNTunnelUIViewSet)
+router.register("vpn-tunnel-endpoints", views.VPNTunnelEndpointUIViewSet)
+
+urlpatterns = []
+urlpatterns += router.urls