netbox-config-diff 2.14.1__tar.gz → 2.14.3__tar.gz

{netbox_config_diff-2.14.1 → netbox_config_diff-2.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-config-diff
-Version: 2.14.1
+Version: 2.14.3
 Summary: Push rendered device configurations from NetBox to devices and apply them.
 Author: Artem Kotik
 Author-email: miaow2@yandex.ru

{netbox_config_diff-2.14.1 → netbox_config_diff-2.14.3}/netbox_config_diff/__init__.py

@@ -2,7 +2,7 @@ from netbox.plugins import PluginConfig
 
 __author__ = "Artem Kotik"
 __email__ = "miaow2@yandex.ru"
-__version__ = "2.14.1"
+__version__ = "2.14.3"
 
 
 class ConfigDiffConfig(PluginConfig):

{netbox_config_diff-2.14.1 → netbox_config_diff-2.14.3}/netbox_config_diff/api/serializers.py

@@ -101,21 +101,24 @@ class ConfigurationRequestSerializer(NetBoxModelSerializer):
 
     def validate(self, data):
         if data.get("devices"):
-            if devices := data["devices"].filter(platform__platform_setting__isnull=True):
+            if devices := Device.objects.filter(id__in=[d.id for d in data["devices"]]).filter(
+                platform__platform_setting__isnull=True
+            ):
                 platforms = {d.platform.name for d in devices}
                 raise ValidationError({"devices": f"Assign PlatformSetting for platform(s): {', '.join(platforms)}"})
 
-            if drivers := {
-                device.platform.platform_setting.driver
-                for device in data["devices"]
-                if device.platform.platform_setting.driver not in ACCEPTABLE_DRIVERS
-            }:
-                raise ValidationError({"devices": f"Driver(s) not supported: {', '.join(drivers)}"})
-
-            if devices := list(filter(lambda x: x.get_config_template() is None, data["devices"])):
-                raise ValidationError(
-                    {"devices": f"Define config template for device(s): {', '.join(d.name for d in devices)}"}
-                )
+            unsupported_drivers = {
+                d.platform.platform_setting.driver
+                for d in data["devices"]
+                if d.platform.platform_setting.driver not in ACCEPTABLE_DRIVERS
+            }
+            if unsupported_drivers:
+                raise ValidationError({"devices": f"Driver(s) not supported: {', '.join(unsupported_drivers)}"})
+
+            devices_without_template = [d for d in data["devices"] if d.get_config_template() is None]
+            if devices_without_template:
+                names = ", ".join(d.name for d in devices_without_template)
+                raise ValidationError({"devices": f"Define config template for device(s): {names}"})
 
         return super().validate(data)
 

{netbox_config_diff-2.14.1 → netbox_config_diff-2.14.3}/netbox_config_diff/graphql/filters.py

@@ -5,7 +5,7 @@ import strawberry
 import strawberry_django
 from netbox.graphql.filters import ChangeLoggedModelFilter, NetBoxModelFilter, PrimaryModelFilter
 from strawberry.scalars import ID
-from strawberry_django import DatetimeFilterLookup
+from strawberry_django import DatetimeFilterLookup, StrFilterLookup
 
 from netbox_config_diff.models import ConfigCompliance, ConfigurationRequest, PlatformSetting, Substitute
 
@@ -23,18 +23,18 @@ class ConfigComplianceFilter(ChangeLoggedModelFilter):
     status: Annotated["ConfigComplianceStatusEnum", strawberry.lazy("netbox_config_diff.graphql.enums")] | None = (
         strawberry_django.filter_field()
     )
-    diff: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    error: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    actual_config: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    rendered_config: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    missing: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    extra: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    patch: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
+    diff: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    error: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    actual_config: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    rendered_config: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    missing: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    extra: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    patch: StrFilterLookup[str] | None = strawberry_django.filter_field()
 
 
 @strawberry_django.filter(ConfigurationRequest, lookups=True)
 class ConfigurationRequestFilter(PrimaryModelFilter):
-    description: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
+    description: StrFilterLookup[str] | None = strawberry_django.filter_field()
     status: Annotated["ConfigurationRequestStatusEnum", strawberry.lazy("netbox_config_diff.graphql.enums")] | None = (
         strawberry_django.filter_field()
     )
@@ -64,10 +64,10 @@ class PlatformSettingFilter(NetBoxModelFilter):
         strawberry_django.filter_field()
     )
     platform_id: ID | None = strawberry_django.filter_field()
-    driver: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    description: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    command: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    exclude_regex: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
+    driver: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    description: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    command: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    exclude_regex: StrFilterLookup[str] | None = strawberry_django.filter_field()
 
 
 @strawberry_django.filter(Substitute, lookups=True)
