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  }