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

     1  /*
     2  Copyright 2014 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  	"k8s.io/apimachinery/pkg/api/resource"
    23  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    24  	"k8s.io/apimachinery/pkg/fields"
    25  	"k8s.io/apimachinery/pkg/labels"
    26  	"k8s.io/apimachinery/pkg/runtime"
    27  	"k8s.io/apiserver/pkg/registry/generic"
    28  	genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
    29  	etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing"
    30  	api "k8s.io/kubernetes/pkg/apis/core"
    31  	_ "k8s.io/kubernetes/pkg/apis/core/install"
    32  	"k8s.io/kubernetes/pkg/registry/registrytest"
    33  )
    34  
    35  func newStorage(t *testing.T) (*REST, *etcd3testing.EtcdTestServer) {
    36  	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
    37  	restOptions := generic.RESTOptions{
    38  		StorageConfig:           etcdStorage,
    39  		Decorator:               generic.UndecoratedStorage,
    40  		DeleteCollectionWorkers: 1,
    41  		ResourcePrefix:          "limitranges",
    42  	}
    43  	rest, err := NewREST(restOptions)
    44  	if err != nil {
    45  		t.Fatalf("unexpected error from REST storage: %v", err)
    46  	}
    47  	return rest, server
    48  }
    49  
    50  func validNewLimitRange() *api.LimitRange {
    51  	return &api.LimitRange{
    52  		ObjectMeta: metav1.ObjectMeta{
    53  			Name:      "foo",
    54  			Namespace: metav1.NamespaceDefault,
    55  		},
    56  		Spec: api.LimitRangeSpec{
    57  			Limits: []api.LimitRangeItem{
    58  				{
    59  					Type: api.LimitTypePod,
    60  					Max: api.ResourceList{
    61  						api.ResourceCPU:    resource.MustParse("100"),
    62  						api.ResourceMemory: resource.MustParse("10000"),
    63  					},
    64  					Min: api.ResourceList{
    65  						api.ResourceCPU:    resource.MustParse("0"),
    66  						api.ResourceMemory: resource.MustParse("100"),
    67  					},
    68  				},
    69  			},
    70  		},
    71  	}
    72  }
    73  
    74  func TestCreate(t *testing.T) {
    75  	storage, server := newStorage(t)
    76  	defer server.Terminate(t)
    77  	defer storage.Store.DestroyFunc()
    78  	test := genericregistrytest.New(t, storage.Store).GeneratesName()
    79  	validLimitRange := validNewLimitRange()
    80  	validLimitRange.ObjectMeta = metav1.ObjectMeta{}
    81  	test.TestCreate(
    82  		// valid
    83  		validLimitRange,
    84  		// invalid
    85  		&api.LimitRange{
    86  			ObjectMeta: metav1.ObjectMeta{Name: "_-a123-a_"},
    87  		},
    88  	)
    89  }
    90  
    91  func TestUpdate(t *testing.T) {
    92  	storage, server := newStorage(t)
    93  	defer server.Terminate(t)
    94  	defer storage.Store.DestroyFunc()
    95  	test := genericregistrytest.New(t, storage.Store).AllowCreateOnUpdate()
    96  	test.TestUpdate(
    97  		// valid
    98  		validNewLimitRange(),
    99  		// updateFunc
   100  		func(obj runtime.Object) runtime.Object {
   101  			object := obj.(*api.LimitRange)
   102  			object.Spec.Limits = []api.LimitRangeItem{
   103  				{
   104  					Type: api.LimitTypePod,
   105  					Max: api.ResourceList{
   106  						api.ResourceCPU:    resource.MustParse("1000"),
   107  						api.ResourceMemory: resource.MustParse("100000"),
   108  					},
   109  					Min: api.ResourceList{
   110  						api.ResourceCPU:    resource.MustParse("10"),
   111  						api.ResourceMemory: resource.MustParse("1000"),
   112  					},
   113  				},
   114  			}
   115  			return object
   116  		},
   117  	)
   118  }
   119  
   120  func TestDelete(t *testing.T) {
   121  	storage, server := newStorage(t)
   122  	defer server.Terminate(t)
   123  	defer storage.Store.DestroyFunc()
   124  	test := genericregistrytest.New(t, storage.Store)
   125  	test.TestDelete(validNewLimitRange())
   126  }
   127  
   128  func TestGet(t *testing.T) {
   129  	storage, server := newStorage(t)
   130  	defer server.Terminate(t)
   131  	defer storage.Store.DestroyFunc()
   132  	test := genericregistrytest.New(t, storage.Store)
   133  	test.TestGet(validNewLimitRange())
   134  }
   135  
   136  func TestList(t *testing.T) {
   137  	storage, server := newStorage(t)
   138  	defer server.Terminate(t)
   139  	defer storage.Store.DestroyFunc()
   140  	test := genericregistrytest.New(t, storage.Store)
   141  	test.TestList(validNewLimitRange())
   142  }
   143  
   144  func TestWatch(t *testing.T) {
   145  	storage, server := newStorage(t)
   146  	defer server.Terminate(t)
   147  	defer storage.Store.DestroyFunc()
   148  	test := genericregistrytest.New(t, storage.Store)
   149  	test.TestWatch(
   150  		validNewLimitRange(),
   151  		// matching labels
   152  		[]labels.Set{},
   153  		// not matching labels
   154  		[]labels.Set{
   155  			{"foo": "bar"},
   156  		},
   157  		// matching fields
   158  		[]fields.Set{},
   159  		// not matching fields
   160  		[]fields.Set{
   161  			{"metadata.name": "bar"},
   162  			{"name": "foo"},
   163  		},
   164  	)
   165  }
   166  
   167  func TestShortNames(t *testing.T) {
   168  	storage, server := newStorage(t)
   169  	defer server.Terminate(t)
   170  	defer storage.Store.DestroyFunc()
   171  	expected := []string{"limits"}
   172  	registrytest.AssertShortNames(t, storage, expected)
   173  }