nautobot 2.3.5__py3-none-any.whl → 2.3.7__py3-none-any.whl

nautobot/ipam/api/serializers.py

@@ -118,7 +118,7 @@ class RIRSerializer(NautobotModelSerializer):
 #
 
 
-class VLANGroupSerializer(NautobotModelSerializer):
+class VLANGroupSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
     vlan_count = serializers.IntegerField(read_only=True)
 
     class Meta:
@@ -481,6 +481,35 @@ class IPAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin
         return super().validate(data)
 
 
+class VLANAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
+    """
+    Input serializer for POST to /api/ipam/vlan-groups/<id>/available-vlans/, i.e. allocating VLAN from VLANGroup.
+    """
+
+    vid = serializers.IntegerField(required=False, min_value=constants.VLAN_VID_MIN, max_value=constants.VLAN_VID_MAX)
+
+    def validate(self, data):
+        """Skip `ValidatedModel` validation.
+        This allows to skip `vid` attribute of `VLAN` model, while validate name and status.
+        """
+        return data
+
+    class Meta(VLANSerializer.Meta):
+        model = VLAN
+        fields = (
+            # permit "vid" and "vlan_group" for `VLAN` consistency.
+            # validate them under `VLANGroupViewSet`
+            "vid",
+            "vlan_group",
+            "name",
+            "status",
+            "role",
+            "tenant",
+            "description",
+            "custom_fields",
+        )
+
+
 #
 # IP address to interface
 #

nautobot/ipam/api/views.py

@@ -6,12 +6,15 @@ from rest_framework import status
 from rest_framework.decorators import action
 from rest_framework.exceptions import APIException
 from rest_framework.response import Response
+from rest_framework.serializers import IntegerField, ListSerializer
 
+from nautobot.core.api.authentication import TokenPermissions
 from nautobot.core.models.querysets import count_related
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.dcim.models import Location
 from nautobot.extras.api.views import NautobotModelViewSet
 from nautobot.ipam import filters
