Google Git
Sign in
cos/third_party/kubernetes/refs/heads/release-R129/./pkg/apis/batch/validation/validation_test.go
blob: 9a4166c386176c02e581872b0a870fb03cccfa5f [file] [log] [blame] [edit]
/*
Copyright 2016 The Kubernetes 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 validation
import (
"errors"
_ "time/tzdata"
"fmt"
"strings"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/validation/field"
"k8s.io/kubernetes/pkg/apis/batch"
api "k8s.io/kubernetes/pkg/apis/core"
corevalidation "k8s.io/kubernetes/pkg/apis/core/validation"
"k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
var (
timeZoneEmpty = ""
timeZoneLocal = "LOCAL"
timeZoneUTC = "UTC"
timeZoneCorrect = "Europe/Rome"
timeZoneBadPrefix = " Europe/Rome"
timeZoneBadSuffix = "Europe/Rome "
timeZoneBadName = "Europe/InvalidRome"
timeZoneEmptySpace = " "
)
var ignoreErrValueDetail = cmpopts.IgnoreFields(field.Error{}, "BadValue", "Detail")
func getValidManualSelector() *metav1.LabelSelector {
return &metav1.LabelSelector{
MatchLabels: map[string]string{"a": "b"},
}
}
func getValidPodTemplateSpecForManual(selector *metav1.LabelSelector) api.PodTemplateSpec {
return api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: selector.MatchLabels,
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
}
}
func getValidGeneratedSelector() *metav1.LabelSelector {
return &metav1.LabelSelector{
MatchLabels: map[string]string{batch.ControllerUidLabel: "1a2b3c", batch.LegacyControllerUidLabel: "1a2b3c", batch.JobNameLabel: "myjob", batch.LegacyJobNameLabel: "myjob"},
}
}
func getValidPodTemplateSpecForGenerated(selector *metav1.LabelSelector) api.PodTemplateSpec {
return api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: selector.MatchLabels,
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
InitContainers: []api.Container{{Name: "def", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
}
}
func TestValidateJob(t *testing.T) {
validJobObjectMeta := metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
}
validManualSelector := getValidManualSelector()
failedPodReplacement := batch.Failed
terminatingOrFailedPodReplacement := batch.TerminatingOrFailed
validPodTemplateSpecForManual := getValidPodTemplateSpecForManual(validManualSelector)
validGeneratedSelector := getValidGeneratedSelector()
validPodTemplateSpecForGenerated := getValidPodTemplateSpecForGenerated(validGeneratedSelector)
validPodTemplateSpecForGeneratedRestartPolicyNever := getValidPodTemplateSpecForGenerated(validGeneratedSelector)
validPodTemplateSpecForGeneratedRestartPolicyNever.Spec.RestartPolicy = api.RestartPolicyNever
validHostNetPodTemplateSpec := func() api.PodTemplateSpec {
spec := getValidPodTemplateSpecForGenerated(validGeneratedSelector)
spec.Spec.SecurityContext = &api.PodSecurityContext{
HostNetwork: true,
}
spec.Spec.Containers[0].Ports = []api.ContainerPort{{
ContainerPort: 12345,
Protocol: api.ProtocolTCP,
}}
return spec
}()
successCases := map[string]struct {
opts JobValidationOptions
job batch.Job
}{
"valid success policy": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](10),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{
{
SucceededCount: ptr.To[int32](1),
SucceededIndexes: ptr.To("0,2,4"),
},
{
SucceededIndexes: ptr.To("1,3,5-9"),
},
},
},
},
},
},
"valid pod failure policy": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
Status: api.ConditionTrue,
}},
}, {
Action: batch.PodFailurePolicyActionFailJob,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.PodConditionType("CustomConditionType"),
Status: api.ConditionFalse,
}},
}, {
Action: batch.PodFailurePolicyActionCount,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
ContainerName: pointer.String("abc"),
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{1, 2, 3},
},
}, {
Action: batch.PodFailurePolicyActionIgnore,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
ContainerName: pointer.String("def"),
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{4},
},
}, {
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpNotIn,
Values: []int32{5, 6, 7},
},
}},
},
},
},
},
"valid pod failure policy with FailIndex": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: pointer.Int32(2),
BackoffLimitPerIndex: pointer.Int32(1),
Selector: validGeneratedSelector,
ManualSelector: pointer.Bool(true),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailIndex,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{10},
},
}},
},
},
},
},
"valid manual selector": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
Annotations: map[string]string{"foo": "bar"},
},
Spec: batch.JobSpec{
Selector: validManualSelector,
ManualSelector: pointer.Bool(true),
Template: validPodTemplateSpecForManual,
},
},
},
"valid generated selector": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
},
"valid pod replacement": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
PodReplacementPolicy: &terminatingOrFailedPodReplacement,
},
},
},
"valid pod replacement with failed": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
PodReplacementPolicy: &failedPodReplacement,
},
},
},
"valid hostnet": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validHostNetPodTemplateSpec,
},
},
},
"valid NonIndexed completion mode": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
CompletionMode: completionModePtr(batch.NonIndexedCompletion),
},
},
},
"valid Indexed completion mode": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: pointer.Int32(2),
Parallelism: pointer.Int32(100000),
},
},
},
"valid parallelism and maxFailedIndexes for high completions when backoffLimitPerIndex is used": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Completions: pointer.Int32(100_000),
Parallelism: pointer.Int32(100_000),
MaxFailedIndexes: pointer.Int32(100_000),
BackoffLimitPerIndex: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"valid parallelism and maxFailedIndexes for unlimited completions when backoffLimitPerIndex is used": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Completions: pointer.Int32(1_000_000_000),
Parallelism: pointer.Int32(10_000),
MaxFailedIndexes: pointer.Int32(10_000),
BackoffLimitPerIndex: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"valid job tracking annotation": {
opts: JobValidationOptions{
RequirePrefixedLabels: true,
},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
},
"valid batch labels": {
opts: JobValidationOptions{
RequirePrefixedLabels: true,
},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
},
"do not allow new batch labels": {
opts: JobValidationOptions{
RequirePrefixedLabels: false,
},
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: &metav1.LabelSelector{
MatchLabels: map[string]string{batch.LegacyControllerUidLabel: "1a2b3c"},
},
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{batch.LegacyControllerUidLabel: "1a2b3c", batch.LegacyJobNameLabel: "myjob"},
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
InitContainers: []api.Container{{Name: "def", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
},
"valid managedBy field": {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
ManagedBy: ptr.To("example.com/foo"),
},
},
},
}
for k, v := range successCases {
t.Run(k, func(t *testing.T) {
if errs := ValidateJob(&v.job, v.opts); len(errs) != 0 {
t.Errorf("Got unexpected validation errors: %v", errs)
}
})
}
negative := int32(-1)
negative64 := int64(-1)
errorCases := map[string]struct {
opts JobValidationOptions
job batch.Job
}{
`spec.managedBy: Too long: may not be longer than 63`: {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
ManagedBy: ptr.To("example.com/" + strings.Repeat("x", 60)),
},
},
},
`spec.managedBy: Invalid value: "invalid custom controller name": must be a domain-prefixed path (such as "acme.io/foo")`: {
opts: JobValidationOptions{RequirePrefixedLabels: true},
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
ManagedBy: ptr.To("invalid custom controller name"),
},
},
},
`spec.successPolicy: Invalid value: batch.SuccessPolicy{Rules:[]batch.SuccessPolicyRule{}}: requires indexed completion mode`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.successPolicy.rules: Required value: at least one rules must be specified when the successPolicy is specified`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.successPolicy.rules[0]: Required value: at least one of succeededCount or succeededIndexes must be specified`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededCount: nil,
SucceededIndexes: nil,
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.successPolicy.rules[0].succeededIndexes: Invalid value: "invalid-format": error parsing succeededIndexes: cannot convert string to integer for index: "invalid"`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededIndexes: ptr.To("invalid-format"),
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.successPolicy.rules[0].succeededIndexes: Too long: must have at most 65536 bytes`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededIndexes: ptr.To(strings.Repeat("1", maxJobSuccessPolicySucceededIndexesLimit+1)),
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.successPolicy.rules[0].succeededCount: must be greater than or equal to 0`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededCount: ptr.To[int32](-1),
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.successPolicy.rules[0].succeededCount: Invalid value: 6: must be less than or equal to 5 (the number of specified completions)`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededCount: ptr.To[int32](6),
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.successPolicy.rules[0].succeededCount: Invalid value: 4: must be less than or equal to 3 (the number of indexes in the specified succeededIndexes field)`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededCount: ptr.To[int32](4),
SucceededIndexes: ptr.To("0-2"),
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.successPolicy.rules: Too many: 21: must have at most 20 items`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: func() []batch.SuccessPolicyRule {
var rules []batch.SuccessPolicyRule
for i := 0; i < 21; i++ {
rules = append(rules, batch.SuccessPolicyRule{
SucceededCount: ptr.To[int32](5),
})
}
return rules
}(),
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0]: Invalid value: specifying one of OnExitCodes and OnPodConditions is required`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onExitCodes.values[1]: Duplicate value: 11`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{11, 11},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onExitCodes.values: Too many: 256: must have at most 255 items`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: func() (values []int32) {
tooManyValues := make([]int32, maxPodFailurePolicyOnExitCodesValues+1)
for i := range tooManyValues {
tooManyValues[i] = int32(i)
}
return tooManyValues
}(),
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules: Too many: 21: must have at most 20 items`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: func() []batch.PodFailurePolicyRule {
tooManyRules := make([]batch.PodFailurePolicyRule, maxPodFailurePolicyRules+1)
for i := range tooManyRules {
tooManyRules[i] = batch.PodFailurePolicyRule{
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{int32(i + 1)},
},
}
}
return tooManyRules
}(),
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onPodConditions: Too many: 21: must have at most 20 items`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
OnPodConditions: func() []batch.PodFailurePolicyOnPodConditionsPattern {
tooManyPatterns := make([]batch.PodFailurePolicyOnPodConditionsPattern, maxPodFailurePolicyOnPodConditionsPatterns+1)
for i := range tooManyPatterns {
tooManyPatterns[i] = batch.PodFailurePolicyOnPodConditionsPattern{
Type: api.PodConditionType(fmt.Sprintf("CustomType_%d", i)),
Status: api.ConditionTrue,
}
}
return tooManyPatterns
}(),
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onExitCodes.values[2]: Duplicate value: 13`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{12, 13, 13, 13},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onExitCodes.values: Invalid value: []int32{19, 11}: must be ordered`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{19, 11},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onExitCodes.values: Invalid value: []int32{}: at least one value is required`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].action: Required value: valid values: ["Count" "FailIndex" "FailJob" "Ignore"]`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: "",
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{1, 2, 3},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onExitCodes.operator: Required value: valid values: ["In" "NotIn"]`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: "",
Values: []int32{1, 2, 3},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0]: Invalid value: specifying both OnExitCodes and OnPodConditions is not supported`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
ContainerName: pointer.String("abc"),
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{1, 2, 3},
},
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
Status: api.ConditionTrue,
}},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onExitCodes.values[1]: Invalid value: 0: must not be 0 for the In operator`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{1, 0, 2},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[1].onExitCodes.containerName: Invalid value: "xyz": must be one of the container or initContainer names in the pod template`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
ContainerName: pointer.String("abc"),
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{1, 2, 3},
},
}, {
Action: batch.PodFailurePolicyActionFailJob,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
ContainerName: pointer.String("xyz"),
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{5, 6, 7},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].action: Unsupported value: "UnknownAction": supported values: "Count", "FailIndex", "FailJob", "Ignore"`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: "UnknownAction",
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
ContainerName: pointer.String("abc"),
Operator: batch.PodFailurePolicyOnExitCodesOpIn,
Values: []int32{1, 2, 3},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onExitCodes.operator: Unsupported value: "UnknownOperator": supported values: "In", "NotIn"`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnExitCodes: &batch.PodFailurePolicyOnExitCodesRequirement{
Operator: "UnknownOperator",
Values: []int32{1, 2, 3},
},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onPodConditions[0].status: Required value: valid values: ["False" "True" "Unknown"]`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
}},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onPodConditions[0].status: Unsupported value: "UnknownStatus": supported values: "False", "True", "Unknown"`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
Status: "UnknownStatus",
}},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onPodConditions[0].type: Invalid value: "": name part must be non-empty`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Status: api.ConditionTrue,
}},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podFailurePolicy.rules[0].onPodConditions[0].type: Invalid value: "Invalid Condition Type": name part must consist of alphanumeric characters, '-', '_' or '.', and must start and end with an alphanumeric character (e.g. 'MyName', or 'my.name', or '123-abc', regex used for validation is '([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]')`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.PodConditionType("Invalid Condition Type"),
Status: api.ConditionTrue,
}},
}},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podReplacementPolicy: Unsupported value: "TerminatingOrFailed": supported values: "Failed"`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
PodReplacementPolicy: &terminatingOrFailedPodReplacement,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
Status: api.ConditionTrue,
}},
},
},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.podReplacementPolicy: Unsupported value: "": supported values: "Failed", "TerminatingOrFailed"`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
PodReplacementPolicy: (*batch.PodReplacementPolicy)(pointer.String("")),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
`spec.template.spec.restartPolicy: Invalid value: "OnFailure": only "Never" is supported when podFailurePolicy is specified`: {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: validGeneratedSelector.MatchLabels,
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.parallelism:must be greater than or equal to 0": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Parallelism: &negative,
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.backoffLimit:must be greater than or equal to 0": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
BackoffLimit: pointer.Int32(-1),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.backoffLimitPerIndex: Invalid value: 1: requires indexed completion mode": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
BackoffLimitPerIndex: pointer.Int32(1),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.backoffLimitPerIndex:must be greater than or equal to 0": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
BackoffLimitPerIndex: pointer.Int32(-1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.maxFailedIndexes: Invalid value: 11: must be less than or equal to completions": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Completions: pointer.Int32(10),
MaxFailedIndexes: pointer.Int32(11),
BackoffLimitPerIndex: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.maxFailedIndexes: Required value: must be specified when completions is above 100000": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Completions: pointer.Int32(100_001),
BackoffLimitPerIndex: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.parallelism: Invalid value: 50000: must be less than or equal to 10000 when completions are above 100000 and used with backoff limit per index": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Completions: pointer.Int32(100_001),
Parallelism: pointer.Int32(50_000),
BackoffLimitPerIndex: pointer.Int32(1),
MaxFailedIndexes: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.maxFailedIndexes: Invalid value: 100001: must be less than or equal to 100000": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Completions: pointer.Int32(100_001),
BackoffLimitPerIndex: pointer.Int32(1),
MaxFailedIndexes: pointer.Int32(100_001),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.maxFailedIndexes: Invalid value: 50000: must be less than or equal to 10000 when completions are above 100000 and used with backoff limit per index": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
Completions: pointer.Int32(100_001),
BackoffLimitPerIndex: pointer.Int32(1),
MaxFailedIndexes: pointer.Int32(50_000),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.maxFailedIndexes:must be greater than or equal to 0": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
BackoffLimitPerIndex: pointer.Int32(1),
MaxFailedIndexes: pointer.Int32(-1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.backoffLimitPerIndex: Required value: when maxFailedIndexes is specified": {
job: batch.Job{
ObjectMeta: validJobObjectMeta,
Spec: batch.JobSpec{
MaxFailedIndexes: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.completions:must be greater than or equal to 0": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Completions: &negative,
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.activeDeadlineSeconds:must be greater than or equal to 0": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
ActiveDeadlineSeconds: &negative64,
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.selector:Required value": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.template.metadata.labels: Invalid value: map[string]string{\"y\":\"z\"}: `selector` does not match template `labels`": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validManualSelector,
ManualSelector: pointer.Bool(true),
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{"y": "z"},
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.template.metadata.labels: Invalid value: map[string]string{\"controller-uid\":\"4d5e6f\"}: `selector` does not match template `labels`": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validManualSelector,
ManualSelector: pointer.Bool(true),
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{"controller-uid": "4d5e6f"},
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.template.spec.restartPolicy: Required value": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validManualSelector,
ManualSelector: pointer.Bool(true),
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: validManualSelector.MatchLabels,
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyAlways,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.template.spec.restartPolicy: Unsupported value": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validManualSelector,
ManualSelector: pointer.Bool(true),
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: validManualSelector.MatchLabels,
},
Spec: api.PodSpec{
RestartPolicy: "Invalid",
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.ttlSecondsAfterFinished: must be greater than or equal to 0": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
TTLSecondsAfterFinished: &negative,
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.completions: Required value: when completion mode is Indexed": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.parallelism: must be less than or equal to 100000 when completion mode is Indexed": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: pointer.Int32(2),
Parallelism: pointer.Int32(100001),
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.template.metadata.labels[controller-uid]: Required value: must be '1a2b3c'": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: &metav1.LabelSelector{
MatchLabels: map[string]string{batch.LegacyControllerUidLabel: "1a2b3c"},
},
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{batch.LegacyJobNameLabel: "myjob"},
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
InitContainers: []api.Container{{Name: "def", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
opts: JobValidationOptions{},
},
"metadata.uid: Required value": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
},
Spec: batch.JobSpec{
Selector: &metav1.LabelSelector{
MatchLabels: map[string]string{batch.LegacyControllerUidLabel: "test"},
},
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{batch.LegacyJobNameLabel: "myjob"},
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
InitContainers: []api.Container{{Name: "def", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
opts: JobValidationOptions{},
},
"spec.selector: Invalid value: v1.LabelSelector{MatchLabels:map[string]string{\"a\":\"b\"}, MatchExpressions:[]v1.LabelSelectorRequirement(nil)}: `selector` not auto-generated": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: &metav1.LabelSelector{
MatchLabels: map[string]string{"a": "b"},
},
Template: validPodTemplateSpecForGenerated,
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
"spec.template.metadata.labels[batch.kubernetes.io/controller-uid]: Required value: must be '1a2b3c'": {
job: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "myjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.JobSpec{
Selector: &metav1.LabelSelector{
MatchLabels: map[string]string{batch.ControllerUidLabel: "1a2b3c"},
},
Template: api.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{batch.JobNameLabel: "myjob", batch.LegacyControllerUidLabel: "1a2b3c", batch.LegacyJobNameLabel: "myjob"},
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
InitContainers: []api.Container{{Name: "def", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
opts: JobValidationOptions{RequirePrefixedLabels: true},
},
}
for k, v := range errorCases {
t.Run(k, func(t *testing.T) {
errs := ValidateJob(&v.job, v.opts)
if len(errs) == 0 {
t.Errorf("expected failure for %s", k)
} else {
s := strings.SplitN(k, ":", 2)
err := errs[0]
if err.Field != s[0] || !strings.Contains(err.Error(), s[1]) {
t.Errorf("unexpected error: %v, expected: %s", err, k)
}
}
})
}
}
func TestValidateJobUpdate(t *testing.T) {
validGeneratedSelector := getValidGeneratedSelector()
validPodTemplateSpecForGenerated := getValidPodTemplateSpecForGenerated(validGeneratedSelector)
validPodTemplateSpecForGeneratedRestartPolicyNever := getValidPodTemplateSpecForGenerated(validGeneratedSelector)
validPodTemplateSpecForGeneratedRestartPolicyNever.Spec.RestartPolicy = api.RestartPolicyNever
validNodeAffinity := &api.Affinity{
NodeAffinity: &api.NodeAffinity{
RequiredDuringSchedulingIgnoredDuringExecution: &api.NodeSelector{
NodeSelectorTerms: []api.NodeSelectorTerm{{
MatchExpressions: []api.NodeSelectorRequirement{{
Key: "foo",
Operator: api.NodeSelectorOpIn,
Values: []string{"bar", "value2"},
}},
}},
},
},
}
validPodTemplateWithAffinity := getValidPodTemplateSpecForGenerated(validGeneratedSelector)
validPodTemplateWithAffinity.Spec.Affinity = &api.Affinity{
NodeAffinity: &api.NodeAffinity{
RequiredDuringSchedulingIgnoredDuringExecution: &api.NodeSelector{
NodeSelectorTerms: []api.NodeSelectorTerm{{
MatchExpressions: []api.NodeSelectorRequirement{{
Key: "foo",
Operator: api.NodeSelectorOpIn,
Values: []string{"bar", "value"},
}},
}},
},
},
}
// This is to test immutability of the selector, both the new and old
// selector should match the labels in the template, which is immutable
// on its own; therfore, the only way to test selector immutability is
// when the new selector is changed but still matches the existing labels.
newSelector := getValidGeneratedSelector()
newSelector.MatchLabels["foo"] = "bar"
validTolerations := []api.Toleration{{
Key: "foo",
Operator: api.TolerationOpEqual,
Value: "bar",
Effect: api.TaintEffectPreferNoSchedule,
}}
cases := map[string]struct {
old batch.Job
update func(*batch.Job)
opts JobValidationOptions
err *field.Error
}{
"mutable fields": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
Parallelism: pointer.Int32(5),
ActiveDeadlineSeconds: pointer.Int64(2),
TTLSecondsAfterFinished: pointer.Int32(1),
},
},
update: func(job *batch.Job) {
job.Spec.Parallelism = pointer.Int32(2)
job.Spec.ActiveDeadlineSeconds = pointer.Int64(3)
job.Spec.TTLSecondsAfterFinished = pointer.Int32(2)
job.Spec.ManualSelector = pointer.Bool(true)
},
},
"invalid attempt to set managedBy field": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.ManagedBy = ptr.To("example.com/custom-controller")
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.managedBy",
},
},
"invalid update of the managedBy field": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
ManagedBy: ptr.To("example.com/custom-controller1"),
},
},
update: func(job *batch.Job) {
job.Spec.ManagedBy = ptr.To("example.com/custom-controller2")
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.managedBy",
},
},
"immutable completions for non-indexed jobs": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Completions = pointer.Int32(1)
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.completions",
},
},
"immutable completions for indexed job when AllowElasticIndexedJobs is false": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Completions = pointer.Int32(1)
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.completions",
},
},
"immutable selector": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: getValidPodTemplateSpecForGenerated(newSelector),
},
},
update: func(job *batch.Job) {
job.Spec.Selector = newSelector
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.selector",
},
},
"add success policy": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
},
},
update: func(job *batch.Job) {
job.Spec.SuccessPolicy = &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededCount: ptr.To[int32](2),
}},
}
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.successPolicy",
},
},
"update success policy": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededIndexes: ptr.To("1-3"),
}},
},
},
},
update: func(job *batch.Job) {
job.Spec.SuccessPolicy.Rules = append(job.Spec.SuccessPolicy.Rules, batch.SuccessPolicyRule{
SucceededCount: ptr.To[int32](3),
})
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.successPolicy",
},
},
"remove success policy": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: ptr.To[int32](5),
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
SuccessPolicy: &batch.SuccessPolicy{
Rules: []batch.SuccessPolicyRule{{
SucceededIndexes: ptr.To("1-3"),
}},
},
},
},
update: func(job *batch.Job) {
job.Spec.SuccessPolicy = nil
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.successPolicy",
},
},
"add pod failure policy": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
},
},
update: func(job *batch.Job) {
job.Spec.PodFailurePolicy = &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
Status: api.ConditionTrue,
}},
}},
}
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.podFailurePolicy",
},
},
"update pod failure policy": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
Status: api.ConditionTrue,
}},
}},
},
},
},
update: func(job *batch.Job) {
job.Spec.PodFailurePolicy.Rules = append(job.Spec.PodFailurePolicy.Rules, batch.PodFailurePolicyRule{
Action: batch.PodFailurePolicyActionCount,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
Status: api.ConditionTrue,
}},
})
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.podFailurePolicy",
},
},
"remove pod failure policy": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
PodFailurePolicy: &batch.PodFailurePolicy{
Rules: []batch.PodFailurePolicyRule{{
Action: batch.PodFailurePolicyActionIgnore,
OnPodConditions: []batch.PodFailurePolicyOnPodConditionsPattern{{
Type: api.DisruptionTarget,
Status: api.ConditionTrue,
}},
}},
},
},
},
update: func(job *batch.Job) {
job.Spec.PodFailurePolicy = nil
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.podFailurePolicy",
},
},
"set backoff limit per index": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
Completions: pointer.Int32(3),
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
update: func(job *batch.Job) {
job.Spec.BackoffLimitPerIndex = pointer.Int32(1)
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.backoffLimitPerIndex",
},
},
"unset backoff limit per index": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
Completions: pointer.Int32(3),
CompletionMode: completionModePtr(batch.IndexedCompletion),
BackoffLimitPerIndex: pointer.Int32(1),
},
},
update: func(job *batch.Job) {
job.Spec.BackoffLimitPerIndex = nil
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.backoffLimitPerIndex",
},
},
"update backoff limit per index": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
Completions: pointer.Int32(3),
CompletionMode: completionModePtr(batch.IndexedCompletion),
BackoffLimitPerIndex: pointer.Int32(1),
},
},
update: func(job *batch.Job) {
job.Spec.BackoffLimitPerIndex = pointer.Int32(2)
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.backoffLimitPerIndex",
},
},
"set max failed indexes": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
Completions: pointer.Int32(3),
CompletionMode: completionModePtr(batch.IndexedCompletion),
BackoffLimitPerIndex: pointer.Int32(1),
},
},
update: func(job *batch.Job) {
job.Spec.MaxFailedIndexes = pointer.Int32(1)
},
},
"unset max failed indexes": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
Completions: pointer.Int32(3),
CompletionMode: completionModePtr(batch.IndexedCompletion),
BackoffLimitPerIndex: pointer.Int32(1),
MaxFailedIndexes: pointer.Int32(1),
},
},
update: func(job *batch.Job) {
job.Spec.MaxFailedIndexes = nil
},
},
"update max failed indexes": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGeneratedRestartPolicyNever,
Completions: pointer.Int32(3),
CompletionMode: completionModePtr(batch.IndexedCompletion),
BackoffLimitPerIndex: pointer.Int32(1),
MaxFailedIndexes: pointer.Int32(1),
},
},
update: func(job *batch.Job) {
job.Spec.MaxFailedIndexes = pointer.Int32(2)
},
},
"immutable pod template": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
Completions: pointer.Int32(3),
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.DNSPolicy = api.DNSClusterFirstWithHostNet
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.template",
},
},
"immutable completion mode": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
CompletionMode: completionModePtr(batch.IndexedCompletion),
Completions: pointer.Int32(2),
},
},
update: func(job *batch.Job) {
job.Spec.CompletionMode = completionModePtr(batch.NonIndexedCompletion)
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.completionMode",
},
},
"immutable completions for non-indexed job when AllowElasticIndexedJobs is true": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
CompletionMode: completionModePtr(batch.NonIndexedCompletion),
Completions: pointer.Int32(2),
},
},
update: func(job *batch.Job) {
job.Spec.Completions = pointer.Int32(4)
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.completions",
},
opts: JobValidationOptions{AllowElasticIndexedJobs: true},
},
"immutable node affinity": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.Affinity = validNodeAffinity
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.template",
},
},
"add node affinity": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.Affinity = validNodeAffinity
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"update node affinity": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateWithAffinity,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.Affinity = validNodeAffinity
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"remove node affinity": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateWithAffinity,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.Affinity.NodeAffinity = nil
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"remove affinity": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateWithAffinity,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.Affinity = nil
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"immutable tolerations": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.Tolerations = validTolerations
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.template",
},
},
"mutable tolerations": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.Tolerations = validTolerations
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"immutable node selector": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.NodeSelector = map[string]string{"foo": "bar"}
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.template",
},
},
"mutable node selector": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.NodeSelector = map[string]string{"foo": "bar"}
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"immutable annotations": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Annotations = map[string]string{"foo": "baz"}
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.template",
},
},
"mutable annotations": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Annotations = map[string]string{"foo": "baz"}
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"immutable labels": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
newLabels := getValidGeneratedSelector().MatchLabels
newLabels["bar"] = "baz"
job.Spec.Template.Labels = newLabels
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.template",
},
},
"mutable labels": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
newLabels := getValidGeneratedSelector().MatchLabels
newLabels["bar"] = "baz"
job.Spec.Template.Labels = newLabels
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"immutable schedulingGates": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.SchedulingGates = append(job.Spec.Template.Spec.SchedulingGates, api.PodSchedulingGate{Name: "gate"})
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.template",
},
},
"mutable schedulingGates": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
},
},
update: func(job *batch.Job) {
job.Spec.Template.Spec.SchedulingGates = append(job.Spec.Template.Spec.SchedulingGates, api.PodSchedulingGate{Name: "gate"})
},
opts: JobValidationOptions{
AllowMutableSchedulingDirectives: true,
},
},
"update completions and parallelism to same value is valid": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
Completions: pointer.Int32(1),
Parallelism: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
update: func(job *batch.Job) {
job.Spec.Completions = pointer.Int32(2)
job.Spec.Parallelism = pointer.Int32(2)
},
opts: JobValidationOptions{
AllowElasticIndexedJobs: true,
},
},
"previous parallelism != previous completions, new parallelism == new completions": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
Completions: pointer.Int32(1),
Parallelism: pointer.Int32(2),
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
update: func(job *batch.Job) {
job.Spec.Completions = pointer.Int32(3)
job.Spec.Parallelism = pointer.Int32(3)
},
opts: JobValidationOptions{
AllowElasticIndexedJobs: true,
},
},
"indexed job updating completions and parallelism to different values is invalid": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
Completions: pointer.Int32(1),
Parallelism: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
update: func(job *batch.Job) {
job.Spec.Completions = pointer.Int32(2)
job.Spec.Parallelism = pointer.Int32(3)
},
opts: JobValidationOptions{
AllowElasticIndexedJobs: true,
},
err: &field.Error{
Type: field.ErrorTypeInvalid,
Field: "spec.completions",
},
},
"indexed job with completions set updated to nil does not panic": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
Completions: pointer.Int32(1),
Parallelism: pointer.Int32(1),
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
update: func(job *batch.Job) {
job.Spec.Completions = nil
job.Spec.Parallelism = pointer.Int32(3)
},
opts: JobValidationOptions{
AllowElasticIndexedJobs: true,
},
err: &field.Error{
Type: field.ErrorTypeRequired,
Field: "spec.completions",
},
},
"indexed job with completions unchanged, parallelism reduced to less than completions": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
Completions: pointer.Int32(2),
Parallelism: pointer.Int32(2),
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
update: func(job *batch.Job) {
job.Spec.Completions = pointer.Int32(2)
job.Spec.Parallelism = pointer.Int32(1)
},
opts: JobValidationOptions{
AllowElasticIndexedJobs: true,
},
},
"indexed job with completions unchanged, parallelism increased higher than completions": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
Spec: batch.JobSpec{
Selector: validGeneratedSelector,
Template: validPodTemplateSpecForGenerated,
Completions: pointer.Int32(2),
Parallelism: pointer.Int32(2),
CompletionMode: completionModePtr(batch.IndexedCompletion),
},
},
update: func(job *batch.Job) {
job.Spec.Completions = pointer.Int32(2)
job.Spec.Parallelism = pointer.Int32(3)
},
opts: JobValidationOptions{
AllowElasticIndexedJobs: true,
},
},
}
ignoreValueAndDetail := cmpopts.IgnoreFields(field.Error{}, "BadValue", "Detail")
for k, tc := range cases {
t.Run(k, func(t *testing.T) {
tc.old.ResourceVersion = "1"
update := tc.old.DeepCopy()
tc.update(update)
errs := ValidateJobUpdate(update, &tc.old, tc.opts)
var wantErrs field.ErrorList
if tc.err != nil {
wantErrs = append(wantErrs, tc.err)
}
if diff := cmp.Diff(wantErrs, errs, ignoreValueAndDetail); diff != "" {
t.Errorf("Unexpected validation errors (-want,+got):\n%s", diff)
}
})
}
}
func TestValidateJobUpdateStatus(t *testing.T) {
cases := map[string]struct {
opts JobStatusValidationOptions
old batch.Job
update batch.Job
wantErrs field.ErrorList
}{
"valid": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "abc",
Namespace: metav1.NamespaceDefault,
ResourceVersion: "1",
},
Status: batch.JobStatus{
Active: 1,
Succeeded: 2,
Failed: 3,
Terminating: pointer.Int32(4),
},
},
update: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "abc",
Namespace: metav1.NamespaceDefault,
ResourceVersion: "1",
},
Status: batch.JobStatus{
Active: 2,
Succeeded: 3,
Failed: 4,
Ready: pointer.Int32(1),
Terminating: pointer.Int32(4),
},
},
},
"nil ready and terminating": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "abc",
Namespace: metav1.NamespaceDefault,
ResourceVersion: "1",
},
Status: batch.JobStatus{
Active: 1,
Succeeded: 2,
Failed: 3,
},
},
update: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "abc",
Namespace: metav1.NamespaceDefault,
ResourceVersion: "1",
},
Status: batch.JobStatus{
Active: 2,
Succeeded: 3,
Failed: 4,
},
},
},
"negative counts": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "abc",
Namespace: metav1.NamespaceDefault,
ResourceVersion: "10",
},
Status: batch.JobStatus{
Active: 1,
Succeeded: 2,
Failed: 3,
Terminating: pointer.Int32(4),
},
},
update: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "abc",
Namespace: metav1.NamespaceDefault,
ResourceVersion: "10",
},
Status: batch.JobStatus{
Active: -1,
Succeeded: -2,
Failed: -3,
Ready: pointer.Int32(-1),
Terminating: pointer.Int32(-2),
},
},
wantErrs: field.ErrorList{
{Type: field.ErrorTypeInvalid, Field: "status.active"},
{Type: field.ErrorTypeInvalid, Field: "status.succeeded"},
{Type: field.ErrorTypeInvalid, Field: "status.failed"},
{Type: field.ErrorTypeInvalid, Field: "status.ready"},
{Type: field.ErrorTypeInvalid, Field: "status.terminating"},
},
},
"empty and duplicated uncounted pods": {
old: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "abc",
Namespace: metav1.NamespaceDefault,
ResourceVersion: "5",
},
},
update: batch.Job{
ObjectMeta: metav1.ObjectMeta{
Name: "abc",
Namespace: metav1.NamespaceDefault,
ResourceVersion: "5",
},
Status: batch.JobStatus{
UncountedTerminatedPods: &batch.UncountedTerminatedPods{
Succeeded: []types.UID{"a", "b", "c", "a", ""},
Failed: []types.UID{"c", "d", "e", "d", ""},
},
},
},
wantErrs: field.ErrorList{
{Type: field.ErrorTypeDuplicate, Field: "status.uncountedTerminatedPods.succeeded[3]"},
{Type: field.ErrorTypeInvalid, Field: "status.uncountedTerminatedPods.succeeded[4]"},
{Type: field.ErrorTypeDuplicate, Field: "status.uncountedTerminatedPods.failed[0]"},
{Type: field.ErrorTypeDuplicate, Field: "status.uncountedTerminatedPods.failed[3]"},
{Type: field.ErrorTypeInvalid, Field: "status.uncountedTerminatedPods.failed[4]"},
},
},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
errs := ValidateJobUpdateStatus(&tc.update, &tc.old, tc.opts)
if diff := cmp.Diff(tc.wantErrs, errs, ignoreErrValueDetail); diff != "" {
t.Errorf("Unexpected errors (-want,+got):\n%s", diff)
}
})
}
}
func TestValidateCronJob(t *testing.T) {
validManualSelector := getValidManualSelector()
validPodTemplateSpec := getValidPodTemplateSpecForGenerated(getValidGeneratedSelector())
validPodTemplateSpec.Labels = map[string]string{}
validHostNetPodTemplateSpec := func() api.PodTemplateSpec {
spec := getValidPodTemplateSpecForGenerated(getValidGeneratedSelector())
spec.Spec.SecurityContext = &api.PodSecurityContext{
HostNetwork: true,
}
spec.Spec.Containers[0].Ports = []api.ContainerPort{{
ContainerPort: 12345,
Protocol: api.ProtocolTCP,
}}
return spec
}()
successCases := map[string]batch.CronJob{
"basic scheduled job": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"hostnet job": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validHostNetPodTemplateSpec,
},
},
},
},
"non-standard scheduled": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "@hourly",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"correct timeZone value": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: &timeZoneCorrect,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
}
for k, v := range successCases {
t.Run(k, func(t *testing.T) {
if errs := ValidateCronJobCreate(&v, corevalidation.PodValidationOptions{}); len(errs) != 0 {
t.Errorf("expected success for %s: %v", k, errs)
}
// Update validation should pass same success cases
// copy to avoid polluting the testcase object, set a resourceVersion to allow validating update, and test a no-op update
v = *v.DeepCopy()
v.ResourceVersion = "1"
if errs := ValidateCronJobUpdate(&v, &v, corevalidation.PodValidationOptions{}); len(errs) != 0 {
t.Errorf("expected success for %s: %v", k, errs)
}
})
}
negative := int32(-1)
negative64 := int64(-1)
errorCases := map[string]batch.CronJob{
"spec.schedule: Invalid value": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "error",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.schedule: Required value": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.timeZone: timeZone must be nil or non-empty string": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: &timeZoneEmpty,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.timeZone: timeZone must be an explicit time zone as defined in https://www.iana.org/time-zones": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: &timeZoneLocal,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.timeZone: Invalid value: \" Continent/Zone\": unknown time zone Continent/Zone": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: &timeZoneBadPrefix,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.timeZone: Invalid value: \"Continent/InvalidZone\": unknown time zone Continent/InvalidZone": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: &timeZoneBadName,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.timeZone: Invalid value: \" \": unknown time zone ": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: &timeZoneEmptySpace,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.timeZone: Invalid value: \"Continent/Zone \": unknown time zone Continent/Zone ": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: &timeZoneBadSuffix,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.startingDeadlineSeconds:must be greater than or equal to 0": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
StartingDeadlineSeconds: &negative64,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.successfulJobsHistoryLimit: must be greater than or equal to 0": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
SuccessfulJobsHistoryLimit: &negative,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.failedJobsHistoryLimit: must be greater than or equal to 0": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
FailedJobsHistoryLimit: &negative,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.concurrencyPolicy: Required value": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.jobTemplate.spec.parallelism:must be greater than or equal to 0": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Parallelism: &negative,
Template: validPodTemplateSpec,
},
},
},
},
"spec.jobTemplate.spec.completions:must be greater than or equal to 0": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Completions: &negative,
Template: validPodTemplateSpec,
},
},
},
},
"spec.jobTemplate.spec.activeDeadlineSeconds:must be greater than or equal to 0": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
ActiveDeadlineSeconds: &negative64,
Template: validPodTemplateSpec,
},
},
},
},
"spec.jobTemplate.spec.selector: Invalid value: {\"matchLabels\":{\"a\":\"b\"}}: `selector` will be auto-generated": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Selector: validManualSelector,
Template: validPodTemplateSpec,
},
},
},
},
"metadata.name: must be no more than 52 characters": {
ObjectMeta: metav1.ObjectMeta{
Name: "10000000002000000000300000000040000000005000000000123",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"spec.jobTemplate.spec.manualSelector: Unsupported value": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
ManualSelector: pointer.Bool(true),
Template: validPodTemplateSpec,
},
},
},
},
"spec.jobTemplate.spec.template.spec.restartPolicy: Required value": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: api.PodTemplateSpec{
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyAlways,
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
},
},
"spec.jobTemplate.spec.template.spec.restartPolicy: Unsupported value": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: api.PodTemplateSpec{
Spec: api.PodSpec{
RestartPolicy: "Invalid",
DNSPolicy: api.DNSClusterFirst,
Containers: []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
},
},
},
},
},
},
"spec.jobTemplate.spec.ttlSecondsAfterFinished:must be greater than or equal to 0": {
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: "* * * * ?",
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
TTLSecondsAfterFinished: &negative,
Template: validPodTemplateSpec,
},
},
},
},
}
for k, v := range errorCases {
t.Run(k, func(t *testing.T) {
errs := ValidateCronJobCreate(&v, corevalidation.PodValidationOptions{})
if len(errs) == 0 {
t.Errorf("expected failure for %s", k)
} else {
s := strings.Split(k, ":")
err := errs[0]
if err.Field != s[0] || !strings.Contains(err.Error(), s[1]) {
t.Errorf("unexpected error: %v, expected: %s", err, k)
}
}
// Update validation should fail all failure cases other than the 52 character name limit
// copy to avoid polluting the testcase object, set a resourceVersion to allow validating update, and test a no-op update
oldSpec := *v.DeepCopy()
oldSpec.ResourceVersion = "1"
oldSpec.Spec.TimeZone = nil
newSpec := *v.DeepCopy()
newSpec.ResourceVersion = "2"
errs = ValidateCronJobUpdate(&newSpec, &oldSpec, corevalidation.PodValidationOptions{})
if len(errs) == 0 {
if k == "metadata.name: must be no more than 52 characters" {
return
}
t.Errorf("expected failure for %s", k)
} else {
s := strings.Split(k, ":")
err := errs[0]
if err.Field != s[0] || !strings.Contains(err.Error(), s[1]) {
t.Errorf("unexpected error: %v, expected: %s", err, k)
}
}
})
}
}
func TestValidateCronJobScheduleTZ(t *testing.T) {
validPodTemplateSpec := getValidPodTemplateSpecForGenerated(getValidGeneratedSelector())
validPodTemplateSpec.Labels = map[string]string{}
validSchedule := "0 * * * *"
invalidSchedule := "TZ=UTC 0 * * * *"
invalidCronJob := &batch.CronJob{
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: invalidSchedule,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
}
validCronJob := &batch.CronJob{
ObjectMeta: metav1.ObjectMeta{
Name: "mycronjob",
Namespace: metav1.NamespaceDefault,
UID: types.UID("1a2b3c"),
},
Spec: batch.CronJobSpec{
Schedule: validSchedule,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
}
testCases := map[string]struct {
cronJob *batch.CronJob
createErr string
update func(*batch.CronJob)
updateErr string
}{
"update removing TZ should work": {
cronJob: invalidCronJob,
createErr: "cannot use TZ or CRON_TZ in schedule",
update: func(cj *batch.CronJob) {
cj.Spec.Schedule = validSchedule
},
},
"update not modifying TZ should work": {
cronJob: invalidCronJob,
createErr: "cannot use TZ or CRON_TZ in schedule, use timeZone field instead",
update: func(cj *batch.CronJob) {
cj.Spec.Schedule = invalidSchedule
},
},
"update not modifying TZ but adding .spec.timeZone should fail": {
cronJob: invalidCronJob,
createErr: "cannot use TZ or CRON_TZ in schedule, use timeZone field instead",
update: func(cj *batch.CronJob) {
cj.Spec.TimeZone = &timeZoneUTC
},
updateErr: "cannot use both timeZone field and TZ or CRON_TZ in schedule",
},
"update adding TZ should fail": {
cronJob: validCronJob,
update: func(cj *batch.CronJob) {
cj.Spec.Schedule = invalidSchedule
},
updateErr: "cannot use TZ or CRON_TZ in schedule",
},
}
for k, v := range testCases {
t.Run(k, func(t *testing.T) {
errs := ValidateCronJobCreate(v.cronJob, corevalidation.PodValidationOptions{})
if len(errs) > 0 {
err := errs[0]
if len(v.createErr) == 0 {
t.Errorf("unexpected error: %#v, none expected", err)
return
}
if !strings.Contains(err.Error(), v.createErr) {
t.Errorf("unexpected error: %v, expected: %s", err, v.createErr)
}
} else if len(v.createErr) != 0 {
t.Errorf("no error, expected %v", v.createErr)
return
}
oldSpec := v.cronJob.DeepCopy()
oldSpec.ResourceVersion = "1"
newSpec := v.cronJob.DeepCopy()
newSpec.ResourceVersion = "2"
if v.update != nil {
v.update(newSpec)
}
errs = ValidateCronJobUpdate(newSpec, oldSpec, corevalidation.PodValidationOptions{})
if len(errs) > 0 {
err := errs[0]
if len(v.updateErr) == 0 {
t.Errorf("unexpected error: %#v, none expected", err)
return
}
if !strings.Contains(err.Error(), v.updateErr) {
t.Errorf("unexpected error: %v, expected: %s", err, v.updateErr)
}
} else if len(v.updateErr) != 0 {
t.Errorf("no error, expected %v", v.updateErr)
return
}
})
}
}
func TestValidateCronJobSpec(t *testing.T) {
validPodTemplateSpec := getValidPodTemplateSpecForGenerated(getValidGeneratedSelector())
validPodTemplateSpec.Labels = map[string]string{}
type testCase struct {
old *batch.CronJobSpec
new *batch.CronJobSpec
expectErr bool
}
cases := map[string]testCase{
"no validation because timeZone is nil for old and new": {
old: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: nil,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
new: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: nil,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"check validation because timeZone is different for new": {
old: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: nil,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
new: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("America/New_York"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"check validation because timeZone is different for new and invalid": {
old: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: nil,
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
new: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("broken"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
expectErr: true,
},
"old timeZone and new timeZone are valid": {
old: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("America/New_York"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
new: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("America/Chicago"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"old timeZone is valid, but new timeZone is invalid": {
old: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("America/New_York"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
new: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("broken"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
expectErr: true,
},
"old timeZone and new timeZone are invalid, but unchanged": {
old: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("broken"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
new: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("broken"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
"old timeZone and new timeZone are invalid, but different": {
old: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("broken"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
new: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("still broken"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
expectErr: true,
},
"old timeZone is invalid, but new timeZone is valid": {
old: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("broken"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
new: &batch.CronJobSpec{
Schedule: "0 * * * *",
TimeZone: pointer.String("America/New_York"),
ConcurrencyPolicy: batch.AllowConcurrent,
JobTemplate: batch.JobTemplateSpec{
Spec: batch.JobSpec{
Template: validPodTemplateSpec,
},
},
},
},
}
for k, v := range cases {
errs := validateCronJobSpec(v.new, v.old, field.NewPath("spec"), corevalidation.PodValidationOptions{})
if len(errs) > 0 && !v.expectErr {
t.Errorf("unexpected error for %s: %v", k, errs)
} else if len(errs) == 0 && v.expectErr {
t.Errorf("expected error for %s but got nil", k)
}
}
}
func completionModePtr(m batch.CompletionMode) *batch.CompletionMode {
return &m
}
func TestTimeZones(t *testing.T) {
// all valid time zones as of go1.19 release on 2022-08-02
data := []string{
`Africa/Abidjan`,
`Africa/Accra`,
`Africa/Addis_Ababa`,
`Africa/Algiers`,
`Africa/Asmara`,
`Africa/Asmera`,
`Africa/Bamako`,
`Africa/Bangui`,
`Africa/Banjul`,
`Africa/Bissau`,
`Africa/Blantyre`,
`Africa/Brazzaville`,
`Africa/Bujumbura`,
`Africa/Cairo`,
`Africa/Casablanca`,
`Africa/Ceuta`,
`Africa/Conakry`,
`Africa/Dakar`,
`Africa/Dar_es_Salaam`,
`Africa/Djibouti`,
`Africa/Douala`,
`Africa/El_Aaiun`,
`Africa/Freetown`,
`Africa/Gaborone`,
`Africa/Harare`,
`Africa/Johannesburg`,
`Africa/Juba`,
`Africa/Kampala`,
`Africa/Khartoum`,
`Africa/Kigali`,
`Africa/Kinshasa`,
`Africa/Lagos`,
`Africa/Libreville`,
`Africa/Lome`,
`Africa/Luanda`,
`Africa/Lubumbashi`,
`Africa/Lusaka`,
`Africa/Malabo`,
`Africa/Maputo`,
`Africa/Maseru`,
`Africa/Mbabane`,
`Africa/Mogadishu`,
`Africa/Monrovia`,
`Africa/Nairobi`,
`Africa/Ndjamena`,
`Africa/Niamey`,
`Africa/Nouakchott`,
`Africa/Ouagadougou`,
`Africa/Porto-Novo`,
`Africa/Sao_Tome`,
`Africa/Timbuktu`,
`Africa/Tripoli`,
`Africa/Tunis`,
`Africa/Windhoek`,
`America/Adak`,
`America/Anchorage`,
`America/Anguilla`,
`America/Antigua`,
`America/Araguaina`,
`America/Argentina/Buenos_Aires`,
`America/Argentina/Catamarca`,
`America/Argentina/ComodRivadavia`,
`America/Argentina/Cordoba`,
`America/Argentina/Jujuy`,
`America/Argentina/La_Rioja`,
`America/Argentina/Mendoza`,
`America/Argentina/Rio_Gallegos`,
`America/Argentina/Salta`,
`America/Argentina/San_Juan`,
`America/Argentina/San_Luis`,
`America/Argentina/Tucuman`,
`America/Argentina/Ushuaia`,
`America/Aruba`,
`America/Asuncion`,
`America/Atikokan`,
`America/Atka`,
`America/Bahia`,
`America/Bahia_Banderas`,
`America/Barbados`,
`America/Belem`,
`America/Belize`,
`America/Blanc-Sablon`,
`America/Boa_Vista`,
`America/Bogota`,
`America/Boise`,
`America/Buenos_Aires`,
`America/Cambridge_Bay`,
`America/Campo_Grande`,
`America/Cancun`,
`America/Caracas`,
`America/Catamarca`,
`America/Cayenne`,
`America/Cayman`,
`America/Chicago`,
`America/Chihuahua`,
`America/Coral_Harbour`,
`America/Cordoba`,
`America/Costa_Rica`,
`America/Creston`,
`America/Cuiaba`,
`America/Curacao`,
`America/Danmarkshavn`,
`America/Dawson`,
`America/Dawson_Creek`,
`America/Denver`,
`America/Detroit`,
`America/Dominica`,
`America/Edmonton`,
`America/Eirunepe`,
`America/El_Salvador`,
`America/Ensenada`,
`America/Fort_Nelson`,
`America/Fort_Wayne`,
`America/Fortaleza`,
`America/Glace_Bay`,
`America/Godthab`,
`America/Goose_Bay`,
`America/Grand_Turk`,
`America/Grenada`,
`America/Guadeloupe`,
`America/Guatemala`,
`America/Guayaquil`,
`America/Guyana`,
`America/Halifax`,
`America/Havana`,
`America/Hermosillo`,
`America/Indiana/Indianapolis`,
`America/Indiana/Knox`,
`America/Indiana/Marengo`,
`America/Indiana/Petersburg`,
`America/Indiana/Tell_City`,
`America/Indiana/Vevay`,
`America/Indiana/Vincennes`,
`America/Indiana/Winamac`,
`America/Indianapolis`,
`America/Inuvik`,
`America/Iqaluit`,
`America/Jamaica`,
`America/Jujuy`,
`America/Juneau`,
`America/Kentucky/Louisville`,
`America/Kentucky/Monticello`,
`America/Knox_IN`,
`America/Kralendijk`,
`America/La_Paz`,
`America/Lima`,
`America/Los_Angeles`,
`America/Louisville`,
`America/Lower_Princes`,
`America/Maceio`,
`America/Managua`,
`America/Manaus`,
`America/Marigot`,
`America/Martinique`,
`America/Matamoros`,
`America/Mazatlan`,
`America/Mendoza`,
`America/Menominee`,
`America/Merida`,
`America/Metlakatla`,
`America/Mexico_City`,
`America/Miquelon`,
`America/Moncton`,
`America/Monterrey`,
`America/Montevideo`,
`America/Montreal`,
`America/Montserrat`,
`America/Nassau`,
`America/New_York`,
`America/Nipigon`,
`America/Nome`,
`America/Noronha`,
`America/North_Dakota/Beulah`,
`America/North_Dakota/Center`,
`America/North_Dakota/New_Salem`,
`America/Nuuk`,
`America/Ojinaga`,
`America/Panama`,
`America/Pangnirtung`,
`America/Paramaribo`,
`America/Phoenix`,
`America/Port-au-Prince`,
`America/Port_of_Spain`,
`America/Porto_Acre`,
`America/Porto_Velho`,
`America/Puerto_Rico`,
`America/Punta_Arenas`,
`America/Rainy_River`,
`America/Rankin_Inlet`,
`America/Recife`,
`America/Regina`,
`America/Resolute`,
`America/Rio_Branco`,
`America/Rosario`,
`America/Santa_Isabel`,
`America/Santarem`,
`America/Santiago`,
`America/Santo_Domingo`,
`America/Sao_Paulo`,
`America/Scoresbysund`,
`America/Shiprock`,
`America/Sitka`,
`America/St_Barthelemy`,
`America/St_Johns`,
`America/St_Kitts`,
`America/St_Lucia`,
`America/St_Thomas`,
`America/St_Vincent`,
`America/Swift_Current`,
`America/Tegucigalpa`,
`America/Thule`,
`America/Thunder_Bay`,
`America/Tijuana`,
`America/Toronto`,
`America/Tortola`,
`America/Vancouver`,
`America/Virgin`,
`America/Whitehorse`,
`America/Winnipeg`,
`America/Yakutat`,
`America/Yellowknife`,
`Antarctica/Casey`,
`Antarctica/Davis`,
`Antarctica/DumontDUrville`,
`Antarctica/Macquarie`,
`Antarctica/Mawson`,
`Antarctica/McMurdo`,
`Antarctica/Palmer`,
`Antarctica/Rothera`,
`Antarctica/South_Pole`,
`Antarctica/Syowa`,
`Antarctica/Troll`,
`Antarctica/Vostok`,
`Arctic/Longyearbyen`,
`Asia/Aden`,
`Asia/Almaty`,
`Asia/Amman`,
`Asia/Anadyr`,
`Asia/Aqtau`,
`Asia/Aqtobe`,
`Asia/Ashgabat`,
`Asia/Ashkhabad`,
`Asia/Atyrau`,
`Asia/Baghdad`,
`Asia/Bahrain`,
`Asia/Baku`,
`Asia/Bangkok`,
`Asia/Barnaul`,
`Asia/Beirut`,
`Asia/Bishkek`,
`Asia/Brunei`,
`Asia/Calcutta`,
`Asia/Chita`,
`Asia/Choibalsan`,
`Asia/Chongqing`,
`Asia/Chungking`,
`Asia/Colombo`,
`Asia/Dacca`,
`Asia/Damascus`,
`Asia/Dhaka`,
`Asia/Dili`,
`Asia/Dubai`,
`Asia/Dushanbe`,
`Asia/Famagusta`,
`Asia/Gaza`,
`Asia/Harbin`,
`Asia/Hebron`,
`Asia/Ho_Chi_Minh`,
`Asia/Hong_Kong`,
`Asia/Hovd`,
`Asia/Irkutsk`,
`Asia/Istanbul`,
`Asia/Jakarta`,
`Asia/Jayapura`,
`Asia/Jerusalem`,
`Asia/Kabul`,
`Asia/Kamchatka`,
`Asia/Karachi`,
`Asia/Kashgar`,
`Asia/Kathmandu`,
`Asia/Katmandu`,
`Asia/Khandyga`,
`Asia/Kolkata`,
`Asia/Krasnoyarsk`,
`Asia/Kuala_Lumpur`,
`Asia/Kuching`,
`Asia/Kuwait`,
`Asia/Macao`,
`Asia/Macau`,
`Asia/Magadan`,
`Asia/Makassar`,
`Asia/Manila`,
`Asia/Muscat`,
`Asia/Nicosia`,
`Asia/Novokuznetsk`,
`Asia/Novosibirsk`,
`Asia/Omsk`,
`Asia/Oral`,
`Asia/Phnom_Penh`,
`Asia/Pontianak`,
`Asia/Pyongyang`,
`Asia/Qatar`,
`Asia/Qostanay`,
`Asia/Qyzylorda`,
`Asia/Rangoon`,
`Asia/Riyadh`,
`Asia/Saigon`,
`Asia/Sakhalin`,
`Asia/Samarkand`,
`Asia/Seoul`,
`Asia/Shanghai`,
`Asia/Singapore`,
`Asia/Srednekolymsk`,
`Asia/Taipei`,
`Asia/Tashkent`,
`Asia/Tbilisi`,
`Asia/Tehran`,
`Asia/Tel_Aviv`,
`Asia/Thimbu`,
`Asia/Thimphu`,
`Asia/Tokyo`,
`Asia/Tomsk`,
`Asia/Ujung_Pandang`,
`Asia/Ulaanbaatar`,
`Asia/Ulan_Bator`,
`Asia/Urumqi`,
`Asia/Ust-Nera`,
`Asia/Vientiane`,
`Asia/Vladivostok`,
`Asia/Yakutsk`,
`Asia/Yangon`,
`Asia/Yekaterinburg`,
`Asia/Yerevan`,
`Atlantic/Azores`,
`Atlantic/Bermuda`,
`Atlantic/Canary`,
`Atlantic/Cape_Verde`,
`Atlantic/Faeroe`,
`Atlantic/Faroe`,
`Atlantic/Jan_Mayen`,
`Atlantic/Madeira`,
`Atlantic/Reykjavik`,
`Atlantic/South_Georgia`,
`Atlantic/St_Helena`,
`Atlantic/Stanley`,
`Australia/ACT`,
`Australia/Adelaide`,
`Australia/Brisbane`,
`Australia/Broken_Hill`,
`Australia/Canberra`,
`Australia/Currie`,
`Australia/Darwin`,
`Australia/Eucla`,
`Australia/Hobart`,
`Australia/LHI`,
`Australia/Lindeman`,
`Australia/Lord_Howe`,
`Australia/Melbourne`,
`Australia/North`,
`Australia/NSW`,
`Australia/Perth`,
`Australia/Queensland`,
`Australia/South`,
`Australia/Sydney`,
`Australia/Tasmania`,
`Australia/Victoria`,
`Australia/West`,
`Australia/Yancowinna`,
`Brazil/Acre`,
`Brazil/DeNoronha`,
`Brazil/East`,
`Brazil/West`,
`Canada/Atlantic`,
`Canada/Central`,
`Canada/Eastern`,
`Canada/Mountain`,
`Canada/Newfoundland`,
`Canada/Pacific`,
`Canada/Saskatchewan`,
`Canada/Yukon`,
`CET`,
`Chile/Continental`,
`Chile/EasterIsland`,
`CST6CDT`,
`Cuba`,
`EET`,
`Egypt`,
`Eire`,
`EST`,
`EST5EDT`,
`Etc/GMT`,
`Etc/GMT+0`,
`Etc/GMT+1`,
`Etc/GMT+10`,
`Etc/GMT+11`,
`Etc/GMT+12`,
`Etc/GMT+2`,
`Etc/GMT+3`,
`Etc/GMT+4`,
`Etc/GMT+5`,
`Etc/GMT+6`,
`Etc/GMT+7`,
`Etc/GMT+8`,
`Etc/GMT+9`,
`Etc/GMT-0`,
`Etc/GMT-1`,
`Etc/GMT-10`,
`Etc/GMT-11`,
`Etc/GMT-12`,
`Etc/GMT-13`,
`Etc/GMT-14`,
`Etc/GMT-2`,
`Etc/GMT-3`,
`Etc/GMT-4`,
`Etc/GMT-5`,
`Etc/GMT-6`,
`Etc/GMT-7`,
`Etc/GMT-8`,
`Etc/GMT-9`,
`Etc/GMT0`,
`Etc/Greenwich`,
`Etc/UCT`,
`Etc/Universal`,
`Etc/UTC`,
`Etc/Zulu`,
`Europe/Amsterdam`,
`Europe/Andorra`,
`Europe/Astrakhan`,
`Europe/Athens`,
`Europe/Belfast`,
`Europe/Belgrade`,
`Europe/Berlin`,
`Europe/Bratislava`,
`Europe/Brussels`,
`Europe/Bucharest`,
`Europe/Budapest`,
`Europe/Busingen`,
`Europe/Chisinau`,
`Europe/Copenhagen`,
`Europe/Dublin`,
`Europe/Gibraltar`,
`Europe/Guernsey`,
`Europe/Helsinki`,
`Europe/Isle_of_Man`,
`Europe/Istanbul`,
`Europe/Jersey`,
`Europe/Kaliningrad`,
`Europe/Kiev`,
`Europe/Kirov`,
`Europe/Lisbon`,
`Europe/Ljubljana`,
`Europe/London`,
`Europe/Luxembourg`,
`Europe/Madrid`,
`Europe/Malta`,
`Europe/Mariehamn`,
`Europe/Minsk`,
`Europe/Monaco`,
`Europe/Moscow`,
`Europe/Nicosia`,
`Europe/Oslo`,
`Europe/Paris`,
`Europe/Podgorica`,
`Europe/Prague`,
`Europe/Riga`,
`Europe/Rome`,
`Europe/Samara`,
`Europe/San_Marino`,
`Europe/Sarajevo`,
`Europe/Saratov`,
`Europe/Simferopol`,
`Europe/Skopje`,
`Europe/Sofia`,
`Europe/Stockholm`,
`Europe/Tallinn`,
`Europe/Tirane`,
`Europe/Tiraspol`,
`Europe/Ulyanovsk`,
`Europe/Uzhgorod`,
`Europe/Vaduz`,
`Europe/Vatican`,
`Europe/Vienna`,
`Europe/Vilnius`,
`Europe/Volgograd`,
`Europe/Warsaw`,
`Europe/Zagreb`,
`Europe/Zaporozhye`,
`Europe/Zurich`,
`Factory`,
`GB`,
`GB-Eire`,
`GMT`,
`GMT+0`,
`GMT-0`,
`GMT0`,
`Greenwich`,
`Hongkong`,
`HST`,
`Iceland`,
`Indian/Antananarivo`,
`Indian/Chagos`,
`Indian/Christmas`,
`Indian/Cocos`,
`Indian/Comoro`,
`Indian/Kerguelen`,
`Indian/Mahe`,
`Indian/Maldives`,
`Indian/Mauritius`,
`Indian/Mayotte`,
`Indian/Reunion`,
`Iran`,
`Israel`,
`Jamaica`,
`Japan`,
`Kwajalein`,
`Libya`,
`MET`,
`Mexico/BajaNorte`,
`Mexico/BajaSur`,
`Mexico/General`,
`MST`,
`MST7MDT`,
`Navajo`,
`NZ`,
`NZ-CHAT`,
`Pacific/Apia`,
`Pacific/Auckland`,
`Pacific/Bougainville`,
`Pacific/Chatham`,
`Pacific/Chuuk`,
`Pacific/Easter`,
`Pacific/Efate`,
`Pacific/Enderbury`,
`Pacific/Fakaofo`,
`Pacific/Fiji`,
`Pacific/Funafuti`,
`Pacific/Galapagos`,
`Pacific/Gambier`,
`Pacific/Guadalcanal`,
`Pacific/Guam`,
`Pacific/Honolulu`,
`Pacific/Johnston`,
`Pacific/Kanton`,
`Pacific/Kiritimati`,
`Pacific/Kosrae`,
`Pacific/Kwajalein`,
`Pacific/Majuro`,
`Pacific/Marquesas`,
`Pacific/Midway`,
`Pacific/Nauru`,
`Pacific/Niue`,
`Pacific/Norfolk`,
`Pacific/Noumea`,
`Pacific/Pago_Pago`,
`Pacific/Palau`,
`Pacific/Pitcairn`,
`Pacific/Pohnpei`,
`Pacific/Ponape`,
`Pacific/Port_Moresby`,
`Pacific/Rarotonga`,
`Pacific/Saipan`,
`Pacific/Samoa`,
`Pacific/Tahiti`,
`Pacific/Tarawa`,
`Pacific/Tongatapu`,
`Pacific/Truk`,
`Pacific/Wake`,
`Pacific/Wallis`,
`Pacific/Yap`,
`Poland`,
`Portugal`,
`PRC`,
`PST8PDT`,
`ROC`,
`ROK`,
`Singapore`,
`Turkey`,
`UCT`,
`Universal`,
`US/Alaska`,
`US/Aleutian`,
`US/Arizona`,
`US/Central`,
`US/East-Indiana`,
`US/Eastern`,
`US/Hawaii`,
`US/Indiana-Starke`,
`US/Michigan`,
`US/Mountain`,
`US/Pacific`,
`US/Samoa`,
`UTC`,
`W-SU`,
`WET`,
`Zulu`,
}
for _, tz := range data {
errs := validateTimeZone(&tz, nil)
if len(errs) > 0 {
t.Errorf("%s failed: %v", tz, errs)
}
}
}
func TestValidateIndexesString(t *testing.T) {
testCases := map[string]struct {
indexesString string
completions int32
wantTotal int32
wantError error
}{
"empty is valid": {
indexesString: "",
completions: 6,
wantTotal: 0,
},
"single number is valid": {
indexesString: "1",
completions: 6,
wantTotal: 1,
},
"single interval is valid": {
indexesString: "1-3",
completions: 6,
wantTotal: 3,
},
"mixed intervals valid": {
indexesString: "0,1-3,5,7-10",
completions: 12,
wantTotal: 9,
},
"invalid due to extra space": {
indexesString: "0,1-3, 5",
completions: 6,
wantTotal: 0,
wantError: errors.New(`cannot convert string to integer for index: " 5"`),
},
"invalid due to too large index": {
indexesString: "0,1-3,5",
completions: 5,
wantTotal: 0,
wantError: errors.New(`too large index: "5"`),
},
"invalid due to non-increasing order of intervals": {
indexesString: "1-3,0,5",
completions: 6,
wantTotal: 0,
wantError: errors.New(`non-increasing order, previous: 3, current: 0`),
},
"invalid due to non-increasing order between intervals": {
indexesString: "0,0,5",
completions: 6,
wantTotal: 0,
wantError: errors.New(`non-increasing order, previous: 0, current: 0`),
},
"invalid due to non-increasing order within interval": {
indexesString: "0,1-1,5",
completions: 6,
wantTotal: 0,
wantError: errors.New(`non-increasing order, previous: 1, current: 1`),
},
"invalid due to starting with '-'": {
indexesString: "-1,0",
completions: 6,
wantTotal: 0,
wantError: errors.New(`cannot convert string to integer for index: ""`),
},
"invalid due to ending with '-'": {
indexesString: "0,1-",
completions: 6,
wantTotal: 0,
wantError: errors.New(`cannot convert string to integer for index: ""`),
},
"invalid due to repeated '-'": {
indexesString: "0,1--3",
completions: 6,
wantTotal: 0,
wantError: errors.New(`the fragment "1--3" violates the requirement that an index interval can have at most two parts separated by '-'`),
},
"invalid due to repeated ','": {
indexesString: "0,,1,3",
completions: 6,
wantTotal: 0,
wantError: errors.New(`cannot convert string to integer for index: ""`),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
gotTotal, gotErr := validateIndexesFormat(tc.indexesString, tc.completions)
if tc.wantError == nil && gotErr != nil {
t.Errorf("unexpected error: %s", gotErr)
} else if tc.wantError != nil && gotErr == nil {
t.Errorf("missing error: %s", tc.wantError)
} else if tc.wantError != nil && gotErr != nil {
if diff := cmp.Diff(tc.wantError.Error(), gotErr.Error()); diff != "" {
t.Errorf("unexpected error, diff: %s", diff)
}
}
if tc.wantTotal != gotTotal {
t.Errorf("unexpected total want:%d, got:%d", tc.wantTotal, gotTotal)
}
})
}
}
func TestValidateFailedIndexesNotOverlapCompleted(t *testing.T) {
testCases := map[string]struct {
completedIndexesStr string
failedIndexesStr string
completions int32
wantError error
}{
"empty intervals": {
completedIndexesStr: "",
failedIndexesStr: "",
completions: 6,
},
"empty completed intervals": {
completedIndexesStr: "",
failedIndexesStr: "1-3",
completions: 6,
},
"empty failed intervals": {
completedIndexesStr: "1-2",
failedIndexesStr: "",
completions: 6,
},
"non-overlapping intervals": {
completedIndexesStr: "0,2-4,6-8,12-19",
failedIndexesStr: "1,9-10",
completions: 20,
},
"overlapping intervals": {
completedIndexesStr: "0,2-4,6-8,12-19",
failedIndexesStr: "1,8,9-10",
completions: 20,
wantError: errors.New("failedIndexes and completedIndexes overlap at index: 8"),
},
"overlapping intervals, corrupted completed interval skipped": {
completedIndexesStr: "0,2-4,x,6-8,12-19",
failedIndexesStr: "1,8,9-10",
completions: 20,
wantError: errors.New("failedIndexes and completedIndexes overlap at index: 8"),
},
"overlapping intervals, corrupted failed interval skipped": {
completedIndexesStr: "0,2-4,6-8,12-19",
failedIndexesStr: "1,y,8,9-10",
completions: 20,
wantError: errors.New("failedIndexes and completedIndexes overlap at index: 8"),
},
"overlapping intervals, first corrupted intervals skipped": {
completedIndexesStr: "x,0,2-4,6-8,12-19",
failedIndexesStr: "y,1,8,9-10",
completions: 20,
wantError: errors.New("failedIndexes and completedIndexes overlap at index: 8"),
},
"non-overlapping intervals, last intervals corrupted": {
completedIndexesStr: "0,2-4,6-8,12-19,x",
failedIndexesStr: "1,9-10,y",
completions: 20,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
gotErr := validateFailedIndexesNotOverlapCompleted(tc.completedIndexesStr, tc.failedIndexesStr, tc.completions)
if tc.wantError == nil && gotErr != nil {
t.Errorf("unexpected error: %s", gotErr)
} else if tc.wantError != nil && gotErr == nil {
t.Errorf("missing error: %s", tc.wantError)
} else if tc.wantError != nil && gotErr != nil {
if diff := cmp.Diff(tc.wantError.Error(), gotErr.Error()); diff != "" {
t.Errorf("unexpected error, diff: %s", diff)
}
}
})
}
}