diff --git a/pkg/controllers/job/job_controller_actions_test.go b/pkg/controllers/job/job_controller_actions_test.go
index 17f9a50183..83df17afdd 100644
--- a/pkg/controllers/job/job_controller_actions_test.go
+++ b/pkg/controllers/job/job_controller_actions_test.go
@@ -96,67 +96,70 @@ func TestKillJobFunc(t *testing.T) {
 
 	for i, testcase := range testcases {
 
-		fakeController := newFakeController()
-		jobPlugins := make(map[string][]string)
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
+			jobPlugins := make(map[string][]string)
 
-		for _, service := range testcase.Services {
-			_, err := fakeController.kubeClients.CoreV1().Services(namespace).Create(&service)
-			if err != nil {
-				t.Error("Error While Creating Service")
+			for _, service := range testcase.Services {
+				_, err := fakeController.kubeClients.CoreV1().Services(namespace).Create(&service)
+				if err != nil {
+					t.Error("Error While Creating Service")
+				}
+			}
+
+			for _, configMap := range testcase.ConfigMaps {
+				_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Create(&configMap)
+				if err != nil {
+					t.Error("Error While Creating ConfigMaps")
+				}
+			}
+
+			for _, pod := range testcase.Pods {
+				_, err := fakeController.kubeClients.CoreV1().Pods(namespace).Create(pod)
+				if err != nil {
+					t.Error("Error While Creating ConfigMaps")
+				}
 			}
-		}
 
-		for _, configMap := range testcase.ConfigMaps {
-			_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Create(&configMap)
+			_, err := fakeController.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.Job)
 			if err != nil {
-				t.Error("Error While Creating ConfigMaps")
+				t.Error("Error While Creating Jobs")
+			}
+			err = fakeController.cache.Add(testcase.Job)
+			if err != nil {
+				t.Error("Error While Adding Job in cache")
 			}
-		}
 
-		for _, pod := range testcase.Pods {
-			_, err := fakeController.kubeClients.CoreV1().Pods(namespace).Create(pod)
+			for _, plugin := range testcase.Plugins {
+				jobPlugins[plugin] = make([]string, 0)
+			}
+
+			testcase.JobInfo.Job = testcase.Job
+			testcase.JobInfo.Job.Spec.Plugins = jobPlugins
+
+			err = fakeController.killJob(testcase.JobInfo, testcase.PodRetainPhase, testcase.UpdateStatus)
 			if err != nil {
-				t.Error("Error While Creating ConfigMaps")
+				t.Errorf("Case %d (%s): expected: No Error, but got error %s", i, testcase.Name, err.Error())
 			}
-		}
-
-		_, err := fakeController.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.Job)
-		if err != nil {
-			t.Error("Error While Creating Jobs")
-		}
-		err = fakeController.cache.Add(testcase.Job)
-		if err != nil {
-			t.Error("Error While Adding Job in cache")
-		}
-
-		for _, plugin := range testcase.Plugins {
-			jobPlugins[plugin] = make([]string, 0)
-		}
-
-		testcase.JobInfo.Job = testcase.Job
-		testcase.JobInfo.Job.Spec.Plugins = jobPlugins
-
-		err = fakeController.killJob(testcase.JobInfo, testcase.PodRetainPhase, testcase.UpdateStatus)
-		if err != nil {
-			t.Errorf("Case %d (%s): expected: No Error, but got error %s", i, testcase.Name, err.Error())
-		}
-
-		for _, plugin := range testcase.Plugins {
-
-			if plugin == "svc" {
-				_, err = fakeController.kubeClients.CoreV1().Services(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
-				if err == nil {
-					t.Errorf("Case %d (%s): expected: Service to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+
+			for _, plugin := range testcase.Plugins {
+
+				if plugin == "svc" {
+					_, err = fakeController.kubeClients.CoreV1().Services(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
+					if err == nil {
+						t.Errorf("Case %d (%s): expected: Service to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+					}
 				}
-			}
 
-			if plugin == "ssh" {
-				_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-ssh"), metav1.GetOptions{})
-				if err == nil {
-					t.Errorf("Case %d (%s): expected: ConfigMap to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+				if plugin == "ssh" {
+					_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-ssh"), metav1.GetOptions{})
+					if err == nil {
+						t.Errorf("Case %d (%s): expected: ConfigMap to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+					}
 				}
 			}
-		}
+
+		})
 	}
 }
 
@@ -203,70 +206,73 @@ func TestCreateJobFunc(t *testing.T) {
 
 	for i, testcase := range testcases {
 
-		fakeController := newFakeController()
-		jobPlugins := make(map[string][]string)
-
-		for _, plugin := range testcase.Plugins {
-			jobPlugins[plugin] = make([]string, 0)
-		}
-		testcase.JobInfo.Job = testcase.Job
-		testcase.JobInfo.Job.Spec.Plugins = jobPlugins
-
-		_, err := fakeController.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.Job)
-		if err != nil {
-			t.Errorf("Case %d (%s): expected: No Error, but got error %s", i, testcase.Name, err.Error())
-		}
-
-		err = fakeController.cache.Add(testcase.Job)
-		if err != nil {
-			t.Error("Error While Adding Job in cache")
-		}
-
-		err = fakeController.createJob(testcase.JobInfo, testcase.UpdateStatus)
-		if err != nil {
-			t.Errorf("Case %d (%s): expected: No Error, but got error %s", i, testcase.Name, err.Error())
-		}
-
-		job, err := fakeController.vkClients.BatchV1alpha1().Jobs(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
-		if err != nil {
-			t.Errorf("Case %d (%s): expected: No Error, but got error %s", i, testcase.Name, err.Error())
-		}
-		for _, plugin := range testcase.Plugins {
-
-			if plugin == "svc" {
-				_, err = fakeController.kubeClients.CoreV1().Services(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
-				if err != nil {
-					t.Errorf("Case %d (%s): expected: Service to be created, but not created because of error %s", i, testcase.Name, err.Error())
-				}
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
+			jobPlugins := make(map[string][]string)
 
-				_, err = fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-svc"), metav1.GetOptions{})
-				if err != nil {
-					t.Errorf("Case %d (%s): expected: Service to be created, but not created because of error %s", i, testcase.Name, err.Error())
-				}
+			for _, plugin := range testcase.Plugins {
+				jobPlugins[plugin] = make([]string, 0)
+			}
+			testcase.JobInfo.Job = testcase.Job
+			testcase.JobInfo.Job.Spec.Plugins = jobPlugins
 
-				exist := job.Status.ControlledResources["plugin-svc"]
-				if exist == "" {
-					t.Errorf("Case %d (%s): expected: ControlledResources should be added, but not got added", i, testcase.Name)
-				}
+			_, err := fakeController.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.Job)
+			if err != nil {
+				t.Errorf("Case %d (%s): expected: No Error, but got error %s", i, testcase.Name, err.Error())
 			}
 
-			if plugin == "ssh" {
-				_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-ssh"), metav1.GetOptions{})
-				if err != nil {
-					t.Errorf("Case %d (%s): expected: ConfigMap to be created, but not created because of error %s", i, testcase.Name, err.Error())
+			err = fakeController.cache.Add(testcase.Job)
+			if err != nil {
+				t.Error("Error While Adding Job in cache")
+			}
+
+			err = fakeController.createJob(testcase.JobInfo, testcase.UpdateStatus)
+			if err != nil {
+				t.Errorf("Case %d (%s): expected: No Error, but got error %s", i, testcase.Name, err.Error())
+			}
+
+			job, err := fakeController.vkClients.BatchV1alpha1().Jobs(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
+			if err != nil {
+				t.Errorf("Case %d (%s): expected: No Error, but got error %s", i, testcase.Name, err.Error())
+			}
+			for _, plugin := range testcase.Plugins {
+
+				if plugin == "svc" {
+					_, err = fakeController.kubeClients.CoreV1().Services(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
+					if err != nil {
+						t.Errorf("Case %d (%s): expected: Service to be created, but not created because of error %s", i, testcase.Name, err.Error())
+					}
+
+					_, err = fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-svc"), metav1.GetOptions{})
+					if err != nil {
+						t.Errorf("Case %d (%s): expected: Service to be created, but not created because of error %s", i, testcase.Name, err.Error())
+					}
+
+					exist := job.Status.ControlledResources["plugin-svc"]
+					if exist == "" {
+						t.Errorf("Case %d (%s): expected: ControlledResources should be added, but not got added", i, testcase.Name)
+					}
 				}
-				exist := job.Status.ControlledResources["plugin-ssh"]
-				if exist == "" {
-					t.Errorf("Case %d (%s): expected: ControlledResources should be added, but not got added", i, testcase.Name)
+
+				if plugin == "ssh" {
+					_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-ssh"), metav1.GetOptions{})
+					if err != nil {
+						t.Errorf("Case %d (%s): expected: ConfigMap to be created, but not created because of error %s", i, testcase.Name, err.Error())
+					}
+					exist := job.Status.ControlledResources["plugin-ssh"]
+					if exist == "" {
+						t.Errorf("Case %d (%s): expected: ControlledResources should be added, but not got added", i, testcase.Name)
+					}
 				}
-			}
-			if plugin == "env" {
-				exist := job.Status.ControlledResources["plugin-env"]
-				if exist == "" {
-					t.Errorf("Case %d (%s): expected: ControlledResources should be added, but not got added", i, testcase.Name)
+				if plugin == "env" {
+					exist := job.Status.ControlledResources["plugin-env"]
+					if exist == "" {
+						t.Errorf("Case %d (%s): expected: ControlledResources should be added, but not got added", i, testcase.Name)
+					}
 				}
 			}
-		}
+		})
+
 	}
 }
 
@@ -343,44 +349,46 @@ func TestSyncJobFunc(t *testing.T) {
 	}
 	for i, testcase := range testcases {
 
-		fakeController := newFakeController()
-		jobPlugins := make(map[string][]string)
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
+			jobPlugins := make(map[string][]string)
 
-		for _, plugin := range testcase.Plugins {
-			jobPlugins[plugin] = make([]string, 0)
-		}
-		testcase.JobInfo.Job = testcase.Job
-		testcase.JobInfo.Job.Spec.Plugins = jobPlugins
+			for _, plugin := range testcase.Plugins {
+				jobPlugins[plugin] = make([]string, 0)
+			}
+			testcase.JobInfo.Job = testcase.Job
+			testcase.JobInfo.Job.Spec.Plugins = jobPlugins
+
+			for _, pod := range testcase.Pods {
+				_, err := fakeController.kubeClients.CoreV1().Pods(namespace).Create(pod)
+				if err != nil {
+					t.Error("Error While Creating pods")
+				}
+			}
+
+			_, err := fakeController.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.Job)
+			if err != nil {
+				t.Errorf("Expected no Error while creating job, but got error: %s", err)
+			}
+
+			err = fakeController.cache.Add(testcase.Job)
+			if err != nil {
+				t.Error("Error While Adding Job in cache")
+			}
+
+			err = fakeController.syncJob(testcase.JobInfo, nil)
+			if err != testcase.ExpextVal {
+				t.Errorf("Expected no error while syncing job, but got error: %s", err)
+			}
 
-		for _, pod := range testcase.Pods {
-			_, err := fakeController.kubeClients.CoreV1().Pods(namespace).Create(pod)
+			podList, err := fakeController.kubeClients.CoreV1().Pods(namespace).List(metav1.ListOptions{})
 			if err != nil {
-				t.Error("Error While Creating pods")
+				t.Errorf("Expected no error while listing pods, but got error %s in case %d", err, i)
 			}
-		}
-
-		_, err := fakeController.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.Job)
-		if err != nil {
-			t.Errorf("Expected no Error while creating job, but got error: %s", err)
-		}
-
-		err = fakeController.cache.Add(testcase.Job)
-		if err != nil {
-			t.Error("Error While Adding Job in cache")
-		}
-
-		err = fakeController.syncJob(testcase.JobInfo, nil)
-		if err != testcase.ExpextVal {
-			t.Errorf("Expected no error while syncing job, but got error: %s", err)
-		}
-
-		podList, err := fakeController.kubeClients.CoreV1().Pods(namespace).List(metav1.ListOptions{})
-		if err != nil {
-			t.Errorf("Expected no error while listing pods, but got error %s in case %d", err, i)
-		}
-		if testcase.TotalNumPods != len(podList.Items) {
-			t.Errorf("Expected Total number of pods to be same as podlist count: Expected: %d, Got: %d in case: %d", testcase.TotalNumPods, len(podList.Items), i)
-		}
+			if testcase.TotalNumPods != len(podList.Items) {
+				t.Errorf("Expected Total number of pods to be same as podlist count: Expected: %d, Got: %d in case: %d", testcase.TotalNumPods, len(podList.Items), i)
+			}
+		})
 	}
 }
 
@@ -412,16 +420,19 @@ func TestCreateJobIOIfNotExistFunc(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		fakeController := newFakeController()
 
-		job, err := fakeController.createJobIOIfNotExist(testcase.Job)
-		if err != testcase.ExpextVal {
-			t.Errorf("Expected Return value to be : %s, but got: %s in testcase %d", testcase.ExpextVal, err, i)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
+
+			job, err := fakeController.createJobIOIfNotExist(testcase.Job)
+			if err != testcase.ExpextVal {
+				t.Errorf("Expected Return value to be : %s, but got: %s in testcase %d", testcase.ExpextVal, err, i)
+			}
 
-		if len(job.Spec.Volumes) == 0 {
-			t.Errorf("Expected number of volumes to be greater than 0 but got: %d in case: %d", len(job.Spec.Volumes), i)
-		}
+			if len(job.Spec.Volumes) == 0 {
+				t.Errorf("Expected number of volumes to be greater than 0 but got: %d in case: %d", len(job.Spec.Volumes), i)
+			}
+		})
 	}
 }
 
@@ -450,16 +461,18 @@ func TestCreatePVCFunc(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		fakeController := newFakeController()
-
-		err := fakeController.createPVC(testcase.Job, "pvc1", testcase.VolumeClaim)
-		if err != testcase.ExpextVal {
-			t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
-		}
-		_, err = fakeController.kubeClients.CoreV1().PersistentVolumeClaims(namespace).Get("pvc1", metav1.GetOptions{})
-		if err != nil {
-			t.Error("Expected PVC to get created, but not created")
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
+
+			err := fakeController.createPVC(testcase.Job, "pvc1", testcase.VolumeClaim)
+			if err != testcase.ExpextVal {
+				t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
+			}
+			_, err = fakeController.kubeClients.CoreV1().PersistentVolumeClaims(namespace).Get("pvc1", metav1.GetOptions{})
+			if err != nil {
+				t.Error("Expected PVC to get created, but not created")
+			}
+		})
 	}
 }
 
@@ -484,17 +497,20 @@ func TestCreatePodGroupIfNotExistFunc(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		fakeController := newFakeController()
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
 
-		err := fakeController.createPodGroupIfNotExist(testcase.Job)
-		if err != testcase.ExpextVal {
-			t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
-		}
+			err := fakeController.createPodGroupIfNotExist(testcase.Job)
+			if err != testcase.ExpextVal {
+				t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
+			}
+
+			_, err = fakeController.kbClients.SchedulingV1alpha2().PodGroups(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
+			if err != nil {
+				t.Error("Expected PodGroup to get created, but not created")
+			}
+		})
 
-		_, err = fakeController.kbClients.SchedulingV1alpha2().PodGroups(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
-		if err != nil {
-			t.Error("Expected PodGroup to get created, but not created")
-		}
 	}
 }
 
@@ -526,23 +542,25 @@ func TestDeleteJobPod(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		fakeController := newFakeController()
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
 
-		for _, pod := range testcase.Pods {
-			_, err := fakeController.kubeClients.CoreV1().Pods(namespace).Create(pod)
-			if err != nil {
-				t.Error("Expected error not to occur")
+			for _, pod := range testcase.Pods {
+				_, err := fakeController.kubeClients.CoreV1().Pods(namespace).Create(pod)
+				if err != nil {
+					t.Error("Expected error not to occur")
+				}
 			}
-		}
 
-		err := fakeController.deleteJobPod(testcase.Job.Name, testcase.DeletePod)
-		if err != testcase.ExpextVal {
-			t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
-		}
+			err := fakeController.deleteJobPod(testcase.Job.Name, testcase.DeletePod)
+			if err != testcase.ExpextVal {
+				t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
+			}
 
-		_, err = fakeController.kubeClients.CoreV1().Pods(namespace).Get("job1-task1-0", metav1.GetOptions{})
-		if err == nil {
-			t.Error("Expected Pod to be deleted but not deleted")
-		}
+			_, err = fakeController.kubeClients.CoreV1().Pods(namespace).Get("job1-task1-0", metav1.GetOptions{})
+			if err == nil {
+				t.Error("Expected Pod to be deleted but not deleted")
+			}
+		})
 	}
 }
