k8s.io/kubernetes@v1.31.0-alpha.0.0.20240520171757-56147500dadc/pkg/registry/batch/cronjob/storage/storage_test.go (about)

     1  /*
     2  Copyright 2016 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package storage
    18  
    19  import (
    20  	"testing"
    21  
    22  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    23  	"k8s.io/apimachinery/pkg/fields"
    24  	"k8s.io/apimachinery/pkg/labels"
    25  	"k8s.io/apimachinery/pkg/runtime"
    26  	"k8s.io/apiserver/pkg/registry/generic"
    27  	genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
    28  	etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing"
    29  	"k8s.io/kubernetes/pkg/apis/batch"
    30  	api "k8s.io/kubernetes/pkg/apis/core"
    31  	"k8s.io/kubernetes/pkg/registry/registrytest"
    32  )
    33  
    34  // TODO: allow for global factory override
    35  func newStorage(t *testing.T) (*REST, *StatusREST, *etcd3testing.EtcdTestServer) {
    36  	etcdStorage, server := registrytest.NewEtcdStorageForResource(t, batch.SchemeGroupVersion.WithResource("cronjobs").GroupResource())
    37  	restOptions := generic.RESTOptions{
    38  		StorageConfig:           etcdStorage,
    39  		Decorator:               generic.UndecoratedStorage,
    40  		DeleteCollectionWorkers: 1,
    41  		ResourcePrefix:          "cronjobs",
    42  	}
    43  	storage, statusStorage, err := NewREST(restOptions)
    44  	if err != nil {
    45  		t.Fatalf("unexpected error from REST storage: %v", err)
    46  	}
    47  	return storage, statusStorage, server
    48  }
    49  
    50  func validNewCronJob() *batch.CronJob {
    51  	return &batch.CronJob{
    52  		ObjectMeta: metav1.ObjectMeta{
    53  			Name:      "foo",
    54  			Namespace: metav1.NamespaceDefault,
    55  		},
    56  		Spec: batch.CronJobSpec{
    57  			Schedule:          "* * * * ?",
    58  			ConcurrencyPolicy: batch.AllowConcurrent,
    59  			JobTemplate: batch.JobTemplateSpec{
    60  				Spec: batch.JobSpec{
    61  					Template: api.PodTemplateSpec{
    62  						Spec: api.PodSpec{
    63  							RestartPolicy: api.RestartPolicyOnFailure,
    64  							DNSPolicy:     api.DNSClusterFirst,
    65  							Containers: []api.Container{{
    66  								Name: "abc", Image: "image",
    67  								ImagePullPolicy:          api.PullIfNotPresent,
    68  								TerminationMessagePolicy: api.TerminationMessageReadFile,
    69  							}},
    70  						},
    71  					},
    72  				},
    73  			},
    74  		},
    75  	}
    76  }
    77  
    78  func TestCreate(t *testing.T) {
    79  	storage, _, server := newStorage(t)
    80  	defer server.Terminate(t)
    81  	defer storage.Store.DestroyFunc()
    82  	test := genericregistrytest.New(t, storage.Store)
    83  	validCronJob := validNewCronJob()
    84  	validCronJob.ObjectMeta = metav1.ObjectMeta{}
    85  	test.TestCreate(
    86  		// valid
    87  		validCronJob,
    88  		// invalid (empty spec)
    89  		&batch.CronJob{
    90  			Spec: batch.CronJobSpec{},
    91  		},
    92  	)
    93  }
    94  
    95  func TestUpdate(t *testing.T) {
    96  	storage, _, server := newStorage(t)
    97  	defer server.Terminate(t)
    98  	defer storage.Store.DestroyFunc()
    99  	test := genericregistrytest.New(t, storage.Store)
   100  	schedule := "1 1 1 1 ?"
   101  	test.TestUpdate(
   102  		// valid
   103  		validNewCronJob(),
   104  		// updateFunc
   105  		func(obj runtime.Object) runtime.Object {
   106  			object := obj.(*batch.CronJob)
   107  			object.Spec.Schedule = schedule
   108  			return object
   109  		},
   110  		// invalid updateFunc
   111  		func(obj runtime.Object) runtime.Object {
   112  			object := obj.(*batch.CronJob)
   113  			object.Spec.Schedule = "* * *"
   114  			return object
   115  		},
   116  	)
   117  }
   118  
   119  func TestDelete(t *testing.T) {
   120  	storage, _, server := newStorage(t)
   121  	defer server.Terminate(t)
   122  	defer storage.Store.DestroyFunc()
   123  	test := genericregistrytest.New(t, storage.Store)
   124  	test.TestDelete(validNewCronJob())
   125  }
   126  
   127  func TestGet(t *testing.T) {
   128  	storage, _, server := newStorage(t)
   129  	defer server.Terminate(t)
   130  	defer storage.Store.DestroyFunc()
   131  	test := genericregistrytest.New(t, storage.Store)
   132  	test.TestGet(validNewCronJob())
   133  }
   134  
   135  func TestList(t *testing.T) {
   136  	storage, _, server := newStorage(t)
   137  	defer server.Terminate(t)
   138  	defer storage.Store.DestroyFunc()
   139  	test := genericregistrytest.New(t, storage.Store)
   140  	test.TestList(validNewCronJob())
   141  }
   142  
   143  func TestWatch(t *testing.T) {
   144  	storage, _, server := newStorage(t)
   145  	defer server.Terminate(t)
   146  	defer storage.Store.DestroyFunc()
   147  	test := genericregistrytest.New(t, storage.Store)
   148  	test.TestWatch(
   149  		validNewCronJob(),
   150  		// matching labels
   151  		[]labels.Set{},
   152  		// not matching labels
   153  		[]labels.Set{
   154  			{"x": "y"},
   155  		},
   156  		// matching fields
   157  		[]fields.Set{},
   158  		// not matching fields
   159  		[]fields.Set{
   160  			{"metadata.name": "xyz"},
   161  			{"name": "foo"},
   162  		},
   163  	)
   164  }
   165  
   166  // TODO: test update /status