Add create tests

netbox_sys_plugin/api/serializers.py

@@ -98,16 +98,68 @@ class VirtualMachineTypeSerializer(NetBoxModelSerializer):
         fields = '__all__'
 
 class VmAssignedVirtualMachineTypeSerializer(NetBoxModelSerializer):
-    id = serializers.IntegerField(read_only=True)
-    virtual_machine = NestedVirtualMachineSerializer(source='assigned_object', read_only=True)
-    virtual_machine_type = VirtualMachineTypeSerializer()
-    assigned_object_id = serializers.IntegerField(write_only=True)
-    assigned_object_type = serializers.CharField(write_only=True)
-    display = serializers.CharField(source="__str__")
+    """
+    Serializer for VmAssignedVirtualMachineType.
+    Includes nested representations for related objects.
+    """
+    virtual_machine_type = serializers.PrimaryKeyRelatedField(
+        queryset=VirtualMachineType.objects.all()
+    )
+    assigned_object_type = serializers.PrimaryKeyRelatedField(
+        queryset=ContentType.objects.all()
+    )
+    assigned_object_id = serializers.IntegerField()
+
+    # Optional: Add any extra fields for enhanced representation
+    virtual_machine_type_name = serializers.SerializerMethodField()
+    assigned_object = serializers.SerializerMethodField()
 
     class Meta:
         model = VmAssignedVirtualMachineType
-        fields = '__all__'
+        fields = [
+            'id',
+            'virtual_machine_type',
+            'virtual_machine_type_name',
+            'virtual_machine_type_assignment_desc',
+            'assigned_object_type',
+            'assigned_object_id',
+            'assigned_object',
+            'created',
+            'last_updated',
+        ]
+
+    def get_virtual_machine_type_name(self, obj):
+        """Get the name of the related VirtualMachineType."""
+        return obj.virtual_machine_type.virtual_machine_type_name if obj.virtual_machine_type else None
+
+    def get_assigned_object(self, obj):
+        """Get the assigned object representation."""
+        assigned_object = obj.assigned_object
+        if isinstance(assigned_object, VirtualMachine):
+            return {
+                "id": assigned_object.id,
+                "name": assigned_object.name,
+                "cluster": assigned_object.cluster.name if assigned_object.cluster else None,
+            }
+        return None
+
+    def validate(self, data):
+        """
+        Perform additional validation, including checking for unique constraints.
+        """
+        virtual_machine_type = data.get('virtual_machine_type')
+        assigned_object_type = data.get('assigned_object_type')
+        assigned_object_id = data.get('assigned_object_id')
+
+        if VmAssignedVirtualMachineType.objects.filter(
+            virtual_machine_type=virtual_machine_type,
+            assigned_object_type=assigned_object_type,
+            assigned_object_id=assigned_object_id
+        ).exists():
+            raise serializers.ValidationError(
+                "The combination of virtual_machine_type, assigned_object_type, and assigned_object_id must be unique."
+            )
+        return data
 
 class DomainNamesSerializer(NetBoxModelSerializer):
     id = serializers.IntegerField(read_only=True)

netbox_sys_plugin/api/views.py

@@ -27,7 +27,7 @@ class VmAssignedVirtualMachineTypeViewSet(viewsets.ModelViewSet):
     queryset = VmAssignedVirtualMachineType.objects.prefetch_related(Prefetch(
             'virtual_machine_type', queryset=VirtualMachineType.objects.all(),  
         ),)
-    serializer_class = NestedVmAssignedVirtualMachineTypeSerializer
+    serializer_class = VmAssignedVirtualMachineTypeSerializer
     http_method_names = ["get", "post", "patch", "delete", "options"]
 
 class VirtualMachineTypeViewSet(viewsets.ModelViewSet):

netbox_sys_plugin/tests/vm_assigned_virtual_machine_type/test_vm_assigned_virtual_machine_type_api.py

@@ -8,92 +8,71 @@ from netbox_sys_plugin.models import VirtualMachineType, VmAssignedVirtualMachin
 from ..base import BaseAPITestCase
 
 class VmAssignedVirtualMachineTypeApiTestCase(BaseAPITestCase):
-    """Test suite for VirtualMachinedomain_names API"""
+    """Test suite for VmAssignedVirtualMachineType API"""
     model = VmAssignedVirtualMachineType
     brief_fields = ["virtual_machine_type", "assigned_object_id", "assigned_object_type"]
 