+from nautobot.ipam.api import serializers
 from nautobot.ipam.models import (
     IPAddress,
     IPAddressToInterface,
@@ -29,8 +32,6 @@ from nautobot.ipam.models import (
     VRFPrefixAssignment,
 )
 
-from . import serializers
-
 #
 # Namespace
 #
@@ -387,10 +388,171 @@ class IPAddressToInterfaceViewSet(NautobotModelViewSet):
 
 
 class VLANGroupViewSet(NautobotModelViewSet):
-    queryset = VLANGroup.objects.select_related("location").annotate(vlan_count=count_related(VLAN, "vlan_group"))
+    queryset = (
+        VLANGroup.objects.select_related("location")
+        .prefetch_related("tags")
+        .annotate(vlan_count=count_related(VLAN, "vlan_group"))
+    )
     serializer_class = serializers.VLANGroupSerializer
     filterset_class = filters.VLANGroupFilterSet
 
+    def restrict_queryset(self, request, *args, **kwargs):
+        """
+        Apply "view" permissions on the POST /available-vlans/ endpoint, otherwise as ModelViewSetMixin.
+        """
+        if request.user.is_authenticated and self.action == "available_vlans":
+            self.queryset = self.queryset.restrict(request.user, "view")
+        else:
+            super().restrict_queryset(request, *args, **kwargs)
+
+    class AvailableVLANPermissions(TokenPermissions):
+        """As nautobot.core.api.authentication.TokenPermissions, but enforcing add_vlan permission."""
+
+        perms_map = {
+            "GET": ["ipam.view_vlangroup"],
+            "POST": ["ipam.view_vlangroup", "ipam.add_vlan"],
+        }
+
+    @extend_schema(methods=["get"], responses={200: ListSerializer(child=IntegerField())})
+    @extend_schema(
+        methods=["post"],
+        responses={201: serializers.VLANSerializer(many=True)},
+        request=serializers.VLANAllocationSerializer(many=True),
+    )
+    @action(
+        detail=True,
+        name="Available VLAN IDs",
+        url_path="available-vlans",
+        methods=["get", "post"],
+        permission_classes=[AvailableVLANPermissions],
+        filterset_class=None,
+    )
+    def available_vlans(self, request, pk=None):
+        """
+        A convenience method for listing available VLAN IDs within a VLANGroup.
+        By default, the number of VIDs returned will be equivalent to PAGINATE_COUNT.
+        An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed, however results will not be paginated.
+        """
+        vlan_group = get_object_or_404(self.queryset, pk=pk)
+
+        if request.method == "POST":
+            with cache.lock(
+                "nautobot.ipam.api.views.available_vlans", blocking_timeout=5, timeout=settings.REDIS_LOCK_TIMEOUT
+            ):
+                # Normalize to a list of objects
+                serializer = serializers.VLANAllocationSerializer(
+                    data=request.data if isinstance(request.data, list) else [request.data],
+                    many=True,
+                    context={
+                        "request": request,
+                        "vlan_group": vlan_group,
+                    },
+                )
+                serializer.is_valid(raise_exception=True)
+                requested_vlans = serializer.validated_data
+
+                # Determine if the requested number of VLANs is available
+                available_vids = vlan_group.available_vids
+                if len(available_vids) < len(requested_vlans):
+                    return Response(
+                        {
+                            "detail": (
+                                f"An insufficient number of VLANs are available within the VLANGroup {vlan_group} "
+                                f"({len(requested_vlans)} requested, {len(available_vids)} available)"
+                            )
+                        },
+                        status=status.HTTP_204_NO_CONTENT,
+                    )
+
+                # Prioritise and check for explicitly requested VIDs. Remove them from available_vids
+                for requested_vlan in requested_vlans:
+                    # Check requested `vid` for availability.
+                    # This will also catch if same `vid` was requested multiple times in a request.
+                    if "vid" in requested_vlan and requested_vlan["vid"] not in available_vids:
+                        return Response(
+                            {"detail": f"VLAN {requested_vlan['vid']} is not available within the VLANGroup."},
+                            status=status.HTTP_204_NO_CONTENT,
+                        )
+                    elif "vid" in requested_vlan and requested_vlan["vid"] in available_vids:
+                        available_vids.remove(requested_vlan["vid"])
+
+                # Assign VLAN IDs from the list of VLANGroup's available VLAN IDs.
+                # Available_vids now does not contain explicitly requested vids.
+                _available_vids = iter(available_vids)
+
+                for requested_vlan in requested_vlans:
+                    if "vid" not in requested_vlan:
+                        requested_vlan["vid"] = next(_available_vids)
+
+                    # Check requested `vlan_group`
+                    if "vlan_group" in requested_vlan and requested_vlan["vlan_group"] != vlan_group:
+                        return Response(
+                            {
+                                "detail": f"Invalid VLAN Group requested: {requested_vlan['vlan_group']}. "
+                                f"Only VLAN Group {vlan_group} is permitted."
+                            },
+                            status=status.HTTP_204_NO_CONTENT,
+                        )
+                    else:
+                        requested_vlan["vlan_group"] = vlan_group.pk
+
+                    # Rewrite custom field data
+                    requested_vlan["custom_fields"] = requested_vlan.pop("_custom_field_data", {})
+
+                # Initialize the serializer with a list or a single object depending on what was requested
+                context = {"request": request, "depth": 0}
+
+                if isinstance(request.data, list):
+                    serializer = serializers.VLANSerializer(data=requested_vlans, many=True, context=context)
+                else:
+                    serializer = serializers.VLANSerializer(data=requested_vlans[0], context=context)
+
+                # Create the new VLANs
+                serializer.is_valid(raise_exception=True)
+                serializer.save()
+
+                data = serializer.data
+
+                return Response(
+                    data={
+                        "count": len(data),
+                        "next": None,
+                        "previous": None,
+                        "results": data,
+                    },
+                    status=status.HTTP_201_CREATED,
+                )
+
+        else:
+            try:
+                limit = int(request.query_params.get("limit", get_settings_or_config("PAGINATE_COUNT")))
+            except ValueError:
+                limit = get_settings_or_config("PAGINATE_COUNT")
+
+            if get_settings_or_config("MAX_PAGE_SIZE"):
+                limit = min(limit, get_settings_or_config("MAX_PAGE_SIZE"))
+
+            if isinstance(limit, int) and limit >= 0:
+                vids = vlan_group.available_vids[0:limit]
+            else:
+                vids = vlan_group.available_vids
+
+            serializer = ListSerializer(
+                child=IntegerField(),
+                data=vids,
+            )
+            serializer.is_valid(raise_exception=True)
+            data = serializer.validated_data
+
+            return Response(
+                {
+                    "count": len(data),
+                    "next": None,
+                    "previous": None,
+                    "results": data,
+                }
+            )
+
 
 #
 # VLANs

nautobot/ipam/filters.py

@@ -539,7 +539,7 @@ class IPAddressToInterfaceFilterSet(NautobotFilterSet):
 class VLANGroupFilterSet(NautobotFilterSet, LocatableModelFilterSetMixin, NameSearchFilterSet):
     class Meta:
         model = VLANGroup
-        fields = ["id", "name", "description"]
+        fields = ["id", "name", "description", "tags"]
 
 
 class VLANFilterSet(

nautobot/ipam/forms.py

@@ -727,7 +727,9 @@ class VLANGroupForm(LocatableModelFormMixin, NautobotModelForm):
         fields = [
             "location",
             "name",
+            "range",
             "description",
+            "tags",
         ]
 
 

nautobot/ipam/migrations/0050_vlangroup_range.py

@@ -0,0 +1,24 @@
+# Generated by Django 4.2.16 on 2024-10-02 17:14
+
+from django.db import migrations
+
+import nautobot.core.models.fields
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ipam", "0049_vrf_data_migration"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="vlangroup",
+            name="range",
+            field=nautobot.core.models.fields.PositiveRangeNumberTextField(default="1-4094"),
+        ),
+        migrations.AddField(
+            model_name="vlangroup",
+            name="tags",
+            field=nautobot.core.models.fields.TagsField(through="extras.TaggedItem", to="extras.Tag"),
+        ),
+    ]

