github.com/sgoings/helm@v2.0.0-alpha.2.0.20170406211108-734e92851ac3+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 }