-
     @classmethod
     def setUpTestData(cls):
-
-        """Set up test data for DomainNames API"""
+        """Set up test data for VmAssignedVirtualMachineType API"""
         cls.vm_ct = ContentType.objects.get_for_model(VirtualMachine)
 
-        # Create a ClusterType
-        cls.cluster_type_aws = ClusterType.objects.create(name="Test ClusterType AWS")
-        cls.cluster_type_vmware = ClusterType.objects.create(name="Test ClusterType VMWare")
+        # Create ClusterTypes
+        cls.cluster_type_aws = ClusterType.objects.create(name="Test ClusterType AWS", slug='test-cluster-type-aws')
+        cls.cluster_type_vmware = ClusterType.objects.create(name="Test ClusterType VMWare", slug='test-cluster-type-vmware')
 
-        # Create a Cluster linked to the ClusterType
-        cls.cluster_aws = Cluster.objects.create(name="Test Cluster", type=cls.cluster_type_aws)
-        cls.cluster_vmware = Cluster.objects.create(name="Test Cluster", type=cls.cluster_type_aws)
+        # Create Clusters linked to the ClusterTypes
+        cls.cluster_aws = Cluster.objects.create(name="Test Cluster AWS", type=cls.cluster_type_aws)
+        cls.cluster_vmware = Cluster.objects.create(name="Test Cluster VMWare", type=cls.cluster_type_vmware)
 
-        # Create a VirtualMachine linked to the Cluster
+        # Create VirtualMachines linked to the Clusters
         cls.virtual_machine = VirtualMachine.objects.create(
             name="Test VM",
             status="active",
             cluster=cls.cluster_aws
         )
-
-        # Create a VirtualMachine 2 linked to the Cluster
         cls.virtual_machine2 = VirtualMachine.objects.create(
             name="Test VM2",
             status="active",
             cluster=cls.cluster_aws
         )
 
-        # Create a VirtualMachine 3 linked to the Cluster
-        cls.virtual_machine3 = VirtualMachine.objects.create(
-            name="Test VM3",
-            status="active",
-            cluster=cls.cluster_aws
-        )
-
-        # Create a VirtualMachine 4 linked to the Cluster
         cls.virtual_machine4 = VirtualMachine.objects.create(
             name="Test VM4",
             status="active",
             cluster=cls.cluster_vmware
         )
-        # Create a VirtualMachine 5 linked to the Cluster
-        cls.virtual_machine5 = VirtualMachine.objects.create(
-            name="Test VM5",
-            status="active",
-            cluster=cls.cluster_vmware
-        )
-        # Create a VirtualMachine 6 linked to the Cluster
-        cls.virtual_machine6 = VirtualMachine.objects.create(
-            name="Test VM6",
-            status="active",
-            cluster=cls.cluster_vmware
-        )
 
-        # Create VirtualMachineType 
-        cls.virtual_machine_type_aws = VirtualMachineType.objects.create(virtual_machine_type_name = 'AWS', assigned_object = cls.cluster_type)
-        cls.virtual_machine_type_vmware = VirtualMachineType.objects.create(virtual_machine_type_name = 'VMWare', assigned_object = cls.cluster_type)
-
-        # Assign VirtualMachineType to VM
-        VmAssignedVirtualMachineType.objects.create(virtual_machine_type = cls.virtual_machine_type_aws, 
-                                                    assigned_object_id = cls.virtual_machine)
-        VmAssignedVirtualMachineType.objects.create(virtual_machine_type = cls.virtual_machine_type_vmware, 
-                                                    assigned_object_id = cls.virtual_machine4)
+        # Create VirtualMachineTypes
+        cls.virtual_machine_type_aws = VirtualMachineType.objects.create(
+            virtual_machine_type_name='AWS',
+            assigned_object=cls.cluster_type_aws,
+            virtual_machine_type_desc='AWS description'
+        )
 
+        cls.virtual_machine_type_vmware = VirtualMachineType.objects.create(
+            virtual_machine_type_name='VMWare',
+            assigned_object=cls.cluster_type_vmware,
+            virtual_machine_type_desc='VMWare description'
+        )
 
-        # Create domain_names entries linked to the VirtualMachine
-        # DomainNames.objects.create(
-        #     domain_names={'domain1':'ec.test.test','domain2':'ec.test2.test2'},
-        #     assigned_object=cls.virtual_machine
+        # # Assign VirtualMachineTypes to VirtualMachines
+        # VmAssignedVirtualMachineType.objects.create(
+        #     virtual_machine_type=cls.virtual_machine_type_aws,
+        #     assigned_object_id=cls.virtual_machine.id
         # )
