nautobot 2.4.3__py3-none-any.whl → 2.4.4__py3-none-any.whl

nautobot/ipam/models.py

@@ -135,6 +135,12 @@ class VRF(PrimaryModel):
         through="ipam.VRFDeviceAssignment",
         through_fields=("vrf", "virtual_machine"),
     )
+    virtual_device_contexts = models.ManyToManyField(
+        to="dcim.VirtualDeviceContext",
+        related_name="vrfs",
+        through="ipam.VRFDeviceAssignment",
+        through_fields=("vrf", "virtual_device_context"),
+    )
     prefixes = models.ManyToManyField(
         to="ipam.Prefix",
         related_name="vrfs",
@@ -238,6 +244,41 @@ class VRF(PrimaryModel):
         instance = self.virtual_machines.through.objects.get(vrf=self, virtual_machine=virtual_machine)
         return instance.delete()
 
+    def add_virtual_device_context(self, virtual_device_context, rd="", name=""):
+        """
+        Add a `virtual_device_context` to this VRF, optionally overloading `rd` and `name`.
+
+        If `rd` or `name` are not provided, the values from this VRF will be inherited.
+
+        Args:
+            virtual_device_context (VirtualDeviceContext): VirtualDeviceContext instance
+            rd (str): (Optional) RD of the VRF when associated with this VirtualDeviceContext
+            name (str): (Optional) Name of the VRF when associated with this VirtualDeviceContext
+
+        Returns:
+            VRFDeviceAssignment instance
+        """
+        instance = self.virtual_device_contexts.through(
+            vrf=self, virtual_device_context=virtual_device_context, rd=rd, name=name
+        )
+        instance.validated_save()
+        return instance
+
+    def remove_virtual_device_context(self, virtual_device_context):
+        """
+        Remove a `virtual_device_context` from this VRF.
+
+        Args:
+            virtual_device_context (VirtualDeviceContext): VirtualDeviceContext instance
+
+        Returns:
+            tuple (int, dict): Number of objects deleted and a dict with number of deletions.
+        """
+        instance = self.virtual_device_contexts.through.objects.get(
+            vrf=self, virtual_device_context=virtual_device_context
+        )
+        return instance.delete()
+
     def add_prefix(self, prefix):
         """
         Add a `prefix` to this VRF. Each object must be in the same Namespace.
@@ -275,6 +316,9 @@ class VRFDeviceAssignment(BaseModel):
     virtual_machine = models.ForeignKey(
         "virtualization.VirtualMachine", null=True, blank=True, on_delete=models.CASCADE, related_name="vrf_assignments"
     )
+    virtual_device_context = models.ForeignKey(
+        "dcim.VirtualDeviceContext", null=True, blank=True, on_delete=models.CASCADE, related_name="vrf_assignments"
+    )
     rd = models.CharField(  # noqa: DJ001  # django-nullable-model-string-field -- see below
         max_length=constants.VRF_RD_MAX_LENGTH,
         blank=True,
@@ -289,14 +333,16 @@ class VRFDeviceAssignment(BaseModel):
         unique_together = [
             ["vrf", "device"],
             ["vrf", "virtual_machine"],
+            ["vrf", "virtual_device_context"],
             # TODO: desirable in the future, but too strict for 1.x-to-2.0 data migrations,
             #       as multiple "cleanup" VRFs in different cleanup namespaces might be assigned to a single device/VM.
             # ["device", "rd", "name"],
             # ["virtual_machine", "rd", "name"],
+            # ["virtual_device_context", "rd", "name"],
         ]
 
     def __str__(self):
-        obj = self.device or self.virtual_machine
+        obj = self.device or self.virtual_machine or self.virtual_device_context
         return f"{self.vrf} [{obj}] (rd: {self.rd}, name: {self.name})"
 
     def clean(self):
@@ -310,11 +356,23 @@ class VRFDeviceAssignment(BaseModel):
         if not self.name:
             self.name = self.vrf.name
 
-        # A VRF must belong to a Device *or* to a VirtualMachine.
+        # A VRF must belong to a Device *or* to a VirtualMachine *or* to a Virtual Device Context.
         if all([self.device, self.virtual_machine]):
-            raise ValidationError("A VRF cannot be associated with both a device and a virtual machine.")
-        if not any([self.device, self.virtual_machine]):
-            raise ValidationError("A VRF must be associated with either a device or a virtual machine.")
+            raise ValidationError(
+                "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual machine."
+            )
+        if all([self.device, self.virtual_device_context]):
+            raise ValidationError(
+                "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual device context."
+            )
+        if all([self.virtual_machine, self.virtual_device_context]):
+            raise ValidationError(
+                "A VRFDeviceAssignment entry cannot be associated with both a virtual machine and a virtual device context."
+            )
+        if not any([self.device, self.virtual_machine, self.virtual_device_context]):
+            raise ValidationError(
+                "A VRFDeviceAssignment entry must be associated with a device, a virtual machine, or a virtual device context."
+            )
 
 
 @extras_features("graphql")

nautobot/ipam/tables.py

@@ -247,13 +247,27 @@ class VRFDeviceAssignmentTable(BaseTable):
         linkify=lambda record: record.vrf.namespace.get_absolute_url(),
         accessor="vrf.namespace.name",
     )
-    device = tables.Column(
-        linkify=lambda record: record.device.get_absolute_url(), accessor="device.name", verbose_name="Device"
+    related_object_type = tables.TemplateColumn(
+        template_code="""
+        {% if record.device %}
+            Device
+        {% elif record.virtual_machine %}
+            Virtual Machine
+        {% else %}
+            Virtual Device Context
+        {% endif %}
+        """
     )
-    virtual_machine = tables.Column(
-        linkify=lambda record: record.virtual_machine.get_absolute_url(),
-        accessor="virtual_machine.name",
-        verbose_name="Virtual Machine",
+    related_object_name = tables.TemplateColumn(
+        template_code="""
+        {% if record.device %}
+            <a href="{{ record.device.get_absolute_url }}">{{ record.device.name }}</a>
+        {% elif record.virtual_machine %}
+            <a href="{{ record.virtual_machine.get_absolute_url }}">{{ record.virtual_machine.name }}</a>
+        {% else %}
+            <a href="{{ record.virtual_device_context.get_absolute_url }}">{{ record.virtual_device_context.name }}</a>
+        {% endif %}
+        """
     )
     rd = tables.Column(verbose_name="VRF RD")
     tenant = TenantColumn(accessor="vrf.tenant")
@@ -261,7 +275,7 @@ class VRFDeviceAssignmentTable(BaseTable):
     class Meta(BaseTable.Meta):
         model = VRFDeviceAssignment
         orderable = False
-        fields = ("vrf", "namespace", "device", "virtual_machine", "rd", "tenant")
+        fields = ("vrf", "related_object_type", "related_object_name", "namespace", "rd", "tenant")
 
 
 class VRFPrefixAssignmentTable(BaseTable):

nautobot/ipam/tests/test_api.py

@@ -13,7 +13,15 @@ from rest_framework import status
 from nautobot.core.testing import APITestCase, APIViewTestCases, disable_warnings
 from nautobot.core.testing.api import APITransactionTestCase
 from nautobot.dcim.choices import InterfaceTypeChoices
-from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType, Manufacturer
+from nautobot.dcim.models import (
+    Device,
+    DeviceType,
+    Interface,
+    Location,
+    LocationType,
+    Manufacturer,
+    VirtualDeviceContext,
+)
 from nautobot.extras.models import CustomField, Role, Status
 from nautobot.ipam import choices
 from nautobot.ipam.models import (
@@ -118,6 +126,7 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
     def setUpTestData(cls):
         cls.vrfs = VRF.objects.all()
         cls.devices = Device.objects.all()
+        cls.vdcs = VirtualDeviceContext.objects.all()
         locations = Location.objects.filter(location_type__name="Campus")
         cluster_type = ClusterType.objects.create(name="Test Cluster Type")
         clusters = (
@@ -154,25 +163,42 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
             virtual_machine=cls.test_vm,
             rd="65000:4",
         )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[0],
+            name="VRFDeviceAssignment 1",
+            rd="65000:5",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[1],
+        )
+
+        cls.update_data = {
+            "name": "VRFDeviceAssignment 2",
+            "rd": "65000:7",
+        }
 
         cls.create_data = [
             {
                 "vrf": cls.vrfs[2].pk,
                 "device": cls.devices[4].pk,
-                "virtual_machine": None,
-                "rd": "65000:4",
+                "rd": "65000:7",
             },
             {
                 "vrf": cls.vrfs[3].pk,
-                "device": None,
                 "virtual_machine": cls.test_vm.pk,
-                "rd": "65000:5",
+                "rd": "65000:8",
             },
             {
                 "vrf": cls.vrfs[4].pk,
                 "device": cls.devices[6].pk,
-                "virtual_machine": None,
-                "rd": "65000:6",
+                "name": "VRFDeviceAssignment 3",
+                "rd": "65000:9",
+            },
+            {
+                "vrf": cls.vrfs[4].pk,
+                "virtual_device_context": cls.vdcs[0].pk,
             },
         ]
         cls.bulk_update_data = {
@@ -181,39 +207,66 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
 
     def test_creating_invalid_vrf_device_assignments(self):
         # Add object-level permission
-        duplicate_device_create_data = {
-            "vrf": self.vrfs[0].pk,
-            "device": self.devices[1].pk,
-            "virtual_machine": None,
-            "rd": "65000:6",
-        }
-        duplicate_vm_create_data = {
-            "vrf": self.vrfs[1].pk,
-            "device": None,
-            "virtual_machine": self.test_vm.pk,
-            "rd": "65000:6",
-        }
-        invalid_create_data = {
-            "vrf": self.vrfs[2].pk,
-            "device": self.devices[6].pk,
-            "virtual_machine": self.test_vm.pk,
-            "rd": "65000:6",
-        }
         self.add_permissions("ipam.add_vrfdeviceassignment")
-        response = self.client.post(self._get_list_url(), duplicate_device_create_data, format="json", **self.header)
-        self.assertContains(
-            response, "The fields device, vrf must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
-        )
-        response = self.client.post(self._get_list_url(), duplicate_vm_create_data, format="json", **self.header)
-        self.assertContains(
-            response, "The fields virtual_machine, vrf must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
-        )
-        response = self.client.post(self._get_list_url(), invalid_create_data, format="json", **self.header)
-        self.assertContains(
-            response,
-            "A VRF cannot be associated with both a device and a virtual machine.",
-            status_code=status.HTTP_400_BAD_REQUEST,
-        )
+        duplicate_create_data = [
+            {
+                "vrf": self.vrfs[0].pk,
+                "device": self.devices[1].pk,
+                "rd": "65000:6",
+            },
+            {
+                "vrf": self.vrfs[1].pk,
+                "virtual_machine": self.test_vm.pk,
+                "rd": "65000:6",
+            },
+            {
+                "vrf": self.vrfs[0].pk,
+                "virtual_device_context": self.vdcs[1].pk,
+                "rd": "65000:6",
+            },
+        ]
+        expected_responses = [
+            "The fields device, vrf must make a unique set.",
+            "The fields virtual_machine, vrf must make a unique set.",
+            "The fields virtual_device_context, vrf must make a unique set.",
+        ]
+        for i, data in enumerate(duplicate_create_data):
+            response = self.client.post(self._get_list_url(), data, format="json", **self.header)
+            self.assertContains(response, expected_responses[i], status_code=status.HTTP_400_BAD_REQUEST)
+
+        # Test VRFDeviceAssignment model clean() code paths
+        vrf = VRF.objects.create(name="New VRF ", namespace=Namespace.objects.first())
+        invalid_create_data = [
+            {
+                "vrf": vrf.pk,
+                "device": self.devices[6].pk,
+                "virtual_machine": self.test_vm.pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "device": self.devices[7].pk,
+                "virtual_device_context": self.vdcs[2].pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "virtual_machine": self.test_vm.pk,
+                "virtual_device_context": self.vdcs[3].pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "name": "VRFDeviceAssignment 5",
+                "rd": "65000:6",
+            },
+        ]
+        expected_responses = [
+            "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual machine.",
+            "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual device context.",
+            "A VRFDeviceAssignment entry cannot be associated with both a virtual machine and a virtual device context.",
+            "A VRFDeviceAssignment entry must be associated with a device, a virtual machine, or a virtual device context.",
+        ]
+        for i, data in enumerate(invalid_create_data):
+            response = self.client.post(self._get_list_url(), data, format="json", **self.header)
+            self.assertContains(response, expected_responses[i], status_code=status.HTTP_400_BAD_REQUEST)
 
 
 class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
@@ -221,50 +274,38 @@ class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
 
     @classmethod
     def setUpTestData(cls):
+        cls.namespace = (
+            Namespace.objects.annotate(prefixes_count=Count("prefixes")).filter(prefixes_count__gte=3).first()
+        )
         cls.vrfs = (
-            VRF.objects.annotate(prefixes_count=Count("namespace__prefixes")).filter(prefixes_count__gte=2).distinct()
+            VRF.objects.create(name="TEST VRF 1", namespace=cls.namespace),
+            VRF.objects.create(name="TEST VRF 2", namespace=cls.namespace),
         )
-        cls.prefixes = Prefix.objects.all()
+        cls.prefixes = Prefix.objects.filter(namespace=cls.namespace)
 
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[0],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[0].namespace)[0],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[0],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[0].namespace)[1],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[1],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[1].namespace)[0],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[1],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[1].namespace)[1],
-        )
         cls.create_data = [
             {
-                "vrf": cls.vrfs[2].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[2].namespace).exclude(vrfs=cls.vrfs[2])[0].pk,
+                "vrf": cls.vrfs[0].pk,
+                "prefix": cls.prefixes.first().pk,
             },
             {
-                "vrf": cls.vrfs[3].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[3].namespace).exclude(vrfs=cls.vrfs[3])[0].pk,
+                "vrf": cls.vrfs[0].pk,
+                "prefix": cls.prefixes.last().pk,
             },
             {
-                "vrf": cls.vrfs[4].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[4].namespace).exclude(vrfs=cls.vrfs[4])[0].pk,
+                "vrf": cls.vrfs[1].pk,
+                "prefix": cls.prefixes.first().pk,
             },
         ]
 
     def test_creating_invalid_vrf_prefix_assignments(self):
         duplicate_create_data = {
-            "vrf": self.vrfs[0].pk,
-            "prefix": self.prefixes.filter(namespace=self.vrfs[0].namespace)[0].pk,
+            "vrf": VRFPrefixAssignment.objects.first().vrf.pk,
+            "prefix": VRFPrefixAssignment.objects.first().prefix.pk,
         }
         wrong_namespace_create_data = {
             "vrf": self.vrfs[0].pk,
-            "prefix": self.prefixes.exclude(namespace=self.vrfs[0].namespace)[0].pk,
+            "prefix": Prefix.objects.exclude(namespace=self.namespace)[0].pk,
         }
         missing_field_create_data = {
             "vrf": self.vrfs[0].pk,

nautobot/ipam/tests/test_filters.py

@@ -10,6 +10,7 @@ from nautobot.dcim.models import (
     Location,
     LocationType,
     Manufacturer,
+    VirtualDeviceContext,
 )
 from nautobot.extras.models import Role, Status, Tag
 from nautobot.ipam.choices import PrefixTypeChoices, ServiceProtocolChoices
@@ -24,7 +25,9 @@ from nautobot.ipam.filters import (
     VLANFilterSet,
     VLANGroupFilterSet,
     VLANLocationAssignmentFilterSet,
+    VRFDeviceAssignmentFilterSet,
     VRFFilterSet,
+    VRFPrefixAssignmentFilterSet,
 )
 from nautobot.ipam.models import (
     IPAddress,
@@ -39,6 +42,8 @@ from nautobot.ipam.models import (
     VLANGroup,
     VLANLocationAssignment,
     VRF,
+    VRFDeviceAssignment,
+    VRFPrefixAssignment,
 )
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import (
@@ -66,12 +71,19 @@ class VRFTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterT
     # skip testing "rd" attribute for generic q filter test as it's not trivially modifiable
     exclude_q_filter_predicates = ["rd"]
     generic_filter_tests = (
+        # ("device", "devices__id"),
+        # ("device", "devices__name"),
         ("export_targets", "export_targets__id"),
         ("export_targets", "export_targets__name"),
         ("import_targets", "import_targets__id"),
         ("import_targets", "import_targets__name"),
+        ("prefix", "prefixes__id"),
         ("name",),
+        ("namespace", "namespace__id"),
+        ("namespace", "namespace__name"),
         ("rd",),
+        # ("virtual_machines", "virtual_machines__id"),
+        # ("virtual_machines", "virtual_machines__name"),
     )
 
     @classmethod
@@ -79,6 +91,36 @@ class VRFTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterT
         instance = cls.queryset.first()
         instance.tags.set(Tag.objects.all()[:2])
 
+    def test_prefix_filter_by_string(self):
+        """Test filtering by prefix strings as an alternative to pk."""
+        prefix = self.queryset.filter(prefixes__isnull=False).first().prefixes.first()
+        params = {"prefix": [prefix.prefix]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefixes__network=prefix.network, prefixes__prefix_length=prefix.prefix_length),
+            ordered=False,
+        )
+
+
+class VRFPrefixAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = VRFPrefixAssignment.objects.all()
+    filterset = VRFPrefixAssignmentFilterSet
+    generic_filter_tests = (
+        ("prefix", "prefix__id"),
+        ("vrf", "vrf__id"),
+        ("vrf", "vrf__name"),
+    )
+
+    def test_prefix_filter_by_string(self):
+        """Test filtering by prefix strings as an alternative to pk."""
+        prefix = self.queryset.first().prefix
+        params = {"prefix": [prefix.prefix]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefix__network=prefix.network, prefix__prefix_length=prefix.prefix_length),
+            ordered=False,
+        )
+
 
 class RouteTargetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = RouteTarget.objects.all()
@@ -190,15 +232,32 @@ class PrefixLocationAssignmentTestCase(FilterTestCases.FilterTestCase):
     # )
 
     def test_prefix(self):
-        ipv4_prefix = str(self.queryset.filter(prefix__ip_version=4).first().prefix)
-        ipv6_prefix = str(self.queryset.filter(prefix__ip_version=6).first().prefix)
+        ipv4_prefix = self.queryset.filter(prefix__ip_version=4).first().prefix
+        ipv6_prefix = self.queryset.filter(prefix__ip_version=6).first().prefix
+
+        params = {"prefix": [ipv4_prefix.prefix, ipv6_prefix.pk]}
+
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefix=ipv6_prefix)
+            | self.queryset.filter(
+                prefix__network=ipv4_prefix.network,
+                prefix__prefix_length=ipv4_prefix.prefix_length,
+                prefix__broadcast=ipv4_prefix.broadcast,
+            ),
+            ordered=False,
+        )
 
-        params = {"prefix": [ipv4_prefix, ipv6_prefix]}
-        prefix_queryset = Prefix.objects.net_equals(ipv4_prefix, ipv6_prefix)
+        params = {"prefix": [ipv4_prefix.pk, ipv6_prefix.prefix]}
 
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs,
-            self.queryset.filter(prefix__in=prefix_queryset),
+            self.queryset.filter(prefix=ipv4_prefix)
+            | self.queryset.filter(
+                prefix__network=ipv6_prefix.network,
+                prefix__prefix_length=ipv6_prefix.prefix_length,
+                prefix__broadcast=ipv6_prefix.broadcast,
+            ),
             ordered=False,
         )
 
@@ -289,11 +348,21 @@ class PrefixFilterCustomDataTestCase(TestCase):
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs, self.queryset.filter(parent=parent4)
         )
+        params = {"parent": ["10.0.0.0/16"]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(parent__network="10.0.0.0", parent__prefix_length=16),
+        )
         parent6 = Prefix.objects.get(prefix="2001:db8::/32", namespace=self.namespace)
         params = {"parent": [str(parent6.pk)]}
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs, self.queryset.filter(parent=parent6)
         )
+        params = {"parent": ["2001:db8::/32"]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(parent__network="2001:db8::", parent__prefix_length=32),
+        )
 
     def test_ip_version(self):
         params = {"ip_version": "6"}
@@ -980,6 +1049,77 @@ class IPAddressToInterfaceTestCase(FilterTestCases.FilterTestCase):
                 )
 
 
+class VRFDeviceAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = VRFDeviceAssignment.objects.all()
+    filterset = VRFDeviceAssignmentFilterSet
+    generic_filter_tests = (
+        ["vrf", "vrf__id"],
+        ["vrf", "vrf__name"],
+        ["device", "device__id"],
+        ["device", "device__name"],
+        ["virtual_machine", "virtual_machine__id"],
+        ["virtual_machine", "virtual_machine__name"],
+        ["virtual_device_context", "virtual_device_context__id"],
+        ["virtual_device_context", "virtual_device_context__name"],
+        ["name"],
+        ["rd"],
+    )
+
+    @classmethod
+    def setUpTestData(cls):
+        # Creating VRFDeviceAssignment instances manually until VRFFactory is enhanced to generate VRFDeviceAssignments
+        cls.vrfs = VRF.objects.all()
+        cls.devices = Device.objects.all()
+        cls.vdcs = VirtualDeviceContext.objects.all()
+        locations = Location.objects.filter(location_type__name="Campus")
+        cluster_type = ClusterType.objects.create(name="Test Cluster Type")
+        cluster = Cluster.objects.create(name="Cluster 1", cluster_type=cluster_type, location=locations[0])
+        vm_status = Status.objects.get_for_model(VirtualMachine).first()
+        vm_role = Role.objects.get_for_model(VirtualMachine).first()
+        cls.test_vm_1 = VirtualMachine.objects.create(
+            cluster=cluster,
+            name="VM 1",
+            role=vm_role,
+            status=vm_status,
+        )
+        cls.test_vm_2 = VirtualMachine.objects.create(
+            cluster=cluster,
+            name="VM 2",
+            role=vm_role,
+            status=vm_status,
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            device=cls.devices[0],
+            rd="65000:1",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            device=cls.devices[1],
+            rd="65000:2",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_machine=cls.test_vm_1,
+            rd="65000:3",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[1],
+            virtual_machine=cls.test_vm_2,
+            rd="65000:4",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[0],
+            name="VRFDeviceAssignment 1",
+            rd="65000:5",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[1],
+        )
+
+
 class VLANGroupTestCase(FilterTestCases.FilterTestCase):
     queryset = VLANGroup.objects.all()
     filterset = VLANGroupFilterSet

nautobot/ipam/tests/test_views.py

@@ -2,6 +2,7 @@ import datetime
 import random
 
 from django.contrib.contenttypes.models import ContentType
+from django.db.models import Count
 from django.test import override_settings
 from django.urls import reverse
 from django.utils.html import strip_tags
@@ -13,7 +14,15 @@ from nautobot.core.templatetags.helpers import hyperlinked_object, queryset_to_p
 from nautobot.core.testing import ModelViewTestCase, post_data, ViewTestCases
 from nautobot.core.testing.utils import extract_page_body
 from nautobot.core.utils.lookup import get_route_for_model
-from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType, Manufacturer
+from nautobot.dcim.models import (
+    Device,
+    DeviceType,
+    Interface,
+    Location,
+    LocationType,
+    Manufacturer,
+    VirtualDeviceContext,
+)
 from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
 from nautobot.extras.models import (
     CustomField,
@@ -72,8 +81,9 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     @classmethod
     def setUpTestData(cls):
         tenants = Tenant.objects.all()[:2]
-        namespace = Prefix.objects.first().namespace
+        namespace = Namespace.objects.annotate(prefix_count=Count("prefixes")).filter(prefix_count__gt=2).first()
         prefixes = Prefix.objects.filter(namespace=namespace)
+        vdcs = VirtualDeviceContext.objects.all()
         vrf_statuses = Status.objects.get_for_model(VRF)
 
         cls.form_data = {
@@ -85,6 +95,7 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "prefixes": [prefixes[1].id],
             "tags": [t.pk for t in Tag.objects.get_for_model(VRF)],
             "status": vrf_statuses.first().pk,
+            "virtual_device_contexts": [vdcs[0].id, vdcs[1].id],
         }
 
         cls.bulk_edit_data = {
@@ -94,6 +105,8 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "namespace": prefixes[0].namespace.id,
             "add_prefixes": [prefixes[0].id],
             "remove_prefixes": [prefixes[1].id],
+            "add_virtual_device_contexts": [vdcs[2].id, vdcs[3].id],
+            "remove_virtual_device_contexts": [vdcs[0].id],
         }
 
 

nautobot/project-static/css/base.css

@@ -1022,3 +1022,14 @@ a.tile.clickable:visited {
     text-decoration: none;
     background-color: #646464;
 }
+
+/* Monaco Editor container */
+.editor-container {
+    display: flex;  /* Use flexbox for layout */
+    flex-direction: column;
+    flex: 1;  /* Allow container to grow */
+    min-height: 100px;
+    position: relative;  /* Required for Monaco's absolute positioning */
+    overflow: hidden;  /* Let Monaco handle scrolling */
+}
+