nautobot 2.1.7__py3-none-any.whl → 2.1.9__py3-none-any.whl

nautobot/tenancy/tests/test_filters.py

@@ -52,19 +52,6 @@ class TenantGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
             TenantGroup.objects.filter(children__in=[child_groups[0], child_groups[1]]).distinct(),
         )
 
-    def test_has_children(self):
-        """Test the `has_children` filter."""
-        params = {"has_children": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            TenantGroup.objects.filter(children__isnull=False).distinct(),
-        )
-        params = {"has_children": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            TenantGroup.objects.filter(children__isnull=True).distinct(),
-        )
-
     def test_tenants(self):
         """Test the `tenants` filter."""
         tenants = Tenant.objects.filter(tenant_group__isnull=False)
@@ -74,19 +61,6 @@ class TenantGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
             TenantGroup.objects.filter(tenants__in=[tenants[0], tenants[1]]).distinct(),
         )
 
-    def test_has_tenants(self):
-        """Test the `has_tenants` filter."""
-        params = {"has_tenants": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            TenantGroup.objects.filter(tenants__isnull=False).distinct(),
-        )
-        params = {"has_tenants": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            TenantGroup.objects.filter(tenants__isnull=True).distinct(),
-        )
-
 
 class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = Tenant.objects.all()
@@ -160,19 +134,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(circuits__in=circuits).distinct(),
         )
 
-    def test_has_circuits(self):
-        """Test the `has_circuits` filter."""
-        params = {"has_circuits": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(circuits__isnull=False).distinct(),
-        )
-        params = {"has_circuits": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(circuits__isnull=True).distinct(),
-        )
-
     def test_clusters(self):
         """Test the `clusters` filter."""
         clusters = list(Cluster.objects.filter(tenant__isnull=False))[:2]
@@ -182,19 +143,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(clusters__in=clusters).distinct(),
         )
 
-    def test_has_clusters(self):
-        """Test the `has_clusters` filter."""
-        params = {"has_clusters": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(clusters__isnull=False).distinct(),
-        )
-        params = {"has_clusters": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(clusters__isnull=True).distinct(),
-        )
-
     def test_devices(self):
         """Test the `devices` filter."""
         params = {"devices": [self.devices[0].pk, self.devices[1].name]}
@@ -203,19 +151,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(devices__in=self.devices).distinct(),
         )
 
-    def test_has_devices(self):
-        """Test the `has_devices` filter."""
-        params = {"has_devices": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(devices__isnull=False).distinct(),
-        )
-        params = {"has_devices": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(devices__isnull=True).distinct(),
-        )
-
     def test_tenant_group(self):
         groups = list(TenantGroup.objects.filter(tenants__isnull=False))[:2]
         groups_including_children = []
@@ -241,19 +176,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(ip_addresses__in=ip_addresses).distinct(),
         )
 
-    def test_has_ip_addresses(self):
-        """Test the `has_ip_addresses` filter."""
-        params = {"has_ip_addresses": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(ip_addresses__isnull=False).distinct(),
-        )
-        params = {"has_ip_addresses": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(ip_addresses__isnull=True).distinct(),
-        )
-
     def test_locations(self):
         params = {"locations": [self.locations[0].pk, self.locations[1].name]}
         self.assertQuerysetEqualAndNotEmpty(
@@ -261,18 +183,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(locations__in=[self.locations[0], self.locations[1]]).distinct(),
         )
 
-    def test_has_locations(self):
-        params = {"has_locations": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(locations__isnull=False).distinct(),
-        )
-        params = {"has_locations": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(locations__isnull=True).distinct(),
-        )
-
     def test_prefixes(self):
         """Test the `prefixes` filter."""
         prefixes = list(Prefix.objects.filter(tenant__isnull=False))[:2]
@@ -282,19 +192,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(prefixes__in=prefixes).distinct(),
         )
 
-    def test_has_prefixes(self):
-        """Test the `has_prefixes` filter."""
-        params = {"has_prefixes": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(prefixes__isnull=False).distinct(),
-        )
-        params = {"has_prefixes": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(prefixes__isnull=True).distinct(),
-        )
-
     def test_rack_reservations(self):
         """Test the `rack_reservations` filter."""
         rack_reservations = list(RackReservation.objects.filter(tenant__isnull=False))[:2]