-        # DomainNames.objects.create(
-        #     domain_names={'domain1':'ec.test.test','domain2':'ec.test2.test2'},
-        #     assigned_object=cls.virtual_machine2
+
+        # VmAssignedVirtualMachineType.objects.create(
+        #     virtual_machine_type=cls.virtual_machine_type_vmware,
+        #     assigned_object_id=cls.virtual_machine4.id
         # )
 
         # Data for valid creation
         cls.valid_create_data = [
             {
                 "virtual_machine_type": cls.virtual_machine_type_aws.pk,
-                "assigned_object_type": cls.cluster_type_aws.pk,
-                "assigned_object_id": cls.virtual_machine.id,
+                "assigned_object_id": cls.virtual_machine2.id,
+                "assigned_object_type": cls.vm_ct.pk
             }
         ]
 
@@ -105,30 +84,16 @@ class VmAssignedVirtualMachineTypeApiTestCase(BaseAPITestCase):
                 "assigned_object_id": cls.virtual_machine4.id,
             },
             {
-                "virtual_machine_type": cls.virtual_machine_type_vmware.pk,
-                "assigned_object_type": cls.cluster_type_aws.pk,
+                "virtual_machine_type": cls.virtual_machine_type_vmware.id,
+                "assigned_object_type": cls.vm_ct.pk,
                 "assigned_object_id": None,  # Missing VirtualMachine
             },
         ]
 
-        # # Data for checking unique key
-        # cls.valid_check_unique_data = [
-        #     {
-        #         "domain_names": {'domain1':'ec.test.test','domain2':'ec.test2.test2'},
-        #         "assigned_object_type": cls.vm_ct.pk,
-        #         "assigned_object_id": cls.virtual_machine6.id, # Same Virtual Machine
-        #     },
-        #     {
-        #         "domain_names": {'domain1':'ec.test.test','domain2':'ec.test2.test2'},
-        #         "assigned_object_type": cls.vm_ct.pk,
-        #         "assigned_object_id": cls.virtual_machine6.id, # Same Virtual Machine
-        #     }
-        # ]
-
-    def test_create_valid_VirtualMachineType_assigment(self):
-        """Test creating a valid Domain Names"""
+    def test_create_valid_virtual_machine_type_assignment(self):
+        """Test creating a valid VmAssignedVirtualMachineType"""
         obj_perm = ObjectPermission(
-            name="Create Domain Names Permission",
+            name="Create VmAssignedVirtualMachineType Permission",
             actions=["add", "view"],
         )
         obj_perm.save()
