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

nautobot/virtualization/tests/test_models.py

@@ -154,6 +154,11 @@ class VMInterfaceTestCase(TestCase):  # TODO: change to BaseModelTestCase
         self.assertEqual(count, 1)
         self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ips[-1], vm_interface=vm_interface).count(), 1)
 
+        # add a single instance which is already there
+        count = vm_interface.add_ip_addresses(ips[-1])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ips[-1], vm_interface=vm_interface).count(), 1)
+
         # add multiple instances
         count = vm_interface.add_ip_addresses(ips[:5])
         self.assertEqual(count, 5)
@@ -161,12 +166,27 @@ class VMInterfaceTestCase(TestCase):  # TODO: change to BaseModelTestCase
         for ip in ips[:5]:
             self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, vm_interface=vm_interface).count(), 1)
 
+        # add multiple instances all of which are already there
+        count = vm_interface.add_ip_addresses(ips[:5])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(vm_interface=vm_interface).count(), 6)
+        for ip in ips[:5]:
+            self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, vm_interface=vm_interface).count(), 1)
+
+        # add multiple IPs some of which are there
+        count = vm_interface.add_ip_addresses(ips[3:7])
+        self.assertEqual(count, 2)
+        self.assertEqual(IPAddressToInterface.objects.filter(vm_interface=vm_interface).count(), 8)
+        for ip in ips[3:7]:
+            self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, vm_interface=vm_interface).count(), 1)
+
     def test_remove_ip_addresses(self):
         """Test the `remove_ip_addresses` helper method on `VMInterface`"""
         vm_interface = VMInterface.objects.create(
             name="Int1", virtual_machine=self.virtualmachine, status=self.int_status
         )
-        ips = list(IPAddress.objects.all()[:10])
+        ips = list(IPAddress.objects.filter(ip_version=4)[:10])
+        self.assertEqual(len(ips), 10)
 
         # baseline (no vm_interface to ip address relationships exists)
         self.assertFalse(IPAddressToInterface.objects.filter(vm_interface=vm_interface).exists())
@@ -179,13 +199,28 @@ class VMInterfaceTestCase(TestCase):  # TODO: change to BaseModelTestCase
         self.assertEqual(count, 1)
         self.assertEqual(IPAddressToInterface.objects.filter(vm_interface=vm_interface).count(), 9)
 
+        # remove a single instance which has already been removed
+        count = vm_interface.remove_ip_addresses(ips[-1])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(vm_interface=vm_interface).count(), 9)
+
         # remove multiple instances
         count = vm_interface.remove_ip_addresses(ips[:5])
         self.assertEqual(count, 5)
         self.assertEqual(IPAddressToInterface.objects.filter(vm_interface=vm_interface).count(), 4)
 
+        # remove multiple instances all which have already been removed
+        count = vm_interface.remove_ip_addresses(ips[:5])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(vm_interface=vm_interface).count(), 4)
+
+        # remove multiple instances some of which have already been removed
+        count = vm_interface.remove_ip_addresses(ips[3:7])
+        self.assertEqual(count, 2)
+        self.assertEqual(IPAddressToInterface.objects.filter(vm_interface=vm_interface).count(), 2)
+
         count = vm_interface.remove_ip_addresses(ips)
-        self.assertEqual(count, 4)
+        self.assertEqual(count, 2)
         self.assertEqual(IPAddressToInterface.objects.filter(vm_interface=vm_interface).count(), 0)
 
         # Test the pre_delete signal for IPAddressToInterface instances
@@ -194,9 +229,14 @@ class VMInterfaceTestCase(TestCase):  # TODO: change to BaseModelTestCase
         self.virtualmachine.primary_ip6 = vm_interface.ip_addresses.all().filter(ip_version=6).first()
         self.virtualmachine.save()
 
-        vm_interface.remove_ip_addresses(self.virtualmachine.primary_ip4)
+        count = vm_interface.remove_ip_addresses(self.virtualmachine.primary_ip4)
+        self.assertEqual(count, 1)
         self.virtualmachine.refresh_from_db()
         self.assertEqual(self.virtualmachine.primary_ip4, None)