diff --git a/pkg/controllers/job/job_controller_handler_test.go b/pkg/controllers/job/job_controller_handler_test.go
index 0bd12acae2..1df6e2a599 100644
--- a/pkg/controllers/job/job_controller_handler_test.go
+++ b/pkg/controllers/job/job_controller_handler_test.go
@@ -135,12 +135,14 @@ func TestAddCommandFunc(t *testing.T) {
 	}
 
 	for i, testcase := range testCases {
-		controller := newController()
-		controller.addCommand(testcase.command)
-		len := controller.commandQueue.Len()
-		if testcase.ExpectValue != len {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectValue, len)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			controller := newController()
+			controller.addCommand(testcase.command)
+			len := controller.commandQueue.Len()
+			if testcase.ExpectValue != len {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectValue, len)
+			}
+		})
 	}
 }
 
@@ -164,18 +166,20 @@ func TestJobAddFunc(t *testing.T) {
 		},
 	}
 	for i, testcase := range testCases {
-		controller := newController()
-		controller.addJob(testcase.job)
-		key := fmt.Sprintf("%s/%s", testcase.job.Namespace, testcase.job.Name)
-		job, err := controller.cache.Get(key)
-		if job == nil || err != nil {
-			t.Errorf("Error while Adding Job in case %d with error %s", i, err)
-		}
-		queue := controller.getWorkerQueue(key)
-		len := queue.Len()
-		if testcase.ExpectValue != len {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectValue, len)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			controller := newController()
+			controller.addJob(testcase.job)
+			key := fmt.Sprintf("%s/%s", testcase.job.Namespace, testcase.job.Name)
+			job, err := controller.cache.Get(key)
+			if job == nil || err != nil {
+				t.Errorf("Error while Adding Job in case %d with error %s", i, err)
+			}
+			queue := controller.getWorkerQueue(key)
+			len := queue.Len()
+			if testcase.ExpectValue != len {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectValue, len)
+			}
+		})
 	}
 }
 
