readability enhancement for cj controller unit test

This commit is contained in:
jlsong01 2022-01-20 11:39:43 +08:00
parent 7c013c3f64
commit 79d921e040

View File

@ -50,12 +50,6 @@ var (
errorSchedule = "obvious error schedule"
// schedule is hourly on the hour
onTheHour = "0 * * * ?"
A = batchv1.AllowConcurrent
f = batchv1.ForbidConcurrent
R = batchv1.ReplaceConcurrent
T = true
F = false
)
// returns a cronJob with some fields filled in.
@ -69,7 +63,7 @@ func cronJob() batchv1.CronJob {
},
Spec: batchv1.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batchv1.AllowConcurrent,
ConcurrencyPolicy: "Allow",
JobTemplate: batchv1.JobTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{"a": "b"},
@ -173,6 +167,7 @@ func TestControllerV2SyncCronJob(t *testing.T) {
// cj status
ranPreviously bool
stillActive bool
jobPresentInCJActiveStatus bool
jobCreationTime time.Time
@ -187,73 +182,579 @@ func TestControllerV2SyncCronJob(t *testing.T) {
expectErr bool
expectRequeueAfter bool
jobStillNotFoundInLister bool
jobPresentInCJActiveStatus bool
jobCreateError error
}{
"never ran, not valid schedule, A": {A, F, errorSchedule, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 1, F, F, F, T, nil},
"never ran, not valid schedule, F": {f, F, errorSchedule, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 1, F, F, F, T, nil},
"never ran, not valid schedule, R": {f, F, errorSchedule, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 1, F, F, F, T, nil},
"never ran, not time, A": {A, F, onTheHour, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil},
"never ran, not time, F": {f, F, onTheHour, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil},
"never ran, not time, R": {R, F, onTheHour, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil},
"never ran, is time, A": {A, F, onTheHour, noDead, F, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"never ran, is time, F": {f, F, onTheHour, noDead, F, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"never ran, is time, R": {R, F, onTheHour, noDead, F, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"never ran, is time, suspended": {A, T, onTheHour, noDead, F, F, justAfterThePriorHour(), *justAfterTheHour(), F, F, 0, 0, F, F, F, T, nil},
"never ran, is time, past deadline": {A, F, onTheHour, shortDead, F, F, justAfterThePriorHour(), justAfterTheHour().Add(time.Minute * time.Duration(shortDead+1)), F, F, 0, 0, F, T, F, T, nil},
"never ran, is time, not past deadline": {A, F, onTheHour, longDead, F, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"never ran, not valid schedule, A": {
concurrencyPolicy: "Allow",
schedule: errorSchedule,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectedWarnings: 1,
jobPresentInCJActiveStatus: true,
},
"never ran, not valid schedule, F": {
concurrencyPolicy: "Forbid",
schedule: errorSchedule,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectedWarnings: 1,
jobPresentInCJActiveStatus: true,
},
"never ran, not valid schedule, R": {
concurrencyPolicy: "Forbid",
schedule: errorSchedule,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectedWarnings: 1,
jobPresentInCJActiveStatus: true,
},
"never ran, not time, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true},
"never ran, not time, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"never ran, not time, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"never ran, is time, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"never ran, is time, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"never ran, is time, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"never ran, is time, suspended": {
concurrencyPolicy: "Allow",
suspend: true,
schedule: onTheHour,
deadline: noDead,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
jobPresentInCJActiveStatus: true,
},
"never ran, is time, past deadline": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: shortDead,
jobCreationTime: justAfterThePriorHour(),
now: justAfterTheHour().Add(time.Minute * time.Duration(shortDead+1)),
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"never ran, is time, not past deadline": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: longDead,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, not time, A": {A, F, onTheHour, noDead, T, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil},
"prev ran but done, not time, F": {f, F, onTheHour, noDead, T, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil},
"prev ran but done, not time, R": {R, F, onTheHour, noDead, T, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil},
"prev ran but done, is time, A": {A, F, onTheHour, noDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, is time, F": {f, F, onTheHour, noDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, is time, R": {R, F, onTheHour, noDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, is time, suspended": {A, T, onTheHour, noDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), F, F, 0, 0, F, F, F, T, nil},
"prev ran but done, is time, past deadline": {A, F, onTheHour, shortDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), F, F, 0, 0, F, T, F, T, nil},
"prev ran but done, is time, not past deadline": {A, F, onTheHour, longDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, not time, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, not time, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, not time, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, is time, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, is time, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, is time, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, is time, suspended": {
concurrencyPolicy: "Allow",
suspend: true,
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
jobPresentInCJActiveStatus: true,
},
"prev ran but done, is time, past deadline": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: shortDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, is time, not past deadline": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"still active, not time, A": {A, F, onTheHour, noDead, T, T, justAfterThePriorHour(), justBeforeTheHour(), F, F, 1, 0, F, T, F, T, nil},
"still active, not time, F": {f, F, onTheHour, noDead, T, T, justAfterThePriorHour(), justBeforeTheHour(), F, F, 1, 0, F, T, F, T, nil},
"still active, not time, R": {R, F, onTheHour, noDead, T, T, justAfterThePriorHour(), justBeforeTheHour(), F, F, 1, 0, F, T, F, T, nil},
"still active, is time, A": {A, F, onTheHour, noDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), T, F, 2, 0, F, T, F, T, nil},
"still active, is time, F": {f, F, onTheHour, noDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), F, F, 1, 0, F, T, F, T, nil},
"still active, is time, R": {R, F, onTheHour, noDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), T, T, 1, 0, F, T, F, T, nil},
"still active, is time, suspended": {A, T, onTheHour, noDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), F, F, 1, 0, F, F, F, T, nil},
"still active, is time, past deadline": {A, F, onTheHour, shortDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), F, F, 1, 0, F, T, F, T, nil},
"still active, is time, not past deadline": {A, F, onTheHour, longDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), T, F, 2, 0, F, T, F, T, nil},
"still active, not time, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"still active, not time, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"still active, not time, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: justBeforeTheHour(),
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"still active, is time, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 2,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"still active, is time, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"still active, is time, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectDelete: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"still active, is time, suspended": {
concurrencyPolicy: "Allow",
suspend: true,
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectActive: 1,
jobPresentInCJActiveStatus: true,
},
"still active, is time, past deadline": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: shortDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"still active, is time, not past deadline": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: justAfterThePriorHour(),
now: *justAfterTheHour(),
expectCreate: true,
expectActive: 2,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
// Controller should fail to schedule these, as there are too many missed starting times
// and either no deadline or a too long deadline.
"prev ran but done, long overdue, not past deadline, A": {A, F, onTheHour, longDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 1, F, T, F, T, nil},
"prev ran but done, long overdue, not past deadline, R": {R, F, onTheHour, longDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 1, F, T, F, T, nil},
"prev ran but done, long overdue, not past deadline, F": {f, F, onTheHour, longDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 1, F, T, F, T, nil},
"prev ran but done, long overdue, no deadline, A": {A, F, onTheHour, noDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 1, F, T, F, T, nil},
"prev ran but done, long overdue, no deadline, R": {R, F, onTheHour, noDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 1, F, T, F, T, nil},
"prev ran but done, long overdue, no deadline, F": {f, F, onTheHour, noDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 1, F, T, F, T, nil},
"prev ran but done, long overdue, not past deadline, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectedWarnings: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, not past deadline, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectedWarnings: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, not past deadline, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectedWarnings: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, no deadline, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectedWarnings: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, no deadline, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectedWarnings: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, no deadline, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectedWarnings: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, past medium deadline, A": {A, F, onTheHour, mediumDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, long overdue, past short deadline, A": {A, F, onTheHour, shortDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, long overdue, past medium deadline, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: mediumDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, past short deadline, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: shortDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, past medium deadline, R": {R, F, onTheHour, mediumDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, long overdue, past short deadline, R": {R, F, onTheHour, shortDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, long overdue, past medium deadline, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: mediumDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, past short deadline, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: shortDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, past medium deadline, F": {f, F, onTheHour, mediumDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, long overdue, past short deadline, F": {f, F, onTheHour, shortDead, T, F, justAfterThePriorHour(), weekAfterTheHour(), T, F, 1, 0, F, T, F, T, nil},
"prev ran but done, long overdue, past medium deadline, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: mediumDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
"prev ran but done, long overdue, past short deadline, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: shortDead,
ranPreviously: true,
jobCreationTime: justAfterThePriorHour(),
now: weekAfterTheHour(),
expectCreate: true,
expectActive: 1,
expectRequeueAfter: true,
jobPresentInCJActiveStatus: true,
},
// Tests for time skews
// the controller sees job is created, takes no actions
"this ran but done, time drifted back, F": {f, F, onTheHour, noDead, T, F, *justAfterTheHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, F, errors.NewAlreadyExists(schema.GroupResource{Resource: "jobs", Group: "batch"}, "")},
"this ran but done, time drifted back, F": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: noDead,
ranPreviously: true,
jobCreationTime: *justAfterTheHour(),
now: justBeforeTheHour(),
expectRequeueAfter: true,
jobCreateError: errors.NewAlreadyExists(schema.GroupResource{Resource: "jobs", Group: "batch"}, "")},
// Tests for slow job lister
"this started but went missing, not past deadline, A": {A, F, onTheHour, longDead, T, T, topOfTheHour().Add(time.Millisecond * 100), justAfterTheHour().Add(time.Millisecond * 100), F, F, 1, 0, F, T, T, T, nil},
"this started but went missing, not past deadline, f": {f, F, onTheHour, longDead, T, T, topOfTheHour().Add(time.Millisecond * 100), justAfterTheHour().Add(time.Millisecond * 100), F, F, 1, 0, F, T, T, T, nil},
"this started but went missing, not past deadline, R": {R, F, onTheHour, longDead, T, T, topOfTheHour().Add(time.Millisecond * 100), justAfterTheHour().Add(time.Millisecond * 100), F, F, 1, 0, F, T, T, T, nil},
"this started but went missing, not past deadline, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: topOfTheHour().Add(time.Millisecond * 100),
now: justAfterTheHour().Add(time.Millisecond * 100),
expectActive: 1,
expectRequeueAfter: true,
jobStillNotFoundInLister: true,
jobPresentInCJActiveStatus: true,
},
"this started but went missing, not past deadline, f": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: topOfTheHour().Add(time.Millisecond * 100),
now: justAfterTheHour().Add(time.Millisecond * 100),
expectActive: 1,
expectRequeueAfter: true,
jobStillNotFoundInLister: true,
jobPresentInCJActiveStatus: true,
},
"this started but went missing, not past deadline, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: topOfTheHour().Add(time.Millisecond * 100),
now: justAfterTheHour().Add(time.Millisecond * 100),
expectActive: 1,
expectRequeueAfter: true,
jobStillNotFoundInLister: true,
jobPresentInCJActiveStatus: true,
},
// Tests for slow cronjob list
"this started but is not present in cronjob active list, not past deadline, A": {A, F, onTheHour, longDead, T, T, topOfTheHour().Add(time.Millisecond * 100), justAfterTheHour().Add(time.Millisecond * 100), F, F, 1, 0, F, T, F, F, nil},
"this started but is not present in cronjob active list, not past deadline, f": {f, F, onTheHour, longDead, T, T, topOfTheHour().Add(time.Millisecond * 100), justAfterTheHour().Add(time.Millisecond * 100), F, F, 1, 0, F, T, F, F, nil},
"this started but is not present in cronjob active list, not past deadline, R": {R, F, onTheHour, longDead, T, T, topOfTheHour().Add(time.Millisecond * 100), justAfterTheHour().Add(time.Millisecond * 100), F, F, 1, 0, F, T, F, F, nil},
"this started but is not present in cronjob active list, not past deadline, A": {
concurrencyPolicy: "Allow",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: topOfTheHour().Add(time.Millisecond * 100),
now: justAfterTheHour().Add(time.Millisecond * 100),
expectActive: 1,
expectRequeueAfter: true,
},
"this started but is not present in cronjob active list, not past deadline, f": {
concurrencyPolicy: "Forbid",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: topOfTheHour().Add(time.Millisecond * 100),
now: justAfterTheHour().Add(time.Millisecond * 100),
expectActive: 1,
expectRequeueAfter: true,
},
"this started but is not present in cronjob active list, not past deadline, R": {
concurrencyPolicy: "Replace",
schedule: onTheHour,
deadline: longDead,
ranPreviously: true,
stillActive: true,
jobCreationTime: topOfTheHour().Add(time.Millisecond * 100),
now: justAfterTheHour().Add(time.Millisecond * 100),
expectActive: 1,
expectRequeueAfter: true,
},
}
for name, tc := range testCases {
name := name