github.com/migueleliasweb/helm@v2.6.1+incompatible/pkg/storage/driver/memory_test.go (about)

     1  /*
     2  Copyright 2016 The Kubernetes Authors All rights reserved.
     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
    18  
    19  import (
    20  	"reflect"
    21  	"testing"
    22  
    23  	rspb "k8s.io/helm/pkg/proto/hapi/release"
    24  )
    25  
    26  func TestMemoryName(t *testing.T) {
    27  	if mem := NewMemory(); mem.Name() != MemoryDriverName {
    28  		t.Errorf("Expected name to be %q, got %q", MemoryDriverName, mem.Name())
    29  	}
    30  }
    31  
    32  func TestMemoryCreate(t *testing.T) {
    33  	var tests = []struct {
    34  		desc string
    35  		rls  *rspb.Release
    36  		err  bool
    37  	}{
    38  		{
    39  			"create should success",
    40  			releaseStub("rls-c", 1, "default", rspb.Status_DEPLOYED),
    41  			false,
    42  		},
    43  		{
    44  			"create should fail (release already exists)",
    45  			releaseStub("rls-a", 1, "default", rspb.Status_DEPLOYED),
    46  			true,
    47  		},
    48  	}
    49  
    50  	ts := tsFixtureMemory(t)
    51  	for _, tt := range tests {
    52  		key := testKey(tt.rls.Name, tt.rls.Version)
    53  		rls := tt.rls
    54  
    55  		if err := ts.Create(key, rls); err != nil {
    56  			if !tt.err {
    57  				t.Fatalf("failed to create %q: %s", tt.desc, err)
    58  			}
    59  		}
    60  	}
    61  }
    62  
    63  func TestMemoryGet(t *testing.T) {
    64  	var tests = []struct {
    65  		desc string
    66  		key  string
    67  		err  bool
    68  	}{
    69  		{"release key should exist", "rls-a.v1", false},
    70  		{"release key should not exist", "rls-a.v5", true},
    71  	}
    72  
    73  	ts := tsFixtureMemory(t)
    74  	for _, tt := range tests {
    75  		if _, err := ts.Get(tt.key); err != nil {
    76  			if !tt.err {
    77  				t.Fatalf("Failed %q to get '%s': %q\n", tt.desc, tt.key, err)
    78  			}
    79  		}
    80  	}
    81  }
    82  
    83  func TestMemoryQuery(t *testing.T) {
    84  	var tests = []struct {
    85  		desc string
    86  		xlen int
    87  		lbs  map[string]string
    88  	}{
    89  		{
    90  			"should be 2 query results",
    91  			2,
    92  			map[string]string{"STATUS": "DEPLOYED"},
    93  		},
    94  	}
    95  
    96  	ts := tsFixtureMemory(t)
    97  	for _, tt := range tests {
    98  		l, err := ts.Query(tt.lbs)
    99  		if err != nil {
   100  			t.Fatalf("Failed to query: %s\n", err)
   101  		}
   102  
   103  		if tt.xlen != len(l) {
   104  			t.Fatalf("Expected %d results, actual %d\n", tt.xlen, len(l))
   105  		}
   106  	}
   107  }
   108  
   109  func TestMemoryUpdate(t *testing.T) {
   110  	var tests = []struct {
   111  		desc string
   112  		key  string
   113  		rls  *rspb.Release
   114  		err  bool
   115  	}{
   116  		{
   117  			"update release status",
   118  			"rls-a.v4",
   119  			releaseStub("rls-a", 4, "default", rspb.Status_SUPERSEDED),
   120  			false,
   121  		},
   122  		{
   123  			"update release does not exist",
   124  			"rls-z.v1",
   125  			releaseStub("rls-z", 1, "default", rspb.Status_DELETED),
   126  			true,
   127  		},
   128  	}
   129  
   130  	ts := tsFixtureMemory(t)
   131  	for _, tt := range tests {
   132  		if err := ts.Update(tt.key, tt.rls); err != nil {
   133  			if !tt.err {
   134  				t.Fatalf("Failed %q: %s\n", tt.desc, err)
   135  			}
   136  			continue
   137  		}
   138  
   139  		r, err := ts.Get(tt.key)
   140  		if err != nil {
   141  			t.Fatalf("Failed to get: %s\n", err)
   142  		}
   143  
   144  		if !reflect.DeepEqual(r, tt.rls) {
   145  			t.Fatalf("Expected %s, actual %s\n", tt.rls, r)
   146  		}
   147  	}
   148  }
   149  
   150  func TestMemoryDelete(t *testing.T) {
   151  	var tests = []struct {
   152  		desc string
   153  		key  string
   154  		err  bool
   155  	}{
   156  		{"release key should exist", "rls-a.v1", false},
   157  		{"release key should not exist", "rls-a.v5", true},
   158  	}
   159  
   160  	ts := tsFixtureMemory(t)
   161  	for _, tt := range tests {
   162  		if _, err := ts.Delete(tt.key); err != nil {
   163  			if !tt.err {
   164  				t.Fatalf("Failed %q to get '%s': %q\n", tt.desc, tt.key, err)
   165  			}
   166  		}
   167  	}
   168  }