nautobot 2.2.9__py3-none-any.whl → 2.3.0b1__py3-none-any.whl

nautobot/apps/forms.py

@@ -71,6 +71,7 @@ from nautobot.extras.forms import (
     CustomFieldModelBulkEditFormMixin,
     CustomFieldModelCSVForm,
     CustomFieldModelFormMixin,
+    DynamicGroupModelFormMixin,
     NautobotBulkEditForm,
     NautobotModelForm,
     NoteModelBulkEditFormMixin,
@@ -87,6 +88,7 @@ from nautobot.extras.forms.forms import (
     provider_choices_with_blank,
 )
 from nautobot.extras.forms.mixins import (
+    ContactTeamModelFilterFormMixin,
     CustomFieldModelFilterFormMixin,
     NoteFormBase,
     RelationshipModelFilterFormMixin,
@@ -109,6 +111,7 @@ __all__ = (
     "ColorSelect",
     "CommentField",
     "ConfirmationForm",
+    "ContactTeamModelFilterFormMixin",
     "ContentTypeSelect",
     "CSVChoiceField",
     "CSVContentTypeField",
@@ -126,6 +129,7 @@ __all__ = (
     "DateTimePicker",
     "dynamic_formset_factory",
     "DynamicFilterForm",
+    "DynamicGroupModelFormMixin",
     "DynamicModelChoiceField",
     "DynamicModelChoiceMixin",
     "DynamicModelMultipleChoiceField",

nautobot/apps/models.py

@@ -44,7 +44,13 @@ from nautobot.extras.models import (
     StatusField,
     StatusModel,
 )
-from nautobot.extras.models.mixins import DynamicGroupMixin, NotesMixin
+from nautobot.extras.models.mixins import (
+    ContactMixin,
+    DynamicGroupMixin,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    SavedViewMixin,
+)
 from nautobot.extras.models.models import ConfigContextSchemaValidationMixin
 from nautobot.extras.plugins import CustomValidator
 from nautobot.extras.utils import extras_features
@@ -65,12 +71,14 @@ __all__ = (
     "ConfigContextSchemaValidationMixin",
     "construct_composite_key",
     "construct_natural_slug",
+    "ContactMixin",
     "ContentTypeRelatedQuerySet",
     "count_related",
     "CustomFieldModel",
     "CustomValidator",
     "deconstruct_composite_key",
     "DynamicGroupMixin",
+    "DynamicGroupsModelMixin",
     "EmptyGroupByJSONBAgg",
     "EnhancedURLValidator",
     "ExclusionValidator",
@@ -97,6 +105,7 @@ __all__ = (
     "PrimaryModel",
     "RelationshipModel",
     "RestrictedQuerySet",
+    "SavedViewMixin",
     "serialize_object_v2",
     "serialize_object",
     "slugify_dashes_to_underscores",

nautobot/circuits/__init__.py

@@ -1 +0,0 @@
-default_app_config = "nautobot.circuits.apps.CircuitsConfig"

nautobot/circuits/apps.py

@@ -2,6 +2,7 @@ from nautobot.core.apps import NautobotConfig
 
 
 class CircuitsConfig(NautobotConfig):
+    default = True
     name = "nautobot.circuits"
     verbose_name = "Circuits"
     searchable_models = [

nautobot/circuits/factory.py

@@ -3,6 +3,7 @@ import faker
 
 from nautobot.circuits import choices
 from nautobot.circuits.models import Circuit, CircuitTermination, CircuitType, Provider, ProviderNetwork
+from nautobot.cloud.models import CloudNetwork
 from nautobot.core.factory import (
     NautobotBoolIterator,
     OrganizationalModelFactory,
@@ -83,9 +84,7 @@ class ProviderNetworkFactory(PrimaryModelFactory):
         model = ProviderNetwork
         exclude = ("has_description", "has_comments")
 
-    name = factory.LazyAttribute(
-        lambda o: f"{o.provider.name} Network {faker.Faker().word(part_of_speech='noun')}"[:100]
-    )
+    name = factory.LazyAttributeSequence(lambda o, n: f"{o.provider.name} Network {n + 1}"[:100])
     provider = random_instance(Provider, allow_null=False)
 
     has_description = NautobotBoolIterator()
@@ -105,6 +104,7 @@ class CircuitTerminationFactory(PrimaryModelFactory):
             "has_xconnect_id",
             "has_pp_info",
             "has_description",
+            "has_cloud_network",
         )
 
     circuit = factory.LazyAttribute(
@@ -122,11 +122,23 @@ class CircuitTerminationFactory(PrimaryModelFactory):
         None,
     )
 
+    has_cloud_network = factory.Faker("pybool")
+
+    @factory.lazy_attribute
+    def cloud_network(self):
+        if not self.has_cloud_network:
+            return None
+        if self.has_location:
+            return None
+        return faker.Faker().random_element(elements=CloudNetwork.objects.all())
+
     @factory.lazy_attribute
     def provider_network(self):
         # location and provider_network are mutually exclusive but cannot both be null
         if self.has_location:
             return None
+        if self.has_cloud_network:
+            return None
         if ProviderNetwork.objects.filter(provider=self.circuit.provider).exists():
             return faker.Faker().random_element(elements=ProviderNetwork.objects.filter(provider=self.circuit.provider))
         return ProviderNetworkFactory(provider=self.circuit.provider)

nautobot/circuits/filters.py

@@ -1,5 +1,6 @@
 import django_filters
 
+from nautobot.cloud.models import CloudNetwork
 from nautobot.core.filters import (
     BaseFilterSet,
     NameSearchFilterSet,
@@ -57,6 +58,7 @@ class ProviderFilterSet(NautobotFilterSet):
         label="Has provider networks",
     )
     location = TreeNodeMultipleChoiceFilter(
+        prefers_id=True,
         field_name="circuits__circuit_terminations__location",
         queryset=Location.objects.all(),
         to_field_name="name",
@@ -140,6 +142,7 @@ class CircuitFilterSet(NautobotFilterSet, StatusModelFilterSetMixin, TenancyMode
         label="Circuit type (name or ID)",
     )
     location = TreeNodeMultipleChoiceFilter(
+        prefers_id=True,
         field_name="circuit_terminations__location",
         queryset=Location.objects.all(),
         to_field_name="name",
@@ -158,6 +161,13 @@ class CircuitFilterSet(NautobotFilterSet, StatusModelFilterSetMixin, TenancyMode
         label="Termination Z (ID)",
     )
 
+    cloud_network = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="circuit_terminations__cloud_network",
+        queryset=CloudNetwork.objects.all(),
+        to_field_name="name",
+        label="Cloud Network (name or ID)",
+    )
+
     class Meta:
         model = Circuit
         fields = [
@@ -196,6 +206,9 @@ class CircuitTerminationFilterSet(
         to_field_name="name",
         label="Provider Network (name or ID)",
     )
+    cloud_network = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=CloudNetwork.objects.all(), to_field_name="name", label="Cloud Network (name or ID)"
+    )
 
     class Meta:
         model = CircuitTermination

nautobot/circuits/forms.py

@@ -1,5 +1,6 @@
 from django import forms
 
+from nautobot.cloud.models import CloudNetwork
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.forms import (
     CommentField,
@@ -215,6 +216,7 @@ class CircuitFilterForm(
         "circuit_type",
         "provider",
         "provider_network",
+        "cloud_network",
         "status",
         "location",
         "tenant_group",
@@ -233,6 +235,12 @@ class CircuitFilterForm(
         to_field_name="name",
         label="Provider Network",
     )
+    cloud_network = DynamicModelMultipleChoiceField(
+        queryset=CloudNetwork.objects.all(),
+        required=False,
+        to_field_name="name",
+        label="Cloud Network",
+    )
     commit_rate = forms.IntegerField(required=False, min_value=0, label="Commit rate (Kbps)")
     tags = TagFilterField(model)
 
@@ -246,6 +254,7 @@ class CircuitTerminationForm(LocatableModelFormMixin, NautobotModelForm):
     provider_network = DynamicModelChoiceField(
         queryset=ProviderNetwork.objects.all(), required=False, label="Provider Network"
     )
+    cloud_network = DynamicModelChoiceField(queryset=CloudNetwork.objects.all(), required=False, label="Cloud Network")
 
     class Meta:
         model = CircuitTermination
@@ -253,6 +262,7 @@ class CircuitTerminationForm(LocatableModelFormMixin, NautobotModelForm):
             "term_side",
             "location",
             "provider_network",
+            "cloud_network",
             "port_speed",
             "upstream_speed",
             "xconnect_id",
@@ -277,3 +287,6 @@ class CircuitTerminationFilterForm(LocatableModelFilterFormMixin, NautobotFilter
     provider_network = DynamicModelMultipleChoiceField(
         queryset=ProviderNetwork.objects.all(), to_field_name="name", required=False
     )
+    cloud_network = DynamicModelMultipleChoiceField(
+        queryset=CloudNetwork.objects.all(), to_field_name="name", required=False
+    )

nautobot/circuits/migrations/0021_alter_circuit_status_alter_circuittermination__path.py

@@ -0,0 +1,32 @@
+# Generated by Django 4.2.9 on 2024-01-17 18:52
+
+from django.db import migrations
+import django.db.models.deletion
+
+import nautobot.core.models.fields
+import nautobot.extras.models.statuses
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0104_contact_contactassociation_team"),
+        ("dcim", "0053_create_device_family_model"),
+        ("circuits", "0020_update_all_charfields_max_length_to_255"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="circuit",
+            name="status",
+            field=nautobot.extras.models.statuses.StatusField(
+                on_delete=django.db.models.deletion.PROTECT, to="extras.status"
+            ),
+        ),
+        migrations.AlterField(
+            model_name="circuittermination",
+            name="_path",
+            field=nautobot.core.models.fields.ForeignKeyWithAutoRelatedName(
+                blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to="dcim.cablepath"
+            ),
+        ),
+    ]

nautobot/circuits/migrations/0022_circuittermination_cloud_network.py

@@ -0,0 +1,25 @@
+# Generated by Django 4.2.14 on 2024-07-18 16:08
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("cloud", "0001_initial"),
+        ("circuits", "0021_alter_circuit_status_alter_circuittermination__path"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="circuittermination",
+            name="cloud_network",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="circuit_terminations",
+                to="cloud.cloudnetwork",
+            ),
+        ),
+    ]

nautobot/circuits/models.py

@@ -205,6 +205,13 @@ class CircuitTermination(PrimaryModel, PathEndpoint, CableTermination):
         blank=True,
         null=True,
     )
+    cloud_network = models.ForeignKey(
+        to="cloud.CloudNetwork",
+        on_delete=models.PROTECT,
+        related_name="circuit_terminations",
+        blank=True,
+        null=True,
+    )
     port_speed = models.PositiveIntegerField(verbose_name="Port speed (Kbps)", blank=True, null=True)
     upstream_speed = models.PositiveIntegerField(
         blank=True,
@@ -221,16 +228,22 @@ class CircuitTermination(PrimaryModel, PathEndpoint, CableTermination):
         unique_together = ["circuit", "term_side"]
 
     def __str__(self):
-        return f"Termination {self.term_side}: {self.location or self.provider_network}"
+        return f"Termination {self.term_side}: {self.location or self.provider_network or self.cloud_network}"
 
     def clean(self):
         super().clean()
 
         # Must define either location *or* provider network
-        if self.location is None and self.provider_network is None:
-            raise ValidationError("A circuit termination must attach to either a location or a provider network.")
+        if self.location is None and self.provider_network is None and self.cloud_network is None:
+            raise ValidationError(
+                "A circuit termination must attach to a location, a provider network or a cloud network."
+            )
         if self.location and self.provider_network:
             raise ValidationError("A circuit termination cannot attach to both a location and a provider network.")
+        elif self.location and self.cloud_network:
+            raise ValidationError("A circuit termination cannot attach to both a location and a cloud network.")
+        elif self.provider_network and self.cloud_network:
+            raise ValidationError("A circuit termination cannot attach to both a provider network and a cloud network.")
         # A valid location for contenttype CircuitTermination must be assigned.
         if self.location is not None:
             if ContentType.objects.get_for_model(self) not in self.location.location_type.content_types.all():

nautobot/circuits/tables.py

@@ -4,6 +4,7 @@ from django_tables2.utils import Accessor
 from nautobot.core.tables import (
     BaseTable,
     ButtonsColumn,
+    LinkedCountColumn,
     TagColumn,
     ToggleColumn,
 )
@@ -18,6 +19,8 @@ CIRCUIT_TERMINATION_PARENT = """
 {{ value.provider_network|hyperlinked_object }}
 {% elif value.location %}
 {{ value.location|hyperlinked_object }}
+{% elif value.cloud_network %}
+{{ value.cloud_network|hyperlinked_object }}
 {% else %}
 {{ None|placeholder }}
 {% endif %}
@@ -48,7 +51,11 @@ class ProviderNetworkTable(BaseTable):
 class ProviderTable(BaseTable):
     pk = ToggleColumn()
     name = tables.LinkColumn()
-    circuit_count = tables.Column(accessor=Accessor("count_circuits"), verbose_name="Circuits")
+    circuit_count = LinkedCountColumn(
+        viewname="circuits:circuit_list",
+        url_params={"provider": "pk"},
+        verbose_name="Circuits",
+    )
     tags = TagColumn(url_name="circuits:provider_list")
 
     class Meta(BaseTable.Meta):
@@ -75,7 +82,11 @@ class ProviderTable(BaseTable):
 class CircuitTypeTable(BaseTable):
     pk = ToggleColumn()
     name = tables.LinkColumn()
-    circuit_count = tables.Column(verbose_name="Circuits")
+    circuit_count = LinkedCountColumn(
+        viewname="circuits:circuit_list",
+        url_params={"circuit_type": "pk"},
+        verbose_name="Circuits",
+    )
     actions = ButtonsColumn(CircuitType)
 
     class Meta(BaseTable.Meta):
@@ -155,6 +166,7 @@ class CircuitTerminationTable(BaseTable):
     term_side = tables.Column(linkify=True)
     location = tables.Column(linkify=True)
     provider_network = tables.Column(linkify=True)
+    cloud_network = tables.Column(linkify=True)
     cable = tables.Column(linkify=True)
 
     class Meta(BaseTable.Meta):
@@ -165,6 +177,7 @@ class CircuitTerminationTable(BaseTable):
             "term_side",
             "location",
             "provider_network",
+            "cloud_network",
             "cable",
             "port_speed",
             "upstream_speed",
@@ -179,4 +192,5 @@ class CircuitTerminationTable(BaseTable):
             "term_side",
             "location",
             "provider_network",
+            "cloud_network",
         )

nautobot/circuits/templates/circuits/circuittermination_create.html

@@ -25,20 +25,28 @@
                     <p class="form-control-static">{{ form.term_side.value }}</p>
                 </div>
             </div>
+                {% with location_tab_active=form.initial.location %}
                 {% with providernetwork_tab_active=form.initial.provider_network %}
+                {% with cloudnetwork_tab_active=form.initial.cloud_network %}
                     <ul class="nav nav-tabs" role="tablist">
-                        <li role="presentation"{% if not providernetwork_tab_active %} class="active"{% endif %}><a href="#location" role="tab" data-toggle="tab">Location</a></li>
+                        <li role="presentation"{% if location_tab_active or not providernetwork_tab_active and not cloudnetwork_tab_active %} class="active"{% endif %}><a href="#location" role="tab" data-toggle="tab">Location</a></li>
                         <li role="presentation"{% if providernetwork_tab_active %} class="active"{% endif %}><a href="#providernetwork" role="tab" data-toggle="tab">Provider Network</a></li>
+                        <li role="presentation"{% if cloudnetwork_tab_active %} class="active"{% endif %}><a href="#cloudnetwork" role="tab" data-toggle="tab">Cloud Network</a></li>
                     </ul>
                     <div class="tab-content">
-                        <div class="tab-pane{% if not providernetwork_tab_active %} active{% endif %}" id="location">
+                        <div class="tab-pane{% if location_tab_active or not providernetwork_tab_active and not cloudnetwork_tab_active %} active{% endif %}" id="location">
                             {% render_field form.location %}
                         </div>
                         <div class="tab-pane{% if providernetwork_tab_active %} active{% endif %}" id="providernetwork">
                             {% render_field form.provider_network %}
                         </div>
+                        <div class="tab-pane{% if cloudnetwork_tab_active %} active{% endif %}" id="cloudnetwork">
+                            {% render_field form.cloud_network %}
+                        </div>
                     </div>
                 {% endwith %}
+                {% endwith %}
+                {% endwith %}
         </div>
     </div>
     <div class="panel panel-default">

nautobot/circuits/templates/circuits/circuittermination_retrieve.html

@@ -24,6 +24,12 @@
                             {{ object.provider_network|hyperlinked_object }}
                         </td>
                     {% endif %}
+                    {% if object.cloud_network %}
+                        <td>Cloud Network</td>
+                        <td>
+                            {{ object.cloud_network|hyperlinked_object }}
+                        </td>
+                    {% endif %}
                 </tr>
                 {% if object.location %}
                 <tr>

nautobot/circuits/templates/circuits/inc/circuit_termination.html

@@ -82,11 +82,16 @@
                     {% endif %}
                 </td>
             </tr>
-            {% else %}
+            {% elif termination.provider_network %}
             <tr>
                 <td>Provider Network</td>
                 <td>{{ termination.provider_network|hyperlinked_object }}</td>
             </tr>
+            {% else %}
+            <tr>
+                <td>Cloud Network</td>
+                <td>{{ termination.cloud_network|hyperlinked_object }}</td>
+            </tr>
             {% endif %}
             <tr>
                 <td>Speed</td>

nautobot/circuits/tests/test_api.py

@@ -28,7 +28,9 @@ class ProviderTest(APIViewTestCases.APIViewTestCase):
         {
             "name": "Provider 6",
         },
-        {"name": "Provider 7"},
+        {
+            "name": "Provider 7",
+        },
     ]
     bulk_update_data = {
         "asn": 1234,
@@ -250,12 +252,12 @@ class CircuitTerminationTest(APIViewTestCases.APIViewTestCase):
                 circuits[0].circuit_termination_a.get_absolute_url(api=True),
                 **self.header,
             )
-            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.status_code, 200, response.json())
             response = self.client.get(
                 circuits[0].circuit_termination_z.get_absolute_url(api=True),
                 **self.header,
             )
-            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.status_code, 200, response.json())
 
         with self.subTest("Assert CircuitTermination Cable connected to a FrontPort and CircuitTermination"):
             Cable.objects.create(
@@ -275,9 +277,9 @@ class CircuitTerminationTest(APIViewTestCases.APIViewTestCase):
                 circuits[2].circuit_termination_a.get_absolute_url(api=True),
                 **self.header,
             )
-            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.status_code, 200, response.json())
             response = self.client.get(
                 circuits[2].circuit_termination_z.get_absolute_url(api=True),
                 **self.header,
             )
-            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.status_code, 200, response.json())

nautobot/circuits/tests/test_filters.py

@@ -89,6 +89,8 @@ class CircuitTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFil
         ["provider", "provider__name"],
         ["provider_network", "circuit_terminations__provider_network__id"],
         ["provider_network", "circuit_terminations__provider_network__name"],
+        ["cloud_network", "circuit_terminations__cloud_network__id"],
+        ["cloud_network", "circuit_terminations__cloud_network__name"],
         ["circuit_type", "circuit_type__id"],
         ["circuit_type", "circuit_type__name"],
         ["status", "status__id"],
@@ -108,7 +110,9 @@ class CircuitTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFil
             has_location=True,
             location=locations[1],
         )
-        expected = self.queryset.filter(circuit_terminations__location__in=[locations[0].pk, locations[1].pk])
+        expected = self.queryset.filter(
+            circuit_terminations__location__in=[locations[0].pk, locations[1].pk]
+        ).distinct()
         params = {"location": [locations[0].pk, locations[1].pk]}
         self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, expected)
         params = {"location": [locations[0].name, locations[1].name]}
@@ -127,6 +131,8 @@ class CircuitTerminationTestCase(FilterTestCases.FilterTestCase):
     generic_filter_tests = (
         ["circuit", "circuit__cid"],
         ["circuit", "circuit__id"],
+        ["cloud_network", "cloud_network__name"],
+        ["cloud_network", "cloud_network__id"],
         ["description"],
         ["port_speed"],
         ["pp_info"],
@@ -157,7 +163,8 @@ class CircuitTerminationTestCase(FilterTestCases.FilterTestCase):
             location=location,
         )
         interface_status = Status.objects.get_for_model(Interface).first()
-        interface1 = Interface.objects.create(device=device1, name="eth0", status=interface_status)
+        interface_role = Role.objects.get_for_model(Interface).first()
+        interface1 = Interface.objects.create(device=device1, name="eth0", status=interface_status, role=interface_role)
         interface2 = Interface.objects.create(device=device2, name="eth0", status=interface_status)
 
         circuit_terminations = CircuitTermination.objects.all()
@@ -182,17 +189,17 @@ class CircuitTerminationTestCase(FilterTestCases.FilterTestCase):
             with self.subTest(f"term_side: {choice}"):
                 params = {"term_side": [choice]}
                 filterset_result = self.filterset(params, self.queryset).qs
-                qs_result = self.queryset.filter(term_side=choice)
+                qs_result = self.queryset.filter(term_side=choice).distinct()
                 self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
 
     def test_connected(self):
         params = {"connected": True}
         filterset_result = self.filterset(params, self.queryset).qs
-        qs_result = self.queryset.filter(_path__is_active=True)
+        qs_result = self.queryset.filter(_path__is_active=True).distinct()
         self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
         params = {"connected": False}
         filterset_result = self.filterset(params, self.queryset).qs
-        qs_result = self.queryset.filter(Q(_path__isnull=True) | Q(_path__is_active=False))
+        qs_result = self.queryset.filter(Q(_path__isnull=True) | Q(_path__is_active=False)).distinct()
         self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
 
 

nautobot/circuits/tests/test_models.py

@@ -3,6 +3,7 @@ from django.core.exceptions import ValidationError
 
 from nautobot.circuits.choices import CircuitTerminationSideChoices
 from nautobot.circuits.models import Circuit, CircuitTermination, CircuitType, Provider, ProviderNetwork
+from nautobot.cloud.models import CloudAccount, CloudNetwork, CloudResourceType
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.dcim.models import Location, LocationType
 from nautobot.extras.models import Status
@@ -28,11 +29,19 @@ class CircuitTerminationModelTestCase(ModelTestCases.BaseModelTestCase):
         cls.location_1 = Location.objects.filter(location_type=location_type_1)[0]
         cls.location_2 = Location.objects.filter(location_type=location_type_2)[0]
 
-    def test_location_or_provider_network_are_required(self):
+        cloud_resource_type = CloudResourceType.objects.get_for_model(CloudNetwork).first()
+        cloud_account = CloudAccount.objects.filter(provider=cloud_resource_type.provider).first()
+        cls.cloud_network = CloudNetwork(
+            cloud_account=cloud_account,
+            cloud_resource_type=cloud_resource_type,
+            name="Cloud Network 1",
+        )
+
+    def test_location_or_provider_network_or_cloud_network_are_required(self):
         ct = CircuitTermination(circuit=self.circuit, term_side=CircuitTerminationSideChoices.SIDE_A)
         with self.assertRaises(ValidationError) as cm:
             ct.validated_save()
-        self.assertIn("must attach to either a location or a provider network", str(cm.exception))
+        self.assertIn("must attach to a location, a provider network or a cloud network", str(cm.exception))
 
     def test_location_and_provider_network_mutually_exclusive(self):
         ct = CircuitTermination(
@@ -45,6 +54,28 @@ class CircuitTerminationModelTestCase(ModelTestCases.BaseModelTestCase):
             ct.validated_save()
         self.assertIn("cannot attach to both a location and a provider network", str(cm.exception))
 
+    def test_location_and_cloud_network_mutually_exclusive(self):
+        ct = CircuitTermination(
+            circuit=self.circuit,
+            term_side=CircuitTerminationSideChoices.SIDE_A,
+            cloud_network=self.cloud_network,
+            location=self.location_2,
+        )
+        with self.assertRaises(ValidationError) as cm:
+            ct.validated_save()
+        self.assertIn("cannot attach to both a location and a cloud network", str(cm.exception))
+
+    def test_provider_network_and_cloud_network_mutually_exclusive(self):
+        ct = CircuitTermination(
+            circuit=self.circuit,
+            term_side=CircuitTerminationSideChoices.SIDE_A,
+            cloud_network=self.cloud_network,
+            provider_network=self.provider_network,
+        )
+        with self.assertRaises(ValidationError) as cm:
+            ct.validated_save()
+        self.assertIn("cannot attach to both a provider network and a cloud network", str(cm.exception))
+
     def test_location_content_type_enforced(self):
         ct = CircuitTermination(
             circuit=self.circuit,

nautobot/circuits/views.py

@@ -5,7 +5,6 @@ from django.shortcuts import get_object_or_404, redirect, render
 from django_tables2 import RequestConfig
 
 from nautobot.core.forms import ConfirmationForm
-from nautobot.core.models.querysets import count_related
 from nautobot.core.views import generic, mixins as view_mixins
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.viewsets import NautobotUIViewSet
@@ -29,7 +28,7 @@ class CircuitTypeUIViewSet(
     filterset_class = filters.CircuitTypeFilterSet
     filterset_form_class = forms.CircuitTypeFilterForm
     form_class = forms.CircuitTypeForm
-    queryset = CircuitType.objects.annotate(circuit_count=count_related(Circuit, "circuit_type"))
+    queryset = CircuitType.objects.all()
     serializer_class = serializers.CircuitTypeSerializer
     table_class = tables.CircuitTypeTable
 
@@ -92,7 +91,7 @@ class ProviderUIViewSet(NautobotUIViewSet):
     filterset_class = filters.ProviderFilterSet
     filterset_form_class = forms.ProviderFilterForm
     form_class = forms.ProviderForm
-    queryset = Provider.objects.annotate(count_circuits=count_related(Circuit, "provider"))
+    queryset = Provider.objects.all()
     serializer_class = serializers.ProviderSerializer
     table_class = tables.ProviderTable