@@ -304,19 +201,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(rack_reservations__in=rack_reservations).distinct(),
         )
 
-    def test_has_rack_reservations(self):
-        """Test the `has_rack_reservations` filter."""
-        params = {"has_rack_reservations": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(rack_reservations__isnull=False).distinct(),
-        )
-        params = {"has_rack_reservations": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(rack_reservations__isnull=True).distinct(),
-        )
-
     def test_racks(self):
         """Test the `racks` filter."""
         racks = list(Rack.objects.filter(tenant__isnull=False))[:2]
@@ -326,19 +210,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(racks__in=racks).distinct(),
         )
 
-    def test_has_racks(self):
-        """Test the `has_racks` filter."""
-        params = {"has_racks": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(racks__isnull=False).distinct(),
-        )
-        params = {"has_racks": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(racks__isnull=True).distinct(),
-        )
-
     def test_route_targets(self):
         """Test the `route_targets` filter."""
         route_targets = list(RouteTarget.objects.filter(tenant__isnull=False))[:2]
@@ -348,19 +219,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(route_targets__in=route_targets).distinct(),
         )
 
-    def test_has_route_targets(self):
-        """Test the `has_route_targets` filter."""
-        params = {"has_route_targets": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(route_targets__isnull=False).distinct(),
-        )
-        params = {"has_route_targets": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(route_targets__isnull=True).distinct(),
-        )
-
     def test_virtual_machines(self):
         """Test the `virtual_machines` filter."""
         virtual_machines = list(VirtualMachine.objects.filter(tenant__isnull=False))[:2]
@@ -370,19 +228,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(virtual_machines__in=virtual_machines).distinct(),
         )
 
-    def test_has_virtual_machines(self):
-        """Test the `has_virtual_machines` filter."""
-        params = {"has_virtual_machines": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(virtual_machines__isnull=False).distinct(),
-        )
-        params = {"has_virtual_machines": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(virtual_machines__isnull=True).distinct(),
-        )
-
     def test_vlans(self):
         """Test the `vlans` filter."""
         vlans = list(VLAN.objects.filter(tenant__isnull=False))[:2]
@@ -392,19 +237,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(vlans__in=vlans).distinct(),
         )
 
-    def test_has_vlans(self):
-        """Test the `has_vlans` filter."""
-        params = {"has_vlans": True}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(vlans__isnull=False).distinct(),
-        )
-        params = {"has_vlans": False}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(vlans__isnull=True).distinct(),
-        )
-
     def test_vrfs(self):
         """Test the `vrfs` filter."""
         vrfs = list(VRF.objects.filter(tenant__isnull=False))[:2]

nautobot/users/api/urls.py

@@ -2,8 +2,7 @@ from nautobot.core.api.routers import OrderedDefaultRouter
 
 from . import views
 
-router = OrderedDefaultRouter()
-router.APIRootView = views.UsersRootView
+router = OrderedDefaultRouter(view_name="Users")
 
 # Users and groups
 router.register("users", views.UserViewSet)

nautobot/users/api/views.py

@@ -1,14 +1,10 @@
-from django.contrib.auth import get_user_model, login, logout
+from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.db.models import Count
-from django.utils.decorators import method_decorator
-from django.views.decorators.csrf import ensure_csrf_cookie
 from drf_spectacular.utils import extend_schema, extend_schema_view, OpenApiTypes
 from rest_framework.authentication import BasicAuthentication
-from rest_framework.decorators import action
-from rest_framework.permissions import AllowAny, IsAuthenticated
+from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
-from rest_framework.routers import APIRootView
 from rest_framework.viewsets import ViewSet
 
 from nautobot.core.api.serializers import BulkOperationIntegerIDSerializer
@@ -20,16 +16,6 @@ from nautobot.users.models import ObjectPermission, Token
 
 from . import serializers
 
-
-class UsersRootView(APIRootView):
-    """
-    Users API root view
-    """
-
-    def get_view_name(self):
-        return "Users"
-
-
 #
 # Users and groups
 #
@@ -40,40 +26,6 @@ class UserViewSet(ModelViewSet):
     serializer_class = serializers.UserSerializer
     filterset_class = filters.UserFilterSet
 