nautobot/ipam/models.py

@@ -10,8 +10,9 @@ from django.utils.functional import cached_property
 import netaddr
 
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
+from nautobot.core.forms.utils import parse_numeric_range
 from nautobot.core.models import BaseManager, BaseModel
-from nautobot.core.models.fields import JSONArrayField
+from nautobot.core.models.fields import JSONArrayField, PositiveRangeNumberTextField
 from nautobot.core.models.generics import OrganizationalModel, PrimaryModel
 from nautobot.core.models.utils import array_to_string
 from nautobot.core.utils.data import UtilizationData
@@ -1274,11 +1275,14 @@ class IPAddressToInterface(BaseModel):
 
 
 @extras_features(
+    "custom_links",
     "custom_validators",
+    "export_templates",
     "graphql",
     "locations",
+    "webhooks",
 )
-class VLANGroup(OrganizationalModel):
+class VLANGroup(PrimaryModel):
     """
     A VLAN group is an arbitrary collection of VLANs within which VLAN IDs and names must be unique.
     """
@@ -1293,11 +1297,36 @@ class VLANGroup(OrganizationalModel):
     )
     description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
 
+    range = PositiveRangeNumberTextField(
+        blank=False,
+        default="1-4094",
+        help_text="Permitted VID range(s) as comma-separated list, default '1-4094' if left blank.",
+        min_boundary=constants.VLAN_VID_MIN,
+        max_boundary=constants.VLAN_VID_MAX,
+    )
+
     class Meta:
         ordering = ("name",)
         verbose_name = "VLAN group"
         verbose_name_plural = "VLAN groups"
 
