storage_test.go

Documentation: k8s.io/kubernetes/pkg/registry/scheduling/priorityclass/storage

     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  	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
    27  	"k8s.io/apiserver/pkg/registry/generic"
    28  	genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
    29  	"k8s.io/apiserver/pkg/registry/rest"
    30  	etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing"
    31  	"k8s.io/kubernetes/pkg/apis/scheduling"
    32  	schedulingapiv1 "k8s.io/kubernetes/pkg/apis/scheduling/v1"
    33  	"k8s.io/kubernetes/pkg/registry/registrytest"
    34  )
    35  
    36  func newStorage(t *testing.T) (*REST, *etcd3testing.EtcdTestServer) {
    37  	etcdStorage, server := registrytest.NewEtcdStorage(t, scheduling.GroupName)
    38  	restOptions := generic.RESTOptions{
    39  		StorageConfig:           etcdStorage,
    40  		Decorator:               generic.UndecoratedStorage,
    41  		DeleteCollectionWorkers: 1,
    42  		ResourcePrefix:          "priorityclasses",
    43  	}
    44  	rest, err := NewREST(restOptions)
    45  	if err != nil {
    46  		t.Fatalf("unable to create REST %v", err)
    47  	}
    48  	return rest, server
    49  }
    50  
    51  func validNewPriorityClass() *scheduling.PriorityClass {
    52  	return &scheduling.PriorityClass{
    53  		ObjectMeta: metav1.ObjectMeta{
    54  			Name: "foo",
    55  		},
    56  		Value:         100,
    57  		GlobalDefault: false,
    58  		Description:   "This is created only for testing.",
    59  	}
    60  }
    61  
    62  func TestCreate(t *testing.T) {
    63  	storage, server := newStorage(t)
    64  	defer server.Terminate(t)
    65  	defer storage.Store.DestroyFunc()
    66  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
    67  	test.TestCreate(
    68  		validNewPriorityClass(),
    69  		// invalid cases
    70  		&scheduling.PriorityClass{
    71  			ObjectMeta: metav1.ObjectMeta{
    72  				Name: "*badName",
    73  			},
    74  			Value:         100,
    75  			GlobalDefault: true,
    76  			Description:   "This is created only for testing.",
    77  		},
    78  	)
    79  }
    80  
    81  func TestUpdate(t *testing.T) {
    82  	storage, server := newStorage(t)
    83  	defer server.Terminate(t)
    84  	defer storage.Store.DestroyFunc()
    85  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
    86  	test.TestUpdate(
    87  		// valid
    88  		validNewPriorityClass(),
    89  		// There is no valid update function
    90  		func(obj runtime.Object) runtime.Object {
    91  			pc := obj.(*scheduling.PriorityClass)
    92  			pc.Value = 100
    93  			pc.GlobalDefault = false
    94  			return pc
    95  		},
    96  		// invalid updates
    97  		// Change Value
    98  		func(obj runtime.Object) runtime.Object {
    99  			pc := obj.(*scheduling.PriorityClass)
   100  			pc.Value = 200
   101  			pc.GlobalDefault = false
   102  			return pc
   103  		},
   104  	)
   105  }
   106  
   107  func TestDelete(t *testing.T) {
   108  	storage, server := newStorage(t)
   109  	defer server.Terminate(t)
   110  	defer storage.Store.DestroyFunc()
   111  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
   112  	test.TestDelete(validNewPriorityClass())
   113  }
   114  
   115  // TestDeleteSystemPriorityClass checks that system priority classes cannot be deleted.
   116  func TestDeleteSystemPriorityClass(t *testing.T) {
   117  	storage, server := newStorage(t)
   118  	defer server.Terminate(t)
   119  	defer storage.Store.DestroyFunc()
   120  	key := "test/system-node-critical"
   121  	ctx := genericapirequest.NewContext()
   122  	pc := schedulingapiv1.SystemPriorityClasses()[0]
   123  	internalPc := &scheduling.PriorityClass{}
   124  	if err := schedulingapiv1.Convert_v1_PriorityClass_To_scheduling_PriorityClass(pc, internalPc, nil); err != nil {
   125  		t.Fatal(err)
   126  	}
   127  	if err := storage.Store.Storage.Create(ctx, key, internalPc, nil, 0, false); err != nil {
   128  		t.Fatalf("unexpected error: %v", err)
   129  	}
   130  	if _, _, err := storage.Delete(ctx, pc.Name, rest.ValidateAllObjectFunc, nil); err == nil {
   131  		t.Error("expected to receive an error")
   132  	}
   133  }
   134  
   135  func TestGet(t *testing.T) {
   136  	storage, server := newStorage(t)
   137  	defer server.Terminate(t)
   138  	defer storage.Store.DestroyFunc()
   139  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
   140  	test.TestGet(validNewPriorityClass())
   141  }
   142  
   143  func TestList(t *testing.T) {
   144  	storage, server := newStorage(t)
   145  	defer server.Terminate(t)
   146  	defer storage.Store.DestroyFunc()
   147  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
   148  	test.TestList(validNewPriorityClass())
   149  }
   150  
   151  func TestWatch(t *testing.T) {
   152  	storage, server := newStorage(t)
   153  	defer server.Terminate(t)
   154  	defer storage.Store.DestroyFunc()
   155  	test := genericregistrytest.New(t, storage.Store).ClusterScope()
   156  	test.TestWatch(
   157  		validNewPriorityClass(),
   158  		// matching labels
   159  		[]labels.Set{},
   160  		// not matching labels
   161  		[]labels.Set{
   162  			{"foo": "bar"},
   163  		},
   164  		// matching fields
   165  		[]fields.Set{
   166  			{"metadata.name": "foo"},
   167  		},
   168  		// not matching fields
   169  		[]fields.Set{
   170  			{"metadata.name": "bar"},
   171  		},
   172  	)
   173  }
   174  
   175  func TestShortNames(t *testing.T) {
   176  	storage, server := newStorage(t)
   177  	defer server.Terminate(t)
   178  	defer storage.Store.DestroyFunc()
   179  	expected := []string{"pc"}
   180  	registrytest.AssertShortNames(t, storage, expected)
   181  }
   182
View as plain text