-    @action(methods=["GET"], detail=False, url_path="my-profile")
-    def my_profile(self, request):
-        serializer = self.serializer_class(instance=request.user, context={"request": request})
-        return Response(serializer.data)
-
-    @method_decorator(ensure_csrf_cookie)
-    @action(methods=["GET"], detail=False, permission_classes=[AllowAny])
-    def session(self, request):
-        from django.conf import settings as django_settings
-        from django.urls import reverse
-        from social_django.context_processors import backends
-
-        from nautobot.core.settings_funcs import sso_auth_enabled
-
-        serializer = self.serializer_class(instance=request.user, context={"request": request})
-
-        _backends = []
-        sso_enabled = sso_auth_enabled(django_settings.AUTHENTICATION_BACKENDS)
-
-        social_auth_backends = backends(request)["backends"]
-        if sso_enabled:
-            for backend in social_auth_backends["backends"]:
-                _backends.append(reverse("social:begin", kwargs={"backend": backend}))
-
-        resp = {
-            "user": serializer.data,
-            "logged_in": request.user.is_authenticated,
-            "sso_enabled": sso_enabled,
-            "sso_user": (len(social_auth_backends["associated"]) > 0),
-            "backends": _backends,
-        }
-
-        return Response(resp)
-
 
 @extend_schema_view(
     bulk_destroy=extend_schema(request=BulkOperationIntegerIDSerializer(many=True)),
@@ -101,21 +53,6 @@ class TokenViewSet(ModelViewSet):
         classes = super().authentication_classes
         return [*classes, BasicAuthentication]
 
-    # TODO(timizuo): Move authenticate and logout to its own view;
-    #  as it is not proper to be on this.
-    @action(methods=["POST"], detail=False, permission_classes=[AllowAny])
-    def authenticate(self, request):
-        serializer = serializers.UserLoginSerializer(data=request.data, context=self.get_serializer_context())
-        serializer.is_valid(raise_exception=True)
-        user = serializer.validated_data["user"]
-        login(request, user=user)
-        return Response(status=200)
-
-    @action(methods=["GET"], detail=False)
-    def logout(self, request):
-        logout(request)
-        return Response(status=200)
-
     def get_queryset(self):
         """
         Limit users to their own Tokens.

nautobot/users/views.py

@@ -7,7 +7,6 @@ from django.contrib.auth import (
     logout as auth_logout,
     update_session_auth_hash,
 )
-from django.contrib.auth.mixins import LoginRequiredMixin
 from django.http import HttpResponseForbidden, HttpResponseRedirect
 from django.shortcuts import get_object_or_404, redirect, render
 from django.urls import reverse
@@ -18,6 +17,7 @@ from django.views.decorators.debug import sensitive_post_parameters
 from django.views.generic import View
 
 from nautobot.core.forms import ConfirmationForm
+from nautobot.core.views.generic import GenericView
 
 from .forms import AdvancedProfileSettingsForm, LoginForm, PasswordChangeForm, TokenForm
 from .models import Token
@@ -118,7 +118,7 @@ def is_django_auth_user(request):
     return request.session.get(BACKEND_SESSION_KEY, None) == "nautobot.core.authentication.ObjectPermissionBackend"
 
 
-class ProfileView(LoginRequiredMixin, View):
+class ProfileView(GenericView):
     template_name = "users/profile.html"
 
     def get(self, request):
@@ -132,7 +132,7 @@ class ProfileView(LoginRequiredMixin, View):
         )
 
 
-class UserConfigView(LoginRequiredMixin, View):
+class UserConfigView(GenericView):
     template_name = "users/preferences.html"
 
     def get(self, request):
@@ -160,7 +160,7 @@ class UserConfigView(LoginRequiredMixin, View):
         return redirect("user:preferences")
 
 
-class ChangePasswordView(LoginRequiredMixin, View):
+class ChangePasswordView(GenericView):
     template_name = "users/change_password.html"
 
     RESTRICTED_NOTICE = "Remotely authenticated user credentials cannot be changed within Nautobot."
@@ -218,7 +218,7 @@ class ChangePasswordView(LoginRequiredMixin, View):
 #
 
 
-class TokenListView(LoginRequiredMixin, View):
+class TokenListView(GenericView):
     def get(self, request):
         tokens = Token.objects.filter(user=request.user)
 
@@ -233,7 +233,7 @@ class TokenListView(LoginRequiredMixin, View):
         )
 
 
-class TokenEditView(LoginRequiredMixin, View):
+class TokenEditView(GenericView):
     def get(self, request, pk=None):
         if pk is not None:
             if not request.user.has_perm("users.change_token"):
@@ -292,7 +292,7 @@ class TokenEditView(LoginRequiredMixin, View):
         )
 
 
-class TokenDeleteView(LoginRequiredMixin, View):
+class TokenDeleteView(GenericView):
     def get(self, request, pk):
         token = get_object_or_404(Token.objects.filter(user=request.user), pk=pk)
         initial_data = {
@@ -336,7 +336,7 @@ class TokenDeleteView(LoginRequiredMixin, View):
 #
 
 
-class AdvancedProfileSettingsEditView(LoginRequiredMixin, View):
+class AdvancedProfileSettingsEditView(GenericView):
     template_name = "users/advanced_settings_edit.html"
 
     def get(self, request):

nautobot/virtualization/api/urls.py

@@ -2,8 +2,7 @@ from nautobot.core.api.routers import OrderedDefaultRouter
 
 from . import views
 
-router = OrderedDefaultRouter()
-router.APIRootView = views.VirtualizationRootView
+router = OrderedDefaultRouter(view_name="Virtualization")
 
 # Clusters
 router.register("cluster-types", views.ClusterTypeViewSet)

nautobot/virtualization/api/views.py

@@ -1,5 +1,3 @@
-from rest_framework.routers import APIRootView
-
 from nautobot.core.models.querysets import count_related
 from nautobot.dcim.models import Device
 from nautobot.extras.api.views import (
@@ -19,16 +17,6 @@ from nautobot.virtualization.models import (
 
 from . import serializers
 
-
-class VirtualizationRootView(APIRootView):
-    """
-    Virtualization API root view
-    """
-
-    def get_view_name(self):
-        return "Virtualization"
-
-
 #
 # Clusters
 #

nautobot/virtualization/tests/test_filters.py

@@ -49,13 +49,6 @@ class ClusterTypeTestCase(FilterTestCases.NameOnlyFilterTestCase):
             params = {"clusters": [self.clusters[0].pk, self.clusters[1].name]}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
-        with self.subTest("Has Clusters"):
-            params = {"has_clusters": True}
-            self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
-            params = {"has_clusters": False}
-            self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-
 
 class ClusterGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = ClusterGroup.objects.all()
@@ -89,13 +82,6 @@ class ClusterGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
             params = {"clusters": [self.clusters[0].pk, self.clusters[1].name]}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
-        with self.subTest("Has Clusters"):
-            params = {"has_clusters": True}
-            self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
-            params = {"has_clusters": False}
-            self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-
 
 class ClusterTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = Cluster.objects.all()
@@ -192,25 +178,11 @@ class ClusterTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFil
             params = {"devices": [self.device.pk, self.device.name]}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
-        with self.subTest("Has Devices"):
-            params = {"has_devices": True}
-            self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-
-            params = {"has_devices": False}
-            self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
     def test_virtual_machines(self):
         with self.subTest("Virtual Machines"):
             params = {"virtual_machines": [self.virtualmachine.pk, self.virtualmachine.name]}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
-        with self.subTest("Has Virtual Machines"):
-            params = {"has_virtual_machines": True}
-            self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-
-            params = {"has_virtual_machines": False}
-            self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
     def test_location(self):
         params = {"location": [self.locations[0].pk, self.locations[1].pk]}
         self.assertQuerysetEqual(

{nautobot-2.1.7.dist-info → nautobot-2.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nautobot
-Version: 2.1.7
+Version: 2.1.9
 Summary: Source of truth and network automation platform.
 Home-page: https://nautobot.com
 License: Apache-2.0
@@ -22,7 +22,7 @@ Provides-Extra: mysql
 Provides-Extra: napalm
 Provides-Extra: remote-storage
 Provides-Extra: sso
-Requires-Dist: Django (>=3.2.24,<3.3.0)
+Requires-Dist: Django (>=3.2.25,<3.3.0)
 Requires-Dist: GitPython (>=3.1.41,<3.2.0)
 Requires-Dist: Jinja2 (>=3.1.3,<3.2.0)
 Requires-Dist: Markdown (>=3.3.7,<3.4.0)