@@ -256,19 +260,21 @@ func TestUpdateJobFunc(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		controller := newController()
-		controller.addJob(testcase.oldJob)
-		controller.updateJob(testcase.oldJob, testcase.newJob)
-		key := fmt.Sprintf("%s/%s", testcase.newJob.Namespace, testcase.newJob.Name)
-		job, err := controller.cache.Get(key)
-
-		if job == nil || err != nil {
-			t.Errorf("Error while Updating Job in case %d with error %s", i, err)
-		}
-
-		if job.Job.Status.State.Phase != testcase.newJob.Status.State.Phase {
-			t.Errorf("Error while Updating Job in case %d with error %s", i, err)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			controller := newController()
+			controller.addJob(testcase.oldJob)
+			controller.updateJob(testcase.oldJob, testcase.newJob)
+			key := fmt.Sprintf("%s/%s", testcase.newJob.Namespace, testcase.newJob.Name)
+			job, err := controller.cache.Get(key)
+
+			if job == nil || err != nil {
+				t.Errorf("Error while Updating Job in case %d with error %s", i, err)
+			}
+
+			if job.Job.Status.State.Phase != testcase.newJob.Status.State.Phase {
+				t.Errorf("Error while Updating Job in case %d with error %s", i, err)
+			}
+		})
 	}
 }
 
@@ -322,27 +328,30 @@ func TestAddPodFunc(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		controller := newController()
-		controller.addJob(testcase.Job)
-		for _, pod := range testcase.pods {
-			addPodAnnotation(pod, testcase.Annotation)
-			controller.addPod(pod)
-		}
 
-		key := fmt.Sprintf("%s/%s", testcase.Job.Namespace, testcase.Job.Name)
-		job, err := controller.cache.Get(key)
-
-		if job == nil || err != nil {
-			t.Errorf("Error while Getting Job in case %d with error %s", i, err)
-		}
-
-		var totalPods int
-		for _, task := range job.Pods {
-			totalPods = len(task)
-		}
-		if totalPods != testcase.ExpectedValue {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectedValue, totalPods)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			controller := newController()
+			controller.addJob(testcase.Job)
+			for _, pod := range testcase.pods {
+				addPodAnnotation(pod, testcase.Annotation)
+				controller.addPod(pod)
+			}
+
+			key := fmt.Sprintf("%s/%s", testcase.Job.Namespace, testcase.Job.Name)
+			job, err := controller.cache.Get(key)
+
+			if job == nil || err != nil {
+				t.Errorf("Error while Getting Job in case %d with error %s", i, err)
+			}
+
+			var totalPods int
+			for _, task := range job.Pods {
+				totalPods = len(task)
+			}
+			if totalPods != testcase.ExpectedValue {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectedValue, totalPods)
+			}
+		})
 	}
 }
 