@@ -76,6 +76,6 @@ class SubstituteFilter(NetBoxModelFilter):
         Annotated["PlatformSettingFilter", strawberry.lazy("netbox_config_diff.graphql.filters")] | None
     ) = strawberry_django.filter_field()
     platform_setting_id: ID | None = strawberry_django.filter_field()
-    name: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    description: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
-    regexp: strawberry_django.FilterLookup[str] | None = strawberry_django.filter_field()
+    name: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    description: StrFilterLookup[str] | None = strawberry_django.filter_field()
+    regexp: StrFilterLookup[str] | None = strawberry_django.filter_field()

{netbox_config_diff-2.14.1 → netbox_config_diff-2.14.3}/netbox_config_diff.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-config-diff
-Version: 2.14.1
+Version: 2.14.3
 Summary: Push rendered device configurations from NetBox to devices and apply them.
 Author: Artem Kotik
 Author-email: miaow2@yandex.ru

{netbox_config_diff-2.14.1 → netbox_config_diff-2.14.3}/netbox_config_diff.egg-info/SOURCES.txt

@@ -107,4 +107,5 @@ tests/conftest.py
 tests/factories.py
 tests/test_compliance.py
 tests/test_compliance_utils.py
+tests/test_configurtion_request.py
 tests/test_urls.py

{netbox_config_diff-2.14.1 → netbox_config_diff-2.14.3}/tests/conftest.py

@@ -5,6 +5,7 @@ import pytest
 from django.db import connection
 from django.test.utils import setup_databases
 from faker import Faker
+from rest_framework.test import APIClient
 from typing_extensions import Unpack
 
 from netbox_config_diff.compliance.base import ConfigDiffBase
@@ -125,3 +126,16 @@ def devicedataclass_factory() -> "DeviceDataClassDataFactory":
 def devicedataclass_data(devicedataclass_factory: "DeviceDataClassDataFactory") -> ConplianceDeviceDataClass:
     data = devicedataclass_factory()
     return ConplianceDeviceDataClass(**data)
+
+
+@pytest.fixture
+def api_client():
+    """Basic API client fixture."""
+    return APIClient()
+
+
+@pytest.fixture
+def authenticated_api_client(api_client, admin_user):
+    """Authenticated API client fixture using admin user."""
+    api_client.force_authenticate(user=admin_user)
+    return api_client

{netbox_config_diff-2.14.1 → netbox_config_diff-2.14.3}/tests/factories.py

@@ -94,6 +94,19 @@ class ConfigComplianceFactory(DjangoModelFactory):
         model = ConfigCompliance
 
 
