k8s.io/kubernetes@v1.29.3/pkg/registry/resource/resourceclass/storage/storage_test.go (about)

     1  /*
     2  Copyright 2022 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/resource"
    30  	_ "k8s.io/kubernetes/pkg/apis/resource/install"
    31  	"k8s.io/kubernetes/pkg/registry/registrytest"
    32  )
    33  
    34  func newStorage(t *testing.T) (*REST, *etcd3testing.EtcdTestServer) {
    35  	etcdStorage, server := registrytest.NewEtcdStorage(t, resource.GroupName)
    36  	restOptions := generic.RESTOptions{
    37  		StorageConfig:           etcdStorage,
    38  		Decorator:               generic.UndecoratedStorage,
    39  		DeleteCollectionWorkers: 1,
    40  		ResourcePrefix:          "resourceclasses",
    41  	}
    42  	resourceClassStorage, err := NewREST(restOptions)
    43  	if err != nil {
    44  		t.Fatalf("unexpected error from REST storage: %v", err)
    45  	}
    46  	return resourceClassStorage, server
    47  }
    48  
    49  func validNewClass(name string) *resource.ResourceClass {
    50  	return &resource.ResourceClass{
    51  		ObjectMeta: metav1.ObjectMeta{
    52  			Name: name,
    53  		},
    54  		DriverName: "cdi.example.com",
    55  	}
    56  }
    57  
    58  func TestCreate(t *testing.T) {
    59  	storage, server := newStorage(t)
    60  	defer server.Terminate(t)
    61  	defer storage.Store.DestroyFunc()
    62  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
    63  	resourceClass := validNewClass("foo")
    64  	resourceClass.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
    65  	test.TestCreate(
    66  		// valid
    67  		resourceClass,
    68  		// invalid
    69  		&resource.ResourceClass{
    70  			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
    71  		},
    72  	)
    73  }
    74  
    75  func TestUpdate(t *testing.T) {
    76  	storage, server := newStorage(t)
    77  	defer server.Terminate(t)
    78  	defer storage.Store.DestroyFunc()
    79  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
    80  	test.TestUpdate(
    81  		// valid
    82  		validNewClass("foo"),
    83  		// updateFunc
    84  		func(obj runtime.Object) runtime.Object {
    85  			object := obj.(*resource.ResourceClass)
    86  			object.ParametersRef = &resource.ResourceClassParametersReference{Kind: "cdiexample", Name: "some-name"}
    87  			return object
    88  		},
    89  		//invalid update
    90  		func(obj runtime.Object) runtime.Object {
    91  			object := obj.(*resource.ResourceClass)
    92  			object.DriverName = ""
    93  			return object
    94  		},
    95  	)
    96  
    97  }
    98  
    99  func TestDelete(t *testing.T) {
   100  	storage, server := newStorage(t)
   101  	defer server.Terminate(t)
   102  	defer storage.Store.DestroyFunc()
   103  	test := genericregistrytest.New(t, storage.Store).ClusterScope().ReturnDeletedObject()
   104  	test.TestDelete(validNewClass("foo"))
   105  }
   106  
   107  func TestGet(t *testing.T) {
   108  	storage, server := newStorage(t)
   109  	defer server.Terminate(t)
   110  	defer storage.Store.DestroyFunc()
   111  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
   112  	test.TestGet(validNewClass("foo"))
   113  }
   114  
   115  func TestList(t *testing.T) {
   116  	storage, server := newStorage(t)
   117  	defer server.Terminate(t)
   118  	defer storage.Store.DestroyFunc()
   119  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
   120  	test.TestList(validNewClass("foo"))
   121  }
   122  
   123  func TestWatch(t *testing.T) {
   124  	storage, server := newStorage(t)
   125  	defer server.Terminate(t)
   126  	defer storage.Store.DestroyFunc()
   127  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
   128  	test.TestWatch(
   129  		validNewClass("foo"),
   130  		// matching labels
   131  		[]labels.Set{},
   132  		// not matching labels
   133  		[]labels.Set{
   134  			{"foo": "bar"},
   135  		},
   136  		// matching fields
   137  		[]fields.Set{
   138  			{"metadata.name": "foo"},
   139  		},
   140  		// not matching fields
   141  		[]fields.Set{
   142  			{"metadata.name": "bar"},
   143  		},
   144  	)
   145  }