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" errorSchedule = "obvious error schedule"
// schedule is hourly on the hour // schedule is hourly on the hour
onTheHour = "0 * * * ?" onTheHour = "0 * * * ?"
A = batchv1.AllowConcurrent
f = batchv1.ForbidConcurrent
R = batchv1.ReplaceConcurrent
T = true
F = false
) )
// returns a cronJob with some fields filled in. // returns a cronJob with some fields filled in.
@ -69,7 +63,7 @@ func cronJob() batchv1.CronJob {
}, },
Spec: batchv1.CronJobSpec{ Spec: batchv1.CronJobSpec{
Schedule: "* * * * ?", Schedule: "* * * * ?",
ConcurrencyPolicy: batchv1.AllowConcurrent, ConcurrencyPolicy: "Allow",
JobTemplate: batchv1.JobTemplateSpec{ JobTemplate: batchv1.JobTemplateSpec{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{"a": "b"}, Labels: map[string]string{"a": "b"},
@ -171,8 +165,9 @@ func TestControllerV2SyncCronJob(t *testing.T) {
deadline int64 deadline int64
// cj status // cj status
ranPreviously bool ranPreviously bool
stillActive bool stillActive bool
jobPresentInCJActiveStatus bool
jobCreationTime time.Time jobCreationTime time.Time
@ -180,80 +175,586 @@ func TestControllerV2SyncCronJob(t *testing.T) {
now time.Time now time.Time
// expectations // expectations
expectCreate bool expectCreate bool
expectDelete bool expectDelete bool
expectActive int expectActive int
expectedWarnings int expectedWarnings int
expectErr bool expectErr bool
expectRequeueAfter bool expectRequeueAfter bool
jobStillNotFoundInLister bool jobStillNotFoundInLister bool
jobPresentInCJActiveStatus bool jobCreateError error
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, A": {
"never ran, not valid schedule, F": {f, F, errorSchedule, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 1, F, F, F, T, nil}, concurrencyPolicy: "Allow",
"never ran, not valid schedule, R": {f, F, errorSchedule, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 1, F, F, F, T, nil}, schedule: errorSchedule,
"never ran, not time, A": {A, F, onTheHour, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil}, deadline: noDead,
"never ran, not time, F": {f, F, onTheHour, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil}, jobCreationTime: justAfterThePriorHour(),
"never ran, not time, R": {R, F, onTheHour, noDead, F, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil}, now: justBeforeTheHour(),
"never ran, is time, A": {A, F, onTheHour, noDead, F, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil}, expectedWarnings: 1,
"never ran, is time, F": {f, F, onTheHour, noDead, F, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil}, jobPresentInCJActiveStatus: true,
"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, not valid schedule, F": {
"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}, concurrencyPolicy: "Forbid",
"never ran, is time, not past deadline": {A, F, onTheHour, longDead, F, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil}, 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, A": {
"prev ran but done, not time, F": {f, F, onTheHour, noDead, T, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil}, concurrencyPolicy: "Allow",
"prev ran but done, not time, R": {R, F, onTheHour, noDead, T, F, justAfterThePriorHour(), justBeforeTheHour(), F, F, 0, 0, F, T, F, T, nil}, schedule: onTheHour,
"prev ran but done, is time, A": {A, F, onTheHour, noDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil}, deadline: noDead,
"prev ran but done, is time, F": {f, F, onTheHour, noDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil}, ranPreviously: true,
"prev ran but done, is time, R": {R, F, onTheHour, noDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), T, F, 1, 0, F, T, F, T, nil}, jobCreationTime: justAfterThePriorHour(),
"prev ran but done, is time, suspended": {A, T, onTheHour, noDead, T, F, justAfterThePriorHour(), *justAfterTheHour(), F, F, 0, 0, F, F, F, T, nil}, now: justBeforeTheHour(),
"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}, expectRequeueAfter: true,
"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}, 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, A": {
"still active, not time, F": {f, F, onTheHour, noDead, T, T, justAfterThePriorHour(), justBeforeTheHour(), F, F, 1, 0, F, T, F, T, nil}, concurrencyPolicy: "Allow",
"still active, not time, R": {R, F, onTheHour, noDead, T, T, justAfterThePriorHour(), justBeforeTheHour(), F, F, 1, 0, F, T, F, T, nil}, schedule: onTheHour,
"still active, is time, A": {A, F, onTheHour, noDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), T, F, 2, 0, F, T, F, T, nil}, deadline: noDead,
"still active, is time, F": {f, F, onTheHour, noDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), F, F, 1, 0, F, T, F, T, nil}, ranPreviously: true,
"still active, is time, R": {R, F, onTheHour, noDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), T, T, 1, 0, F, T, F, T, nil}, stillActive: true,
"still active, is time, suspended": {A, T, onTheHour, noDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), F, F, 1, 0, F, F, F, T, nil}, jobCreationTime: justAfterThePriorHour(),
"still active, is time, past deadline": {A, F, onTheHour, shortDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), F, F, 1, 0, F, T, F, T, nil}, now: justBeforeTheHour(),
"still active, is time, not past deadline": {A, F, onTheHour, longDead, T, T, justAfterThePriorHour(), *justAfterTheHour(), T, F, 2, 0, F, T, F, T, nil}, 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 // Controller should fail to schedule these, as there are too many missed starting times
// and either no deadline or a too long deadline. // 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, A": {
"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}, concurrencyPolicy: "Allow",
"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}, schedule: onTheHour,
"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}, deadline: longDead,
"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}, ranPreviously: true,
"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}, 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 medium deadline, A": {
"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}, 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 medium deadline, R": {
"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}, 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 medium deadline, F": {
"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}, 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 // Tests for time skews
// the controller sees job is created, takes no actions // 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 // 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, A": {
"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}, concurrencyPolicy: "Allow",
"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}, 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 // 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, A": {
"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}, concurrencyPolicy: "Allow",
"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}, 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 { for name, tc := range testCases {
name := name name := name