From 0632933dccecda0b8006cdf506f82333aad96525 Mon Sep 17 00:00:00 2001 From: alyssavu Date: Wed, 27 Nov 2024 21:53:01 +0000 Subject: [PATCH] update test --- .../clusterloader2/kubernetes_client.py | 9 ++- .../python/tests/test_kubernetes_client.py | 75 ++++++++++++------- 2 files changed, 54 insertions(+), 30 deletions(-) diff --git a/modules/python/clusterloader2/kubernetes_client.py b/modules/python/clusterloader2/kubernetes_client.py index 8525842bf..f3e08ff76 100644 --- a/modules/python/clusterloader2/kubernetes_client.py +++ b/modules/python/clusterloader2/kubernetes_client.py @@ -88,12 +88,17 @@ def delete_persistent_volume_claim_by_namespace(self, namespace): for pvc in pvcs: self.api.delete_namespaced_persistent_volume_claim(pvc.metadata.name, namespace, body=client.V1DeleteOptions()) + def get_volume_attachments(self): + return self.storage.list_volume_attachment().items + def get_attached_volume_attachments(self): - volume_attachments = self.storage.list_volume_attachment().items + volume_attachments = self.get_volume_attachments() return [attachment for attachment in volume_attachments if attachment.status.attached] def create_namespace(self, namespace): - # Check if namespace exists + """ + Returns the namespace object if it exists, otherwise creates it. + """ try: namespace = self.api.read_namespace(namespace) return namespace diff --git a/modules/python/tests/test_kubernetes_client.py b/modules/python/tests/test_kubernetes_client.py index e871651bc..990d19316 100644 --- a/modules/python/tests/test_kubernetes_client.py +++ b/modules/python/tests/test_kubernetes_client.py @@ -4,7 +4,7 @@ V1Node, V1NodeStatus, V1NodeCondition, V1NodeSpec, V1ObjectMeta, V1Taint, V1PersistentVolumeClaim, V1PersistentVolumeClaimStatus, V1VolumeAttachment, V1VolumeAttachmentStatus, V1VolumeAttachmentSpec, V1VolumeAttachmentSource, - V1PodStatus, V1Pod, V1PodSpec, V1Namespace + V1PodList, V1PodStatus, V1Pod, V1PodSpec, V1Namespace ) from clusterloader2.kubernetes_client import KubernetesClient @@ -84,6 +84,16 @@ def _create_volume_attachment(self, name, namespace, phase, attacher, node_name) status=V1VolumeAttachmentStatus(attached=phase) ) + @patch("kubernetes.client.CoreV1Api.read_namespace") + def test_create_existing_namespace(self, mock_read_namespace): + name = "test-namespace" + mock_namespace = self._create_namespace(name) + mock_read_namespace.return_value = mock_namespace + + ns = self.client.create_namespace(name) + self.assertEqual(ns.metadata.name, mock_read_namespace.return_value.metadata.name) + mock_read_namespace.assert_called_once_with(name) + @patch('clusterloader2.kubernetes_client.KubernetesClient.create_namespace') @patch('clusterloader2.kubernetes_client.KubernetesClient.delete_namespace') def test_create_delete_namespace(self, mock_delete_namespace, mock_create_namespace): @@ -101,63 +111,72 @@ def test_create_delete_namespace(self, mock_delete_namespace, mock_create_namesp self.assertEqual(mock_delete_namespace.return_value, ns) mock_delete_namespace.assert_called_once_with(name) - @patch('clusterloader2.kubernetes_client.KubernetesClient.get_running_pods_by_namespace') - def test_get_running_pods_by_namespace(self, mock_get_running_pods_by_namespace): + @patch('clusterloader2.kubernetes_client.KubernetesClient.get_pods_by_namespace') + def test_get_running_pods_by_namespace(self, mock_get_pods_by_namespace): namespace = "test-namespace" - running_pods = 10 pending_pods = 5 - labels = {"csi": "true"} - all_pods = [ + labels = {"app": "nginx"} + + mock_get_pods_by_namespace.return_value = [ self._create_pod(namespace=namespace, name=f"pod-{i}", phase="Running", labels=labels) for i in range(running_pods) ] - all_pods.extend( - self._create_pod(namespace=namespace, name=f"pod-{i}", phase="Pending", labels=labels) for i in range(running_pods, pending_pods + running_pods)) + mock_get_pods_by_namespace.return_value.extend( + [self._create_pod(namespace=namespace, name=f"pod-{i}", phase="Pending", labels=labels) for i in range(running_pods, pending_pods + running_pods)] + ) + + self.assertEqual(len(mock_get_pods_by_namespace.return_value), running_pods + pending_pods) - mock_get_running_pods_by_namespace.return_value = [pod for pod in all_pods if pod.status.phase == "Running"] - pods = self.client.get_running_pods_by_namespace(namespace=namespace, label_selector="csi=true") - for pod in pods: + expected_pods = [pod for pod in mock_get_pods_by_namespace.return_value if pod.status.phase == "Running"] + returned_pods = self.client.get_running_pods_by_namespace(namespace=namespace, label_selector="app=nginx") + + for pod in returned_pods: self.assertEqual(pod.metadata.labels, labels) self.assertEqual(pod.status.phase, "Running") - mock_get_running_pods_by_namespace.assert_called_once_with(namespace=namespace, label_selector="csi=true") - self.assertEqual(len(all_pods), running_pods + pending_pods) - self.assertEqual(len(pods), running_pods) + + mock_get_pods_by_namespace.assert_called_once_with(namespace=namespace, label_selector="app=nginx", field_selector=None) + self.assertEqual(len(returned_pods), len(expected_pods)) + self.assertEqual(returned_pods, expected_pods) - @patch('clusterloader2.kubernetes_client.KubernetesClient.get_bound_persistent_volume_claims_by_namespace') + @patch('clusterloader2.kubernetes_client.KubernetesClient.get_persistent_volume_claims_by_namespace') def test_get_bound_persistent_volume_claims_by_namespace(self, mock_get_persistent_volume_claims_by_namespace): namespace = "test-namespace" bound_claims = 10 pending_claims = 5 - all_claims = [ + mock_get_persistent_volume_claims_by_namespace.return_value = [ self._create_pvc(name=f"pvc-{i}", namespace=namespace, phase="Bound") for i in range(bound_claims) ] - all_claims.extend( + mock_get_persistent_volume_claims_by_namespace.return_value.extend( self._create_pvc(name=f"pvc-{i}", namespace=namespace, phase="Pending") for i in range(bound_claims, pending_claims + bound_claims)) - mock_get_persistent_volume_claims_by_namespace.return_value = [claim for claim in all_claims if claim.status.phase == "Bound"] - claims = self.client.get_bound_persistent_volume_claims_by_namespace(namespace=namespace) - self.assertEqual(len(all_claims), bound_claims + pending_claims) - self.assertEqual(len(claims), bound_claims) + self.assertEqual(len(mock_get_persistent_volume_claims_by_namespace.return_value), bound_claims + pending_claims) + + expected_claims = [claim for claim in mock_get_persistent_volume_claims_by_namespace.return_value if claim.status.phase == "Bound"] + returned_claims = self.client.get_bound_persistent_volume_claims_by_namespace(namespace=namespace) + self.assertEqual(len(returned_claims), len(expected_claims)) + self.assertEqual(returned_claims, expected_claims) mock_get_persistent_volume_claims_by_namespace.assert_called_once_with(namespace=namespace) - @patch('clusterloader2.kubernetes_client.KubernetesClient.get_attached_volume_attachments') + @patch('clusterloader2.kubernetes_client.KubernetesClient.get_volume_attachments') def test_get_attached_volume_attachments(self, mock_get_volume_attachments): attached_attachments = 10 detached_attachments = 5 - all_attachments = [ + mock_get_volume_attachments.return_value = [ self._create_volume_attachment( name=f"attachment-{i}", namespace="test-namespace", phase=True, attacher="csi-driver", node_name="node-{i}" ) for i in range(attached_attachments) ] - all_attachments.extend( + mock_get_volume_attachments.return_value.extend( self._create_volume_attachment( name=f"attachment-{i}", namespace="test-namespace", phase=False, attacher="csi-driver", node_name="node-{i}" ) for i in range(attached_attachments, detached_attachments + attached_attachments)) - mock_get_volume_attachments.return_value = [attachment for attachment in all_attachments if attachment.status.attached] - attachments = self.client.get_attached_volume_attachments() - self.assertEqual(len(all_attachments), attached_attachments + detached_attachments) - self.assertEqual(len(attachments), attached_attachments) + self.assertEqual(len(mock_get_volume_attachments.return_value), attached_attachments + detached_attachments) + + expected_volume_attachments = [attachment for attachment in mock_get_volume_attachments.return_value if attachment.status.attached] + returned_volume_attachments = self.client.get_attached_volume_attachments() + self.assertEqual(len(returned_volume_attachments), len(expected_volume_attachments)) + self.assertEqual(returned_volume_attachments, expected_volume_attachments) mock_get_volume_attachments.assert_called_once() if __name__ == '__main__':