storage_test.go

Documentation: k8s.io/kubernetes/pkg/registry/resource/resourceclaimtemplate/storage

     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:          "resourceclaimtemplates",
    41  	}
    42  	resourceClaimTemplateStorage, err := NewREST(restOptions)
    43  	if err != nil {
    44  		t.Fatalf("unexpected error from REST storage: %v", err)
    45  	}
    46  	return resourceClaimTemplateStorage, server
    47  }
    48  
    49  func validNewClaimTemplate(name string) *resource.ResourceClaimTemplate {
    50  	return &resource.ResourceClaimTemplate{
    51  		ObjectMeta: metav1.ObjectMeta{
    52  			Name:      name,
    53  			Namespace: metav1.NamespaceDefault,
    54  		},
    55  		Spec: resource.ResourceClaimTemplateSpec{
    56  			Spec: resource.ResourceClaimSpec{
    57  				ResourceClassName: "valid-class",
    58  				AllocationMode:    resource.AllocationModeImmediate,
    59  			},
    60  		},
    61  	}
    62  }
    63  
    64  func TestCreate(t *testing.T) {
    65  	storage, server := newStorage(t)
    66  	defer server.Terminate(t)
    67  	defer storage.Store.DestroyFunc()
    68  	test := genericregistrytest.New(t, storage.Store)
    69  	resourceClaimTemplate := validNewClaimTemplate("foo")
    70  	resourceClaimTemplate.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
    71  	test.TestCreate(
    72  		// valid
    73  		resourceClaimTemplate,
    74  		// invalid
    75  		&resource.ResourceClaimTemplate{
    76  			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
    77  		},
    78  	)
    79  }
    80  
    81  func TestUpdate(t *testing.T) {
    82  	storage, server := newStorage(t)
    83  	defer server.Terminate(t)
    84  	defer storage.Store.DestroyFunc()
    85  	test := genericregistrytest.New(t, storage.Store)
    86  	test.TestUpdate(
    87  		// valid
    88  		validNewClaimTemplate("foo"),
    89  		// updateFunc
    90  		func(obj runtime.Object) runtime.Object {
    91  			object := obj.(*resource.ResourceClaimTemplate)
    92  			object.Labels = map[string]string{"a": "b"}
    93  			return object
    94  		},
    95  		//invalid update
    96  		func(obj runtime.Object) runtime.Object {
    97  			object := obj.(*resource.ResourceClaimTemplate)
    98  			object.Spec.Spec.ResourceClassName = ""
    99  			return object
   100  		},
   101  	)
   102  
   103  }
   104  
   105  func TestDelete(t *testing.T) {
   106  	storage, server := newStorage(t)
   107  	defer server.Terminate(t)
   108  	defer storage.Store.DestroyFunc()
   109  	test := genericregistrytest.New(t, storage.Store).ReturnDeletedObject()
   110  	test.TestDelete(validNewClaimTemplate("foo"))
   111  }
   112  
   113  func TestGet(t *testing.T) {
   114  	storage, server := newStorage(t)
   115  	defer server.Terminate(t)
   116  	defer storage.Store.DestroyFunc()
   117  	test := genericregistrytest.New(t, storage.Store)
   118  	test.TestGet(validNewClaimTemplate("foo"))
   119  }
   120  
   121  func TestList(t *testing.T) {
   122  	storage, server := newStorage(t)
   123  	defer server.Terminate(t)
   124  	defer storage.Store.DestroyFunc()
   125  	test := genericregistrytest.New(t, storage.Store)
   126  	test.TestList(validNewClaimTemplate("foo"))
   127  }
   128  
   129  func TestWatch(t *testing.T) {
   130  	storage, server := newStorage(t)
   131  	defer server.Terminate(t)
   132  	defer storage.Store.DestroyFunc()
   133  	test := genericregistrytest.New(t, storage.Store)
   134  	test.TestWatch(
   135  		validNewClaimTemplate("foo"),
   136  		// matching labels
   137  		[]labels.Set{},
   138  		// not matching labels
   139  		[]labels.Set{
   140  			{"foo": "bar"},
   141  		},
   142  		// matching fields
   143  		[]fields.Set{
   144  			{"metadata.name": "foo"},
   145  		},
   146  		// not matching fields
   147  		[]fields.Set{
   148  			{"metadata.name": "bar"},
   149  		},
   150  	)
   151  }
   152
View as plain text