@@ -394,25 +403,27 @@ func TestUpdatePodFunc(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		controller := newController()
-		controller.addJob(testcase.Job)
-		addPodAnnotation(testcase.oldPod, testcase.Annotation)
-		addPodAnnotation(testcase.newPod, testcase.Annotation)
-		controller.addPod(testcase.oldPod)
-		controller.updatePod(testcase.oldPod, testcase.newPod)
-
-		key := fmt.Sprintf("%s/%s", testcase.Job.Namespace, testcase.Job.Name)
-		job, err := controller.cache.Get(key)
-
-		if job == nil || err != nil {
-			t.Errorf("Error while Getting Job in case %d with error %s", i, err)
-		}
-
-		pod := job.Pods[testcase.Annotation[vkbatchv1.TaskSpecKey]][testcase.oldPod.Name]
-
-		if pod.Status.Phase != testcase.ExpectedValue {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectedValue, pod.Status.Phase)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			controller := newController()
+			controller.addJob(testcase.Job)
+			addPodAnnotation(testcase.oldPod, testcase.Annotation)
+			addPodAnnotation(testcase.newPod, testcase.Annotation)
+			controller.addPod(testcase.oldPod)
+			controller.updatePod(testcase.oldPod, testcase.newPod)
+
+			key := fmt.Sprintf("%s/%s", testcase.Job.Namespace, testcase.Job.Name)
+			job, err := controller.cache.Get(key)
+
+			if job == nil || err != nil {
+				t.Errorf("Error while Getting Job in case %d with error %s", i, err)
+			}
+
+			pod := job.Pods[testcase.Annotation[vkbatchv1.TaskSpecKey]][testcase.oldPod.Name]
+
+			if pod.Status.Phase != testcase.ExpectedValue {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectedValue, pod.Status.Phase)
+			}
+		})
 	}
 }
 
@@ -470,30 +481,32 @@ func TestDeletePodFunc(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		controller := newController()
-		controller.addJob(testcase.Job)
-		for _, pod := range testcase.availablePods {
-			addPodAnnotation(pod, testcase.Annotation)
-			controller.addPod(pod)
-		}
-
-		addPodAnnotation(testcase.deletePod, testcase.Annotation)
-		controller.deletePod(testcase.deletePod)
-		key := fmt.Sprintf("%s/%s", testcase.Job.Namespace, testcase.Job.Name)
-		job, err := controller.cache.Get(key)
-
-		if job == nil || err != nil {
-			t.Errorf("Error while Getting Job in case %d with error %s", i, err)
-		}
-
-		var totalPods int
-		for _, task := range job.Pods {
-			totalPods = len(task)
-		}
-
-		if totalPods != testcase.ExpectedValue {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectedValue, totalPods)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			controller := newController()
+			controller.addJob(testcase.Job)
+			for _, pod := range testcase.availablePods {
+				addPodAnnotation(pod, testcase.Annotation)
+				controller.addPod(pod)
+			}
+
+			addPodAnnotation(testcase.deletePod, testcase.Annotation)
+			controller.deletePod(testcase.deletePod)
+			key := fmt.Sprintf("%s/%s", testcase.Job.Namespace, testcase.Job.Name)
+			job, err := controller.cache.Get(key)
+
+			if job == nil || err != nil {
+				t.Errorf("Error while Getting Job in case %d with error %s", i, err)
+			}
+
+			var totalPods int
+			for _, task := range job.Pods {
+				totalPods = len(task)
+			}
+
+			if totalPods != testcase.ExpectedValue {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectedValue, totalPods)
+			}
+		})
 	}
 }
 
@@ -538,13 +551,16 @@ func TestUpdatePodGroupFunc(t *testing.T) {
 	}
 
 	for i, testcase := range testCases {
-		controller := newController()
-		controller.updatePodGroup(testcase.oldPodGroup, testcase.newPodGroup)
-		key := fmt.Sprintf("%s/%s", testcase.oldPodGroup.Namespace, testcase.oldPodGroup.Name)
-		queue := controller.getWorkerQueue(key)
-		len := queue.Len()
-		if testcase.ExpectValue != len {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectValue, len)
-		}
+
+		t.Run(testcase.Name, func(t *testing.T) {
+			controller := newController()
+			controller.updatePodGroup(testcase.oldPodGroup, testcase.newPodGroup)
+			key := fmt.Sprintf("%s/%s", testcase.oldPodGroup.Namespace, testcase.oldPodGroup.Name)
+			queue := controller.getWorkerQueue(key)
+			len := queue.Len()
+			if testcase.ExpectValue != len {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.ExpectValue, len)
+			}
+		})
 	}
 }
diff --git a/pkg/controllers/job/job_controller_plugins_test.go b/pkg/controllers/job/job_controller_plugins_test.go
index 0d67a14397..460814f461 100644
--- a/pkg/controllers/job/job_controller_plugins_test.go
+++ b/pkg/controllers/job/job_controller_plugins_test.go
@@ -76,63 +76,65 @@ func TestPluginOnPodCreate(t *testing.T) {
 
 	for i, testcase := range testcases {
 
-		fakeController := newFakeController()
-		jobPlugins := make(map[string][]string)
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
+			jobPlugins := make(map[string][]string)
 
-		for _, plugin := range testcase.Plugins {
-			jobPlugins[plugin] = make([]string, 0)
-		}
+			for _, plugin := range testcase.Plugins {
+				jobPlugins[plugin] = make([]string, 0)
+			}
 
-		testcase.Job.Spec.Plugins = jobPlugins
+			testcase.Job.Spec.Plugins = jobPlugins
 
-		err := fakeController.pluginOnPodCreate(testcase.Job, testcase.Pod)
-		if testcase.RetVal != nil && err.Error() != testcase.RetVal.Error() {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.RetVal, err)
-		}
+			err := fakeController.pluginOnPodCreate(testcase.Job, testcase.Pod)
+			if testcase.RetVal != nil && err.Error() != testcase.RetVal.Error() {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.RetVal, err)
+			}
 