-        vm_interface.remove_ip_addresses(self.virtualmachine.primary_ip6)
+        # NOTE: This effectively tests what happens when you pass remove_ip_addresses None; it
+        # NOTE: does not remove a v6 address, because there are no v6 IPs used in this test
+        # NOTE: class.
+        count = vm_interface.remove_ip_addresses(self.virtualmachine.primary_ip6)
+        self.assertEqual(count, 0)
         self.virtualmachine.refresh_from_db()
         self.assertEqual(self.virtualmachine.primary_ip6, None)

nautobot/vpn/api/serializers.py

@@ -0,0 +1,113 @@
+from rest_framework.serializers import ChoiceField, ListField
+
+from nautobot.apps.api import NautobotModelSerializer, TaggedModelSerializerMixin
+
+from .. import choices, models
+
+
+class VPNProfileSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):  # pylint: disable=too-many-ancestors
+    """VPNProfile Serializer."""
+
+    class Meta:
+        """Meta attributes."""
+
+        model = models.VPNProfile
+        fields = "__all__"
+
+
+class VPNPhase1PolicySerializer(TaggedModelSerializerMixin, NautobotModelSerializer):  # pylint: disable=too-many-ancestors
+    """VPNPhase1Policy Serializer."""
+
+    encryption_algorithm = ListField(
+        child=ChoiceField(choices=choices.EncryptionAlgorithmChoices),
+        allow_empty=True,
+        required=False,
+    )
+    integrity_algorithm = ListField(
+        child=ChoiceField(choices=choices.IntegrityAlgorithmChoices),
+        allow_empty=True,
+        required=False,
+    )
+    dh_group = ListField(
+        child=ChoiceField(choices=choices.DhGroupChoices),
+        allow_empty=True,
+        required=False,
+    )
+
+    class Meta:
+        """Meta attributes."""
+
+        model = models.VPNPhase1Policy
+        fields = "__all__"
+
+
+class VPNPhase2PolicySerializer(TaggedModelSerializerMixin, NautobotModelSerializer):  # pylint: disable=too-many-ancestors
+    """VPNPhase2Policy Serializer."""
+
+    encryption_algorithm = ListField(
+        child=ChoiceField(choices=choices.EncryptionAlgorithmChoices),
+        allow_empty=True,
+        required=False,
+    )
+    integrity_algorithm = ListField(
+        child=ChoiceField(choices=choices.IntegrityAlgorithmChoices),
+        allow_empty=True,
+        required=False,
+    )
+    pfs_group = ListField(
+        child=ChoiceField(choices=choices.DhGroupChoices),
+        allow_empty=True,
+        required=False,
+    )
+
+    class Meta:
+        """Meta attributes."""
+
+        model = models.VPNPhase2Policy
+        fields = "__all__"
+
+
+class VPNProfilePhase1PolicyAssignmentSerializer(NautobotModelSerializer):
+    """Serializer for `VPNProfilePhase1PolicyAssignment` objects."""
+
+    class Meta:
+        model = models.VPNProfilePhase1PolicyAssignment
+        fields = "__all__"
+
+
+class VPNProfilePhase2PolicyAssignmentSerializer(NautobotModelSerializer):
+    """Serializer for `VPNProfilePhase2PolicyAssignment` objects."""
+
+    class Meta:
+        model = models.VPNProfilePhase2PolicyAssignment
+        fields = "__all__"
+
+
+class VPNSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):  # pylint: disable=too-many-ancestors
+    """VPN Serializer."""
+
+    class Meta:
+        """Meta attributes."""
+
+        model = models.VPN
+        fields = "__all__"
+
+
+class VPNTunnelSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):  # pylint: disable=too-many-ancestors
+    """VPNTunnel Serializer."""
+
+    class Meta:
+        """Meta attributes."""
+
+        model = models.VPNTunnel
+        fields = "__all__"
+
+
+class VPNTunnelEndpointSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):  # pylint: disable=too-many-ancestors
+    """VPNTunnelEndpoint Serializer."""
+
+    class Meta:
+        """Meta attributes."""
+
+        model = models.VPNTunnelEndpoint
+        fields = "__all__"

