nautobot 2.0.0a2__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/tests/test_forms.py

@@ -8,7 +8,7 @@ from django.test import TestCase, override_settings
 
 from nautobot.dcim.forms import DeviceForm, LocationBulkEditForm, LocationForm
 import nautobot.dcim.models as dcim_models
-from nautobot.dcim.models import Device, LocationType
+from nautobot.dcim.models import Device, Location, LocationType
 from nautobot.extras.choices import RelationshipTypeChoices
 from nautobot.extras.forms import (
     ConfigContextForm,
@@ -232,7 +232,7 @@ class NoteModelFormTestCase(TestCase):
 
     @classmethod
     def setUpTestData(cls):
-        active = Status.objects.get(slug="active")
+        status = Status.objects.get_for_model(Location).first()
         cls.user = User.objects.create(username="formuser1")
         cls.location_type = LocationType.objects.get(name="Campus")
 
@@ -240,12 +240,11 @@ class NoteModelFormTestCase(TestCase):
             "name": "Location 1",
             "slug": "location-1",
             "location_type": cls.location_type.pk,
-            "status": active.pk,
+            "status": status.pk,
         }
 
     def test_note_object_edit_form(self):
-
-        form = LocationForm(data=dict(**self.location_form_base_data, **{"object_note": "This is a test."}))
+        form = LocationForm(data={**self.location_form_base_data, "object_note": "This is a test."})
         self.assertTrue(form.is_valid())
         obj = form.save()
         form.save_note(
@@ -299,18 +298,21 @@ class RelationshipModelFormTestCase(TestCase):
         cls.location = dcim_models.Location.objects.filter(
             location_type=LocationType.objects.get(name="Campus")
         ).first()
-        cls.manufacturer = dcim_models.Manufacturer.objects.create(name="Manufacturer 1", slug="manufacturer-1")
+        cls.manufacturer = dcim_models.Manufacturer.objects.first()
         cls.device_type = dcim_models.DeviceType.objects.create(model="Device Type 1", manufacturer=cls.manufacturer)
         cls.device_role = Role.objects.get_for_model(Device).first()
-        cls.platform = dcim_models.Platform.objects.create(name="Platform 1", slug="platform-1")
-        cls.status_active = Status.objects.get(slug="active")
+        cls.platform = dcim_models.Platform.objects.create(name="Platform 1")
+        cls.device_status = Status.objects.get_for_model(Device).first()
+        cls.ipaddress_status = Status.objects.get_for_model(ipam_models.IPAddress).first()
+        cls.prefix_status = Status.objects.get_for_model(ipam_models.Prefix).first()
+        cls.vlangroup_status = Status.objects.get_for_model(ipam_models.VLANGroup).first()
         cls.device_1 = dcim_models.Device.objects.create(
             name="Device 1",
             location=cls.location,
             device_type=cls.device_type,
             role=cls.device_role,
             platform=cls.platform,
-            status=cls.status_active,
+            status=cls.device_status,
         )
         cls.device_2 = dcim_models.Device.objects.create(
             name="Device 2",
@@ -318,7 +320,7 @@ class RelationshipModelFormTestCase(TestCase):
             device_type=cls.device_type,
             role=cls.device_role,
             platform=cls.platform,
-            status=cls.status_active,
+            status=cls.device_status,
         )
         cls.device_3 = dcim_models.Device.objects.create(
             name="Device 3",
@@ -326,11 +328,17 @@ class RelationshipModelFormTestCase(TestCase):
             device_type=cls.device_type,
             role=cls.device_role,
             platform=cls.platform,
-            status=cls.status_active,
+            status=cls.device_status,
         )
 
-        cls.ipaddress_1 = ipam_models.IPAddress.objects.create(address="10.1.1.1/24", status=cls.status_active)
-        cls.ipaddress_2 = ipam_models.IPAddress.objects.create(address="10.2.2.2/24", status=cls.status_active)
+        cls.namespace = ipam_models.Namespace.objects.first()
+        ipam_models.Prefix.objects.create(prefix="10.0.0.0/8", namespace=cls.namespace, status=cls.prefix_status)
+        cls.ipaddress_1 = ipam_models.IPAddress.objects.create(
+            address="10.1.1.1/24", namespace=cls.namespace, status=cls.ipaddress_status
+        )
+        cls.ipaddress_2 = ipam_models.IPAddress.objects.create(
+            address="10.2.2.2/24", namespace=cls.namespace, status=cls.ipaddress_status
+        )
 
         cls.vlangroup_1 = ipam_models.VLANGroup.objects.create(
             name="VLAN Group 1", slug="vlan-group-1", location=cls.location
@@ -340,24 +348,24 @@ class RelationshipModelFormTestCase(TestCase):
         )
 
         cls.relationship_1 = Relationship(
-            name="BGP Router-ID",
-            slug="bgp-router-id",
+            label="BGP Router-ID",
+            key="bgp_router_id",
             source_type=ContentType.objects.get_for_model(dcim_models.Device),
             destination_type=ContentType.objects.get_for_model(ipam_models.IPAddress),
             type=RelationshipTypeChoices.TYPE_ONE_TO_ONE,
         )
         cls.relationship_1.validated_save()
         cls.relationship_2 = Relationship(
-            name="Device VLAN Groups",
-            slug="device-vlan-groups",
+            label="Device VLAN Groups",
+            key="device_vlan_groups",
             source_type=ContentType.objects.get_for_model(dcim_models.Device),
             destination_type=ContentType.objects.get_for_model(ipam_models.VLANGroup),
             type=RelationshipTypeChoices.TYPE_ONE_TO_MANY,
         )
         cls.relationship_2.validated_save()
         cls.relationship_3 = Relationship(
-            name="HA Device Peer",
-            slug="ha-device-peer",
+            label="HA Device Peer",
+            key="ha_device_peer",
             source_type=ContentType.objects.get_for_model(dcim_models.Device),
             destination_type=ContentType.objects.get_for_model(dcim_models.Device),
             type=RelationshipTypeChoices.TYPE_ONE_TO_ONE_SYMMETRIC,
@@ -375,11 +383,12 @@ class RelationshipModelFormTestCase(TestCase):
             "face": None,
             "position": None,
             "platform": cls.platform.pk,
-            "status": cls.status_active.pk,
+            "status": cls.device_status.pk,
         }
         cls.ipaddress_form_base_data = {
             "address": "10.3.3.3/24",
-            "status": cls.status_active.pk,
+            "namespace": cls.namespace.pk,
+            "status": cls.ipaddress_status.pk,
         }
         cls.vlangroup_form_base_data = {
             "location": cls.location.pk,
@@ -394,14 +403,12 @@ class RelationshipModelFormTestCase(TestCase):
         It can also create ONE_TO_ONE_SYMMETRIC associations where it is a "peer" object.
         """
         form = DeviceForm(
-            data=dict(
+            data={
                 **self.device_form_base_data,
-                **{
-                    f"cr_{self.relationship_1.slug}__destination": self.ipaddress_1.pk,
-                    f"cr_{self.relationship_2.slug}__destination": [self.vlangroup_1.pk, self.vlangroup_2.pk],
-                    f"cr_{self.relationship_3.slug}__peer": self.device_1.pk,
-                },
-            )
+                f"cr_{self.relationship_1.key}__destination": self.ipaddress_1.pk,
+                f"cr_{self.relationship_2.key}__destination": [self.vlangroup_1.pk, self.vlangroup_2.pk],
+                f"cr_{self.relationship_3.key}__peer": self.device_1.pk,
+            }
         )
         self.assertTrue(form.is_valid())
         self.assertTrue(form.save())
@@ -429,12 +436,10 @@ class RelationshipModelFormTestCase(TestCase):
         A new record can create ONE_TO_ONE associations where it is the "destination" object.
         """
         form = IPAddressForm(
-            data=dict(
+            data={
                 **self.ipaddress_form_base_data,
-                **{
-                    f"cr_{self.relationship_1.slug}__source": self.device_1.pk,
-                },
-            )
+                f"cr_{self.relationship_1.key}__source": self.device_1.pk,
+            }
         )
         self.assertTrue(form.is_valid())
         self.assertTrue(form.save())
@@ -448,12 +453,10 @@ class RelationshipModelFormTestCase(TestCase):
         A new record can create ONE_TO_MANY associations where it is the "destination" object.
         """
         form = VLANGroupForm(
-            data=dict(
+            data={
                 **self.vlangroup_form_base_data,
-                **{
-                    f"cr_{self.relationship_2.slug}__source": self.device_1.pk,
-                },
-            )
+                f"cr_{self.relationship_2.key}__source": self.device_1.pk,
+            }
         )
         self.assertTrue(form.is_valid())
         self.assertTrue(form.save())
@@ -477,24 +480,22 @@ class RelationshipModelFormTestCase(TestCase):
 
         # Can't associate New Device with IP Address 1 (already associated to Device 1)
         form = DeviceForm(
-            data=dict(
-                **self.device_form_base_data, **{f"cr_{self.relationship_1.slug}__destination": self.ipaddress_1.pk}
-            )
+            data={**self.device_form_base_data, f"cr_{self.relationship_1.key}__destination": self.ipaddress_1.pk}
         )
         self.assertFalse(form.is_valid())
         self.assertEqual(
             "10.1.1.1/24 is already involved in a BGP Router-ID relationship",
-            form.errors[f"cr_{self.relationship_1.slug}__destination"][0],
+            form.errors[f"cr_{self.relationship_1.key}__destination"][0],
         )
 
         # Can't associate new IP address with Device 1 (already associated with IP Address 1)
         form = IPAddressForm(
-            data=dict(**self.ipaddress_form_base_data, **{f"cr_{self.relationship_1.slug}__source": self.device_1.pk})
+            data={**self.ipaddress_form_base_data, f"cr_{self.relationship_1.key}__source": self.device_1.pk}
         )
         self.assertFalse(form.is_valid())
         self.assertEqual(
             "Device 1 is already involved in a BGP Router-ID relationship",
-            form.errors[f"cr_{self.relationship_1.slug}__source"][0],
+            form.errors[f"cr_{self.relationship_1.key}__source"][0],
         )
 
     def test_create_relationship_associations_invalid_2(self):
@@ -512,15 +513,15 @@ class RelationshipModelFormTestCase(TestCase):
 
         # Can't associate New Device with VLAN Group 1 (already associated to Device 1)
         form = DeviceForm(
-            data=dict(
+            data={
                 **self.device_form_base_data,
-                **{f"cr_{self.relationship_2.slug}__destination": [self.vlangroup_1.pk, self.vlangroup_2.pk]},
-            )
+                f"cr_{self.relationship_2.key}__destination": [self.vlangroup_1.pk, self.vlangroup_2.pk],
+            }
         )
         self.assertFalse(form.is_valid())
         self.assertEqual(
             "VLAN Group 1 is already involved in a Device VLAN Groups relationship",
-            form.errors[f"cr_{self.relationship_2.slug}__destination"][0],
+            form.errors[f"cr_{self.relationship_2.key}__destination"][0],
         )
 
     def test_create_relationship_associations_invalid_3(self):
@@ -537,23 +538,19 @@ class RelationshipModelFormTestCase(TestCase):
         ).validated_save()
 
         # Peer is already a source for this relationship
-        form = DeviceForm(
-            data=dict(**self.device_form_base_data, **{f"cr_{self.relationship_3.slug}__peer": self.device_1.pk})
-        )
+        form = DeviceForm(data={**self.device_form_base_data, f"cr_{self.relationship_3.key}__peer": self.device_1.pk})
         self.assertFalse(form.is_valid())
         self.assertEqual(
             "Device 1 is already involved in a HA Device Peer relationship",
-            form.errors[f"cr_{self.relationship_3.slug}__peer"][0],
+            form.errors[f"cr_{self.relationship_3.key}__peer"][0],
         )
 
         # Peer is already a destination for this relationship
-        form = DeviceForm(
-            data=dict(**self.device_form_base_data, **{f"cr_{self.relationship_3.slug}__peer": self.device_2.pk})
-        )
+        form = DeviceForm(data={**self.device_form_base_data, f"cr_{self.relationship_3.key}__peer": self.device_2.pk})
         self.assertFalse(form.is_valid())
         self.assertEqual(
             "Device 2 is already involved in a HA Device Peer relationship",
-            form.errors[f"cr_{self.relationship_3.slug}__peer"][0],
+            form.errors[f"cr_{self.relationship_3.key}__peer"][0],
         )
 
     def test_update_relationship_associations_valid_1(self):
@@ -591,10 +588,10 @@ class RelationshipModelFormTestCase(TestCase):
                 "location": self.location,
                 "role": self.device_role,
                 "device_type": self.device_type,
-                "status": self.status_active,
-                f"cr_{self.relationship_1.slug}__destination": self.ipaddress_2.pk,
-                f"cr_{self.relationship_2.slug}__destination": [self.vlangroup_2.pk],
-                f"cr_{self.relationship_3.slug}__peer": self.device_2.pk,
+                "status": self.device_status,
+                f"cr_{self.relationship_1.key}__destination": self.ipaddress_2.pk,
+                f"cr_{self.relationship_2.key}__destination": [self.vlangroup_2.pk],
+                f"cr_{self.relationship_3.key}__peer": self.device_2.pk,
             },
         )
         self.assertTrue(form.is_valid(), form.errors)
@@ -640,8 +637,9 @@ class RelationshipModelFormTestCase(TestCase):
             instance=self.ipaddress_1,
             data={
                 "address": self.ipaddress_1.address,
-                "status": self.status_active,
-                f"cr_{self.relationship_1.slug}__source": self.device_2.pk,
+                "status": self.ipaddress_status,
+                "namespace": self.namespace.pk,
+                f"cr_{self.relationship_1.key}__source": self.device_2.pk,
             },
         )
         self.assertTrue(form.is_valid(), form.errors)
@@ -673,7 +671,7 @@ class RelationshipModelFormTestCase(TestCase):
                 "name": self.vlangroup_1.name,
                 "slug": self.vlangroup_1.slug,
                 "location": self.location,
-                f"cr_{self.relationship_2.slug}__source": self.device_2.pk,
+                f"cr_{self.relationship_2.key}__source": self.device_2.pk,
             },
         )
         self.assertTrue(form.is_valid(), form.errors)
@@ -708,8 +706,8 @@ class RelationshipModelFormTestCase(TestCase):
                 "location": self.location,
                 "role": self.device_role,
                 "device_type": self.device_type,
-                "status": self.status_active,
-                f"cr_{self.relationship_3.slug}__peer": self.device_2.pk,
+                "status": self.device_status,
+                f"cr_{self.relationship_3.key}__peer": self.device_2.pk,
             },
         )
         self.assertTrue(form.is_valid(), form.errors)
@@ -734,14 +732,14 @@ class RelationshipModelFormTestCase(TestCase):
                 "location": self.location,
                 "role": self.device_role,
                 "device_type": self.device_type,
-                "status": self.status_active,
-                f"cr_{self.relationship_3.slug}__peer": self.device_1.pk,
+                "status": self.device_status,
+                f"cr_{self.relationship_3.key}__peer": self.device_1.pk,
             },
         )
         self.assertFalse(form.is_valid())
         self.assertEqual(
             "Object Device 1 cannot form a relationship to itself!",
-            form.errors[f"cr_{self.relationship_3.slug}__peer"][0],
+            form.errors[f"cr_{self.relationship_3.key}__peer"][0],
         )
 
 
@@ -752,16 +750,19 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
 
     @classmethod
     def setUpTestData(cls):
-        active = Status.objects.get(slug="active")
+        status = Status.objects.get_for_model(ipam_models.IPAddress).first()
+        prefix_status = Status.objects.get_for_model(ipam_models.Prefix).first()
         cls.locations = dcim_models.Location.objects.filter(location_type=LocationType.objects.get(name="Campus"))[:2]
+        namespace = ipam_models.Namespace.objects.first()
+        ipam_models.Prefix.objects.create(prefix="10.0.0.0/8", status=prefix_status, namespace=namespace)
         cls.ipaddresses = [
-            ipam_models.IPAddress.objects.create(address="10.1.1.1/24", status=active),
-            ipam_models.IPAddress.objects.create(address="10.2.2.2/24", status=active),
+            ipam_models.IPAddress.objects.create(address="10.1.1.1/24", status=status, namespace=namespace),
+            ipam_models.IPAddress.objects.create(address="10.2.2.2/24", status=status, namespace=namespace),
         ]
 
         cls.rel_1to1 = Relationship(
-            name="Primary IP Address",
-            slug="primary-ip-address",
+            label="Primary IP Address",
+            key="primary_ip_address",
             source_type=ContentType.objects.get_for_model(dcim_models.Location),
             destination_type=ContentType.objects.get_for_model(ipam_models.IPAddress),
             type=RelationshipTypeChoices.TYPE_ONE_TO_ONE,
@@ -769,8 +770,8 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
         cls.rel_1to1.validated_save()
 
         cls.rel_1tom = Relationship(
-            name="Addresses per location",
-            slug="addresses-per-location",
+            label="Addresses per location",
+            key="addresses_per_location",
             source_type=ContentType.objects.get_for_model(dcim_models.Location),
             destination_type=ContentType.objects.get_for_model(ipam_models.IPAddress),
             type=RelationshipTypeChoices.TYPE_ONE_TO_MANY,
@@ -778,8 +779,8 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
         cls.rel_1tom.validated_save()
 
         cls.rel_mtom = Relationship(
-            name="Multiplexing",
-            slug="multiplexing",
+            label="Multiplexing",
+            key="multiplexing",
             source_type=ContentType.objects.get_for_model(dcim_models.Location),
             destination_type=ContentType.objects.get_for_model(ipam_models.IPAddress),
             type=RelationshipTypeChoices.TYPE_MANY_TO_MANY,
@@ -787,8 +788,8 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
         cls.rel_mtom.validated_save()
 
         cls.rel_mtom_s = Relationship(
-            name="Peer Locations",
-            slug="peer-locations",
+            label="Peer Locations",
+            key="peer_locations",
             source_type=ContentType.objects.get_for_model(dcim_models.Location),
             destination_type=ContentType.objects.get_for_model(dcim_models.Location),
             type=RelationshipTypeChoices.TYPE_MANY_TO_MANY_SYMMETRIC,
@@ -800,17 +801,17 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
         self.assertEqual(
             set(form.relationships),
             {
-                "cr_addresses-per-location__destination",
+                "cr_addresses_per_location__destination",
                 "cr_multiplexing__destination",
-                "cr_peer-locations__peer",
-                "cr_primary-ip-address__destination",
+                "cr_peer_locations__peer",
+                "cr_primary_ip_address__destination",
             },
         )
 
         # One-to-many relationship is nullable but not editable
-        self.assertIn("cr_addresses-per-location__destination", form.fields)
-        self.assertTrue(form.fields["cr_addresses-per-location__destination"].disabled)
-        self.assertIn("cr_addresses-per-location__destination", form.nullable_fields)
+        self.assertIn("cr_addresses_per_location__destination", form.fields)
+        self.assertTrue(form.fields["cr_addresses_per_location__destination"].disabled)
+        self.assertIn("cr_addresses_per_location__destination", form.nullable_fields)
 
         # Many-to-many relationship has add/remove fields but is not directly editable or nullable
         self.assertNotIn("cr_multiplexing__destination", form.fields)
@@ -819,30 +820,30 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
         self.assertNotIn("cr_multiplexing__destination", form.nullable_fields)
 
         # Symmetric many-to-many relationship has add/remove fields but is not directly editable or nullable
-        self.assertNotIn("cr_peer-locations__peer", form.fields)
-        self.assertIn("add_cr_peer-locations__peer", form.fields)
-        self.assertIn("remove_cr_peer-locations__peer", form.fields)
-        self.assertNotIn("cr_peer-locations__peer", form.nullable_fields)
+        self.assertNotIn("cr_peer_locations__peer", form.fields)
+        self.assertIn("add_cr_peer_locations__peer", form.fields)
+        self.assertIn("remove_cr_peer_locations__peer", form.fields)
+        self.assertNotIn("cr_peer_locations__peer", form.nullable_fields)
 
         # One-to-one relationship is nullable but not editable
-        self.assertIn("cr_primary-ip-address__destination", form.fields)
-        self.assertTrue(form.fields["cr_primary-ip-address__destination"].disabled)
-        self.assertIn("cr_primary-ip-address__destination", form.nullable_fields)
+        self.assertIn("cr_primary_ip_address__destination", form.fields)
+        self.assertTrue(form.fields["cr_primary_ip_address__destination"].disabled)
+        self.assertIn("cr_primary_ip_address__destination", form.nullable_fields)
 
     def test_ipaddress_form_rendering(self):
         form = IPAddressBulkEditForm(ipam_models.IPAddress)
         self.assertEqual(
             set(form.relationships),
             {
-                "cr_addresses-per-location__source",
+                "cr_addresses_per_location__source",
                 "cr_multiplexing__source",
-                "cr_primary-ip-address__source",
+                "cr_primary_ip_address__source",
             },
         )
 
         # Many-to-one relationship is editable and nullable
-        self.assertIn("cr_addresses-per-location__source", form.fields)
-        self.assertIn("cr_addresses-per-location__source", form.nullable_fields)
+        self.assertIn("cr_addresses_per_location__source", form.fields)
+        self.assertIn("cr_addresses_per_location__source", form.nullable_fields)
 
         # Many-to-many relationship has add/remove fields but is not directly editable or nullable
         self.assertNotIn("cr_multiplexing__source", form.fields)
@@ -851,9 +852,9 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
         self.assertNotIn("cr_multiplexing__source", form.nullable_fields)
 
         # One-to-one relationship is nullable but not editable
-        self.assertIn("cr_primary-ip-address__source", form.fields)
-        self.assertTrue(form.fields["cr_primary-ip-address__source"].disabled)
-        self.assertIn("cr_primary-ip-address__source", form.nullable_fields)
+        self.assertIn("cr_primary_ip_address__source", form.fields)
+        self.assertTrue(form.fields["cr_primary_ip_address__source"].disabled)
+        self.assertIn("cr_primary_ip_address__source", form.nullable_fields)
 
     def test_location_form_nullification(self):
         """Test nullification of existing relationship-associations."""
@@ -884,11 +885,11 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
         form.is_valid()
         form.save_relationships(
             instance=self.locations[0],
-            nullified_fields=["cr_primary-ip-address__destination", "cr_addresses-per-location__destination"],
+            nullified_fields=["cr_primary_ip_address__destination", "cr_addresses_per_location__destination"],
         )
         form.save_relationships(
             instance=self.locations[1],
-            nullified_fields=["cr_primary-ip-address__destination", "cr_addresses-per-location__destination"],
+            nullified_fields=["cr_primary_ip_address__destination", "cr_addresses_per_location__destination"],
         )
 
         self.assertEqual(0, RelationshipAssociation.objects.count())
@@ -900,7 +901,7 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
             data={
                 "pks": [self.locations[0].pk],
                 "add_cr_multiplexing__destination": [ipaddress.pk for ipaddress in self.ipaddresses],
-                "add_cr_peer-locations__peer": [self.locations[1].pk],
+                "add_cr_peer_locations__peer": [self.locations[1].pk],
             },
         )
         form.is_valid()
@@ -943,7 +944,7 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
             data={
                 "pks": [self.locations[0].pk, self.locations[1].pk],
                 "remove_cr_multiplexing__destination": [self.ipaddresses[0].pk],
-                "remove_cr_peer-locations__peer": [self.locations[0].pk, self.locations[1].pk],
+                "remove_cr_peer_locations__peer": [self.locations[0].pk, self.locations[1].pk],
             },
         )
         form.is_valid()
@@ -964,7 +965,7 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
             model=ipam_models.IPAddress,
             data={
                 "pks": [self.ipaddresses[0].pk],
-                "cr_addresses-per-location__source": self.locations[0].pk,
+                "cr_addresses_per_location__source": self.locations[0].pk,
             },
         )
         form.is_valid()
@@ -1144,18 +1145,15 @@ class JobEditFormTestCase(TestCase):
             "grouping": "Overridden grouping",
             "name_override": True,
             "name": "Overridden name",
-            "slug": "overridden-slug",
             "description_override": True,
             "description": "This is an overridden description.",
             "enabled": True,
             "approval_required_override": True,
             "approval_required": True,
-            "commit_default_override": True,
-            "commit_default": False,
+            "dryrun_default_override": True,
+            "dryrun_default": True,
             "hidden_override": True,
             "hidden": True,
-            "read_only_override": True,
-            "read_only": True,
             "soft_time_limit_override": True,
             "soft_time_limit": 350.1,
             "time_limit_override": True,