-		for _, plugin := range testcase.Plugins {
-			if plugin == "env" {
-				for _, container := range testcase.Pod.Spec.Containers {
-					if len(container.Env) == 0 {
-						t.Errorf("case %d (%s): expected: Env Length not to be zero", i, testcase.Name)
+			for _, plugin := range testcase.Plugins {
+				if plugin == "env" {
+					for _, container := range testcase.Pod.Spec.Containers {
+						if len(container.Env) == 0 {
+							t.Errorf("case %d (%s): expected: Env Length not to be zero", i, testcase.Name)
+						}
 					}
 				}
-			}
 
-			if plugin == "svc" {
-				for _, container := range testcase.Pod.Spec.Containers {
-					if len(container.VolumeMounts) == 0 {
-						t.Errorf("case %d (%s): expected: VolumeMount Length not to be zero", i, testcase.Name)
-					}
-					exist := false
-					for _, volume := range container.VolumeMounts {
-						if volume.Name == fmt.Sprint(testcase.Job.Name, "-svc") {
-							exist = true
+				if plugin == "svc" {
+					for _, container := range testcase.Pod.Spec.Containers {
+						if len(container.VolumeMounts) == 0 {
+							t.Errorf("case %d (%s): expected: VolumeMount Length not to be zero", i, testcase.Name)
+						}
+						exist := false
+						for _, volume := range container.VolumeMounts {
+							if volume.Name == fmt.Sprint(testcase.Job.Name, "-svc") {
+								exist = true
+							}
+						}
+						if !exist {
+							t.Errorf("case %d (%s): expected: VolumeMount not created", i, testcase.Name)
 						}
-					}
-					if !exist {
-						t.Errorf("case %d (%s): expected: VolumeMount not created", i, testcase.Name)
 					}
 				}
-			}
 
-			if plugin == "ssh" {
-				for _, container := range testcase.Pod.Spec.Containers {
-					if len(container.VolumeMounts) == 0 {
-						t.Errorf("case %d (%s): expected: VolumeMount Length not to be zero", i, testcase.Name)
-					}
-					exist := false
-					for _, volume := range container.VolumeMounts {
-						if volume.Name == fmt.Sprint(testcase.Job.Name, "-ssh") {
-							exist = true
+				if plugin == "ssh" {
+					for _, container := range testcase.Pod.Spec.Containers {
+						if len(container.VolumeMounts) == 0 {
+							t.Errorf("case %d (%s): expected: VolumeMount Length not to be zero", i, testcase.Name)
+						}
+						exist := false
+						for _, volume := range container.VolumeMounts {
+							if volume.Name == fmt.Sprint(testcase.Job.Name, "-ssh") {
+								exist = true
+							}
+						}
+						if !exist {
+							t.Errorf("case %d (%s): expected: VolumeMount not created", i, testcase.Name)
 						}
-					}
-					if !exist {
-						t.Errorf("case %d (%s): expected: VolumeMount not created", i, testcase.Name)
 					}
 				}
 			}
-		}
+		})
 	}
 }
 
@@ -170,47 +172,49 @@ func TestPluginOnJobAdd(t *testing.T) {
 
 	for i, testcase := range testcases {
 
-		fakeController := newFakeController()
-		jobPlugins := make(map[string][]string)
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
+			jobPlugins := make(map[string][]string)
 
-		for _, plugin := range testcase.Plugins {
-			jobPlugins[plugin] = make([]string, 0)
-		}
+			for _, plugin := range testcase.Plugins {
+				jobPlugins[plugin] = make([]string, 0)
+			}
 
-		testcase.Job.Spec.Plugins = jobPlugins
+			testcase.Job.Spec.Plugins = jobPlugins
 
-		err := fakeController.pluginOnJobAdd(testcase.Job)
-		if testcase.RetVal != nil && err.Error() != testcase.RetVal.Error() {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.RetVal, err)
-		}
+			err := fakeController.pluginOnJobAdd(testcase.Job)
+			if testcase.RetVal != nil && err.Error() != testcase.RetVal.Error() {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.RetVal, err)
+			}
 
-		for _, plugin := range testcase.Plugins {
+			for _, plugin := range testcase.Plugins {
 
-			if plugin == "svc" {
-				_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-svc"), metav1.GetOptions{})
-				if err != nil {
-					t.Errorf("Case %d (%s): expected: ConfigMap to be created, but not created because of error %s", i, testcase.Name, err.Error())
-				}
+				if plugin == "svc" {
+					_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-svc"), metav1.GetOptions{})
+					if err != nil {
+						t.Errorf("Case %d (%s): expected: ConfigMap to be created, but not created because of error %s", i, testcase.Name, err.Error())
+					}
 
-				_, err = fakeController.kubeClients.CoreV1().Services(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
-				if err != nil {
-					t.Errorf("Case %d (%s): expected: Service to be created, but not created because of error %s", i, testcase.Name, err.Error())
+					_, err = fakeController.kubeClients.CoreV1().Services(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
+					if err != nil {
+						t.Errorf("Case %d (%s): expected: Service to be created, but not created because of error %s", i, testcase.Name, err.Error())
+					}
 				}
-			}
 
-			if plugin == "ssh" {
-				_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-ssh"), metav1.GetOptions{})
-				if err != nil {
-					t.Errorf("Case %d (%s): expected: ConfigMap to be created, but not created because of error %s", i, testcase.Name, err.Error())
+				if plugin == "ssh" {
+					_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-ssh"), metav1.GetOptions{})
+					if err != nil {
+						t.Errorf("Case %d (%s): expected: ConfigMap to be created, but not created because of error %s", i, testcase.Name, err.Error())
+					}
 				}
-			}
 
-			if plugin == "env" {
-				if testcase.Job.Status.ControlledResources["plugin-env"] == "" {
-					t.Errorf("Case %d (%s): expected: to find controlled resource, but not found because of error %s", i, testcase.Name, err.Error())
+				if plugin == "env" {
+					if testcase.Job.Status.ControlledResources["plugin-env"] == "" {
+						t.Errorf("Case %d (%s): expected: to find controlled resource, but not found because of error %s", i, testcase.Name, err.Error())
+					}
 				}
 			}
-		}
+		})
 	}
 }
 
@@ -248,40 +252,43 @@ func TestPluginOnJobDelete(t *testing.T) {
 
 	for i, testcase := range testcases {
 
-		fakeController := newFakeController()
-		jobPlugins := make(map[string][]string)
+		t.Run(testcase.Name, func(t *testing.T) {
+			fakeController := newFakeController()
+			jobPlugins := make(map[string][]string)
 
-		for _, plugin := range testcase.Plugins {
-			jobPlugins[plugin] = make([]string, 0)
-		}
+			for _, plugin := range testcase.Plugins {
+				jobPlugins[plugin] = make([]string, 0)
+			}
 
-		testcase.Job.Spec.Plugins = jobPlugins
+			testcase.Job.Spec.Plugins = jobPlugins
 
-		err := fakeController.pluginOnJobDelete(testcase.Job)
-		if testcase.RetVal != nil && err.Error() != testcase.RetVal.Error() {
-			t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.RetVal, err)
-		}
+			err := fakeController.pluginOnJobDelete(testcase.Job)
+			if testcase.RetVal != nil && err.Error() != testcase.RetVal.Error() {
+				t.Errorf("case %d (%s): expected: %v, got %v ", i, testcase.Name, testcase.RetVal, err)
+			}
 
-		for _, plugin := range testcase.Plugins {
+			for _, plugin := range testcase.Plugins {
 
-			if plugin == "svc" {
-				_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-svc"), metav1.GetOptions{})
-				if err == nil {
-					t.Errorf("Case %d (%s): expected: ConfigMap to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
-				}
+				if plugin == "svc" {
+					_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-svc"), metav1.GetOptions{})
+					if err == nil {
+						t.Errorf("Case %d (%s): expected: ConfigMap to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+					}
 
-				_, err = fakeController.kubeClients.CoreV1().Services(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
-				if err == nil {
-					t.Errorf("Case %d (%s): expected: Service to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+					_, err = fakeController.kubeClients.CoreV1().Services(namespace).Get(testcase.Job.Name, metav1.GetOptions{})
+					if err == nil {
+						t.Errorf("Case %d (%s): expected: Service to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+					}
 				}
-			}
 
-			if plugin == "ssh" {
-				_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-ssh"), metav1.GetOptions{})
-				if err == nil {
-					t.Errorf("Case %d (%s): expected: ConfigMap to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+				if plugin == "ssh" {
+					_, err := fakeController.kubeClients.CoreV1().ConfigMaps(namespace).Get(fmt.Sprint(testcase.Job.Name, "-ssh"), metav1.GetOptions{})
+					if err == nil {
+						t.Errorf("Case %d (%s): expected: ConfigMap to be deleted, but not deleted because of error %s", i, testcase.Name, err.Error())
+					}
 				}
 			}
-		}
+		})
+
 	}
 }
diff --git a/pkg/controllers/job/job_controller_util_test.go b/pkg/controllers/job/job_controller_util_test.go
index afd5337606..624e081fff 100644
--- a/pkg/controllers/job/job_controller_util_test.go
+++ b/pkg/controllers/job/job_controller_util_test.go
@@ -45,11 +45,15 @@ func TestMakePodName(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		podName := MakePodName(testcase.JobName, testcase.TaskName, testcase.Index)
 
-		if podName != testcase.ReturnVal {
-			t.Errorf("Expected Return value to be: %s, but got: %s in case %d", testcase.ReturnVal, podName, i)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			podName := MakePodName(testcase.JobName, testcase.TaskName, testcase.Index)
+
+			if podName != testcase.ReturnVal {
+				t.Errorf("Expected Return value to be: %s, but got: %s in case %d", testcase.ReturnVal, podName, i)
+			}
+		})
+
 	}
 }
 
@@ -238,11 +242,14 @@ func TestCreateJobPod(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		pod := createJobPod(testcase.Job, testcase.PodTemplate, testcase.Index)
 
-		if testcase.ReturnVal != nil && pod != nil && pod.Name != testcase.ReturnVal.Name && pod.Namespace != testcase.ReturnVal.Namespace {
-			t.Errorf("Expected Return Value to be %v but got %v in case %d", testcase.ReturnVal, pod, i)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			pod := createJobPod(testcase.Job, testcase.PodTemplate, testcase.Index)
+
+			if testcase.ReturnVal != nil && pod != nil && pod.Name != testcase.ReturnVal.Name && pod.Namespace != testcase.ReturnVal.Namespace {
+				t.Errorf("Expected Return Value to be %v but got %v in case %d", testcase.ReturnVal, pod, i)
+			}
+		})
 	}
 }
 
@@ -607,11 +614,13 @@ func TestApplyPolicies(t *testing.T) {
 
 	for i, testcase := range testcases {
 
-		action := applyPolicies(testcase.Job, testcase.Request)
+		t.Run(testcase.Name, func(t *testing.T) {
+			action := applyPolicies(testcase.Job, testcase.Request)
 
-		if testcase.ReturnVal != "" && action != "" && testcase.ReturnVal != action {
-			t.Errorf("Expected return value to be %s but got %s in case %d", testcase.ReturnVal, action, i)
-		}
+			if testcase.ReturnVal != "" && action != "" && testcase.ReturnVal != action {
+				t.Errorf("Expected return value to be %s but got %s in case %d", testcase.ReturnVal, action, i)
+			}
+		})
 	}
 }
 
@@ -642,7 +651,9 @@ func TestAddResourceList(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		addResourceList(testcase.List, testcase.New, nil)
+		t.Run(testcase.Name, func(t *testing.T) {
+			addResourceList(testcase.List, testcase.New, nil)
+		})
 	}
 }
 
@@ -691,11 +702,14 @@ func TestTasksPriority_Less(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		less := testcase.TasksPriority.Less(testcase.Task1Index, testcase.Task2Index)
 
-		if less != testcase.ReturnVal {
-			t.Errorf("Expected Return Value to be %t, but got %t in case %d", testcase.ReturnVal, less, i)
-		}
+		t.Run(testcase.Name, func(t *testing.T) {
+			less := testcase.TasksPriority.Less(testcase.Task1Index, testcase.Task2Index)
+
+			if less != testcase.ReturnVal {
+				t.Errorf("Expected Return Value to be %t, but got %t in case %d", testcase.ReturnVal, less, i)
+			}
+		})
 	}
 }
 
@@ -742,6 +756,8 @@ func TestTasksPriority_Swap(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		testcase.TasksPriority.Swap(testcase.Task1Index, testcase.Task2Index)
+		t.Run(testcase.Name, func(t *testing.T) {
+			testcase.TasksPriority.Swap(testcase.Task1Index, testcase.Task2Index)
+		})
 	}
 }
diff --git a/pkg/controllers/job/job_state_test.go b/pkg/controllers/job/job_state_test.go
index bb47f2fb28..5a4eca6316 100644
--- a/pkg/controllers/job/job_state_test.go
+++ b/pkg/controllers/job/job_state_test.go
@@ -80,35 +80,37 @@ func TestAbortedState_Execute(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		absState := state.NewState(testcase.JobInfo)
-
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
-
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
-
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
-
-		err = absState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
-		if testcase.Action == v1alpha1.ResumeJobAction {
-			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+		t.Run(testcase.Name, func(t *testing.T) {
+			absState := state.NewState(testcase.JobInfo)
+
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
+
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
 			if err != nil {
-				t.Error("Error while retrieving value from Cache")
+				t.Error("Error while creating Job")
 			}
 
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Restarting {
-				t.Error("Expected Phase to be equal to restarting phase")
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
 			}
-		}
+
+			err = absState.Execute(testcase.Action)
+			if err != nil {
+				t.Errorf("Expected Error not to occur but got: %s", err)
+			}
+			if testcase.Action == v1alpha1.ResumeJobAction {
+				jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+				if err != nil {
+					t.Error("Error while retrieving value from Cache")
+				}
+
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Restarting {
+					t.Error("Expected Phase to be equal to restarting phase")
+				}
+			}
+		})
 	}
 }
 
@@ -190,52 +192,54 @@ func TestAbortingState_Execute(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		absState := state.NewState(testcase.JobInfo)
-
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
-
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
-
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
-
-		err = absState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
-		if testcase.Action == v1alpha1.ResumeJobAction {
-			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+		t.Run(testcase.Name, func(t *testing.T) {
+			absState := state.NewState(testcase.JobInfo)
+
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
+
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
 			if err != nil {
-				t.Error("Error while retrieving value from Cache")
+				t.Error("Error while creating Job")
 			}
 
-			if jobInfo.Job.Status.RetryCount == 0 {
-				t.Error("Retry Count should not be zero")
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
 			}
-		}
 
-		if testcase.Action != v1alpha1.ResumeJobAction {
-			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+			err = absState.Execute(testcase.Action)
 			if err != nil {
-				t.Error("Error while retrieving value from Cache")
+				t.Errorf("Expected Error not to occur but got: %s", err)
 			}
+			if testcase.Action == v1alpha1.ResumeJobAction {
+				jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+				if err != nil {
+					t.Error("Error while retrieving value from Cache")
+				}
 
-			if testcase.JobInfo.Job.Status.Pending == 0 && testcase.JobInfo.Job.Status.Running == 0 && testcase.JobInfo.Job.Status.Terminating == 0 {
-				if jobInfo.Job.Status.State.Phase != v1alpha1.Aborted {
-					t.Error("Phase Should be aborted")
+				if jobInfo.Job.Status.RetryCount == 0 {
+					t.Error("Retry Count should not be zero")
 				}
-			} else {
-				if jobInfo.Job.Status.State.Phase != v1alpha1.Aborting {
-					t.Error("Phase Should be aborted")
+			}
+
+			if testcase.Action != v1alpha1.ResumeJobAction {
+				jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+				if err != nil {
+					t.Error("Error while retrieving value from Cache")
+				}
+
+				if testcase.JobInfo.Job.Status.Pending == 0 && testcase.JobInfo.Job.Status.Running == 0 && testcase.JobInfo.Job.Status.Terminating == 0 {
+					if jobInfo.Job.Status.State.Phase != v1alpha1.Aborted {
+						t.Error("Phase Should be aborted")
+					}
+				} else {
+					if jobInfo.Job.Status.State.Phase != v1alpha1.Aborting {
+						t.Error("Phase Should be aborted")
+					}
 				}
 			}
-		}
+		})
 	}
 }
 
@@ -299,41 +303,43 @@ func TestCompletingState_Execute(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		testState := state.NewState(testcase.JobInfo)
-
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
-
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
-
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
-
-		err = testState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
-
-		jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
-		if err != nil {
-			t.Error("Error while retrieving value from Cache")
-		}
-
-		if testcase.JobInfo.Job.Status.Running == 0 && testcase.JobInfo.Job.Status.Pending == 0 && testcase.JobInfo.Job.Status.Terminating == 0 {
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Completed {
-				fmt.Println(jobInfo.Job.Status.State.Phase)
-				t.Errorf("Expected Phase to be Completed State in test case: %d", i)
+		t.Run(testcase.Name, func(t *testing.T) {
+			testState := state.NewState(testcase.JobInfo)
+
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
+
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while creating Job")
+			}
+
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
 			}
-		} else {
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
-				t.Errorf("Expected Phase to be completing state in test case: %d", i)
+
+			err = testState.Execute(testcase.Action)
+			if err != nil {
+				t.Errorf("Expected Error not to occur but got: %s", err)
 			}
-		}
+
+			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+			if err != nil {
+				t.Error("Error while retrieving value from Cache")
+			}
+
+			if testcase.JobInfo.Job.Status.Running == 0 && testcase.JobInfo.Job.Status.Pending == 0 && testcase.JobInfo.Job.Status.Terminating == 0 {
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Completed {
+					fmt.Println(jobInfo.Job.Status.State.Phase)
+					t.Errorf("Expected Phase to be Completed State in test case: %d", i)
+				}
+			} else {
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
+					t.Errorf("Expected Phase to be completing state in test case: %d", i)
+				}
+			}
+		})
 	}
 }
 
@@ -369,25 +375,27 @@ func TestFinishedState_Execute(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		testState := state.NewState(testcase.JobInfo)
+		t.Run(testcase.Name, func(t *testing.T) {
+			testState := state.NewState(testcase.JobInfo)
 
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
 
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while creating Job")
+			}
 
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
+			}
 
-		err = testState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
+			err = testState.Execute(testcase.Action)
+			if err != nil {
+				t.Errorf("Expected Error not to occur but got: %s", err)
+			}
+		})
 	}
 }
 
@@ -632,62 +640,64 @@ func TestInqueueState_Execute(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		testState := state.NewState(testcase.JobInfo)
-
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
-
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
-
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
-
-		err = testState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
-
-		jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
-		if err != nil {
-			t.Error("Error while retrieving value from Cache")
-		}
-
-		if testcase.Action == v1alpha1.RestartJobAction {
-			// always jump to restarting firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Restarting {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+		t.Run(testcase.Name, func(t *testing.T) {
+			testState := state.NewState(testcase.JobInfo)
+
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
+
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while creating Job")
 			}
-		} else if testcase.Action == v1alpha1.AbortJobAction {
-			// always jump to aborting firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Aborting {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Aborting, jobInfo.Job.Status.State.Phase, i)
+
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
 			}
-		} else if testcase.Action == v1alpha1.TerminateJobAction {
-			// always jump to terminating firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Terminating {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Terminating, jobInfo.Job.Status.State.Phase, i)
+
+			err = testState.Execute(testcase.Action)
+			if err != nil {
+				t.Errorf("Expected Error not to occur but got: %s", err)
 			}
-		} else if testcase.Action == v1alpha1.CompleteJobAction {
-			// always jump to completing firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Completing, jobInfo.Job.Status.State.Phase, i)
+
+			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+			if err != nil {
+				t.Error("Error while retrieving value from Cache")
 			}
-		} else {
-			if jobInfo.Job.Spec.MinAvailable <= jobInfo.Job.Status.Running+jobInfo.Job.Status.Succeeded+jobInfo.Job.Status.Failed {
-				if jobInfo.Job.Status.State.Phase != v1alpha1.Running {
-					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Running, jobInfo.Job.Status.State.Phase, i)
+
+			if testcase.Action == v1alpha1.RestartJobAction {
+				// always jump to restarting firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Restarting {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.AbortJobAction {
+				// always jump to aborting firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Aborting {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Aborting, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.TerminateJobAction {
+				// always jump to terminating firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Terminating {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Terminating, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.CompleteJobAction {
+				// always jump to completing firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Completing, jobInfo.Job.Status.State.Phase, i)
 				}
 			} else {
-				if jobInfo.Job.Status.State.Phase != testcase.JobInfo.Job.Status.State.Phase {
-					t.Errorf("Expected Job phase to %s, but got %s in case %d", testcase.JobInfo.Job.Status.State.Phase, jobInfo.Job.Status.State.Phase, i)
+				if jobInfo.Job.Spec.MinAvailable <= jobInfo.Job.Status.Running+jobInfo.Job.Status.Succeeded+jobInfo.Job.Status.Failed {
+					if jobInfo.Job.Status.State.Phase != v1alpha1.Running {
+						t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Running, jobInfo.Job.Status.State.Phase, i)
+					}
+				} else {
+					if jobInfo.Job.Status.State.Phase != testcase.JobInfo.Job.Status.State.Phase {
+						t.Errorf("Expected Job phase to %s, but got %s in case %d", testcase.JobInfo.Job.Status.State.Phase, jobInfo.Job.Status.State.Phase, i)
+					}
 				}
 			}
-		}
+		})
 	}
 }
 