@@ -138,101 +103,35 @@ class VmAssignedVirtualMachineTypeApiTestCase(BaseAPITestCase):
         form_data = self.valid_create_data[0]
         response = self.client.post(self._get_list_url(), form_data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(response.data["VmAssignedVirtualMachineType"], form_data["VmAssignedVirtualMachineType"])
-
-    # def test_domain_names_unique_key(self):
-    #     """Test domain names unique key"""
-    #     obj_perm = ObjectPermission(
-    #         name="Invalid domain names Permission",
-    #         actions=["add", "view"],
-    #     )
-    #     obj_perm.save()
-    #     obj_perm.users.add(self.user)
-    #     obj_perm.object_types.add(ContentType.objects.get_for_model(DomainNames))
-
-    #     for form_data in self.valid_check_unique_data:
-    #         response = self.client.post(self._get_list_url(), form_data, format="json", **self.header)
-    #     self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-
-    # def test_create_invalid_domain_names(self):
-    #     """Test creating invalid domain names"""
-    #     obj_perm = ObjectPermission(
-    #         name="Invalid domain names Permission",
-    #         actions=["add", "view"],
-    #     )
-    #     obj_perm.save()
-    #     obj_perm.users.add(self.user)
-    #     obj_perm.object_types.add(ContentType.objects.get_for_model(DomainNames))
-
-    #     form_data = self.invalid_create_data[0]
-    #     print("form_data",form_data)
-    #     response = self.client.post(self._get_list_url(), form_data, format="json", **self.header)
-    #     print("RESPONSE API 1",response.data)
-    #     self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-    #     self.assertIn('This field may not be null.',str(response.data))
-
-    #     form_data = self.invalid_create_data[1]
-    #     response = self.client.post(self._get_list_url(), form_data, format="json", **self.header)
-    #     print("RESPONSE API 2",response.data)
-    #     self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-    #     self.assertIn('This field may not be null.',str(response.data))
-
-    # def test_update_domain_names(self):
-    #     """Test updating an existing domain names"""
-    #     domain_names = DomainNames.objects.first()
-    #     obj_perm = ObjectPermission(
-    #         name="Update domain names Permission",
-    #         actions=["change", "view"],
-    #     )
-    #     obj_perm.save()
-    #     obj_perm.users.add(self.user)
-    #     obj_perm.object_types.add(ContentType.objects.get_for_model(DomainNames))
-
-    #     update_data = {'domain_names': {'domain1':'ec.test.test','domain2':'ec.test2.test2'}}
-    #     response = self.client.patch(self._get_detail_url(domain_names), update_data, format="json", **self.header)
-    #     self.assertHttpStatus(response, status.HTTP_200_OK)
-    #     self.assertEqual(response.data["domain_names"], update_data["domain_names"])
-
-    # def test_delete_domain_names(self):
-    #     """Test deleting a domain names"""
-    #     domain_names = DomainNames.objects.first()
-    #     obj_perm = ObjectPermission(
-    #         name="Delete domain names Permission",
-    #         actions=["delete"],
-    #     )
-    #     obj_perm.save()
-    #     obj_perm.users.add(self.user)
-    #     obj_perm.object_types.add(ContentType.objects.get_for_model(DomainNames))
-
-    #     response = self.client.delete(self._get_detail_url(domain_names), **self.header)
-    #     self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
-    #     self.assertFalse(DomainNames.objects.filter(id=domain_names.id).exists())
-
-    # def test_get_all_domain_names(self):
-    #     """Test fetching all domain names"""
-    #     obj_perm = ObjectPermission(
-    #         name="View domain_names Permission",
-    #         actions=["view"],
-    #     )
-    #     obj_perm.save()
-    #     obj_perm.users.add(self.user)
-    #     obj_perm.object_types.add(ContentType.objects.get_for_model(DomainNames))
-
-    #     response = self.client.get(self._get_list_url(), **self.header)
-    #     self.assertHttpStatus(response, status.HTTP_200_OK)
-    #     self.assertGreaterEqual(len(response.data), 2)
-
-    # def test_get_single_domain_names(self):
-    #     """Test fetching a single domain names"""
-    #     obj_perm = ObjectPermission(
-    #         name="View domain names Permission",
-    #         actions=["view"],
-    #     )
-    #     obj_perm.save()
-    #     obj_perm.users.add(self.user)
-    #     obj_perm.object_types.add(ContentType.objects.get_for_model(DomainNames))
-
-    #     domain_names = DomainNames.objects.first()
-    #     response = self.client.get(self._get_detail_url(domain_names), **self.header)
-    #     self.assertHttpStatus(response, status.HTTP_200_OK)
-    #     self.assertEqual(response.data["domain_names"], domain_names.domain_names)
+        self.assertEqual(response.data["assigned_object_id"], form_data["assigned_object_id"])
+        self.assertEqual(response.data["virtual_machine_type"], form_data["virtual_machine_type"])
+
+    def test_create_invalid_virtual_machine_type_assignment(self):
+        """Test creating invalid VmAssignedVirtualMachineType"""
+        obj_perm = ObjectPermission(
+            name="Create Invalid VmAssignedVirtualMachineType Permission",
+            actions=["add", "view"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(VmAssignedVirtualMachineType))
+
+        for form_data in self.invalid_create_data:
+            response = self.client.post(self._get_list_url(), form_data, format="json", **self.header)
+            self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+            self.assertIn('This field may not be null.', str(response.data))
+
+    def test_delete_virtual_machine_type_assignment(self):
+        """Test deleting a VmAssignedVirtualMachineType"""
+        vm_assignment = VmAssignedVirtualMachineType.objects.first()
+        obj_perm = ObjectPermission(
+            name="Delete VmAssignedVirtualMachineType Permission",
+            actions=["delete"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(VmAssignedVirtualMachineType))
+
+        response = self.client.delete(self._get_detail_url(vm_assignment), **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertFalse(VmAssignedVirtualMachineType.objects.filter(id=vm_assignment.id).exists())