nautobot/vpn/api/urls.py

@@ -0,0 +1,19 @@
+"""Django API urlpatterns declaration for the vpn models."""
+
+from nautobot.apps.api import OrderedDefaultRouter
+
+from . import views
+
+app_name = "vpn-api"
+router = OrderedDefaultRouter()
+# add the name of your api endpoint, usually hyphenated model name in plural, e.g. "my-model-classes"
+router.register("vpn-profiles", views.VPNProfileViewSet)
+router.register("vpn-phase-1-policies", views.VPNPhase1PolicyViewSet)
+router.register("vpn-phase-2-policies", views.VPNPhase2PolicyViewSet)
+router.register("vpn-profile-phase-1-policy-assignments", views.VPNProfilePhase1PolicyAssignmentViewSet)
+router.register("vpn-profile-phase-2-policy-assignments", views.VPNProfilePhase2PolicyAssignmentViewSet)
+router.register("vpns", views.VPNViewSet)
+router.register("vpn-tunnels", views.VPNTunnelViewSet)
+router.register("vpn-tunnel-endpoints", views.VPNTunnelEndpointViewSet)
+
+urlpatterns = router.urls

nautobot/vpn/api/views.py

@@ -0,0 +1,70 @@
+"""API views for the vpn models."""
+
+from nautobot.apps.api import ModelViewSet, NautobotModelViewSet
+
+from .. import filters, models
+from ..api import serializers
+
+
+class VPNProfileViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNProfile viewset."""
+
+    queryset = models.VPNProfile.objects.all()
+    serializer_class = serializers.VPNProfileSerializer
+    filterset_class = filters.VPNProfileFilterSet
+
+
+class VPNPhase1PolicyViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNPhase1Policy viewset."""
+
+    queryset = models.VPNPhase1Policy.objects.all()
+    serializer_class = serializers.VPNPhase1PolicySerializer
+    filterset_class = filters.VPNPhase1PolicyFilterSet
+
+
+class VPNPhase2PolicyViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNPhase2Policy viewset."""
+
+    queryset = models.VPNPhase2Policy.objects.all()
+    serializer_class = serializers.VPNPhase2PolicySerializer
+    filterset_class = filters.VPNPhase2PolicyFilterSet
+
+
+class VPNProfilePhase1PolicyAssignmentViewSet(ModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNProfilePhase1PolicyAssignment viewset."""
+
+    queryset = models.VPNProfilePhase1PolicyAssignment.objects.all()
+    serializer_class = serializers.VPNProfilePhase1PolicyAssignmentSerializer
+    filterset_class = filters.VPNProfilePhase1PolicyAssignmentFilterSet
+
+
+class VPNProfilePhase2PolicyAssignmentViewSet(ModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNProfilePhase2PolicyAssignment viewset."""
+
+    queryset = models.VPNProfilePhase2PolicyAssignment.objects.all()
+    serializer_class = serializers.VPNProfilePhase2PolicyAssignmentSerializer
+    filterset_class = filters.VPNProfilePhase2PolicyAssignmentFilterSet
+
+
+class VPNViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPN viewset."""
+
+    queryset = models.VPN.objects.all()
+    serializer_class = serializers.VPNSerializer
+    filterset_class = filters.VPNFilterSet
+
+
+class VPNTunnelViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNTunnel viewset."""
+
+    queryset = models.VPNTunnel.objects.all()
+    serializer_class = serializers.VPNTunnelSerializer
+    filterset_class = filters.VPNTunnelFilterSet
+
+
+class VPNTunnelEndpointViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNTunnelEndpoint viewset."""
+
+    queryset = models.VPNTunnelEndpoint.objects.all()
+    serializer_class = serializers.VPNTunnelEndpointSerializer
+    filterset_class = filters.VPNTunnelEndpointFilterSet

nautobot/vpn/apps.py

@@ -0,0 +1,8 @@
+from nautobot.core.apps import NautobotConfig
+
+
+class VPNConfig(NautobotConfig):
+    default = True
+    name = "nautobot.vpn"
+    verbose_name = "VPNs"
+    searchable_models = []

nautobot/vpn/choices.py

@@ -0,0 +1,171 @@
+"""Custom choices for the vpn models."""
+
+from nautobot.apps.choices import ChoiceSet
+
+
+class VPNTunnelStatusChoices(ChoiceSet):
+    STATUS_ACTIVE = "active"
+    STATUS_DOWN = "down"
+    STATUS_DEPRECATED = "deprecated"
+
+    CHOICES = (
+        (STATUS_ACTIVE, "Active"),
+        (STATUS_DOWN, "Down"),
+        (STATUS_DEPRECATED, "Deprecated"),
+    )
+
+
+class VPNTunnelEndpointRoleChoices(ChoiceSet):
+    ROLE_PEER = "peer"
+    ROLE_HUB = "hub"
+    ROLE_SPOKE = "spoke"
+
+    CHOICES = (
+        (ROLE_PEER, "Peer"),
+        (ROLE_HUB, "Hub"),
+        (ROLE_SPOKE, "Spoke"),
+    )
+
+
+class IkeVersionChoices(ChoiceSet):
+    """Choices for the ike_version field on the VPNPhase1Policy model."""
+
+    ike_v1 = "IKEv1"
+    ike_v2 = "IKEv2"
+
+    CHOICES = (
+        (ike_v1, "IKEv1"),
+        (ike_v2, "IKEv2"),
+    )
+
+
+class EncryptionAlgorithmChoices(ChoiceSet):
+    """Choices for the encryption_algorithm field on the VPNPhase1Policy model."""
+
+    aes_128_cbc = "AES-128-CBC"
+    aes_128_gcm = "AES-128-GCM"
+    aes_192_cbc = "AES-192-CBC"
+    aes_192_gcm = "AES-192-GCM"
+    aes_256_cbc = "AES-256-CBC"
+    aes_256_gcm = "AES-256-GCM"
+    des = "DES"
+    a3des = "3DES"
+
+    CHOICES = (
+        (aes_128_cbc, "AES-128-CBC"),
+        (aes_128_gcm, "AES-128-GCM"),
+        (aes_192_cbc, "AES-192-CBC"),
+        (aes_192_gcm, "AES-192-GCM"),
+        (aes_256_cbc, "AES-256-CBC"),
+        (aes_256_gcm, "AES-256-GCM"),
+        (des, "DES"),
+        (a3des, "3DES"),
+    )
+
+
+class IntegrityAlgorithmChoices(ChoiceSet):
+    """Choices for the integrity_algorithm field on the VPNPhase1Policy model."""
+
+    md5 = "MD5"
+    sha1 = "SHA1"
+    sha256 = "SHA256"
+    sha384 = "SHA384"
+    sha512 = "SHA512"
+
+    CHOICES = (
+        (md5, "MD5"),
+        (sha1, "SHA1"),
+        (sha256, "SHA256"),
+        (sha384, "SHA384"),
+        (sha512, "SHA512"),
+    )
+
+
+class DhGroupChoices(ChoiceSet):
+    """Choices for the dh_group field on the VPNPhase1Policy model."""
+
+    group1 = "1"
+    group2 = "2"
+    group5 = "5"
+    group14 = "14"
+    group19 = "19"
+    group20 = "20"
+    group21 = "21"
+    group22 = "22"
+    group23 = "23"
+    group24 = "24"
+    group25 = "25"
+    group26 = "26"
+    group27 = "27"
+    group28 = "28"
+    group29 = "29"
+    group30 = "30"
+    group31 = "31"
+    group32 = "32"
+    group33 = "33"
+    group34 = "34"
+
+    CHOICES = (
+        (group1, "Group 1"),
+        (group2, "Group 2"),
+        (group5, "Group 5"),
+        (group14, "Group 14"),
+        (group19, "Group 19"),
+        (group20, "Group 20"),
+        (group21, "Group 21"),
+        (group22, "Group 22"),
+        (group23, "Group 23"),
+        (group24, "Group 24"),
+        (group25, "Group 25"),
+        (group26, "Group 26"),
+        (group27, "Group 27"),
+        (group28, "Group 28"),
+        (group29, "Group 29"),
+        (group30, "Group 30"),
+        (group31, "Group 31"),
+        (group32, "Group 32"),
+        (group33, "Group 33"),
+        (group34, "Group 34"),
+    )
+
+
+class AuthenticationMethodChoices(ChoiceSet):
+    """Choices for the authentication_method field on the VPNPhase1Policy model."""
+
+    psk = "PSK"
+    rsa = "RSA"
+    ecdsa = "ECDSA"
+    certificate = "Certificate"
+
+    CHOICES = (
+        (psk, "PSK"),
+        (rsa, "RSA"),
+        (ecdsa, "ECDSA"),
+        (certificate, "Certificate"),
+    )
+
+
+class EncapsulationChoices(ChoiceSet):
+    """Choices for the encapsulation field on the VPNTunnel model."""
+
+    ipsec_transport = "IPsec-Transport"
+    ipsec_tunnel = "IPsec-Tunnel"
+    ip_in_ip = "IP-in-IP"
+    gre = "GRE"
+    wireguard = "WireGuard"
+    l2tp = "L2TP"
+    pptp = "PPTP"
+    openvpn = "OpenVPN"
+    eoip = "EoIP"
+
+    CHOICES = (
+        (ipsec_transport, "IPsec-Transport"),
+        (ipsec_tunnel, "IPsec-Tunnel"),
+        (ip_in_ip, "IP-in-IP"),
+        (gre, "GRE"),
+        (wireguard, "WireGuard"),
+        (l2tp, "L2TP"),
+        (pptp, "PPTP"),
+        (openvpn, "OpenVPN"),
+        (eoip, "EoIP"),
+    )

nautobot/vpn/factory.py

@@ -0,0 +1,209 @@
+import factory
+import faker
+
+from nautobot.core.factory import (
+    get_random_instances,
+    NautobotBoolIterator,
+    PrimaryModelFactory,
+    random_instance,
+    UniqueFaker,
+)
+from nautobot.dcim.models import Device, Interface
+from nautobot.extras.models import DynamicGroup, Role, SecretsGroup, Status
+from nautobot.ipam.models import IPAddress, Prefix
+from nautobot.tenancy.models import Tenant
+from nautobot.vpn import choices, models
+
+
+class VPNPhase1PolicyFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNPhase1Policy
+        exclude = ("has_description", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    ike_version = factory.Faker("random_element", elements=choices.IkeVersionChoices.values())
+    encryption_algorithm = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.EncryptionAlgorithmChoices.values(), unique=True))
+    )
+    integrity_algorithm = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.IntegrityAlgorithmChoices.values(), unique=True))
+    )
+    dh_group = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.DhGroupChoices.values(), unique=True))
+    )
+    lifetime_seconds = factory.Faker("pyint", min_value=0, max_value=3600, step=15)
+    lifetime_kb = factory.Faker("pyint", min_value=0, max_value=1024)
+    authentication_method = factory.Faker("random_element", elements=choices.AuthenticationMethodChoices.values())
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+
+class VPNPhase2PolicyFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNPhase2Policy
+        exclude = ("has_description", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    encryption_algorithm = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.EncryptionAlgorithmChoices.values(), unique=True))
+    )
+    integrity_algorithm = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.IntegrityAlgorithmChoices.values(), unique=True))
+    )
+    pfs_group = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.DhGroupChoices.values(), unique=True))
+    )
+    lifetime = factory.Faker("pyint", min_value=0, max_value=3600, step=15)
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+
+class VPNProfileFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNProfile
+        exclude = ("has_description", "has_role", "has_secrets_group", "has_extra_options", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(models.VPNProfile), allow_null=True),
+        None,
+    )
+    has_secrets_group = NautobotBoolIterator()
+    secrets_group = factory.Maybe(
+        "has_secrets_group",
+        random_instance(SecretsGroup),
+    )
+    keepalive_enabled = NautobotBoolIterator()
+    keepalive_interval = factory.Faker("pyint", min_value=0, max_value=3600, step=3)
+    keepalive_retries = factory.Faker("pyint", min_value=0, max_value=180, step=3)
+    nat_traversal = NautobotBoolIterator()
+    has_extra_options = NautobotBoolIterator()
+    extra_options = factory.Maybe(
+        "has_extra_options", factory.Faker("pydict", nb_elements=2, value_types=[str, bool, int]), None
+    )
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+    @factory.post_generation
+    def vpn_phase1_policies(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.vpn_phase1_policies.set(extracted)
+            else:
+                self.vpn_phase1_policies.set(get_random_instances(models.VPNPhase1Policy, minimum=1))
+
+    @factory.post_generation
+    def vpn_phase2_policies(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.vpn_phase2_policies.set(extracted)
+            else:
+                self.vpn_phase2_policies.set(get_random_instances(models.VPNPhase2Policy, minimum=1))
+
+
+class VPNFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPN
+        exclude = ("has_description", "has_profile", "has_role", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    vpn_id = factory.Faker("word")
+    has_profile = NautobotBoolIterator()
+    vpn_profile = factory.Maybe("has_profile", random_instance(models.VPNProfile), None)
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(models.VPN), allow_null=True),
+        None,
+    )
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+
+class VPNTunnelFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNTunnel
+        exclude = ("has_description", "has_profile", "has_vpn", "has_role", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    tunnel_id = factory.Faker("word")
+    has_profile = NautobotBoolIterator()
+    vpn_profile = factory.Maybe("has_profile", random_instance(models.VPNProfile), None)
+    has_vpn = NautobotBoolIterator()
+    vpn = factory.Maybe("has_vpn", random_instance(models.VPN), None)
+    status = random_instance(
+        lambda: Status.objects.get_for_model(models.VPNTunnel),
+        allow_null=False,
+    )
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(models.VPNTunnel), allow_null=True),
+        None,
+    )
+    encapsulation = factory.Faker("random_element", elements=choices.EncapsulationChoices.values())
+    endpoint_a = factory.Sequence(lambda n: models.VPNTunnelEndpoint.objects.all()[n])
+    endpoint_z = factory.Sequence(lambda n: models.VPNTunnelEndpoint.objects.all()[n + 10])
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+
+class VPNTunnelEndpointFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNTunnelEndpoint
+        exclude = ("has_device", "has_profile", "has_role", "has_tenant")
+
+    has_device = NautobotBoolIterator()
+    device = factory.Maybe("has_device", random_instance(Device), None)
+    source_interface = factory.Maybe(
+        "has_device",
+        random_instance(
+            lambda: Interface.objects.filter(vpn_tunnel_endpoints_src_int__isnull=True, device__isnull=False)
+        ),
+        None,
+    )
+    source_ipaddress = factory.Maybe("has_device", random_instance(IPAddress), None)
+    source_fqdn = factory.Maybe("has_device", "", factory.Faker("word"))
+    tunnel_interface = factory.Maybe(
+        "has_device",
+        random_instance(lambda: Interface.objects.filter(type="tunnel", vpn_tunnel_endpoints_tunnel__isnull=True)),
+        None,
+    )
+    has_profile = NautobotBoolIterator()
+    vpn_profile = factory.Maybe("has_profile", random_instance(models.VPNProfile), None)
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(models.VPNTunnelEndpoint), allow_null=True),
+        None,
+    )
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+    @factory.post_generation
+    def protected_prefixes(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.protected_prefixes.set(extracted)
+            else:
+                self.protected_prefixes.set(get_random_instances(Prefix, minimum=0))
+
+    @factory.post_generation
+    def protected_prefixes_dg(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.protected_prefixes_dg.set(extracted)
+            else:
+                self.protected_prefixes_dg.set(get_random_instances(DynamicGroup, minimum=0))