nautobot 2.3.15b1__py3-none-any.whl → 2.4.0__py3-none-any.whl

nautobot/wireless/templates/wireless/wirelessnetwork_create.html

@@ -0,0 +1,88 @@
+{% extends 'generic/object_create.html' %}
+{% load static %}
+{% load form_helpers %}
+
+{% block form %}
+    <div class="panel panel-default">
+        <div class="panel-heading"><strong>Wireless Network</strong></div>
+        <div class="panel-body">
+            {% render_field form.name %}
+            {% render_field form.ssid %}
+            {% render_field form.description %}
+            {% render_field form.mode %}
+            {% render_field form.authentication %}
+            {% render_field form.secrets_group %}
+            {% render_field form.hidden %}
+            {% render_field form.enabled %}
+        </div>
+    </div>
+    <div class="panel panel-default">
+        <div class="panel-heading"><strong>Controller Managed Device Group Assignment</strong></div>
+        <div class="panel-body">
+            {% if controller_managed_device_groups.errors %}
+                <div class="text-danger">
+                    Please correct the error(s) below:
+
+                    {% for controller_managed_device_group in controller_managed_device_groups.forms %}
+                        {% if controller_managed_device_group.errors %}
+                            {% for error in controller_managed_device_group.errors.values %}{{ error }}{% endfor %}
+                        {% endif %}
+                    {% endfor %}
+                </div>
+            {% endif %}
+            {{ controller_managed_device_groups.non_field_errors }}
+            <table class="table" id="controller_managed_device_groups">
+                {{ controller_managed_device_groups.management_form }}
+                {% for controller_managed_device_group_form in controller_managed_device_groups.forms %}
+                    {% if forloop.first %}
+                        <thead>
+                            <tr>
+                                {% for field in controller_managed_device_group_form.visible_fields %}
+                                    <th>{{ field.label|capfirst }}</th>
+                                {% endfor %}
+                            </tr>
+                        </thead>
+                    {% endif %}
+                    <tr class="formset_row-{{ controller_managed_device_groups.prefix }}">
+                        {% for field in controller_managed_device_group_form.visible_fields %}
+                            <td>
+                                {% if forloop.first %}
+                                    {% for hidden in controller_managed_device_group_form.hidden_fields %}
+                                        {{ hidden }}
+                                    {% endfor %}
+                                {% endif %}
+                                {{ field }}
+                                {% if field.errors %}
+                                    <ul>
+                                        {% for error in field.errors %}
+                                            {# Embed an HTML comment indicating the error for extraction by tests #}
+                                            <!-- FORM-ERROR {{ field.name }}: {{ error }} -->
+                                            <li class="text-danger">{{ error }}</li>
+                                        {% endfor %}
+                                    </ul>
+                                {% endif %}
+                            </td>
+                        {% endfor %}
+                    </tr>
+                {% endfor %}
+            </table>
+        </div>
+    </div>
+    {% include "inc/extras_features_edit_form_fields.html" %}
+{% endblock form %}
+
+{% block javascript %}
+{{ block.super }}
+<script src="{% static 'jquery/jquery.formset.js' %}"></script>
+<script type="text/javascript">
+    $('.formset_row-{{ controller_managed_device_groups.prefix }}').formset({
+        addText: '<span class="mdi mdi-plus-thick" aria-hidden="true"></span> Add another Controller Managed Device Group',
+        addCssClass: 'btn btn-primary add-row',
+        deleteText: '<span class="mdi mdi-trash-can-outline" aria-hidden="true"></span>',
+        deleteCssClass: 'btn btn-danger delete-row',
+        prefix: '{{ controller_managed_device_groups.prefix }}',
+        formCssClass: 'dynamic-formset-{{ controller_managed_device_groups.prefix }}',
+        added: jsify_form
+    });
+</script>
+{% endblock javascript %}

nautobot/wireless/templates/wireless/wirelessnetwork_retrieve.html

@@ -0,0 +1,56 @@
+{% extends 'generic/object_retrieve.html' %}
+{% load helpers %}
+
+{% block content_left_page %}
+    <div class="panel panel-default">
+        <div class="panel-heading">
+            <strong>Wireless Network</strong>
+        </div>
+        <table class="table table-hover panel-body attr-table">
+            <tr>
+                <td>Name</td>
+                <td>
+                    {{ object.name }}
+                </td>
+            </tr>
+            <tr>
+                <td>Description</td>
+                <td>{{ object.description|placeholder }}</td>
+            </tr>
+            <tr>
+                <td>SSID</td>
+                <td>{{ object.ssid }}</td>
+            </tr>
+            <tr>
+                <td>Mode</td>
+                <td>{{ object.mode }}</td>
+            </tr>
+            <tr>
+                <td>Enabled</td>
+                <td>{{ object.enabled }}</td>
+            </tr>
+            <tr>
+                <td>Authentication</td>
+                <td>{{ object.authentication }}</td>
+            </tr>
+            <tr>
+                <td>Secrets Group</td>
+                <td>{{ object.secrets_group|hyperlinked_object }}</td>
+            </tr>
+            <tr>
+                <td>Hidden</td>
+                <td>{{ object.hidden }}</td>
+            </tr>
+            {% include 'inc/tenant_table_row.html' %}
+        </table>
+    </div>
+{% endblock content_left_page %}
+
+{% block content_full_width_page %}
+    <div class="panel panel-default">
+        <div class="panel-heading">
+            <strong>Controller Managed Device Groups</strong>
+        </div>
+        {% include 'inc/table.html' with table=controller_managed_device_groups_table %}
+    </div>
+{% endblock content_full_width_page %}

nautobot/wireless/tests/integration/test_radio_profile.py

@@ -0,0 +1,42 @@
+from django.urls import reverse
+
+from nautobot.core.testing.integration import SeleniumTestCase
+from nautobot.extras.models import JobResult
+
+
+class RadioProfileTestCase(SeleniumTestCase):
+    """
+    Perform set of Radio Profile tests using Selenium.
+    """
+
+    def test_radio_profile_bulk_edit(self):
+        """
+        This test goes through the process of creating a radio profile and performing bulk edit.
+        """
+        self.user.is_superuser = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+
+        # Create a radio profile
+        self.click_navbar_entry("Wireless", "Radio Profiles")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("wireless:radioprofile_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("wireless:radioprofile_add"))
+        self.browser.fill("name", "Test Radio Profile 1")
+        self.browser.find_by_xpath("//select[@id='id_regulatory_domain']/option[@value='PL']").click()
+        self.click_edit_form_create_button()
+
+        # Test bulk edit
+        self.click_navbar_entry("Wireless", "Radio Profiles")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("wireless:radioprofile_list"))
+        self.browser.find_by_xpath("//input[@name='pk']").click()
+        bulk_edit_url = reverse("wireless:radioprofile_bulk_edit")
+        self.browser.find_by_xpath(f"//button[@formaction='{bulk_edit_url}']").click()
+
+        # Submit bulk edit form without any changes
+        self.browser.find_by_xpath("//button[@name='_apply']", wait_time=5).click()
+
+        job_result = JobResult.objects.filter(name="Bulk Edit Objects").first()
+        self.assertEqual(
+            self.browser.url, self.live_server_url + reverse("extras:jobresult", args=[job_result.pk]) + "?tab=main"
+        )

nautobot/wireless/tests/test_api.py

@@ -0,0 +1,247 @@
+from nautobot.core.testing import APIViewTestCases
+from nautobot.dcim.models import ControllerManagedDeviceGroup
+from nautobot.extras.models import SecretsGroup
+from nautobot.ipam.models import VLAN
+from nautobot.tenancy.models import Tenant
+from nautobot.wireless import choices, models
+
+
+class SupportedDataRateTest(APIViewTestCases.APIViewTestCase):
+    model = models.SupportedDataRate
+    choices_fields = ["standard"]
+
+    @classmethod
+    def setUpTestData(cls):
+        models.SupportedDataRate.objects.create(
+            rate=1000, standard=choices.SupportedDataRateStandardChoices.B, mcs_index=1
+        )
+        models.SupportedDataRate.objects.create(
+            rate=6000, standard=choices.SupportedDataRateStandardChoices.G, mcs_index=2
+        )
+        models.SupportedDataRate.objects.create(
+            rate=54000, standard=choices.SupportedDataRateStandardChoices.N, mcs_index=3
+        )
+        cls.create_data = [
+            {
+                "rate": 200000,
+                "standard": "802.11ac",
+                "mcs_index": 4,
+            },
+            {
+                "rate": 574000,
+                "standard": "802.11ax",
+                "mcs_index": 5,
+            },
+            {
+                "rate": 20000000,
+                "standard": "802.11be",
+                "mcs_index": 6,
+            },
+        ]
+        cls.bulk_update_data = {
+            "standard": "802.11a",
+            "mcs_index": 7,
+        }
+
+
+class RadioProfileTest(APIViewTestCases.APIViewTestCase):
+    model = models.RadioProfile
+    choices_fields = ["frequency", "regulatory_domain"]
+
+    @classmethod
+    def setUpTestData(cls):
+        models.RadioProfile.objects.create(
+            name="Radio Profile 1",
+            frequency="2.4GHz",
+            tx_power_min=5,
+            tx_power_max=15,
+            rx_power_min=-70,
+            regulatory_domain=choices.RadioProfileRegulatoryDomainChoices.US,
+            allowed_channel_list=[1, 6, 11],
+            channel_width=[],
+        )
+        models.RadioProfile.objects.create(
+            name="Radio Profile 2",
+            frequency="5GHz",
+            tx_power_min=10,
+            tx_power_max=20,
+            rx_power_min=-75,
+            regulatory_domain=choices.RadioProfileRegulatoryDomainChoices.GB,
+            allowed_channel_list=[36, 40, 44],
+            channel_width=[20, 40, 160],
+        )
+        models.RadioProfile.objects.create(
+            name="Radio Profile 3",
+            frequency="6GHz",
+            tx_power_min=15,
+            tx_power_max=25,
+            rx_power_min=-80,
+            regulatory_domain=choices.RadioProfileRegulatoryDomainChoices.JP,
+            allowed_channel_list=[],
+            channel_width=[20],
+        )
+        cls.create_data = [
+            {
+                "name": "Radio Profile 4",
+                "frequency": "2.4GHz",
+                "tx_power_min": 10,
+                "tx_power_max": 20,
+                "channel_width": [20, 40],
+                "allowed_channel_list": [1, 6, 11],
+                "regulatory_domain": "US",
+                "rx_power_min": -80,
+            },
+            {
+                "name": "Radio Profile 5",
+                "channel_width": [80, 160],
+                "frequency": "5GHz",
+                "regulatory_domain": "AU",
+                "rx_power_min": 5,
+                "allowed_channel_list": [36, 40, 44],
+            },
+            {
+                "name": "Radio Profile 6",
+                "channel_width": [],
+                "frequency": "6GHz",
+                "regulatory_domain": "CA",
+                "tx_power_min": 20,
+                "allowed_channel_list": [],
+            },
+        ]
+        cls.bulk_update_data = {
+            "frequency": "5GHz",
+            "tx_power_min": 5,
+            "regulatory_domain": "GB",
+        }
+
+
+class WirelessNetworkTest(APIViewTestCases.APIViewTestCase):
+    model = models.WirelessNetwork
+    choices_fields = ["mode", "authentication"]
+
+    @classmethod
+    def setUpTestData(cls):
+        SecretsGroup.objects.create(name="Secrets Group 1")
+        tenants = Tenant.objects.all()
+        models.WirelessNetwork.objects.create(
+            name="Wireless Network 1",
+            tenant=tenants[0],
+            authentication=choices.WirelessNetworkAuthenticationChoices.WPA2_PERSONAL,
+            ssid="ssid1",
+            mode=choices.WirelessNetworkModeChoices.LOCAL,
+        )
+        models.WirelessNetwork.objects.create(
+            name="Wireless Network 2",
+            tenant=tenants[1],
+            authentication=choices.WirelessNetworkAuthenticationChoices.WPA2_ENTERPRISE,
+            ssid="ssid2",
+            mode=choices.WirelessNetworkModeChoices.MESH,
+        )
+        models.WirelessNetwork.objects.create(
+            name="Wireless Network 3",
+            tenant=tenants[2],
+            authentication=choices.WirelessNetworkAuthenticationChoices.OPEN,
+            ssid="ssid3",
+            mode=choices.WirelessNetworkModeChoices.BRIDGE,
+        )
+        cls.create_data = [
+            {
+                "name": "Wireless Network 4",
+                "description": "This is wireless network 4",
+                "ssid": "ssid4",
+                "mode": "Central",
+                "enabled": True,
+                "authentication": "WPA2 Personal",
+                "secrets_group": SecretsGroup.objects.first().pk,
+                "hidden": False,
+                "tenant": tenants[3].pk,
+            },
+            {
+                "name": "Wireless Network 5",
+                "tenant": tenants[4].pk,
+                "authentication": "WPA2 Enterprise",
+                "ssid": "ssid5",
+                "mode": "Standalone (Autonomous)",
+            },
+            {
+                "name": "Wireless Network 6",
+                "tenant": tenants[5].pk,
+                "authentication": "WPA3 Personal",
+                "ssid": "ssid6",
+                "mode": "Fabric",
+            },
+        ]
+        cls.bulk_update_data = {
+            "tenant": tenants[6].pk,
+        }
+
+
+class ControllerManagedDeviceGroupRadioProfileAssignmentTest(APIViewTestCases.APIViewTestCase):
+    model = models.ControllerManagedDeviceGroupRadioProfileAssignment
+
+    @classmethod
+    def setUpTestData(cls):
+        controller_managed_device_groups = ControllerManagedDeviceGroup.objects.all()[:3]
+        cls.create_data = [
+            {
+                "controller_managed_device_group": controller_managed_device_groups[0].pk,
+                "radio_profile": models.RadioProfile.objects.exclude(
+                    controller_managed_device_groups=controller_managed_device_groups[0]
+                )
+                .first()
+                .pk,
+            },
+            {
+                "controller_managed_device_group": controller_managed_device_groups[1].pk,
+                "radio_profile": models.RadioProfile.objects.exclude(
+                    controller_managed_device_groups=controller_managed_device_groups[1]
+                )
+                .first()
+                .pk,
+            },
+            {
+                "controller_managed_device_group": controller_managed_device_groups[2].pk,
+                "radio_profile": models.RadioProfile.objects.exclude(
+                    controller_managed_device_groups=controller_managed_device_groups[2]
+                )
+                .first()
+                .pk,
+            },
+        ]
+
+
+class ControllerManagedDeviceGroupWirelessNetworkAssignmentTest(APIViewTestCases.APIViewTestCase):
+    model = models.ControllerManagedDeviceGroupWirelessNetworkAssignment
+
+    @classmethod
+    def setUpTestData(cls):
+        vlans = VLAN.objects.all()
+        controller_managed_device_groups = ControllerManagedDeviceGroup.objects.all()[:3]
+        cls.create_data = [
+            {
+                "controller_managed_device_group": controller_managed_device_groups[0].pk,
+                "wireless_network": models.WirelessNetwork.objects.exclude(
+                    controller_managed_device_groups=controller_managed_device_groups[0]
+                )
+                .first()
+                .pk,
+                "vlan": vlans[0].pk,
+            },
+            {
+                "controller_managed_device_group": controller_managed_device_groups[1].pk,
+                "wireless_network": models.WirelessNetwork.objects.exclude(
+                    controller_managed_device_groups=controller_managed_device_groups[1]
+                )
+                .first()
+                .pk,
+                "vlan": vlans[1].pk,
+            },
+            {
+                "controller_managed_device_group": controller_managed_device_groups[2].pk,
+                "wireless_network": models.WirelessNetwork.objects.exclude(
+                    controller_managed_device_groups=controller_managed_device_groups[2]
+                )
+                .first()
+                .pk,
+            },
+        ]

nautobot/wireless/tests/test_filters.py

@@ -0,0 +1,82 @@
+from nautobot.core.testing import FilterTestCases
+from nautobot.extras.models import SecretsGroup
+from nautobot.wireless import filters, models
+
+
+class SupportedDataRateTestCase(FilterTestCases.FilterTestCase):
+    queryset = models.SupportedDataRate.objects.all()
+    filterset = filters.SupportedDataRateFilterSet
+    generic_filter_tests = [
+        ("mcs_index",),
+        ("radio_profiles", "radio_profiles__id"),
+        ("radio_profiles", "radio_profiles__name"),
+        ("rate",),
+        ("standard",),
+    ]
+
+
+class RadioProfileTestCase(FilterTestCases.FilterTestCase):
+    queryset = models.RadioProfile.objects.all()
+    filterset = filters.RadioProfileFilterSet
+    generic_filter_tests = [
+        ("name",),
+        ("controller_managed_device_groups", "controller_managed_device_groups__id"),
+        ("controller_managed_device_groups", "controller_managed_device_groups__name"),
+        ("frequency",),
+        ("regulatory_domain",),
+    ]
+
+    def test_channel_width(self):
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset({"channel_width": "80"}, self.queryset).qs,
+            self.queryset.filter(channel_width__contains=[80]),
+        )
+
+
+class WirelessNetworkTestCase(FilterTestCases.FilterTestCase):
+    queryset = models.WirelessNetwork.objects.all()
+    filterset = filters.WirelessNetworkFilterSet
+    generic_filter_tests = [
+        ("authentication",),
+        ("controller_managed_device_groups", "controller_managed_device_groups__id"),
+        ("controller_managed_device_groups", "controller_managed_device_groups__name"),
+        ("description",),
+        ("mode",),
+        ("name",),
+        ("secrets_group", "secrets_group__id"),
+        ("secrets_group", "secrets_group__name"),
+        ("ssid",),
+    ]
+
+    @classmethod
+    def setUpTestData(cls):
+        secrets_groups = (
+            SecretsGroup.objects.create(name="Secrets Group 1"),
+            SecretsGroup.objects.create(name="Secrets Group 2"),
+            SecretsGroup.objects.create(name="Secrets Group 3"),
+        )
+        for i, wireless_network in enumerate(models.WirelessNetwork.objects.all()[:3]):
+            wireless_network.secrets_group = secrets_groups[i]
+            wireless_network.validated_save()
+
+
+class ControllerManagedDeviceGroupWirelessNetworkAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = models.ControllerManagedDeviceGroupWirelessNetworkAssignment.objects.all()
+    filterset = filters.ControllerManagedDeviceGroupWirelessNetworkAssignmentFilterSet
+    generic_filter_tests = [
+        ("controller_managed_device_group", "controller_managed_device_group__id"),
+        ("controller_managed_device_group", "controller_managed_device_group__name"),
+        ("wireless_network", "wireless_network__id"),
+        ("wireless_network", "wireless_network__name"),
+    ]
+
+
+class ControllerManagedDeviceGroupRadioProfileAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = models.ControllerManagedDeviceGroupRadioProfileAssignment.objects.all()
+    filterset = filters.ControllerManagedDeviceGroupRadioProfileAssignmentFilterSet
+    generic_filter_tests = [
+        ("controller_managed_device_group", "controller_managed_device_group__id"),
+        ("controller_managed_device_group", "controller_managed_device_group__name"),
+        ("radio_profile", "radio_profile__id"),
+        ("radio_profile", "radio_profile__name"),
+    ]

nautobot/wireless/tests/test_models.py

@@ -0,0 +1,22 @@
+from nautobot.core.testing.models import ModelTestCases
+from nautobot.wireless import models
+
+
+class SupportedDataRateTestCase(ModelTestCases.BaseModelTestCase):
+    model = models.SupportedDataRate
+
+
+class RadioProfileTestCase(ModelTestCases.BaseModelTestCase):
+    model = models.RadioProfile
+
+
+class WirelessNetworkTestCase(ModelTestCases.BaseModelTestCase):
+    model = models.WirelessNetwork
+
+
+class ControllerManagedDeviceGroupWirelessNetworkAssignmentTestCase(ModelTestCases.BaseModelTestCase):
+    model = models.ControllerManagedDeviceGroupWirelessNetworkAssignment
+
+
+class ControllerManagedDeviceGroupRadioProfileAssignmentTestCase(ModelTestCases.BaseModelTestCase):
+    model = models.ControllerManagedDeviceGroupRadioProfileAssignment