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"},
@ -171,8 +165,9 @@ func TestControllerV2SyncCronJob(t *testing.T) {
deadline int64
// cj status
ranPreviously bool
stillActive bool
ranPreviously bool
stillActive bool
jobPresentInCJActiveStatus bool
jobCreationTime time.Time
@ -180,80 +175,586 @@ func TestControllerV2SyncCronJob(t *testing.T) {
now time.Time
// expectations
expectCreate bool
expectDelete bool
expectActive int
expectedWarnings int
expectErr bool
expectRequeueAfter bool
jobStillNotFoundInLister bool
jobPresentInCJActiveStatus bool
jobCreateError error
expectCreate bool
expectDelete bool
expectActive int
expectedWarnings int
expectErr bool
expectRequeueAfter bool
jobStillNotFoundInLister 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