@@ -962,66 +972,68 @@ func TestPendingState_Execute(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		testState := state.NewState(testcase.JobInfo)
-
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
-
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
-
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
-
-		err = testState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
-
-		jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
-		if err != nil {
-			t.Error("Error while retrieving value from Cache")
-		}
-
-		if testcase.Action == v1alpha1.RestartJobAction {
-			// always jump to restarting firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Restarting {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+		t.Run(testcase.Name, func(t *testing.T) {
+			testState := state.NewState(testcase.JobInfo)
+
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
+
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while creating Job")
 			}
-		} else if testcase.Action == v1alpha1.AbortJobAction {
-			// always jump to aborting firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Aborting {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Aborting, jobInfo.Job.Status.State.Phase, i)
+
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
 			}
-		} else if testcase.Action == v1alpha1.TerminateJobAction {
-			// always jump to completing firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Terminating {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Terminating, jobInfo.Job.Status.State.Phase, i)
+
+			err = testState.Execute(testcase.Action)
+			if err != nil {
+				t.Errorf("Expected Error not to occur but got: %s", err)
 			}
-		} else if testcase.Action == v1alpha1.CompleteJobAction {
-			// always jump to completing firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Completing, jobInfo.Job.Status.State.Phase, i)
+
+			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+			if err != nil {
+				t.Error("Error while retrieving value from Cache")
 			}
-		} else if testcase.Action == v1alpha1.EnqueueAction {
-			if jobInfo.Job.Spec.MinAvailable <= jobInfo.Job.Status.Running+jobInfo.Job.Status.Succeeded+jobInfo.Job.Status.Failed {
-				if jobInfo.Job.Status.State.Phase != v1alpha1.Running {
-					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Running, jobInfo.Job.Status.State.Phase, i)
+
+			if testcase.Action == v1alpha1.RestartJobAction {
+				// always jump to restarting firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Restarting {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.AbortJobAction {
+				// always jump to aborting firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Aborting {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Aborting, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.TerminateJobAction {
+				// always jump to completing firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Terminating {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Terminating, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.CompleteJobAction {
+				// always jump to completing firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Completing, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.EnqueueAction {
+				if jobInfo.Job.Spec.MinAvailable <= jobInfo.Job.Status.Running+jobInfo.Job.Status.Succeeded+jobInfo.Job.Status.Failed {
+					if jobInfo.Job.Status.State.Phase != v1alpha1.Running {
+						t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Running, jobInfo.Job.Status.State.Phase, i)
+					}
+				} else {
+					if jobInfo.Job.Status.State.Phase != v1alpha1.Inqueue {
+						t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Inqueue, jobInfo.Job.Status.State.Phase, i)
+					}
 				}
 			} else {
-				if jobInfo.Job.Status.State.Phase != v1alpha1.Inqueue {
-					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Inqueue, jobInfo.Job.Status.State.Phase, i)
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Pending {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Pending, jobInfo.Job.Status.State.Phase, i)
 				}
 			}
