1296 lines
34 KiB
Go
1296 lines
34 KiB
Go
/*
|
|
Copyright 2019 The Volcano Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package job
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
v1 "k8s.io/api/core/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
|
|
"volcano.sh/volcano/pkg/apis/batch/v1alpha1"
|
|
busv1alpha1 "volcano.sh/volcano/pkg/apis/bus/v1alpha1"
|
|
"volcano.sh/volcano/pkg/controllers/apis"
|
|
"volcano.sh/volcano/pkg/controllers/job/state"
|
|
)
|
|
|
|
func TestAbortedState_Execute(t *testing.T) {
|
|
namespace := "test"
|
|
|
|
testcases := []struct {
|
|
Name string
|
|
JobInfo *apis.JobInfo
|
|
Action busv1alpha1.Action
|
|
ExpectedVal error
|
|
}{
|
|
{
|
|
Name: "AbortedState-ResumeAction case",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Aborted,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.ResumeJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "AbortedState-AnyOtherAction case",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Aborted,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
}
|
|
|
|
for _, testcase := range testcases {
|
|
t.Run(testcase.Name, func(t *testing.T) {
|
|
absState := state.NewState(testcase.JobInfo)
|
|
|
|
fakecontroller := newFakeController()
|
|
state.KillJob = fakecontroller.killJob
|
|
|
|
_, err := fakecontroller.vcClient.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 == busv1alpha1.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")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAbortingState_Execute(t *testing.T) {
|
|
namespace := "test"
|
|
|
|
testcases := []struct {
|
|
Name string
|
|
JobInfo *apis.JobInfo
|
|
Action busv1alpha1.Action
|
|
ExpectedVal error
|
|
}{
|
|
{
|
|
Name: "AbortedState-ResumeAction case",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Aborting,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.ResumeJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "AbortedState-AnyOtherAction case with pods count equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Aborting,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "AbortedState-AnyOtherAction case with Pods count not equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Pending: 1,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Aborting,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodPending, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
}
|
|
|
|
for _, testcase := range testcases {
|
|
t.Run(testcase.Name, func(t *testing.T) {
|
|
absState := state.NewState(testcase.JobInfo)
|
|
|
|
fakecontroller := newFakeController()
|
|
state.KillJob = fakecontroller.killJob
|
|
|
|
_, err := fakecontroller.vcClient.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 == busv1alpha1.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.RetryCount == 0 {
|
|
t.Error("Retry Count should not be zero")
|
|
}
|
|
}
|
|
|
|
if testcase.Action != busv1alpha1.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")
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCompletingState_Execute(t *testing.T) {
|
|
|
|
namespace := "test"
|
|
|
|
testcases := []struct {
|
|
Name string
|
|
JobInfo *apis.JobInfo
|
|
Action busv1alpha1.Action
|
|
ExpectedVal error
|
|
}{
|
|
{
|
|
Name: "CompletingState- With pod count not equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Running: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Completing,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.ResumeJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "CompletingState- With pod count equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Completing,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.ResumeJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
}
|
|
|
|
for i, testcase := range testcases {
|
|
t.Run(testcase.Name, func(t *testing.T) {
|
|
testState := state.NewState(testcase.JobInfo)
|
|
|
|
fakecontroller := newFakeController()
|
|
state.KillJob = fakecontroller.killJob
|
|
|
|
_, err := fakecontroller.vcClient.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)
|
|
}
|
|
} else {
|
|
if jobInfo.Job.Status.State.Phase != v1alpha1.Completing {
|
|
t.Errorf("Expected Phase to be completing state in test case: %d", i)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFinishedState_Execute(t *testing.T) {
|
|
namespace := "test"
|
|
|
|
testcases := []struct {
|
|
Name string
|
|
JobInfo *apis.JobInfo
|
|
Action busv1alpha1.Action
|
|
ExpectedVal error
|
|
}{
|
|
{
|
|
Name: "FinishedState Test Case",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Completed,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.ResumeJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
}
|
|
|
|
for _, testcase := range testcases {
|
|
t.Run(testcase.Name, func(t *testing.T) {
|
|
testState := state.NewState(testcase.JobInfo)
|
|
|
|
fakecontroller := newFakeController()
|
|
state.KillJob = fakecontroller.killJob
|
|
|
|
_, err := fakecontroller.vcClient.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)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPendingState_Execute(t *testing.T) {
|
|
namespace := "test"
|
|
|
|
testcases := []struct {
|
|
Name string
|
|
JobInfo *apis.JobInfo
|
|
Action busv1alpha1.Action
|
|
ExpectedVal error
|
|
}{
|
|
{
|
|
Name: "PendingState- RestartJobAction case With terminating pod count equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- RestartJobAction case With terminating pod count not equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- AbortJobAction case With terminating pod count equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.AbortJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- AbortJobAction case With terminating pod count not equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.AbortJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- TerminateJobAction case With terminating pod count not equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.TerminateJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- CompleteJobAction case With terminating pod count equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.CompleteJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- CompleteJobAction case With terminating pod count not equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.CompleteJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- EnqueueAction case With Min Available equal to running pods",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{
|
|
MinAvailable: 3,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Running: 3,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
"pod3": buildPod(namespace, "pod3", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.EnqueueAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- EnqueueAction case With Min Available not equal to running pods",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{
|
|
MinAvailable: 3,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Running: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.EnqueueAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "PendingState- Default case With Min Available equal to running pods",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{
|
|
MinAvailable: 3,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Running: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Pending,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.SyncJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
}
|
|
|
|
for i, testcase := range testcases {
|
|
t.Run(testcase.Name, func(t *testing.T) {
|
|
testState := state.NewState(testcase.JobInfo)
|
|
|
|
fakecontroller := newFakeController()
|
|
state.KillJob = fakecontroller.killJob
|
|
|
|
_, err := fakecontroller.vcClient.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 == busv1alpha1.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 == busv1alpha1.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 == busv1alpha1.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 == busv1alpha1.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 == busv1alpha1.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.Pending {
|
|
t.Errorf("Expected Job phase to %s, but got %s in case %d", v1alpha1.Pending, jobInfo.Job.Status.State.Phase, i)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRestartingState_Execute(t *testing.T) {
|
|
namespace := "test"
|
|
|
|
testcases := []struct {
|
|
Name string
|
|
JobInfo *apis.JobInfo
|
|
Action busv1alpha1.Action
|
|
ExpectedVal error
|
|
}{
|
|
{
|
|
Name: "RestartingState- RetryCount is equal to or greater than MaxRetry",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{
|
|
MaxRetry: 3,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
RetryCount: 3,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Restarting,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RestartingState- RetryCount is less than MaxRetry",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{
|
|
MaxRetry: 3,
|
|
Tasks: []v1alpha1.TaskSpec{
|
|
{
|
|
Name: "task1",
|
|
},
|
|
{
|
|
Name: "task2",
|
|
},
|
|
},
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
RetryCount: 1,
|
|
MinAvailable: 1,
|
|
Terminating: 0,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Restarting,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
}
|
|
|
|
for i, testcase := range testcases {
|
|
t.Run(testcase.Name, func(t *testing.T) {
|
|
testState := state.NewState(testcase.JobInfo)
|
|
|
|
fakecontroller := newFakeController()
|
|
state.KillJob = fakecontroller.killJob
|
|
|
|
_, err := fakecontroller.vcClient.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)
|
|
}
|
|
} 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)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRunningState_Execute(t *testing.T) {
|
|
namespace := "test"
|
|
|
|
testcases := []struct {
|
|
Name string
|
|
JobInfo *apis.JobInfo
|
|
Action busv1alpha1.Action
|
|
ExpectedVal error
|
|
}{
|
|
{
|
|
Name: "RunningState- RestartJobAction case and Terminating Pods not equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- RestartJobAction case and Terminating Pods equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 0,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.RestartJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- AbortAction case and Terminating Pods equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 0,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.AbortJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- AbortAction case and Terminating Pods not equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.AbortJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- TerminateJobAction case and Terminating Pods equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 0,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.TerminateJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- TerminateJobAction case and Terminating Pods not equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.TerminateJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- CompleteJobAction case and Terminating Pods equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 0,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.CompleteJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- CompleteJobAction case and Terminating Pods not equal to 0",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{},
|
|
Status: v1alpha1.JobStatus{
|
|
Terminating: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.CompleteJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- Default case and Total is equal to failed+succeeded",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{
|
|
Tasks: []v1alpha1.TaskSpec{
|
|
{
|
|
Name: "task1",
|
|
Replicas: 2,
|
|
Template: v1.PodTemplateSpec{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "task1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Succeeded: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"job1-task1-0": buildPod(namespace, "pod1", v1.PodSucceeded, nil),
|
|
"job1-task1-1": buildPod(namespace, "pod2", v1.PodSucceeded, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.SyncJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "RunningState- Default case and Total is not equal to failed+succeeded",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "job1",
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1alpha1.JobSpec{
|
|
Tasks: []v1alpha1.TaskSpec{
|
|
{
|
|
Name: "task1",
|
|
Replicas: 2,
|
|
Template: v1.PodTemplateSpec{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "task1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Succeeded: 1,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Running,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"job1-task1-0": buildPod(namespace, "pod1", v1.PodSucceeded, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.SyncJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
}
|
|
|
|
for i, testcase := range testcases {
|
|
t.Run(testcase.Name, func(t *testing.T) {
|
|
testState := state.NewState(testcase.JobInfo)
|
|
|
|
fakecontroller := newFakeController()
|
|
state.KillJob = fakecontroller.killJob
|
|
|
|
_, err := fakecontroller.vcClient.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 == busv1alpha1.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 == busv1alpha1.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 == busv1alpha1.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 == busv1alpha1.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 {
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTerminatingState_Execute(t *testing.T) {
|
|
namespace := "test"
|
|
|
|
testcases := []struct {
|
|
Name string
|
|
JobInfo *apis.JobInfo
|
|
Action busv1alpha1.Action
|
|
ExpectedVal error
|
|
}{
|
|
{
|
|
Name: "TerminatingState- With pod count not equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
Running: 2,
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Terminating,
|
|
},
|
|
},
|
|
},
|
|
Pods: map[string]map[string]*v1.Pod{
|
|
"task1": {
|
|
"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
|
|
"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.TerminateJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
{
|
|
Name: "TerminatingState- With pod count not equal to zero",
|
|
JobInfo: &apis.JobInfo{
|
|
Namespace: namespace,
|
|
Name: "jobinfo1",
|
|
Job: &v1alpha1.Job{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "Job1",
|
|
Namespace: namespace,
|
|
},
|
|
Status: v1alpha1.JobStatus{
|
|
State: v1alpha1.JobState{
|
|
Phase: v1alpha1.Terminating,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Action: busv1alpha1.TerminateJobAction,
|
|
ExpectedVal: nil,
|
|
},
|
|
}
|
|
|
|
for i, testcase := range testcases {
|
|
t.Run(testcase.Name, func(t *testing.T) {
|
|
testState := state.NewState(testcase.JobInfo)
|
|
|
|
fakecontroller := newFakeController()
|
|
state.KillJob = fakecontroller.killJob
|
|
|
|
_, err := fakecontroller.vcClient.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.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)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|