github.com/zoumo/helm@v2.5.0+incompatible/pkg/tiller/release_update_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 tiller 18 19 import ( 20 "strings" 21 "testing" 22 23 "k8s.io/helm/pkg/helm" 24 "k8s.io/helm/pkg/proto/hapi/chart" 25 "k8s.io/helm/pkg/proto/hapi/release" 26 "k8s.io/helm/pkg/proto/hapi/services" 27 ) 28 29 func TestUpdateRelease(t *testing.T) { 30 c := helm.NewContext() 31 rs := rsFixture() 32 rel := releaseStub() 33 rs.env.Releases.Create(rel) 34 35 req := &services.UpdateReleaseRequest{ 36 Name: rel.Name, 37 Chart: &chart.Chart{ 38 Metadata: &chart.Metadata{Name: "hello"}, 39 Templates: []*chart.Template{ 40 {Name: "templates/hello", Data: []byte("hello: world")}, 41 {Name: "templates/hooks", Data: []byte(manifestWithUpgradeHooks)}, 42 }, 43 }, 44 } 45 res, err := rs.UpdateRelease(c, req) 46 if err != nil { 47 t.Fatalf("Failed updated: %s", err) 48 } 49 50 if res.Release.Name == "" { 51 t.Errorf("Expected release name.") 52 } 53 54 if res.Release.Name != rel.Name { 55 t.Errorf("Updated release name does not match previous release name. Expected %s, got %s", rel.Name, res.Release.Name) 56 } 57 58 if res.Release.Namespace != rel.Namespace { 59 t.Errorf("Expected release namespace '%s', got '%s'.", rel.Namespace, res.Release.Namespace) 60 } 61 62 updated, err := rs.env.Releases.Get(res.Release.Name, res.Release.Version) 63 if err != nil { 64 t.Errorf("Expected release for %s (%v).", res.Release.Name, rs.env.Releases) 65 } 66 67 if len(updated.Hooks) != 1 { 68 t.Fatalf("Expected 1 hook, got %d", len(updated.Hooks)) 69 } 70 // if updated.Hooks[0].Manifest != manifestWithUpgradeHooks { 71 // t.Errorf("Unexpected manifest: %v", updated.Hooks[0].Manifest) 72 // } 73 74 if updated.Hooks[0].Events[0] != release.Hook_POST_UPGRADE { 75 t.Errorf("Expected event 0 to be post upgrade") 76 } 77 78 if updated.Hooks[0].Events[1] != release.Hook_PRE_UPGRADE { 79 t.Errorf("Expected event 0 to be pre upgrade") 80 } 81 82 if len(res.Release.Manifest) == 0 { 83 t.Errorf("No manifest returned: %v", res.Release) 84 } 85 86 if res.Release.Config == nil { 87 t.Errorf("Got release without config: %#v", res.Release) 88 } else if res.Release.Config.Raw != rel.Config.Raw { 89 t.Errorf("Expected release values %q, got %q", rel.Config.Raw, res.Release.Config.Raw) 90 } 91 92 if len(updated.Manifest) == 0 { 93 t.Errorf("Expected manifest in %v", res) 94 } 95 96 if !strings.Contains(updated.Manifest, "---\n# Source: hello/templates/hello\nhello: world") { 97 t.Errorf("unexpected output: %s", rel.Manifest) 98 } 99 100 if res.Release.Version != 2 { 101 t.Errorf("Expected release version to be %v, got %v", 2, res.Release.Version) 102 } 103 104 edesc := "Upgrade complete" 105 if got := res.Release.Info.Description; got != edesc { 106 t.Errorf("Expected description %q, got %q", edesc, got) 107 } 108 } 109 func TestUpdateRelease_ResetValues(t *testing.T) { 110 c := helm.NewContext() 111 rs := rsFixture() 112 rel := releaseStub() 113 rs.env.Releases.Create(rel) 114 115 req := &services.UpdateReleaseRequest{ 116 Name: rel.Name, 117 Chart: &chart.Chart{ 118 Metadata: &chart.Metadata{Name: "hello"}, 119 Templates: []*chart.Template{ 120 {Name: "templates/hello", Data: []byte("hello: world")}, 121 {Name: "templates/hooks", Data: []byte(manifestWithUpgradeHooks)}, 122 }, 123 }, 124 ResetValues: true, 125 } 126 res, err := rs.UpdateRelease(c, req) 127 if err != nil { 128 t.Fatalf("Failed updated: %s", err) 129 } 130 // This should have been unset. Config: &chart.Config{Raw: `name: value`}, 131 if res.Release.Config != nil && res.Release.Config.Raw != "" { 132 t.Errorf("Expected chart config to be empty, got %q", res.Release.Config.Raw) 133 } 134 } 135 136 func TestUpdateRelease_ReuseValues(t *testing.T) { 137 c := helm.NewContext() 138 rs := rsFixture() 139 rel := releaseStub() 140 rs.env.Releases.Create(rel) 141 142 req := &services.UpdateReleaseRequest{ 143 Name: rel.Name, 144 Chart: &chart.Chart{ 145 Metadata: &chart.Metadata{Name: "hello"}, 146 Templates: []*chart.Template{ 147 {Name: "templates/hello", Data: []byte("hello: world")}, 148 {Name: "templates/hooks", Data: []byte(manifestWithUpgradeHooks)}, 149 }, 150 // Since reuseValues is set, this should get ignored. 151 Values: &chart.Config{Raw: "foo: bar\n"}, 152 }, 153 Values: &chart.Config{Raw: "name2: val2"}, 154 ReuseValues: true, 155 } 156 res, err := rs.UpdateRelease(c, req) 157 if err != nil { 158 t.Fatalf("Failed updated: %s", err) 159 } 160 // This should have been overwritten with the old value. 161 expect := "name: value\n" 162 if res.Release.Chart.Values != nil && res.Release.Chart.Values.Raw != expect { 163 t.Errorf("Expected chart values to be %q, got %q", expect, res.Release.Chart.Values.Raw) 164 } 165 // This should have the newly-passed overrides. 166 expect = "name2: val2" 167 if res.Release.Config != nil && res.Release.Config.Raw != expect { 168 t.Errorf("Expected request config to be %q, got %q", expect, res.Release.Config.Raw) 169 } 170 } 171 172 func TestUpdateRelease_ResetReuseValues(t *testing.T) { 173 // This verifies that when both reset and reuse are set, reset wins. 174 c := helm.NewContext() 175 rs := rsFixture() 176 rel := releaseStub() 177 rs.env.Releases.Create(rel) 178 179 req := &services.UpdateReleaseRequest{ 180 Name: rel.Name, 181 Chart: &chart.Chart{ 182 Metadata: &chart.Metadata{Name: "hello"}, 183 Templates: []*chart.Template{ 184 {Name: "templates/hello", Data: []byte("hello: world")}, 185 {Name: "templates/hooks", Data: []byte(manifestWithUpgradeHooks)}, 186 }, 187 }, 188 ResetValues: true, 189 ReuseValues: true, 190 } 191 res, err := rs.UpdateRelease(c, req) 192 if err != nil { 193 t.Fatalf("Failed updated: %s", err) 194 } 195 // This should have been unset. Config: &chart.Config{Raw: `name: value`}, 196 if res.Release.Config != nil && res.Release.Config.Raw != "" { 197 t.Errorf("Expected chart config to be empty, got %q", res.Release.Config.Raw) 198 } 199 } 200 201 func TestUpdateReleaseFailure(t *testing.T) { 202 c := helm.NewContext() 203 rs := rsFixture() 204 rel := releaseStub() 205 rs.env.Releases.Create(rel) 206 rs.env.KubeClient = newUpdateFailingKubeClient() 207 208 req := &services.UpdateReleaseRequest{ 209 Name: rel.Name, 210 DisableHooks: true, 211 Chart: &chart.Chart{ 212 Metadata: &chart.Metadata{Name: "hello"}, 213 Templates: []*chart.Template{ 214 {Name: "templates/something", Data: []byte("hello: world")}, 215 }, 216 }, 217 } 218 219 res, err := rs.UpdateRelease(c, req) 220 if err == nil { 221 t.Error("Expected failed update") 222 } 223 224 if updatedStatus := res.Release.Info.Status.Code; updatedStatus != release.Status_FAILED { 225 t.Errorf("Expected FAILED release. Got %d", updatedStatus) 226 } 227 228 edesc := "Upgrade \"angry-panda\" failed: Failed update in kube client" 229 if got := res.Release.Info.Description; got != edesc { 230 t.Errorf("Expected description %q, got %q", edesc, got) 231 } 232 233 oldRelease, err := rs.env.Releases.Get(rel.Name, rel.Version) 234 if err != nil { 235 t.Errorf("Expected to be able to get previous release") 236 } 237 if oldStatus := oldRelease.Info.Status.Code; oldStatus != release.Status_SUPERSEDED { 238 t.Errorf("Expected SUPERSEDED status on previous Release version. Got %v", oldStatus) 239 } 240 } 241 242 func TestUpdateReleaseNoHooks(t *testing.T) { 243 c := helm.NewContext() 244 rs := rsFixture() 245 rel := releaseStub() 246 rs.env.Releases.Create(rel) 247 248 req := &services.UpdateReleaseRequest{ 249 Name: rel.Name, 250 DisableHooks: true, 251 Chart: &chart.Chart{ 252 Metadata: &chart.Metadata{Name: "hello"}, 253 Templates: []*chart.Template{ 254 {Name: "templates/hello", Data: []byte("hello: world")}, 255 {Name: "templates/hooks", Data: []byte(manifestWithUpgradeHooks)}, 256 }, 257 }, 258 } 259 260 res, err := rs.UpdateRelease(c, req) 261 if err != nil { 262 t.Fatalf("Failed updated: %s", err) 263 } 264 265 if hl := res.Release.Hooks[0].LastRun; hl != nil { 266 t.Errorf("Expected that no hooks were run. Got %d", hl) 267 } 268 269 } 270 271 func TestUpdateReleaseNoChanges(t *testing.T) { 272 c := helm.NewContext() 273 rs := rsFixture() 274 rel := releaseStub() 275 rs.env.Releases.Create(rel) 276 277 req := &services.UpdateReleaseRequest{ 278 Name: rel.Name, 279 DisableHooks: true, 280 Chart: rel.GetChart(), 281 } 282 283 _, err := rs.UpdateRelease(c, req) 284 if err != nil { 285 t.Fatalf("Failed updated: %s", err) 286 } 287 }