-		} else {
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Pending {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Pending, jobInfo.Job.Status.State.Phase, i)
-			}
-		}
+		})
 	}
 }
 
@@ -1095,40 +1107,42 @@ func TestRestartingState_Execute(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		testState := state.NewState(testcase.JobInfo)
-
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
-
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
-
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
-
-		err = testState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
-
-		jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
-		if err != nil {
-			t.Error("Error while retrieving value from Cache")
-		}
-
-		if testcase.JobInfo.Job.Spec.MaxRetry <= testcase.JobInfo.Job.Status.RetryCount {
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Failed {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Failed, jobInfo.Job.Status.State.Phase, i)
+		t.Run(testcase.Name, func(t *testing.T) {
+			testState := state.NewState(testcase.JobInfo)
+
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
+
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while creating Job")
 			}
-		} else {
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Pending {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Pending, jobInfo.Job.Status.State.Phase, i)
+
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
+			}
+
+			err = testState.Execute(testcase.Action)
+			if err != nil {
+				t.Errorf("Expected Error not to occur but got: %s", err)
 			}
-		}
+
+			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+			if err != nil {
+				t.Error("Error while retrieving value from Cache")
+			}
+
+			if testcase.JobInfo.Job.Spec.MaxRetry <= testcase.JobInfo.Job.Status.RetryCount {
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Failed {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Failed, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else {
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Pending {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Pending, jobInfo.Job.Status.State.Phase, i)
+				}
+			}
+		})
 	}
 }
 