+    @property
+    def expanded_range(self):
+        """
+        Expand VLAN's range into a list of integers (VLAN IDs).
+        """
+        return parse_numeric_range(self.range)
+
+    @property
+    def available_vids(self):
+        """
+        Return all available VLAN IDs within this VLANGroup as a list.
+        """
+        used_ids = self.vlans.all().values_list("vid", flat=True)
+        available = sorted([vid for vid in self.expanded_range if vid not in used_ids])
+
+        return available
+
     def clean(self):
         super().clean()
 
@@ -1308,18 +1337,25 @@ class VLANGroup(OrganizationalModel):
                     {"location": f'VLAN groups may not associate to locations of type "{self.location.location_type}".'}
                 )
 
+        # Validate ranges for related VLANs.
+        _expanded_range = self.expanded_range
+        out_of_range_vids = [_vlan.vid for _vlan in self.vlans.all() if _vlan.vid not in _expanded_range]
+        if out_of_range_vids:
+            raise ValidationError(
+                {
+                    "range": f"VLAN group range may not be re-sized due to existing VLANs (IDs: {','.join(map(str, out_of_range_vids))})."
+                }
+            )
+
     def __str__(self):
         return self.name
 
     def get_next_available_vid(self):
         """
-        Return the first available VLAN ID (1-4094) in the group.
+        Return the first available VLAN ID in the group's range.
         """
