storage_test.go

Documentation: k8s.io/kubernetes/pkg/registry/apiserverinternal/storageversion/storage

     1  /*
     2  Copyright 2021 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  	"fmt"
    21  	"testing"
    22  
    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  	"k8s.io/kubernetes/pkg/apis/apiserverinternal"
    31  	"k8s.io/kubernetes/pkg/registry/registrytest"
    32  
    33  	// Ensure that admissionregistration package is initialized.
    34  	_ "k8s.io/kubernetes/pkg/apis/apiserverinternal/install"
    35  )
    36  
    37  func TestCreate(t *testing.T) {
    38  	storage, _, server := newStorage(t)
    39  	defer server.Terminate(t)
    40  	defer storage.Store.DestroyFunc()
    41  	test := genericregistrytest.New(t, storage.Store).ClusterScope().Namer(name).GeneratesName()
    42  	storageVersion := validStorageVersion()
    43  	test.TestCreate(
    44  		// valid
    45  		storageVersion,
    46  		// invalid
    47  		newStorageVersion(""),
    48  	)
    49  }
    50  
    51  func TestUpdate(t *testing.T) {
    52  	storage, _, server := newStorage(t)
    53  	defer server.Terminate(t)
    54  	defer storage.Store.DestroyFunc()
    55  	test := genericregistrytest.New(t, storage.Store).ClusterScope().Namer(name).GeneratesName()
    56  
    57  	test.TestUpdate(
    58  		// valid
    59  		validStorageVersion(),
    60  		// updateFunc
    61  		func(obj runtime.Object) runtime.Object {
    62  			object := obj.(*apiserverinternal.StorageVersion)
    63  			update := &apiserverinternal.StorageVersion{
    64  				ObjectMeta: object.ObjectMeta,
    65  			}
    66  			return update
    67  		},
    68  		// invalid updateFunc
    69  		func(obj runtime.Object) runtime.Object {
    70  			object := obj.(*apiserverinternal.StorageVersion)
    71  			object.Name = ""
    72  			return object
    73  		},
    74  	)
    75  }
    76  
    77  func TestGet(t *testing.T) {
    78  	storage, _, server := newStorage(t)
    79  	defer server.Terminate(t)
    80  	defer storage.Store.DestroyFunc()
    81  	test := genericregistrytest.New(t, storage.Store).ClusterScope().Namer(name)
    82  	test.TestGet(validStorageVersion())
    83  }
    84  
    85  func TestList(t *testing.T) {
    86  	storage, _, server := newStorage(t)
    87  	defer server.Terminate(t)
    88  	defer storage.Store.DestroyFunc()
    89  	test := genericregistrytest.New(t, storage.Store).ClusterScope().Namer(name)
    90  	test.TestList(validStorageVersion())
    91  }
    92  
    93  func TestDelete(t *testing.T) {
    94  	storage, _, server := newStorage(t)
    95  	defer server.Terminate(t)
    96  	defer storage.Store.DestroyFunc()
    97  	test := genericregistrytest.New(t, storage.Store).ClusterScope().Namer(name)
    98  	test.TestDelete(validStorageVersion())
    99  }
   100  
   101  func TestWatch(t *testing.T) {
   102  	storage, _, server := newStorage(t)
   103  	defer server.Terminate(t)
   104  	defer storage.Store.DestroyFunc()
   105  	test := genericregistrytest.New(t, storage.Store).ClusterScope().Namer(name).GeneratesName()
   106  	test.TestWatch(
   107  		validStorageVersion(),
   108  		[]labels.Set{},
   109  		[]labels.Set{
   110  			{"hoo": "bar"},
   111  		},
   112  		[]fields.Set{
   113  			{"metadata.name": "core.pods"},
   114  		},
   115  		[]fields.Set{
   116  			{"metadata.name": "nomatch"},
   117  		},
   118  	)
   119  }
   120  
   121  func name(i int) string {
   122  	return fmt.Sprintf("core.pods%d", i)
   123  }
   124  
   125  func validStorageVersion() *apiserverinternal.StorageVersion {
   126  	ssv1 := apiserverinternal.ServerStorageVersion{
   127  		APIServerID:       "1",
   128  		EncodingVersion:   "v1",
   129  		DecodableVersions: []string{"v1", "v2"},
   130  	}
   131  	ssv2 := apiserverinternal.ServerStorageVersion{
   132  		APIServerID:       "2",
   133  		EncodingVersion:   "v1",
   134  		DecodableVersions: []string{"v1", "v2"},
   135  	}
   136  	// ssv3 has a different encoding version
   137  	ssv3 := apiserverinternal.ServerStorageVersion{
   138  		APIServerID:       "3",
   139  		EncodingVersion:   "v2",
   140  		DecodableVersions: []string{"v1", "v2"},
   141  	}
   142  	return &apiserverinternal.StorageVersion{
   143  		ObjectMeta: metav1.ObjectMeta{
   144  			Name: "core.pods",
   145  		},
   146  		Status: apiserverinternal.StorageVersionStatus{
   147  			StorageVersions: []apiserverinternal.ServerStorageVersion{ssv1, ssv2, ssv3},
   148  			Conditions:      commonVersionFalseCondition(),
   149  		},
   150  	}
   151  }
   152  
   153  func commonVersionFalseCondition() []apiserverinternal.StorageVersionCondition {
   154  	return []apiserverinternal.StorageVersionCondition{{
   155  		Type:    apiserverinternal.AllEncodingVersionsEqual,
   156  		Status:  apiserverinternal.ConditionFalse,
   157  		Reason:  "CommonEncodingVersionUnset",
   158  		Message: "Common encoding version unset",
   159  	}}
   160  }
   161  func newStorageVersion(name string) *apiserverinternal.StorageVersion {
   162  	return &apiserverinternal.StorageVersion{
   163  		ObjectMeta: metav1.ObjectMeta{
   164  			Name:   name,
   165  			Labels: map[string]string{"foo": "bar"},
   166  		},
   167  		Status: apiserverinternal.StorageVersionStatus{
   168  			Conditions: commonVersionFalseCondition(),
   169  		},
   170  	}
   171  }
   172  
   173  func newStorage(t *testing.T) (*REST, *StatusREST, *etcd3testing.EtcdTestServer) {
   174  	etcdStorage, server := registrytest.NewEtcdStorage(t, apiserverinternal.GroupName)
   175  	restOptions := generic.RESTOptions{
   176  		StorageConfig:           etcdStorage,
   177  		Decorator:               generic.UndecoratedStorage,
   178  		DeleteCollectionWorkers: 1,
   179  		ResourcePrefix:          "storageversions",
   180  	}
   181  	storageVersionStorage, statusStorage, err := NewREST(restOptions)
   182  	if err != nil {
   183  		t.Fatalf("unexpected error from REST storage: %v", err)
   184  	}
   185  	return storageVersionStorage, statusStorage, server
   186  }
   187
View as plain text