@@ -1423,63 +1437,65 @@ func TestRunningState_Execute(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		testState := state.NewState(testcase.JobInfo)
-
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
-
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
-
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
-
-		err = testState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
-
-		jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
-		if err != nil {
-			t.Error("Error while retrieving value from Cache")
-		}
-
-		if testcase.Action == v1alpha1.RestartJobAction {
-			// always jump to restarting firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Restarting {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+		t.Run(testcase.Name, func(t *testing.T) {
+			testState := state.NewState(testcase.JobInfo)
+
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
+
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while creating Job")
 			}
-		} else if testcase.Action == v1alpha1.AbortJobAction {
-			// always jump to aborting firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Aborting {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
 			}
-		} else if testcase.Action == v1alpha1.TerminateJobAction {
-			// always jump to terminating firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Terminating {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Terminating, jobInfo.Job.Status.State.Phase, i)
+
+			err = testState.Execute(testcase.Action)
+			if err != nil {
+				t.Errorf("Expected Error not to occur but got: %s", err)
 			}
-		} else if testcase.Action == v1alpha1.CompleteJobAction {
-			// always jump to completing firstly
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
-				t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+
+			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+			if err != nil {
+				t.Error("Error while retrieving value from Cache")
 			}
-		} else {
-			total := state.TotalTasks(testcase.JobInfo.Job)
-			if total == testcase.JobInfo.Job.Status.Succeeded+testcase.JobInfo.Job.Status.Failed {
-				if jobInfo.Job.Status.State.Phase != v1alpha1.Completed {
-					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Completed, jobInfo.Job.Status.State.Phase, i)
+
+			if testcase.Action == v1alpha1.RestartJobAction {
+				// always jump to restarting firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Restarting {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.AbortJobAction {
+				// always jump to aborting firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Aborting {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.TerminateJobAction {
+				// always jump to terminating firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Terminating {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Terminating, jobInfo.Job.Status.State.Phase, i)
+				}
+			} else if testcase.Action == v1alpha1.CompleteJobAction {
+				// always jump to completing firstly
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
+					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Restarting, jobInfo.Job.Status.State.Phase, i)
 				}
 			} else {
-				if jobInfo.Job.Status.State.Phase != v1alpha1.Running {
-					t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Running, jobInfo.Job.Status.State.Phase, i)
+				total := state.TotalTasks(testcase.JobInfo.Job)
+				if total == testcase.JobInfo.Job.Status.Succeeded+testcase.JobInfo.Job.Status.Failed {
+					if jobInfo.Job.Status.State.Phase != v1alpha1.Completed {
+						t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Completed, jobInfo.Job.Status.State.Phase, i)
+					}
+				} else {
+					if jobInfo.Job.Status.State.Phase != v1alpha1.Running {
+						t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Running, jobInfo.Job.Status.State.Phase, i)
+					}
 				}
 			}
-		}
+		})
 	}
 }
 
@@ -1542,41 +1558,43 @@ func TestTerminatingState_Execute(t *testing.T) {
 	}
 
 	for i, testcase := range testcases {
-		testState := state.NewState(testcase.JobInfo)
+		t.Run(testcase.Name, func(t *testing.T) {
+			testState := state.NewState(testcase.JobInfo)
 
-		fakecontroller := newFakeController()
-		state.KillJob = fakecontroller.killJob
+			fakecontroller := newFakeController()
+			state.KillJob = fakecontroller.killJob
 
-		_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while creating Job")
-		}
+			_, err := fakecontroller.vkClients.BatchV1alpha1().Jobs(namespace).Create(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while creating Job")
+			}
 
-		err = fakecontroller.cache.Add(testcase.JobInfo.Job)
-		if err != nil {
-			t.Error("Error while adding Job in cache")
-		}
+			err = fakecontroller.cache.Add(testcase.JobInfo.Job)
+			if err != nil {
+				t.Error("Error while adding Job in cache")
+			}
 
-		err = testState.Execute(testcase.Action)
-		if err != nil {
-			t.Errorf("Expected Error not to occur but got: %s", err)
-		}
+			err = testState.Execute(testcase.Action)
+			if err != nil {
+				t.Errorf("Expected Error not to occur but got: %s", err)
+			}
 
-		jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
-		if err != nil {
-			t.Error("Error while retrieving value from Cache")
-		}
+			jobInfo, err := fakecontroller.cache.Get(fmt.Sprintf("%s/%s", testcase.JobInfo.Job.Namespace, testcase.JobInfo.Job.Name))
+			if err != nil {
+				t.Error("Error while retrieving value from Cache")
+			}
 
-		if testcase.JobInfo.Job.Status.Running == 0 && testcase.JobInfo.Job.Status.Pending == 0 && testcase.JobInfo.Job.Status.Terminating == 0 {
+			if testcase.JobInfo.Job.Status.Running == 0 && testcase.JobInfo.Job.Status.Pending == 0 && testcase.JobInfo.Job.Status.Terminating == 0 {
 
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Terminated {
-				fmt.Println(jobInfo.Job.Status.State.Phase)
-				t.Errorf("Expected Phase to be Terminated State in test case: %d", i)
-			}
-		} else {
-			if jobInfo.Job.Status.State.Phase != v1alpha1.Terminating {
-				t.Errorf("Expected Phase to be Terminating state in test case: %d", i)
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Terminated {
+					fmt.Println(jobInfo.Job.Status.State.Phase)
+					t.Errorf("Expected Phase to be Terminated State in test case: %d", i)
+				}
+			} else {
+				if jobInfo.Job.Status.State.Phase != v1alpha1.Terminating {
+					t.Errorf("Expected Phase to be Terminating state in test case: %d", i)
+				}
 			}
-		}
+		})
 	}
 }