-        vlan_ids = VLAN.objects.filter(vlan_group=self).values_list("vid", flat=True)
-        for i in range(1, 4095):
-            if i not in vlan_ids:
-                return i
-        return None
+        _available_vids = self.available_vids
+        return _available_vids[0] if _available_vids else None
 
 
 @extras_features(
@@ -1438,6 +1474,13 @@ class VLAN(PrimaryModel):
         # Return all VM interfaces assigned to this VLAN
         return VMInterface.objects.filter(Q(untagged_vlan_id=self.pk) | Q(tagged_vlans=self.pk)).distinct()
 
+    def clean(self):
+        super().clean()
+
+        # Validate Vlan Group Range
+        if self.vlan_group and self.vid not in self.vlan_group.expanded_range:
+            raise ValidationError({"vid": f"VLAN ID is not contained in VLAN Group range ({self.vlan_group.range})"})
+
 
 @extras_features("graphql")
 class VLANLocationAssignment(BaseModel):

nautobot/ipam/tables.py

@@ -161,9 +161,9 @@ VLAN_LINK = """
 {% url 'ipam:vlan_add' %}\
 ?vid={{ record.vid }}&vlan_group={{ vlan_group.pk }}\
 {% if vlan_group.location %}&location={{ vlan_group.location.pk }}{% endif %}\
-" class="btn btn-xs btn-success">{{ record.available }} VLAN{{ record.available|pluralize }} available</a>\
+" class="btn btn-xs btn-success">{{ record.available }} VLAN{{ record.available|pluralize }} available ({{ record.range }})</a>\
 {% else %}
-    {{ record.available }} VLAN{{ record.available|pluralize }} available
+    {{ record.available }} VLAN{{ record.available|pluralize }} available ({{ record.range }})
 {% endif %}
 """
 
@@ -665,8 +665,8 @@ class VLANGroupTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = VLANGroup
-        fields = ("pk", "name", "location", "vlan_count", "description", "actions")
-        default_columns = ("pk", "name", "location", "vlan_count", "description", "actions")
+        fields = ("pk", "name", "location", "range", "vlan_count", "description", "actions")
+        default_columns = ("pk", "name", "range", "location", "vlan_count", "description", "actions")
 
 
 #

nautobot/ipam/templates/ipam/vlangroup.html

@@ -17,6 +17,10 @@
                     <td>Location</td>
                     <td>{% include 'dcim/inc/location_hierarchy.html' with location=object.location %}</td>
                 </tr>
+                <tr>
+                    <td>Range</td>
+                    <td>{{ object.range }}</td>
+                </tr>
                 <tr>
                     <td>VLANs</td>
                     <td>

nautobot/ipam/tests/test_api.py

@@ -200,14 +200,19 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
         }
         self.add_permissions("ipam.add_vrfdeviceassignment")
         response = self.client.post(self._get_list_url(), duplicate_device_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("The fields device, vrf must make a unique set.", str(response.content))
+        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.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("The fields virtual_machine, vrf must make a unique set.", str(response.content))
+        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.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("A VRF cannot be associated with both a device and a virtual machine.", str(response.content))
+        self.assertContains(
+            response,
+            "A VRF cannot be associated with both a device and a virtual machine.",
+            status_code=status.HTTP_400_BAD_REQUEST,
+        )
 
 
 class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
@@ -266,14 +271,15 @@ class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
         }
         self.add_permissions("ipam.add_vrfprefixassignment")
         response = self.client.post(self._get_list_url(), duplicate_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("The fields vrf, prefix must make a unique set.", str(response.content))
+        self.assertContains(
+            response, "The fields vrf, prefix must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
+        )
         response = self.client.post(self._get_list_url(), wrong_namespace_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Prefix must be in same namespace as VRF", str(response.content))
+        self.assertContains(
+            response, "Prefix must be in same namespace as VRF", status_code=status.HTTP_400_BAD_REQUEST
+        )
         response = self.client.post(self._get_list_url(), missing_field_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("This field may not be null.", str(response.content))
+        self.assertContains(response, "This field may not be null.", status_code=status.HTTP_400_BAD_REQUEST)
 
 
 class RouteTargetTest(APIViewTestCases.APIViewTestCase):
@@ -991,6 +997,15 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         "description": "New description",
     }
 
+    @classmethod
+    def setUpTestData(cls):
+        cls.vlan_group = VLANGroup.objects.create(name="Test", range="5-10,15-20")
+        cls.default_status = Status.objects.first()
+        VLAN.objects.create(name="vlan_5", vid=5, status=cls.default_status, vlan_group=cls.vlan_group)
+        VLAN.objects.create(name="vlan_10", vid=10, status=cls.default_status, vlan_group=cls.vlan_group)
+        VLAN.objects.create(name="vlan_17", vid=17, status=cls.default_status, vlan_group=cls.vlan_group)
+        cls.unused_vids = [6, 7, 8, 9, 15, 16, 18, 19, 20]
+
     def get_deletable_object(self):
         return VLANGroup.objects.create(name="DELETE ME")
 
@@ -1002,6 +1017,171 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         ]
         return [vg.pk for vg in vlangroups]
 
+    def test_list_available_vlans(self):
+        """
+        Test retrieval of all available VLAN IDs within a VLANGroup.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions("ipam.view_vlangroup")
+
+        # Retrieve all available VLAN IDs
+        response = self.client.get(url, **self.header)
+
+        self.assertEqual(response.data["results"], self.unused_vids)
+        self.assertEqual(response.data["count"], len(self.unused_vids))
+
+    def test_create_single_available_vlan(self):
+        """
+        Test creation of the first available VLAN within a VLANGroup.
+        """
+        cf = CustomField.objects.create(key="sor", label="Source of Record Field", type="text")
+        cf.content_types.add(ContentType.objects.get_for_model(VLAN))
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Create all nine available VLANs with individual requests
+        for unused_vid in self.unused_vids:
+            data = {
+                "name": f"VLAN_{unused_vid}",
+                "description": f"Test VLAN {unused_vid}",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+            response = self.client.post(url, data, format="json", **self.header)
+            self.assertHttpStatus(response, status.HTTP_201_CREATED)
+            self.assertEqual(response.data["results"]["name"], data["name"])
+            self.assertEqual(response.data["results"]["vid"], unused_vid)
+            self.assertEqual(response.data["results"]["description"], data["description"])
+            self.assertEqual(response.data["results"]["vlan_group"]["id"], self.vlan_group.pk)
+            self.assertIn("custom_fields", response.data["results"])
+            self.assertIn("sor", response.data["results"]["custom_fields"])
+            self.assertEqual("Nautobot", response.data["results"]["custom_fields"]["sor"])
+
+        # Try to create one more VLAN
+        response = self.client.post(
+            url, {"name": "UTILIZED_VLAN_GROUP", "status": self.default_status.pk}, format="json", **self.header
+        )
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertIn(
+            f"An insufficient number of VLANs are available within the VLANGroup {self.vlan_group}",
+            response.data["detail"],
+        )
+
+    def test_create_multiple_available_vlans(self):
+        """
+        Test the creation of available VLANS within a VLANGroup.
+        """
+        cf = CustomField.objects.create(key="sor", label="Source of Record Field", type="text")
+        cf.content_types.add(ContentType.objects.get_for_model(VLAN))
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create ten VLANs (only nine are available)
+        data = [  # First nine VLANs
+            {
+                "name": f"VLAN_{unused_vid}",
+                "description": f"Test VLAN {unused_vid}",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+            for unused_vid in self.unused_vids
+        ]
+        additional_vlan = [
+            {
+                "name": "VLAN_10",  # Out of range VLAN
+                "description": "Test VLAN 10",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+        ]
+        response = self.client.post(url, data + additional_vlan, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+
+        # Create all nine available VLANs in a single request
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data["results"]), 9)
+
+        for i, vlan_data in enumerate(data):
+            self.assertEqual(response.data["results"][i]["name"], vlan_data["name"])
+            self.assertEqual(response.data["results"][i]["vid"], int(vlan_data["name"].replace("VLAN_", "")))
+            self.assertEqual(response.data["results"][i]["description"], vlan_data["description"])
+            self.assertEqual(response.data["results"][i]["vlan_group"]["id"], self.vlan_group.pk)
+            self.assertIn("custom_fields", response.data["results"][i])
+            self.assertIn("sor", response.data["results"][i]["custom_fields"])
+            self.assertEqual("Nautobot", response.data["results"][i]["custom_fields"]["sor"])
+
+    def test_create_multiple_explicit_vlans(self):
+        """
+        Test the creation of available VLANS within a VLANGroup requesting explicit VLAN IDs.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create VLANs with specified VLAN IDs. Also, explicitly (and redundantly) specify a VLAN Group.
+        data = [
+            {"name": "VLAN_6", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_7", "status": self.default_status.pk, "vid": 7},
+            {"name": "VLAN_8", "status": self.default_status.pk},
+            {"name": "VLAN_9", "status": self.default_status.pk, "vid": 9, "vlan_group": self.vlan_group.pk},
+            {"name": "VLAN_15", "status": self.default_status.pk},
+            {"name": "VLAN_16", "status": self.default_status.pk, "vid": 16, "vlan_group": self.vlan_group.pk},
+        ]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data["results"]), 6)
+
+        for i, vlan_data in enumerate(data):
+            self.assertEqual(response.data["results"][i]["name"], vlan_data["name"])
+            self.assertEqual(response.data["results"][i]["vid"], int(vlan_data["name"].replace("VLAN_", "")))
+            self.assertEqual(response.data["results"][i]["vlan_group"]["id"], self.vlan_group.pk)
+
+    def test_create_invalid_vlans(self):
+        """
+        Test the creation of VLANs using invalid requests.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create VLANs using same vid
+        data = [
+            {"name": "VLAN_6", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_7", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_8", "status": self.default_status.pk},
+        ]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertEqual("VLAN 6 is not available within the VLANGroup.", response.data["detail"])
+
+        # Try to create VLANs specifying other VLAN Group
+        some_other_vlan_group = VLANGroup.objects.create(name="VLAN Group 100-200", range="100-200")
+        data = [{"name": "VLAN_7", "status": self.default_status.pk, "vlan_group": some_other_vlan_group.pk}]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertEqual(
+            f"Invalid VLAN Group requested: {some_other_vlan_group}. Only VLAN Group {self.vlan_group} is permitted.",
+            response.data["detail"],
+        )
+
 
 class VLANTest(APIViewTestCases.APIViewTestCase):
     model = VLAN