k8s.io/kubernetes@v1.29.3/pkg/registry/core/secret/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:          "secrets",
    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 validNewSecret(name string) *api.Secret {
    49  	return &api.Secret{
    50  		ObjectMeta: metav1.ObjectMeta{
    51  			Name:      name,
    52  			Namespace: metav1.NamespaceDefault,
    53  		},
    54  		Data: map[string][]byte{
    55  			"test": []byte("data"),
    56  		},
    57  	}
    58  }
    59  
    60  func TestCreate(t *testing.T) {
    61  	storage, server := newStorage(t)
    62  	defer server.Terminate(t)
    63  	defer storage.Store.DestroyFunc()
    64  	test := genericregistrytest.New(t, storage.Store)
    65  	secret := validNewSecret("foo")
    66  	secret.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo-"}
    67  	test.TestCreate(
    68  		// valid
    69  		secret,
    70  		// invalid
    71  		&api.Secret{},
    72  		&api.Secret{
    73  			ObjectMeta: metav1.ObjectMeta{Name: "name"},
    74  			Data:       map[string][]byte{"name with spaces": []byte("")},
    75  		},
    76  		&api.Secret{
    77  			ObjectMeta: metav1.ObjectMeta{Name: "name"},
    78  			Data:       map[string][]byte{"~.dotfile": []byte("")},
    79  		},
    80  	)
    81  }
    82  
    83  func TestUpdate(t *testing.T) {
    84  	storage, server := newStorage(t)
    85  	defer server.Terminate(t)
    86  	defer storage.Store.DestroyFunc()
    87  	test := genericregistrytest.New(t, storage.Store)
    88  	test.TestUpdate(
    89  		// valid
    90  		validNewSecret("foo"),
    91  		// updateFunc
    92  		func(obj runtime.Object) runtime.Object {
    93  			object := obj.(*api.Secret)
    94  			object.Data["othertest"] = []byte("otherdata")
    95  			return object
    96  		},
    97  	)
    98  }
    99  
   100  func TestDelete(t *testing.T) {
   101  	storage, server := newStorage(t)
   102  	defer server.Terminate(t)
   103  	defer storage.Store.DestroyFunc()
   104  	test := genericregistrytest.New(t, storage.Store)
   105  	test.TestDelete(validNewSecret("foo"))
   106  }
   107  
   108  func TestGet(t *testing.T) {
   109  	storage, server := newStorage(t)
   110  	defer server.Terminate(t)
   111  	defer storage.Store.DestroyFunc()
   112  	test := genericregistrytest.New(t, storage.Store)
   113  	test.TestGet(validNewSecret("foo"))
   114  }
   115  
   116  func TestList(t *testing.T) {
   117  	storage, server := newStorage(t)
   118  	defer server.Terminate(t)
   119  	defer storage.Store.DestroyFunc()
   120  	test := genericregistrytest.New(t, storage.Store)
   121  	test.TestList(validNewSecret("foo"))
   122  }
   123  
   124  func TestWatch(t *testing.T) {
   125  	storage, server := newStorage(t)
   126  	defer server.Terminate(t)
   127  	defer storage.Store.DestroyFunc()
   128  	test := genericregistrytest.New(t, storage.Store)
   129  	test.TestWatch(
   130  		validNewSecret("foo"),
   131  		// matching labels
   132  		[]labels.Set{},
   133  		// not matching labels
   134  		[]labels.Set{
   135  			{"foo": "bar"},
   136  		},
   137  		// matching fields
   138  		[]fields.Set{},
   139  		// not matching fields
   140  		[]fields.Set{
   141  			{"metadata.name": "bar"},
   142  			{"name": "foo"},
   143  		},
   144  	)
   145  }