+class ConfigurationRequestFactory(DjangoModelFactory):
+    class Meta:
+        model = "netbox_config_diff.ConfigurationRequest"
+
+    @factory.post_generation
+    def devices(obj, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for device in extracted:
+                obj.devices.add(device)
+
+
 class DataSourceFactory(DjangoModelFactory):
     name = factory.Sequence(lambda n: f"datasource-{n}")
     source_url = factory.Sequence(lambda n: f"/tmp/{n}")

netbox_config_diff-2.14.3/tests/test_configurtion_request.py

@@ -0,0 +1,229 @@
+from http import HTTPStatus
+from typing import TYPE_CHECKING
+
+import pytest
+from django.urls import reverse
+from users.models import User
+
+from netbox_config_diff.choices import ConfigurationRequestStatusChoices
+from tests.factories import (
+    ConfigurationRequestFactory,
+    DeviceFactory,
+    PlatformSettingFactory,
+)
+
+if TYPE_CHECKING:
+    pass
+
+
+@pytest.mark.django_db()
+def test_configuration_request_list(authenticated_api_client):
+    device = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=device.platform)
+    ConfigurationRequestFactory.create(devices=[device])
+    ConfigurationRequestFactory.create(devices=[device])
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    response = authenticated_api_client.get(url)
+
+    assert response.status_code == HTTPStatus.OK
+    assert response.json()["count"] == 2
+    assert len(response.json()["results"]) == 2
+
+
+@pytest.mark.django_db()
+def test_configuration_request_retrieve(authenticated_api_client):
+    device = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=device.platform)
+    cr = ConfigurationRequestFactory.create(devices=[device])
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-detail", args=[cr.pk])
+    response = authenticated_api_client.get(url)
+
+    assert response.status_code == HTTPStatus.OK
+    data = response.json()
+    assert data["id"] == cr.pk
+    assert data["status"]["value"] == ConfigurationRequestStatusChoices.CREATED
+    assert len(data["devices"]) == 1
+    assert data["devices"][0]["id"] == device.pk
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_success(authenticated_api_client, admin_user):
+    device = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=device.platform)
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {
+        "devices": [device.pk],
+        "description": "Test configuration request",
+        "comments": "Test comments",
+    }
+    response = authenticated_api_client.post(url, payload, format="json")
+
+    assert response.status_code == HTTPStatus.CREATED
+    data = response.json()
+    assert data["status"]["value"] == ConfigurationRequestStatusChoices.CREATED
+    assert data["description"] == "Test configuration request"
+    assert data["comments"] == "Test comments"
+    assert len(data["devices"]) == 1
+    assert data["created_by"]["id"] == admin_user.pk
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_multiple_devices(authenticated_api_client):
+    device1 = DeviceFactory.create()
+    device2 = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=device1.platform)
+    PlatformSettingFactory.create(platform=device2.platform)
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {
+        "devices": [device1.pk, device2.pk],
+        "description": "Multi-device request",
+    }
+    response = authenticated_api_client.post(url, payload, format="json")
+
+    assert response.status_code == HTTPStatus.CREATED
+    data = response.json()
+    assert len(data["devices"]) == 2
+    device_ids = {d["id"] for d in data["devices"]}
+    assert device1.pk in device_ids
+    assert device2.pk in device_ids
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_no_platform_setting(authenticated_api_client):
+    device = DeviceFactory.create()
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {
+        "devices": [device.pk],
+    }
+    response = authenticated_api_client.post(url, payload, format="json")
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    data = response.json()
+    assert "devices" in data
+    assert "Assign PlatformSetting" in str(data["devices"])
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_unsupported_driver(authenticated_api_client):
+    device = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=device.platform, driver="unsupported_driver")
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {
+        "devices": [device.pk],
+    }
+    response = authenticated_api_client.post(url, payload, format="json")
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    data = response.json()
+    assert "devices" in data
+    assert "Driver(s) not supported" in str(data["devices"])
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_no_config_template(authenticated_api_client):
+    device = DeviceFactory.create(config_template=None)
+    PlatformSettingFactory.create(platform=device.platform)
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {
+        "devices": [device.pk],
+    }
+    response = authenticated_api_client.post(url, payload, format="json")
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    data = response.json()
+    assert "devices" in data
+    assert "Define config template" in str(data["devices"])
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_mixed_valid_invalid_devices(authenticated_api_client):
+    valid_device = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=valid_device.platform)
+    invalid_device = DeviceFactory.create()
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {
+        "devices": [valid_device.pk, invalid_device.pk],
+    }
+    response = authenticated_api_client.post(url, payload, format="json")
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    data = response.json()
+    assert "devices" in data
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_empty_devices(authenticated_api_client):
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {
+        "devices": [],
+    }
+    response = authenticated_api_client.post(url, payload, format="json")
+
+    assert response.status_code == HTTPStatus.CREATED
+    data = response.json()
+    assert len(data["devices"]) == 0
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_without_authentication(api_client):
+    device = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=device.platform)
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {
+        "devices": [device.pk],
+    }
+    response = api_client.post(url, payload, format="json")
+    assert response.status_code == HTTPStatus.FORBIDDEN
+
+
+@pytest.mark.django_db()
+def test_configuration_request_list_filtering(authenticated_api_client):
+    device = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=device.platform)
+
+    cr = ConfigurationRequestFactory.create(devices=[device], status=ConfigurationRequestStatusChoices.CREATED)
+    ConfigurationRequestFactory.create(devices=[device], status=ConfigurationRequestStatusChoices.APPROVED)
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+
+    response = authenticated_api_client.get(url, {"status": ConfigurationRequestStatusChoices.CREATED})
+
+    assert response.status_code == HTTPStatus.OK
+    data = response.json()
+
+    assert any(r["id"] == cr.pk for r in data["results"])
+
+
+@pytest.mark.django_db()
+def test_configuration_request_retrieve_nonexistent(authenticated_api_client):
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-detail", args=[9999])
+    response = authenticated_api_client.get(url)
+
+    assert response.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.django_db()
+def test_configuration_request_create_sets_created_by(authenticated_api_client, admin_user):
+    user2 = User.objects.create_user(username="user2", password="pass")
+
+    device = DeviceFactory.create()
+    PlatformSettingFactory.create(platform=device.platform)
+
+    url = reverse("plugins-api:netbox_config_diff-api:configurationrequest-list")
+    payload = {"devices": [device.pk]}
+    response = authenticated_api_client.post(url, payload, format="json")
+
+    assert response.status_code == HTTPStatus.CREATED
+    data = response.json()
+
+    assert data["created_by"]["id"] == admin_user.pk
+    assert data["created_by"]["id"] != user2.pk