nautobot 3.0.0a3__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

nautobot/load_balancers/tests/test_forms.py

@@ -0,0 +1,266 @@
+"""Test virtualserver forms."""
+
+from nautobot.core.testing.forms import FormTestCases
+from nautobot.load_balancers import choices, forms
+from nautobot.load_balancers.tests import LoadBalancerModelsTestCaseMixin
+
+
+# pylint: disable=no-member
+class VirtualServerFormTest(LoadBalancerModelsTestCaseMixin, FormTestCases.BaseFormTestCase):
+    """Test VirtualServer forms."""
+
+    form_class = forms.VirtualServerForm
+
+    def test_specifying_all_fields_success(self):
+        form = forms.VirtualServerForm(
+            data={
+                "name": "Virtual Server 1",
+                "vip": self.ip_address.pk,
+                "enabled": True,
+                "port": 80,
+                "protocol": choices.ProtocolChoices.PROTOCOL_TCP,
+                "load_balancer_pool": self.load_balancer_pools[0].pk,
+                "load_balancer_type": choices.LoadBalancerTypeChoices.TYPE_LAYER4,
+                "tenant": self.tenant1.pk,
+                "source_nat_pool": self.source_nat_pool1.pk,
+                "source_nat_type": choices.SourceNATTypeChoices.TYPE_STATIC,
+                "device": self.device1.pk,
+                "health_check_monitor": self.health_check_monitors[1].pk,
+                "ssl_offload": True,
+                "certificate_profiles": [self.certificate_profiles[0]],
+            }
+        )
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_only_required_success(self):
+        form = forms.VirtualServerForm(
+            data={
+                "name": "Virtual Server 1",
+                "vip": self.ip_address.pk,
+            }
+        )
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_validate_name_is_required(self):
+        form = forms.VirtualServerForm(data={"vip": self.ip_address.pk})
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["name"])
+
+
+# pylint: disable=no-member
+class LoadBalancerPoolFormTest(LoadBalancerModelsTestCaseMixin, FormTestCases.BaseFormTestCase):
+    """Test the LoadBalancerPool form."""
+
+    form_class = forms.LoadBalancerPoolForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+
+        data = {
+            "name": "Load Balance Pool 1",
+            "load_balancing_algorithm": choices.LoadBalancingAlgorithmChoices.ROUND_ROBIN,
+            "health_check_monitor": self.health_check_monitors[0].pk,
+            "tenant": self.tenant1.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {
+            "name": "Load Balance Pool 2",
+            "load_balancing_algorithm": choices.LoadBalancingAlgorithmChoices.ROUND_ROBIN,
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_validate_name_is_required(self):
+        """Test that the name field is required."""
+
+        data = {
+            "load_balancing_algorithm": choices.LoadBalancingAlgorithmChoices.ROUND_ROBIN,
+            "virtual_server": self.virtual_servers[0].pk,
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["name"])
+
+    def test_validate_load_balancing_algorithm_is_required(self):
+        """Test that the load_balancing_algorithm field is required."""
+
+        data = {
+            "name": "Load Balance Pool 4",
+            "virtual_server": self.virtual_servers[0].pk,
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["load_balancing_algorithm"])
+
+
+# pylint: disable=no-member
+class LoadBalancerPoolMemberFormTest(LoadBalancerModelsTestCaseMixin, FormTestCases.BaseFormTestCase):
+    """Test the LoadBalancerPoolMember form."""
+
+    form_class = forms.LoadBalancerPoolMemberForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+
+        data = {
+            "ip_address": self.ip1.pk,
+            "load_balancer_pool": self.load_balancer_pools[0].pk,
+            "certificate_profiles": [self.certificate_profiles[0]],
+            "port": 123,
+            "ssl_offload": True,
+            "health_check_monitor": self.health_check_monitors[1].pk,
+            "tenant": self.tenant1.pk,
+            "status": self.status.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {
+            "ip_address": self.ip2.pk,
+            "load_balancer_pool": self.load_balancer_pools[0].pk,
+            "port": 123,
+            "ssl_offload": False,
+            "status": self.status.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_validate_ip_address_is_required(self):
+        """Test that the ip_address field is required."""
+
+        data = {
+            "load_balancer_pool": self.load_balancer_pools[0].pk,
+            "certificate_profiles": [self.certificate_profiles[0]],
+            "port": 123,
+            "ssl_offload": True,
+            "health_check_monitor": self.health_check_monitors[0].pk,
+            "tenant": self.tenant1.pk,
+            "status": self.status.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["ip_address"])
+
+    def test_validate_load_balancer_pool_is_required(self):
+        """Test that the load_balancer_pool field is required."""
+
+        data = {
+            "ip_address": self.ip1.pk,
+            "certificate_profiles": [self.certificate_profiles[0]],
+            "port": 123,
+            "ssl_offload": True,
+            "health_check_monitor": self.health_check_monitors[0].pk,
+            "tenant": self.tenant1.pk,
+            "status": self.status.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["load_balancer_pool"])
+
+    def test_validate_port_is_required(self):
+        """Test that the port field is required."""
+
+        data = {
+            "ip_address": self.ip1.pk,
+            "load_balancer_pool": self.load_balancer_pools[0].pk,
+            "port": None,
+            "certificate_profiles": [self.certificate_profiles[0]],
+            "ssl_offload": True,
+            "health_check_monitor": self.health_check_monitors[1].pk,
+            "tenant": self.tenant1.pk,
+            "status": self.status.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["port"])
+
+    def test_validate_status_is_required(self):
+        """Test that the status field is required."""
+
+        data = {
+            "ip_address": self.ip1.pk,
+            "load_balancer_pool": self.load_balancer_pools[0].pk,
+            "certificate_profiles": [self.certificate_profiles[0]],
+            "port": 123,
+            "ssl_offload": True,
+            "health_check_monitor": self.health_check_monitors[0].pk,
+            "tenant": self.tenant1.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertFalse(form.is_valid())
+        self.assertIn("This field is required.", form.errors["status"])
+
+
+class HealthCheckMonitorFormTest(LoadBalancerModelsTestCaseMixin, FormTestCases.BaseFormTestCase):
+    """Test the HealthCheckMonitor form."""
+
+    form_class = forms.HealthCheckMonitorForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+
+        data = {
+            "name": "HTTPS Monitor 4",
+            "interval": 4,
+            "retry": 5,
+            "timeout": 6,
+            "port": 443,
+            "health_check_type": choices.HealthCheckTypeChoices.HTTPS,
+            "tenant": self.tenant2.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {"name": "DNS Monitor 4"}
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+
+class CertificateProfileFormTest(LoadBalancerModelsTestCaseMixin, FormTestCases):
+    """Test the CertificateProfile form."""
+
+    form_class = forms.CertificateProfileForm
+
+    def test_specifying_all_fields_success(self):
+        """Test specifying all fields."""
+
+        data = {
+            "name": "Certificate Profile 4",
+            "certificate_type": choices.CertificateTypeChoices.TYPE_CLIENT,
+            "certificate_file_path": "test_certificate.crt",
+            "chain_file_path": "chain.pem",
+            "key_file_path": "id_rsa.key",
+            "expiration_date": "2022-01-01",
+            "cipher": "RSA-AES256-GCM-SHA384",
+            "tenant": self.tenant2.pk,
+        }
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
+
+    def test_specifying_required_fields_success(self):
+        """Test specifying only required fields."""
+
+        data = {"name": "Certificate Profile 5"}
+        form = self.form_class(data=data)
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.save())

nautobot/load_balancers/tests/test_models.py

@@ -0,0 +1,195 @@
+"""Test VirtualServer."""
+
+from django.db.utils import IntegrityError
+
+from nautobot.core.testing.models import ModelTestCases
+from nautobot.ipam.models import IPAddress
+from nautobot.load_balancers import choices, models
+from nautobot.load_balancers.tests import LoadBalancerModelsTestCaseMixin
+
+
+# pylint: disable=no-member
+class TestVirtualServer(LoadBalancerModelsTestCaseMixin, ModelTestCases.BaseModelTestCase):
+    """Test VirtualServer."""
+
+    model = models.VirtualServer
+
+    @classmethod
+    def setUpTestData(cls):
+        """Setup test data."""
+        super().setUpTestData()
+
+        # Create a Virtual Server for the generic tests to use
+        vip = IPAddress.objects.create(address="10.0.0.50/32", namespace=cls.namespace, status=cls.status)
+        cls.virtual_server = models.VirtualServer.objects.create(name="VS0", vip=vip)
+        cls.lb_pool = models.LoadBalancerPool.objects.first()
+
+    def test_create_virtualserver_only_required(self):
+        """Create VirtualServer with only required fields, and validate __str__."""
+        virtual_server = models.VirtualServer.objects.create(name="VS1", vip=self.ip_address)
+        self.assertEqual(virtual_server.name, "VS1")
+        self.assertEqual(str(virtual_server), "VS1")
+
+    def test_create_virtualserver_vip_required(self):
+        """Create VirtualServer without vip."""
+        with self.assertRaises(IntegrityError):
+            models.VirtualServer.objects.create(name="VS1")
+
+    def test_create_virtualserver_all_fields_success(self):
+        """Create VirtualServer with all fields."""
+        # Assign to a device
+        virtual_server = models.VirtualServer.objects.create(
+            name="VS1",
+            vip=self.ip_address,
+            port=80,
+            protocol=choices.ProtocolChoices.PROTOCOL_TCP,
+            source_nat_pool=self.source_nat_pool1,
+            source_nat_type=choices.SourceNATTypeChoices.TYPE_POOL,
+            load_balancer_pool=self.lb_pool,
+            load_balancer_type=choices.LoadBalancerTypeChoices.TYPE_LAYER4,
+            enabled=False,
+            ssl_offload=True,
+            tenant=self.tenant1,
+            device=self.device1,
+        )
+        self.assertEqual(virtual_server.name, "VS1")
+
+        # Assign to a device redundancy group
+        virtual_server.device = None
+        virtual_server.device_redundancy_group = self.device_redundancy_group1
+        virtual_server.save()
+        virtual_server.refresh_from_db()
+        self.assertIsNone(virtual_server.device)
+        self.assertEqual(virtual_server.device_redundancy_group, self.device_redundancy_group1)
+
+        # Assign to a cloud service
+        virtual_server.device_redundancy_group = None
+        virtual_server.cloud_service = self.cloud_service1
+        virtual_server.save()
+        virtual_server.refresh_from_db()
+        self.assertIsNone(virtual_server.device_redundancy_group)
+        self.assertEqual(virtual_server.cloud_service, self.cloud_service1)
+
+        # Assign to a virtual chassis
+        virtual_server.cloud_service = None
+        virtual_server.virtual_chassis = self.virtual_chassis1
+        virtual_server.save()
+        virtual_server.refresh_from_db()
+        self.assertIsNone(virtual_server.cloud_service)
+        self.assertEqual(virtual_server.virtual_chassis, self.virtual_chassis1)
+
+
+class TestLoadBalancerPool(LoadBalancerModelsTestCaseMixin, ModelTestCases.BaseModelTestCase):
+    """Test LoadBalancerPool."""
+
+    model = models.LoadBalancerPool
+
+    @classmethod
+    def setUpTestData(cls):
+        """Setup test data."""
+        super().setUpTestData()
+
+        # Create a LoadBalancerPool for the generic tests to use
+        cls.lb_pool = models.LoadBalancerPool.objects.create(name="Pool0", load_balancing_algorithm="round_robin")
+
+    def test_create_load_balancer_pool_only_required(self):
+        """Create LoadBalancerPool with only required fields, and validate __str__."""
+        lb_pool = models.LoadBalancerPool.objects.create(
+            name="Pool1",
+            load_balancing_algorithm="url_hash",
+        )
+        self.assertEqual(lb_pool.name, "Pool1")
+        self.assertEqual(str(lb_pool), "Pool1")
+
+    def test_create_load_balancer_pool_load_balancing_algorithm_required(self):
+        """Create LoadBalancerPool without load_balancing_algorithm."""
+        with self.assertRaises(IntegrityError):
+            models.LoadBalancerPool.objects.create(name="Pool2", load_balancing_algorithm=None)
+
+    def test_create_load_balancer_pool_name_required(self):
+        """Create LoadBalancerPool without name."""
+        with self.assertRaises(IntegrityError):
+            models.LoadBalancerPool.objects.create(load_balancing_algorithm="url_hash", name=None)
+
+
+# pylint: disable=no-member
+class TestLoadBalancerPoolMemberModel(LoadBalancerModelsTestCaseMixin, ModelTestCases.BaseModelTestCase):
+    """Test LoadBalancerPoolMember model."""
+
+    model = models.LoadBalancerPoolMember
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        # Create a LoadBalancerPool for the generic tests to use
+        cls.lb_pool = models.LoadBalancerPool.objects.create(name="Pool0", load_balancing_algorithm="round_robin")
+
+        # Create a LoadBalancerPoolMember for the generic tests to use
+        cls.load_balancer_pool_member = models.LoadBalancerPoolMember.objects.create(
+            ip_address=cls.ip_address,
+            port=80,
+            tenant=cls.tenant1,
+            ssl_offload=True,
+            load_balancer_pool=cls.lb_pool,
+            status=cls.status,
+        )
+
+    def test_create_load_balancer_pool_member_only_required(self):
+        """Create LoadBalancerPoolMember with only required fields, and validate __str__."""
+        ip_address = IPAddress.objects.create(address="10.0.0.50/32", namespace=self.namespace, status=self.status)
+        load_balancer_pool_member = models.LoadBalancerPoolMember.objects.create(
+            ip_address=ip_address, port=80, load_balancer_pool=self.lb_pool, status=self.status
+        )
+        self.assertEqual(load_balancer_pool_member.port, 80)
+        self.assertEqual(str(load_balancer_pool_member), f"{ip_address.host}:80")
+
+    def test_create_load_balancer_pool_member_ipaddress_required(self):
+        """Create LoadBalancerPoolMember without ipaddress."""
+        with self.assertRaises(IntegrityError):
+            models.LoadBalancerPoolMember.objects.create(port=80, load_balancer_pool=self.lb_pool, status=self.status)
+
+    def test_create_load_balancer_pool_member_port_required(self):
+        """Create LoadBalancerPoolMember without port."""
+        ip_address = IPAddress.objects.create(address="10.0.0.50/32", namespace=self.namespace, status=self.status)
+        with self.assertRaises(IntegrityError):
+            models.LoadBalancerPoolMember.objects.create(
+                ip_address=ip_address, port=None, load_balancer_pool=self.lb_pool, status=self.status
+            )
+
+    def test_create_load_balancer_pool_member_load_balancer_pool_required(self):
+        """Create LoadBalancerPoolMember without load_balancer_pool."""
+        ip_address = IPAddress.objects.create(address="10.0.0.50/32", namespace=self.namespace, status=self.status)
+        with self.assertRaises(IntegrityError):
+            models.LoadBalancerPoolMember.objects.create(ip_address=ip_address, port=80, status=self.status)
+
+    def test_create_load_balancer_pool_member_status_required(self):
+        """Create LoadBalancerPoolMember without status."""
+        ip_address = IPAddress.objects.create(address="10.0.0.50/32", namespace=self.namespace, status=self.status)
+        with self.assertRaises(IntegrityError):
+            models.LoadBalancerPoolMember.objects.create(
+                ip_address=ip_address, port=80, load_balancer_pool=self.lb_pool
+            )
+
+
+class TestHealthCheckMonitorModel(LoadBalancerModelsTestCaseMixin, ModelTestCases.BaseModelTestCase):
+    """Test HealthCheckMonitor model."""
+
+    model = models.HealthCheckMonitor
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+
+class TestCertificateProfileModel(LoadBalancerModelsTestCaseMixin, ModelTestCases.BaseModelTestCase):
+    """Test CertificateProfile model."""
+
+    model = models.CertificateProfile
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()

nautobot/load_balancers/tests/test_views.py

@@ -0,0 +1,229 @@
+"""Unit tests for views."""
+
+import datetime
+
+from django.utils.timezone import make_aware
+
+from nautobot.core.testing.views import ViewTestCases
+from nautobot.load_balancers import choices, models
+from nautobot.load_balancers.tests import LoadBalancerModelsTestCaseMixin
+
+
+# pylint: disable=too-many-ancestors, no-member
+class VirtualServerViewTest(LoadBalancerModelsTestCaseMixin, ViewTestCases.PrimaryObjectViewTestCase):
+    """Test the VirtualServer views."""
+
+    model = models.VirtualServer
+
+    @classmethod
+    def setUpTestData(cls):
+        """Setup test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "VS4",
+            "vip": cls.vips[-4].pk,
+            "port": 4444,
+            "load_balancer_pool": cls.load_balancer_pools[0].pk,
+            "protocol": choices.ProtocolChoices.PROTOCOL_TCP,
+            "source_nat_pool": None,
+            "source_nat_type": "",
+            "load_balancer_type": choices.LoadBalancerTypeChoices.TYPE_LAYER4,
+            "enabled": True,
+            "ssl_offload": False,
+            "device": cls.device1.pk,
+            "device_redundancy_group": None,
+            "cloud_service": None,
+            "virtual_chassis": None,
+            "tenant": None,
+            "health_check_monitor": None,
+        }
+
+        cls.update_data = {
+            "name": "VS5",
+            "vip": cls.vips[-5].pk,
+            "port": 5555,
+            "protocol": choices.ProtocolChoices.PROTOCOL_DNS,
+            "load_balancer_pool": cls.load_balancer_pools[1].pk,
+            "source_nat_pool": None,
+            "source_nat_type": "",
+            "load_balancer_type": choices.LoadBalancerTypeChoices.TYPE_DNS,
+            "enabled": False,
+            "ssl_offload": True,
+            "device": None,
+            "device_redundancy_group": cls.device_redundancy_group1.pk,
+            "cloud_service": None,
+            "virtual_chassis": None,
+            "tenant": None,
+            "health_check_monitor": cls.health_check_monitors[0].pk,
+        }
+
+        cls.bulk_edit_data = {
+            "port": 7777,
+            "protocol": choices.ProtocolChoices.PROTOCOL_ANY,
+            "source_nat_pool": None,
+            "source_nat_type": "",
+            "load_balancer_pool": cls.load_balancer_pools[0].pk,
+            "load_balancer_type": choices.LoadBalancerTypeChoices.TYPE_LAYER2,
+            "enabled": False,
+            "ssl_offload": True,
+            "device": None,
+            "device_redundancy_group": None,
+            "cloud_service": None,
+            "virtual_chassis": cls.virtual_chassis1.pk,
+            "tenant": None,
+            "health_check_monitor": cls.health_check_monitors[1].pk,
+            "add_certificate_profiles": [cls.certificate_profiles[1].pk],
+            "remove_certificate_profiles": [cls.certificate_profiles[0].pk],
+        }
+
+
+# pylint: disable=too-many-ancestors, no-member
+class LoadBalancerPoolViewTestCase(LoadBalancerModelsTestCaseMixin, ViewTestCases.PrimaryObjectViewTestCase):
+    """Test the LoadBalancerPool views."""
+
+    model = models.LoadBalancerPool
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "Load Balancer Pool 1",
+            "load_balancing_algorithm": choices.LoadBalancingAlgorithmChoices.ROUND_ROBIN,
+            "health_check_monitor": None,
+            "tenant": cls.tenant1.pk,
+        }
+
+        cls.update_data = {
+            "name": "Load Balancer Pool 2",
+            "load_balancing_algorithm": choices.LoadBalancingAlgorithmChoices.LEAST_CONNECTIONS,
+            "health_check_monitor": cls.health_check_monitors[0].pk,
+            "tenant": None,
+        }
+
+        cls.bulk_edit_data = {
+            "name": "Load Balancer Pool 2",
+            "load_balancing_algorithm": choices.LoadBalancingAlgorithmChoices.URL_HASH,
+            "health_check_monitor": cls.health_check_monitors[1].pk,
+            "tenant": None,
+        }
+
+
+# pylint: disable=too-many-ancestors, no-member
+class LoadBalancerPoolMemberViewTestCase(LoadBalancerModelsTestCaseMixin, ViewTestCases.PrimaryObjectViewTestCase):
+    """Test the LoadBalancerPoolMember views."""
+
+    model = models.LoadBalancerPoolMember
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "ip_address": cls.ip2.pk,
+            "load_balancer_pool": cls.load_balancer_pools[1].pk,
+            "port": 161,
+            "ssl_offload": True,
+            "tenant": cls.tenant1.pk,
+            "status": cls.status.pk,
+            "health_check_monitor": cls.health_check_monitors[0].pk,
+        }
+
+        cls.bulk_edit_data = {
+            "load_balancer_pool": cls.load_balancer_pools[0].pk,
+            "ssl_offload": False,
+            "tenant": None,
+            "status": cls.status.pk,
+            "health_check_monitor": cls.health_check_monitors[1].pk,
+            "add_certificate_profiles": [cls.certificate_profiles[1].pk],
+            "remove_certificate_profiles": [cls.certificate_profiles[0].pk],
+        }
+
+
+# pylint: disable=too-many-ancestors, no-member
+class HealthCheckMonitorViewTestCase(LoadBalancerModelsTestCaseMixin, ViewTestCases.PrimaryObjectViewTestCase):
+    """Test the HealthCheckMonitor views."""
+
+    model = models.HealthCheckMonitor
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "HTTP Monitor 4",
+            "interval": 35,
+            "retry": 3,
+            "timeout": 30,
+            "port": 8008,
+            "health_check_type": choices.HealthCheckTypeChoices.HTTP,
+            "tenant": cls.tenant1.pk,
+        }
+
+        cls.update_data = {
+            "name": "DNS Monitor 3",
+            "interval": 4,
+            "retry": 5,
+            "timeout": 6,
+            "port": 0,
+            "health_check_type": choices.HealthCheckTypeChoices.DNS,
+            "tenant": cls.tenant2.pk,
+        }
+
+        cls.bulk_edit_data = {
+            "interval": 8,
+            "retry": 9,
+            "timeout": 10,
+            "port": 11,
+            "health_check_type": choices.HealthCheckTypeChoices.TCP,
+            "tenant": None,
+        }
+
+
+# pylint: disable=too-many-ancestors, no-member
+class CertificateProfileViewTestCase(LoadBalancerModelsTestCaseMixin, ViewTestCases.PrimaryObjectViewTestCase):
+    """Test the CertificateProfile views."""
+
+    model = models.CertificateProfile
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+
+        cls.form_data = {
+            "name": "Test Certificate Profile 1",
+            "certificate_type": choices.CertificateTypeChoices.TYPE_CLIENT,
+            "certificate_file_path": "/this/is/a/path.crt",
+            "chain_file_path": "/chain/certificate/path.pem",
+            "key_file_path": "test_key.key",
+            "expiration_date": make_aware(datetime.datetime(2023, 11, 1, 0, 0)),
+            "cipher": "TLS_AES_256_GCM_SHA384",
+            "tenant": cls.tenant1.pk,
+        }
+
+        cls.update_data = {
+            "name": "Test Certificate Profile 2",
+            "certificate_type": choices.CertificateTypeChoices.TYPE_SERVER,
+            "certificate_file_path": "/test_cert.pem",
+            "chain_file_path": "/test_chain.pem",
+            "key_file_path": "/test_key",
+            "expiration_date": make_aware(datetime.datetime(2030, 12, 1, 0, 0)),
+            "cipher": "ECDHE_RSA",
+            "tenant": cls.tenant2.pk,
+        }
+
+        cls.bulk_edit_data = {
+            "name": "Test Certificate Profile 3",
+            "tenant": None,
+            "certificate_type": choices.CertificateTypeChoices.TYPE_MTLS,
+            "certificate_file_path": "/etc/certificate.pem",
+            "chain_file_path": "/bin/chain.pem",
+            "key_file_path": "/home/key",
+            "expiration_date": make_aware(datetime.datetime(2020, 1, 1, 0, 0, 0, 0)),
+            "cipher": "CHACHA20_POLY1305",
+        }