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

nautobot/vpn/tests/test_forms.py

@@ -0,0 +1,293 @@
+"""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 = {
+            "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": "cloud.com"}
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())

nautobot/vpn/tests/test_models.py

@@ -0,0 +1,147 @@
+"""Test vpn models."""
+
+from django.core.exceptions import ValidationError
+
+from nautobot.apps.testing import ModelTestCases
+from nautobot.dcim.models import Device, Interface, Module
+from nautobot.ipam.models import IPAddress
+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_clean(self):
+        """Test model constraints."""
+        with self.subTest("Test source_ipaddress conflicts with source_fqdn"):
+            endpoint = models.VPNTunnelEndpoint(source_ipaddress=IPAddress.objects.first(), source_fqdn="cloud.com")
+            with self.assertRaises(ValidationError):
+                endpoint.clean()
+
+        with self.subTest("Test at least one required field is missing"):
+            endpoint = models.VPNTunnelEndpoint()
+            with self.assertRaises(ValidationError):
+                endpoint.clean()
+
+        with self.subTest("Test Interface without device"):
+            endpoint = models.VPNTunnelEndpoint(
+                source_interface=Interface(
+                    name="Ethernet",
+                    module=Module(),
+                ),
+            )
+            with self.assertRaises(ValidationError):
+                endpoint.clean()
+
+        with self.subTest("Test source_ipaddress is assigned to source_interface"):
+            endpoint = models.VPNTunnelEndpoint(
+                source_interface=Interface.objects.filter(device__isnull=False).first(),
+                source_ipaddress=IPAddress.objects.filter(interfaces__isnull=True).first(),
+            )
+            with self.assertRaises(ValidationError):
+                endpoint.clean()
+
+        with self.subTest("Test source_interface and tunnel_interface are assigned to the same device"):
+            source_int = Interface.objects.filter(device__isnull=False).first()
+            tunnel_int = Interface(
+                name="Tunnel0",
+                device=Device.objects.exclude(id=source_int.device.id).first(),
+                status=source_int.status,
+                type="tunnel",
+            )
+            endpoint = models.VPNTunnelEndpoint(
+                device=source_int.device, source_interface=source_int, tunnel_interface=tunnel_int
+            )
+            with self.assertRaises(ValidationError):
+                endpoint.clean()
+
+    def test_name(self):
+        """Test dynamic name property."""
+        endpoint = models.VPNTunnelEndpoint.objects.filter(source_interface__isnull=False).first()
+        ip = IPAddress.objects.filter(interface_assignments__isnull=True).last()
+        ip.interfaces.add(endpoint.source_interface)
+        endpoint.source_ipaddress = ip
+        endpoint.save()
+
+        with self.subTest("Test name contains interface name, device name and IP address"):
+            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 contains interface name and device name"):
+            endpoint = models.VPNTunnelEndpoint.objects.filter(
+                source_interface__isnull=False, source_ipaddress__isnull=True
+            ).first()
+            self.assertIn(endpoint.source_interface.name, endpoint.name)
+            self.assertIn(endpoint.source_interface.device.name, 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, device__isnull=False).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())