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