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

     1  /*
     2  Copyright 2015 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  	api "k8s.io/kubernetes/pkg/apis/core"
    30  	"k8s.io/kubernetes/pkg/registry/registrytest"
    31  )
    32  
    33  func newStorage(t *testing.T) (*REST, *etcd3testing.EtcdTestServer) {
    34  	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
    35  	restOptions := generic.RESTOptions{
    36  		StorageConfig:           etcdStorage,
    37  		Decorator:               generic.UndecoratedStorage,
    38  		DeleteCollectionWorkers: 1,
    39  		ResourcePrefix:          "configmaps",
    40  	}
    41  	rest, err := NewREST(restOptions)
    42  	if err != nil {
    43  		t.Fatalf("unexpected error from REST storage: %v", err)
    44  	}
    45  	return rest, server
    46  }
    47  
    48  func validNewConfigMap() *api.ConfigMap {
    49  	return &api.ConfigMap{
    50  		ObjectMeta: metav1.ObjectMeta{
    51  			Name:      "foo",
    52  			Namespace: "default",
    53  			Labels: map[string]string{
    54  				"label-1": "value-1",
    55  				"label-2": "value-2",
    56  			},
    57  		},
    58  		Data: map[string]string{
    59  			"test": "data",
    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  
    70  	validConfigMap := validNewConfigMap()
    71  	validConfigMap.ObjectMeta = metav1.ObjectMeta{
    72  		GenerateName: "foo-",
    73  	}
    74  
    75  	test.TestCreate(
    76  		validConfigMap,
    77  		&api.ConfigMap{
    78  			ObjectMeta: metav1.ObjectMeta{Name: "badName"},
    79  			Data: map[string]string{
    80  				"key": "value",
    81  			},
    82  		},
    83  		&api.ConfigMap{
    84  			ObjectMeta: metav1.ObjectMeta{Name: "name-2"},
    85  			Data: map[string]string{
    86  				"..dotfile": "do: nothing\n",
    87  			},
    88  		},
    89  	)
    90  }
    91  
    92  func TestUpdate(t *testing.T) {
    93  	storage, server := newStorage(t)
    94  	defer server.Terminate(t)
    95  	defer storage.Store.DestroyFunc()
    96  	test := genericregistrytest.New(t, storage.Store)
    97  	test.TestUpdate(
    98  		// valid
    99  		validNewConfigMap(),
   100  		// updateFunc
   101  		func(obj runtime.Object) runtime.Object {
   102  			cfg := obj.(*api.ConfigMap)
   103  			cfg.Data["update-test"] = "value"
   104  			return cfg
   105  		},
   106  		// invalid updateFunc
   107  		func(obj runtime.Object) runtime.Object {
   108  			cfg := obj.(*api.ConfigMap)
   109  			cfg.Data["bad*Key"] = "value"
   110  			return cfg
   111  		},
   112  	)
   113  }
   114  
   115  func TestDelete(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)
   120  	test.TestDelete(validNewConfigMap())
   121  }
   122  
   123  func TestGet(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)
   128  	test.TestGet(validNewConfigMap())
   129  }
   130  
   131  func TestList(t *testing.T) {
   132  	storage, server := newStorage(t)
   133  	defer server.Terminate(t)
   134  	defer storage.Store.DestroyFunc()
   135  	test := genericregistrytest.New(t, storage.Store)
   136  	test.TestList(validNewConfigMap())
   137  }
   138  
   139  func TestWatch(t *testing.T) {
   140  	storage, server := newStorage(t)
   141  	defer server.Terminate(t)
   142  	defer storage.Store.DestroyFunc()
   143  	test := genericregistrytest.New(t, storage.Store)
   144  	test.TestWatch(
   145  		validNewConfigMap(),
   146  		// matching labels
   147  		[]labels.Set{
   148  			{"label-1": "value-1"},
   149  			{"label-2": "value-2"},
   150  		},
   151  		// not matching labels
   152  		[]labels.Set{
   153  			{"foo": "bar"},
   154  		},
   155  		// matching fields
   156  		[]fields.Set{
   157  			{"metadata.namespace": "default"},
   158  			{"metadata.name": "foo"},
   159  		},
   160  		// not matching fields
   161  		[]fields.Set{
   162  			{"metadata.name": "bar"},
   163  			{"name": "foo"},
   164  		},
   165  	)
   166  }
   167  
   168  func TestShortNames(t *testing.T) {
   169  	storage, server := newStorage(t)
   170  	defer server.Terminate(t)
   171  	defer storage.Store.DestroyFunc()
   172  	expected := []string{"cm"}
   173  	registrytest.AssertShortNames(t, storage, expected)
   174  }