github.com/Beeketing/helm@v2.12.1+incompatible/pkg/storage/driver/mock_test.go (about) 1 /* 2 Copyright The Helm 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 driver // import "k8s.io/helm/pkg/storage/driver" 18 19 import ( 20 "fmt" 21 "testing" 22 23 "k8s.io/api/core/v1" 24 apierrors "k8s.io/apimachinery/pkg/api/errors" 25 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" 26 "k8s.io/apimachinery/pkg/runtime/schema" 27 corev1 "k8s.io/client-go/kubernetes/typed/core/v1" 28 29 rspb "k8s.io/helm/pkg/proto/hapi/release" 30 ) 31 32 func releaseStub(name string, vers int32, namespace string, code rspb.Status_Code) *rspb.Release { 33 return &rspb.Release{ 34 Name: name, 35 Version: vers, 36 Namespace: namespace, 37 Info: &rspb.Info{Status: &rspb.Status{Code: code}}, 38 } 39 } 40 41 func testKey(name string, vers int32) string { 42 return fmt.Sprintf("%s.v%d", name, vers) 43 } 44 45 func tsFixtureMemory(t *testing.T) *Memory { 46 hs := []*rspb.Release{ 47 // rls-a 48 releaseStub("rls-a", 4, "default", rspb.Status_DEPLOYED), 49 releaseStub("rls-a", 1, "default", rspb.Status_SUPERSEDED), 50 releaseStub("rls-a", 3, "default", rspb.Status_SUPERSEDED), 51 releaseStub("rls-a", 2, "default", rspb.Status_SUPERSEDED), 52 // rls-b 53 releaseStub("rls-b", 4, "default", rspb.Status_DEPLOYED), 54 releaseStub("rls-b", 1, "default", rspb.Status_SUPERSEDED), 55 releaseStub("rls-b", 3, "default", rspb.Status_SUPERSEDED), 56 releaseStub("rls-b", 2, "default", rspb.Status_SUPERSEDED), 57 } 58 59 mem := NewMemory() 60 for _, tt := range hs { 61 err := mem.Create(testKey(tt.Name, tt.Version), tt) 62 if err != nil { 63 t.Fatalf("Test setup failed to create: %s\n", err) 64 } 65 } 66 return mem 67 } 68 69 // newTestFixture initializes a MockConfigMapsInterface. 70 // ConfigMaps are created for each release provided. 71 func newTestFixtureCfgMaps(t *testing.T, releases ...*rspb.Release) *ConfigMaps { 72 var mock MockConfigMapsInterface 73 mock.Init(t, releases...) 74 75 return NewConfigMaps(&mock) 76 } 77 78 // MockConfigMapsInterface mocks a kubernetes ConfigMapsInterface 79 type MockConfigMapsInterface struct { 80 corev1.ConfigMapInterface 81 82 objects map[string]*v1.ConfigMap 83 } 84 85 // Init initializes the MockConfigMapsInterface with the set of releases. 86 func (mock *MockConfigMapsInterface) Init(t *testing.T, releases ...*rspb.Release) { 87 mock.objects = map[string]*v1.ConfigMap{} 88 89 for _, rls := range releases { 90 objkey := testKey(rls.Name, rls.Version) 91 92 cfgmap, err := newConfigMapsObject(objkey, rls, nil) 93 if err != nil { 94 t.Fatalf("Failed to create configmap: %s", err) 95 } 96 mock.objects[objkey] = cfgmap 97 } 98 } 99 100 // Get returns the ConfigMap by name. 101 func (mock *MockConfigMapsInterface) Get(name string, options metav1.GetOptions) (*v1.ConfigMap, error) { 102 object, ok := mock.objects[name] 103 if !ok { 104 return nil, apierrors.NewNotFound(schema.GroupResource{Resource: "tests"}, name) 105 } 106 return object, nil 107 } 108 109 // List returns the a of ConfigMaps. 110 func (mock *MockConfigMapsInterface) List(opts metav1.ListOptions) (*v1.ConfigMapList, error) { 111 var list v1.ConfigMapList 112 for _, cfgmap := range mock.objects { 113 list.Items = append(list.Items, *cfgmap) 114 } 115 return &list, nil 116 } 117 118 // Create creates a new ConfigMap. 119 func (mock *MockConfigMapsInterface) Create(cfgmap *v1.ConfigMap) (*v1.ConfigMap, error) { 120 name := cfgmap.ObjectMeta.Name 121 if object, ok := mock.objects[name]; ok { 122 return object, apierrors.NewAlreadyExists(schema.GroupResource{Resource: "tests"}, name) 123 } 124 mock.objects[name] = cfgmap 125 return cfgmap, nil 126 } 127 128 // Update updates a ConfigMap. 129 func (mock *MockConfigMapsInterface) Update(cfgmap *v1.ConfigMap) (*v1.ConfigMap, error) { 130 name := cfgmap.ObjectMeta.Name 131 if _, ok := mock.objects[name]; !ok { 132 return nil, apierrors.NewNotFound(v1.Resource("tests"), name) 133 } 134 mock.objects[name] = cfgmap 135 return cfgmap, nil 136 } 137 138 // Delete deletes a ConfigMap by name. 139 func (mock *MockConfigMapsInterface) Delete(name string, opts *metav1.DeleteOptions) error { 140 if _, ok := mock.objects[name]; !ok { 141 return apierrors.NewNotFound(v1.Resource("tests"), name) 142 } 143 delete(mock.objects, name) 144 return nil 145 } 146 147 // newTestFixture initializes a MockSecretsInterface. 148 // Secrets are created for each release provided. 149 func newTestFixtureSecrets(t *testing.T, releases ...*rspb.Release) *Secrets { 150 var mock MockSecretsInterface 151 mock.Init(t, releases...) 152 153 return NewSecrets(&mock) 154 } 155 156 // MockSecretsInterface mocks a kubernetes SecretsInterface 157 type MockSecretsInterface struct { 158 corev1.SecretInterface 159 160 objects map[string]*v1.Secret 161 } 162 163 // Init initializes the MockSecretsInterface with the set of releases. 164 func (mock *MockSecretsInterface) Init(t *testing.T, releases ...*rspb.Release) { 165 mock.objects = map[string]*v1.Secret{} 166 167 for _, rls := range releases { 168 objkey := testKey(rls.Name, rls.Version) 169 170 secret, err := newSecretsObject(objkey, rls, nil) 171 if err != nil { 172 t.Fatalf("Failed to create secret: %s", err) 173 } 174 mock.objects[objkey] = secret 175 } 176 } 177 178 // Get returns the Secret by name. 179 func (mock *MockSecretsInterface) Get(name string, options metav1.GetOptions) (*v1.Secret, error) { 180 object, ok := mock.objects[name] 181 if !ok { 182 return nil, apierrors.NewNotFound(schema.GroupResource{Resource: "tests"}, name) 183 } 184 return object, nil 185 } 186 187 // List returns the a of Secret. 188 func (mock *MockSecretsInterface) List(opts metav1.ListOptions) (*v1.SecretList, error) { 189 var list v1.SecretList 190 for _, secret := range mock.objects { 191 list.Items = append(list.Items, *secret) 192 } 193 return &list, nil 194 } 195 196 // Create creates a new Secret. 197 func (mock *MockSecretsInterface) Create(secret *v1.Secret) (*v1.Secret, error) { 198 name := secret.ObjectMeta.Name 199 if object, ok := mock.objects[name]; ok { 200 return object, apierrors.NewAlreadyExists(schema.GroupResource{Resource: "tests"}, name) 201 } 202 mock.objects[name] = secret 203 return secret, nil 204 } 205 206 // Update updates a Secret. 207 func (mock *MockSecretsInterface) Update(secret *v1.Secret) (*v1.Secret, error) { 208 name := secret.ObjectMeta.Name 209 if _, ok := mock.objects[name]; !ok { 210 return nil, apierrors.NewNotFound(schema.GroupResource{Resource: "tests"}, name) 211 } 212 mock.objects[name] = secret 213 return secret, nil 214 } 215 216 // Delete deletes a Secret by name. 217 func (mock *MockSecretsInterface) Delete(name string, opts *metav1.DeleteOptions) error { 218 if _, ok := mock.objects[name]; !ok { 219 return apierrors.NewNotFound(schema.GroupResource{Resource: "tests"}, name) 220 } 221 delete(mock.objects, name) 222 return nil 223 }