1063 lines
29 KiB
Go
1063 lines
29 KiB
Go
/*
|
|
Copyright The Helm Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package tiller
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"regexp"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ghodss/yaml"
|
|
"github.com/golang/protobuf/ptypes/timestamp"
|
|
"github.com/technosophos/moniker"
|
|
"golang.org/x/net/context"
|
|
"google.golang.org/grpc/metadata"
|
|
v1 "k8s.io/api/core/v1"
|
|
"k8s.io/cli-runtime/pkg/resource"
|
|
"k8s.io/client-go/kubernetes/fake"
|
|
|
|
"k8s.io/helm/pkg/helm"
|
|
"k8s.io/helm/pkg/hooks"
|
|
"k8s.io/helm/pkg/kube"
|
|
"k8s.io/helm/pkg/proto/hapi/chart"
|
|
"k8s.io/helm/pkg/proto/hapi/release"
|
|
"k8s.io/helm/pkg/proto/hapi/services"
|
|
"k8s.io/helm/pkg/storage"
|
|
"k8s.io/helm/pkg/storage/driver"
|
|
"k8s.io/helm/pkg/tiller/environment"
|
|
)
|
|
|
|
const notesText = "my notes here"
|
|
|
|
var manifestWithHook = `kind: ConfigMap
|
|
metadata:
|
|
name: test-cm
|
|
annotations:
|
|
"helm.sh/hook": post-install,pre-delete
|
|
data:
|
|
name: value`
|
|
|
|
var manifestWithCRDHook = `
|
|
apiVersion: apiextensions.k8s.io/v1beta1
|
|
kind: CustomResourceDefinition
|
|
metadata:
|
|
name: crontabs.stable.example.com
|
|
annotations:
|
|
"helm.sh/hook": crd-install
|
|
spec:
|
|
group: stable.example.com
|
|
version: v1
|
|
scope: Namespaced
|
|
names:
|
|
plural: crontabs
|
|
singular: crontab
|
|
kind: CronTab
|
|
shortNames:
|
|
- ct
|
|
`
|
|
|
|
var manifestWithTestHook = `kind: Pod
|
|
metadata:
|
|
name: finding-nemo,
|
|
annotations:
|
|
"helm.sh/hook": test-success
|
|
spec:
|
|
containers:
|
|
- name: nemo-test
|
|
image: fake-image
|
|
cmd: fake-command
|
|
`
|
|
|
|
var manifestWithKeep = `kind: ConfigMap
|
|
metadata:
|
|
name: test-cm-keep-a
|
|
annotations:
|
|
"helm.sh/resource-policy": keep
|
|
data:
|
|
name: value
|
|
`
|
|
|
|
var manifestWithKeepEmpty = `kind: ConfigMap
|
|
metadata:
|
|
name: test-cm-keep-b
|
|
annotations:
|
|
"helm.sh/resource-policy": ""
|
|
data:
|
|
name: value
|
|
`
|
|
|
|
var manifestWithUpgradeHooks = `kind: ConfigMap
|
|
metadata:
|
|
name: test-cm
|
|
annotations:
|
|
"helm.sh/hook": post-upgrade,pre-upgrade
|
|
data:
|
|
name: value`
|
|
|
|
var manifestWithRollbackHooks = `kind: ConfigMap
|
|
metadata:
|
|
name: test-cm
|
|
annotations:
|
|
"helm.sh/hook": post-rollback,pre-rollback
|
|
data:
|
|
name: value
|
|
`
|
|
|
|
type chartOptions struct {
|
|
*chart.Chart
|
|
}
|
|
|
|
type chartOption func(*chartOptions)
|
|
|
|
func rsFixture() *ReleaseServer {
|
|
return NewReleaseServer(MockEnvironment(), fake.NewSimpleClientset(), false)
|
|
}
|
|
|
|
func buildChart(opts ...chartOption) *chart.Chart {
|
|
c := &chartOptions{
|
|
Chart: &chart.Chart{
|
|
// TODO: This should be more complete.
|
|
Metadata: &chart.Metadata{
|
|
Name: "hello",
|
|
},
|
|
// This adds a basic template and hooks.
|
|
Templates: []*chart.Template{
|
|
{Name: "templates/hello", Data: []byte("hello: world")},
|
|
{Name: "templates/hooks", Data: []byte(manifestWithHook)},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, opt := range opts {
|
|
opt(c)
|
|
}
|
|
|
|
return c.Chart
|
|
}
|
|
|
|
func withKube(version string) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Metadata.KubeVersion = version
|
|
}
|
|
}
|
|
|
|
func withTiller(version string) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Metadata.TillerVersion = version
|
|
}
|
|
}
|
|
|
|
func withDependency(dependencyOpts ...chartOption) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Dependencies = append(opts.Dependencies, buildChart(dependencyOpts...))
|
|
}
|
|
}
|
|
|
|
func withNotes(notes string) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Templates = append(opts.Templates, &chart.Template{
|
|
Name: "templates/NOTES.txt",
|
|
Data: []byte(notes),
|
|
})
|
|
}
|
|
}
|
|
|
|
func withSampleTemplates() chartOption {
|
|
return func(opts *chartOptions) {
|
|
sampleTemplates := []*chart.Template{
|
|
// This adds basic templates and partials.
|
|
{Name: "templates/goodbye", Data: []byte("goodbye: world")},
|
|
{Name: "templates/empty", Data: []byte("")},
|
|
{Name: "templates/with-partials", Data: []byte(`hello: {{ template "_planet" . }}`)},
|
|
{Name: "templates/partials/_planet", Data: []byte(`{{define "_planet"}}Earth{{end}}`)},
|
|
}
|
|
opts.Templates = append(opts.Templates, sampleTemplates...)
|
|
}
|
|
}
|
|
|
|
type installOptions struct {
|
|
*services.InstallReleaseRequest
|
|
}
|
|
|
|
type installOption func(*installOptions)
|
|
|
|
func withName(name string) installOption {
|
|
return func(opts *installOptions) {
|
|
opts.Name = name
|
|
}
|
|
}
|
|
|
|
func withDryRun() installOption {
|
|
return func(opts *installOptions) {
|
|
opts.DryRun = true
|
|
}
|
|
}
|
|
|
|
func withDisabledHooks() installOption {
|
|
return func(opts *installOptions) {
|
|
opts.DisableHooks = true
|
|
}
|
|
}
|
|
|
|
func withReuseName() installOption {
|
|
return func(opts *installOptions) {
|
|
opts.ReuseName = true
|
|
}
|
|
}
|
|
|
|
func withChart(chartOpts ...chartOption) installOption {
|
|
return func(opts *installOptions) {
|
|
opts.Chart = buildChart(chartOpts...)
|
|
}
|
|
}
|
|
|
|
func withSubNotes() installOption {
|
|
return func(opts *installOptions) {
|
|
opts.SubNotes = true
|
|
}
|
|
}
|
|
|
|
func installRequest(opts ...installOption) *services.InstallReleaseRequest {
|
|
reqOpts := &installOptions{
|
|
&services.InstallReleaseRequest{
|
|
Namespace: "spaced",
|
|
Chart: buildChart(),
|
|
},
|
|
}
|
|
|
|
for _, opt := range opts {
|
|
opt(reqOpts)
|
|
}
|
|
|
|
return reqOpts.InstallReleaseRequest
|
|
}
|
|
|
|
// chartStub creates a fully stubbed out chart.
|
|
func chartStub() *chart.Chart {
|
|
return buildChart(withSampleTemplates())
|
|
}
|
|
|
|
// releaseStub creates a release stub, complete with the chartStub as its chart.
|
|
func releaseStub() *release.Release {
|
|
return namedReleaseStub("angry-panda", release.Status_DEPLOYED)
|
|
}
|
|
|
|
func namedReleaseStub(name string, status release.Status_Code) *release.Release {
|
|
date := timestamp.Timestamp{Seconds: 242085845, Nanos: 0}
|
|
return &release.Release{
|
|
Name: name,
|
|
Info: &release.Info{
|
|
FirstDeployed: &date,
|
|
LastDeployed: &date,
|
|
Status: &release.Status{Code: status},
|
|
Description: "Named Release Stub",
|
|
},
|
|
Chart: chartStub(),
|
|
Config: &chart.Config{Raw: `name: value`},
|
|
Version: 1,
|
|
Hooks: []*release.Hook{
|
|
{
|
|
Name: "test-cm",
|
|
Kind: "ConfigMap",
|
|
Path: "test-cm",
|
|
Manifest: manifestWithHook,
|
|
Events: []release.Hook_Event{
|
|
release.Hook_POST_INSTALL,
|
|
release.Hook_PRE_DELETE,
|
|
},
|
|
},
|
|
{
|
|
Name: "finding-nemo",
|
|
Kind: "Pod",
|
|
Path: "finding-nemo",
|
|
Manifest: manifestWithTestHook,
|
|
Events: []release.Hook_Event{
|
|
release.Hook_RELEASE_TEST_SUCCESS,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func upgradeReleaseVersion(rel *release.Release) *release.Release {
|
|
date := timestamp.Timestamp{Seconds: 242085845, Nanos: 0}
|
|
|
|
rel.Info.Status.Code = release.Status_SUPERSEDED
|
|
return &release.Release{
|
|
Name: rel.Name,
|
|
Info: &release.Info{
|
|
FirstDeployed: rel.Info.FirstDeployed,
|
|
LastDeployed: &date,
|
|
Status: &release.Status{Code: release.Status_DEPLOYED},
|
|
},
|
|
Chart: rel.Chart,
|
|
Config: rel.Config,
|
|
Version: rel.Version + 1,
|
|
}
|
|
}
|
|
|
|
func TestValidName(t *testing.T) {
|
|
for name, valid := range map[string]error{
|
|
"nina pinta santa-maria": errInvalidName,
|
|
"nina-pinta-santa-maria": nil,
|
|
"-nina": errInvalidName,
|
|
"pinta-": errInvalidName,
|
|
"santa-maria": nil,
|
|
"niña": errInvalidName,
|
|
"...": errInvalidName,
|
|
"pinta...": errInvalidName,
|
|
"santa...maria": nil,
|
|
"": errMissingRelease,
|
|
" ": errInvalidName,
|
|
".nina.": errInvalidName,
|
|
"nina.pinta": nil,
|
|
"abcdefghi-abcdefghi-abcdefghi-abcdefghi-abcdefghi-abcd": errInvalidName,
|
|
} {
|
|
if valid != validateReleaseName(name) {
|
|
t.Errorf("Expected %q to be %t", name, valid)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetAllVersionSet(t *testing.T) {
|
|
rs := rsFixture()
|
|
vs, err := GetAllVersionSet(rs.clientset.Discovery())
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !vs.Has("v1") {
|
|
t.Errorf("Expected supported versions to at least include v1.")
|
|
}
|
|
if vs.Has("nosuchversion/v1") {
|
|
t.Error("Non-existent version is reported found.")
|
|
}
|
|
}
|
|
|
|
func TestGetVersionSet(t *testing.T) {
|
|
rs := rsFixture()
|
|
vs, err := GetVersionSet(rs.clientset.Discovery())
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !vs.Has("v1") {
|
|
t.Errorf("Expected supported versions to at least include v1.")
|
|
}
|
|
if vs.Has("nosuchversion/v1") {
|
|
t.Error("Non-existent version is reported found.")
|
|
}
|
|
}
|
|
|
|
func TestUniqName(t *testing.T) {
|
|
rs := rsFixture()
|
|
|
|
rel1 := releaseStub()
|
|
rel2 := releaseStub()
|
|
rel2.Name = "happy-panda"
|
|
rel2.Info.Status.Code = release.Status_DELETED
|
|
|
|
rs.env.Releases.Create(rel1)
|
|
rs.env.Releases.Create(rel2)
|
|
|
|
tests := []struct {
|
|
name string
|
|
expect string
|
|
reuse bool
|
|
err bool
|
|
}{
|
|
{"first", "first", false, false},
|
|
{"", "[a-z]+-[a-z]+", false, false},
|
|
{"angry-panda", "", false, true},
|
|
{"happy-panda", "", false, true},
|
|
{"happy-panda", "happy-panda", true, false},
|
|
{"hungry-hungry-hungry-hungry-hungry-hungry-hungry-hungry-hippos", "", true, true}, // Exceeds max name length
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
u, err := rs.uniqName(tt.name, tt.reuse)
|
|
if err != nil {
|
|
if tt.err {
|
|
continue
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
if tt.err {
|
|
t.Errorf("Expected an error for %q", tt.name)
|
|
}
|
|
if match, err := regexp.MatchString(tt.expect, u); err != nil {
|
|
t.Fatal(err)
|
|
} else if !match {
|
|
t.Errorf("Expected %q to match %q", u, tt.expect)
|
|
}
|
|
}
|
|
}
|
|
|
|
type fakeNamer struct {
|
|
name string
|
|
}
|
|
|
|
func NewFakeNamer(nam string) moniker.Namer {
|
|
return &fakeNamer{
|
|
name: nam,
|
|
}
|
|
}
|
|
|
|
func (f *fakeNamer) Name() string {
|
|
return f.NameSep(" ")
|
|
}
|
|
|
|
func (f *fakeNamer) NameSep(sep string) string {
|
|
return f.name
|
|
}
|
|
|
|
func TestCreateUniqueName(t *testing.T) {
|
|
rs := rsFixture()
|
|
|
|
rel1 := releaseStub()
|
|
rel1.Name = "happy-panda"
|
|
|
|
rs.env.Releases.Create(rel1)
|
|
|
|
tests := []struct {
|
|
name string
|
|
expect string
|
|
err bool
|
|
}{
|
|
{"happy-panda", "ERROR", true},
|
|
{"wobbly-octopus", "[a-z]+-[a-z]+", false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
m := NewFakeNamer(tt.name)
|
|
u, err := rs.createUniqName(m)
|
|
if err != nil {
|
|
if tt.err {
|
|
continue
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
if tt.err {
|
|
t.Errorf("Expected an error for %q", tt.name)
|
|
}
|
|
if match, err := regexp.MatchString(tt.expect, u); err != nil {
|
|
t.Fatal(err)
|
|
} else if !match {
|
|
t.Errorf("Expected %q to match %q", u, tt.expect)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func releaseWithKeepStub(rlsName string) *release.Release {
|
|
ch := &chart.Chart{
|
|
Metadata: &chart.Metadata{
|
|
Name: "bunnychart",
|
|
},
|
|
Templates: []*chart.Template{
|
|
{Name: "templates/configmap-keep-a", Data: []byte(manifestWithKeep)},
|
|
{Name: "templates/configmap-keep-b", Data: []byte(manifestWithKeepEmpty)},
|
|
},
|
|
}
|
|
|
|
date := timestamp.Timestamp{Seconds: 242085845, Nanos: 0}
|
|
rl := &release.Release{
|
|
Name: rlsName,
|
|
Info: &release.Info{
|
|
FirstDeployed: &date,
|
|
LastDeployed: &date,
|
|
Status: &release.Status{Code: release.Status_DEPLOYED},
|
|
},
|
|
Chart: ch,
|
|
Config: &chart.Config{Raw: `name: value`},
|
|
Version: 1,
|
|
}
|
|
|
|
helm.RenderReleaseMock(rl, false)
|
|
|
|
return rl
|
|
}
|
|
|
|
func MockEnvironment() *environment.Environment {
|
|
e := environment.New()
|
|
e.Releases = storage.Init(driver.NewMemory())
|
|
e.KubeClient = &environment.PrintingKubeClient{Out: ioutil.Discard}
|
|
return e
|
|
}
|
|
|
|
func newUpdateFailingKubeClient() *updateFailingKubeClient {
|
|
return &updateFailingKubeClient{
|
|
PrintingKubeClient: environment.PrintingKubeClient{Out: os.Stdout},
|
|
}
|
|
|
|
}
|
|
|
|
type updateFailingKubeClient struct {
|
|
environment.PrintingKubeClient
|
|
}
|
|
|
|
func (u *updateFailingKubeClient) Update(namespace string, originalReader, modifiedReader io.Reader, force bool, recreate bool, timeout int64, shouldWait bool) error {
|
|
return u.UpdateWithOptions(namespace, originalReader, modifiedReader, kube.UpdateOptions{
|
|
Force: force,
|
|
Recreate: recreate,
|
|
Timeout: timeout,
|
|
ShouldWait: shouldWait,
|
|
})
|
|
}
|
|
|
|
func (u *updateFailingKubeClient) UpdateWithOptions(namespace string, originalReader, modifiedReader io.Reader, opts kube.UpdateOptions) error {
|
|
return errors.New("Failed update in kube client")
|
|
}
|
|
|
|
func newHookFailingKubeClient() *hookFailingKubeClient {
|
|
return &hookFailingKubeClient{
|
|
PrintingKubeClient: environment.PrintingKubeClient{Out: ioutil.Discard},
|
|
}
|
|
}
|
|
|
|
type hookFailingKubeClient struct {
|
|
environment.PrintingKubeClient
|
|
}
|
|
|
|
func (h *hookFailingKubeClient) WatchUntilReady(ns string, r io.Reader, timeout int64, shouldWait bool) error {
|
|
return errors.New("Failed watch")
|
|
}
|
|
|
|
func newDeleteFailingKubeClient() *deleteFailingKubeClient {
|
|
return &deleteFailingKubeClient{
|
|
PrintingKubeClient: environment.PrintingKubeClient{Out: ioutil.Discard},
|
|
}
|
|
}
|
|
|
|
type deleteFailingKubeClient struct {
|
|
environment.PrintingKubeClient
|
|
}
|
|
|
|
func (d *deleteFailingKubeClient) Delete(ns string, r io.Reader) error {
|
|
return kube.ErrNoObjectsVisited
|
|
}
|
|
|
|
func (d *deleteFailingKubeClient) DeleteWithTimeout(ns string, r io.Reader, timeout int64, shouldWait bool) error {
|
|
return kube.ErrNoObjectsVisited
|
|
}
|
|
|
|
type mockListServer struct {
|
|
val *services.ListReleasesResponse
|
|
}
|
|
|
|
func (l *mockListServer) Send(res *services.ListReleasesResponse) error {
|
|
l.val = res
|
|
return nil
|
|
}
|
|
|
|
func (l *mockListServer) Context() context.Context { return helm.NewContext() }
|
|
func (l *mockListServer) SendMsg(v interface{}) error { return nil }
|
|
func (l *mockListServer) RecvMsg(v interface{}) error { return nil }
|
|
func (l *mockListServer) SendHeader(m metadata.MD) error { return nil }
|
|
func (l *mockListServer) SetTrailer(m metadata.MD) {}
|
|
func (l *mockListServer) SetHeader(m metadata.MD) error { return nil }
|
|
|
|
type mockRunReleaseTestServer struct{}
|
|
|
|
func (rs mockRunReleaseTestServer) Send(m *services.TestReleaseResponse) error {
|
|
return nil
|
|
}
|
|
func (rs mockRunReleaseTestServer) SetHeader(m metadata.MD) error { return nil }
|
|
func (rs mockRunReleaseTestServer) SendHeader(m metadata.MD) error { return nil }
|
|
func (rs mockRunReleaseTestServer) SetTrailer(m metadata.MD) {}
|
|
func (rs mockRunReleaseTestServer) SendMsg(v interface{}) error { return nil }
|
|
func (rs mockRunReleaseTestServer) RecvMsg(v interface{}) error { return nil }
|
|
func (rs mockRunReleaseTestServer) Context() context.Context {
|
|
return helm.NewContext()
|
|
}
|
|
|
|
type mockHooksManifest struct {
|
|
Metadata struct {
|
|
Name string
|
|
Annotations map[string]string
|
|
}
|
|
}
|
|
type mockHooksKubeClient struct {
|
|
Resources map[string]*mockHooksManifest
|
|
}
|
|
|
|
var errResourceExists = errors.New("resource already exists")
|
|
|
|
func (kc *mockHooksKubeClient) makeManifest(r io.Reader) (*mockHooksManifest, error) {
|
|
b, err := ioutil.ReadAll(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
manifest := &mockHooksManifest{}
|
|
err = yaml.Unmarshal(b, manifest)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return manifest, nil
|
|
}
|
|
func (kc *mockHooksKubeClient) Create(ns string, r io.Reader, timeout int64, shouldWait bool) error {
|
|
manifest, err := kc.makeManifest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, hasKey := kc.Resources[manifest.Metadata.Name]; hasKey {
|
|
return errResourceExists
|
|
}
|
|
|
|
kc.Resources[manifest.Metadata.Name] = manifest
|
|
|
|
return nil
|
|
}
|
|
func (kc *mockHooksKubeClient) Get(ns string, r io.Reader) (string, error) {
|
|
return "", nil
|
|
}
|
|
func (kc *mockHooksKubeClient) Delete(ns string, r io.Reader) error {
|
|
return kc.DeleteWithTimeout(ns, r, 0, false)
|
|
}
|
|
func (kc *mockHooksKubeClient) DeleteWithTimeout(ns string, r io.Reader, timeout int64, shouldWait bool) error {
|
|
manifest, err := kc.makeManifest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
delete(kc.Resources, manifest.Metadata.Name)
|
|
|
|
return nil
|
|
}
|
|
func (kc *mockHooksKubeClient) WatchUntilReady(ns string, r io.Reader, timeout int64, shouldWait bool) error {
|
|
paramManifest, err := kc.makeManifest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
manifest, hasManifest := kc.Resources[paramManifest.Metadata.Name]
|
|
if !hasManifest {
|
|
return fmt.Errorf("mockHooksKubeClient.WatchUntilReady: no such resource %s found", paramManifest.Metadata.Name)
|
|
}
|
|
|
|
if manifest.Metadata.Annotations["mockHooksKubeClient/Emulate"] == "hook-failed" {
|
|
return fmt.Errorf("mockHooksKubeClient.WatchUntilReady: hook-failed")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (kc *mockHooksKubeClient) Update(ns string, currentReader, modifiedReader io.Reader, force bool, recreate bool, timeout int64, shouldWait bool) error {
|
|
return nil
|
|
}
|
|
func (kc *mockHooksKubeClient) UpdateWithOptions(ns string, currentReader, modifiedReader io.Reader, opts kube.UpdateOptions) error {
|
|
return nil
|
|
}
|
|
func (kc *mockHooksKubeClient) Build(ns string, reader io.Reader) (kube.Result, error) {
|
|
return []*resource.Info{}, nil
|
|
}
|
|
func (kc *mockHooksKubeClient) BuildUnstructured(ns string, reader io.Reader) (kube.Result, error) {
|
|
return []*resource.Info{}, nil
|
|
}
|
|
func (kc *mockHooksKubeClient) Validate(ns string, reader io.Reader) error {
|
|
return nil
|
|
}
|
|
func (kc *mockHooksKubeClient) WaitAndGetCompletedPodPhase(namespace string, reader io.Reader, timeout time.Duration) (v1.PodPhase, error) {
|
|
return v1.PodUnknown, nil
|
|
}
|
|
func (kc *mockHooksKubeClient) GetPodLogs(name, namespace string) (io.ReadCloser, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (kc *mockHooksKubeClient) WaitUntilCRDEstablished(reader io.Reader, timeout time.Duration) error {
|
|
return nil
|
|
}
|
|
|
|
func deletePolicyStub(kubeClient *mockHooksKubeClient) *ReleaseServer {
|
|
e := environment.New()
|
|
e.Releases = storage.Init(driver.NewMemory())
|
|
e.KubeClient = kubeClient
|
|
|
|
clientset := fake.NewSimpleClientset()
|
|
return &ReleaseServer{
|
|
ReleaseModule: &LocalReleaseModule{
|
|
clientset: clientset,
|
|
},
|
|
env: e,
|
|
clientset: clientset,
|
|
Log: func(_ string, _ ...interface{}) {},
|
|
}
|
|
}
|
|
|
|
func deletePolicyHookStub(hookName string, extraAnnotations map[string]string, DeletePolicies []release.Hook_DeletePolicy) *release.Hook {
|
|
extraAnnotationsStr := ""
|
|
for k, v := range extraAnnotations {
|
|
extraAnnotationsStr += fmt.Sprintf(" \"%s\": \"%s\"\n", k, v)
|
|
}
|
|
|
|
return &release.Hook{
|
|
Name: hookName,
|
|
Kind: "Job",
|
|
Path: hookName,
|
|
Manifest: fmt.Sprintf(`kind: Job
|
|
metadata:
|
|
name: %s
|
|
annotations:
|
|
"helm.sh/hook": pre-install,pre-upgrade
|
|
%sdata:
|
|
name: value`, hookName, extraAnnotationsStr),
|
|
Events: []release.Hook_Event{
|
|
release.Hook_PRE_INSTALL,
|
|
release.Hook_PRE_UPGRADE,
|
|
},
|
|
DeletePolicies: DeletePolicies,
|
|
}
|
|
}
|
|
|
|
func execHookShouldSucceed(rs *ReleaseServer, hook *release.Hook, releaseName string, namespace string, hookType string) error {
|
|
err := rs.execHook([]*release.Hook{hook}, releaseName, namespace, hookType, 600)
|
|
if err != nil {
|
|
return fmt.Errorf("expected hook %s to be successful: %s", hook.Name, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func execHookShouldFail(rs *ReleaseServer, hook *release.Hook, releaseName string, namespace string, hookType string) error {
|
|
err := rs.execHook([]*release.Hook{hook}, releaseName, namespace, hookType, 600)
|
|
if err == nil {
|
|
return fmt.Errorf("expected hook %s to be failed", hook.Name)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func execHookShouldFailWithError(rs *ReleaseServer, hook *release.Hook, releaseName string, namespace string, hookType string, expectedError error) error {
|
|
err := rs.execHook([]*release.Hook{hook}, releaseName, namespace, hookType, 600)
|
|
if err != expectedError {
|
|
return fmt.Errorf("expected hook %s to fail with error %v, got %v", hook.Name, expectedError, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type deletePolicyContext struct {
|
|
ReleaseServer *ReleaseServer
|
|
ReleaseName string
|
|
Namespace string
|
|
HookName string
|
|
KubeClient *mockHooksKubeClient
|
|
}
|
|
|
|
func newDeletePolicyContext() *deletePolicyContext {
|
|
kubeClient := &mockHooksKubeClient{
|
|
Resources: make(map[string]*mockHooksManifest),
|
|
}
|
|
|
|
return &deletePolicyContext{
|
|
KubeClient: kubeClient,
|
|
ReleaseServer: deletePolicyStub(kubeClient),
|
|
ReleaseName: "flying-carp",
|
|
Namespace: "river",
|
|
HookName: "migration-job",
|
|
}
|
|
}
|
|
|
|
func TestSuccessfulHookWithoutDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
hook := deletePolicyHookStub(ctx.HookName, nil, nil)
|
|
|
|
err := execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be created by kube client", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestFailedHookWithoutDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{"mockHooksKubeClient/Emulate": "hook-failed"},
|
|
nil,
|
|
)
|
|
|
|
err := execHookShouldFail(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be created by kube client", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestSuccessfulHookWithSucceededDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{"helm.sh/hook-delete-policy": "hook-succeeded"},
|
|
[]release.Hook_DeletePolicy{release.Hook_SUCCEEDED},
|
|
)
|
|
|
|
err := execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; hasResource {
|
|
t.Errorf("expected resource %s to be unexisting after hook succeeded", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestSuccessfulHookWithFailedDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{"helm.sh/hook-delete-policy": "hook-failed"},
|
|
[]release.Hook_DeletePolicy{release.Hook_FAILED},
|
|
)
|
|
|
|
err := execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after hook succeeded", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestFailedHookWithSucceededDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{
|
|
"mockHooksKubeClient/Emulate": "hook-failed",
|
|
"helm.sh/hook-delete-policy": "hook-succeeded",
|
|
},
|
|
[]release.Hook_DeletePolicy{release.Hook_SUCCEEDED},
|
|
)
|
|
|
|
err := execHookShouldFail(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after hook failed", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestFailedHookWithFailedDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{
|
|
"mockHooksKubeClient/Emulate": "hook-failed",
|
|
"helm.sh/hook-delete-policy": "hook-failed",
|
|
},
|
|
[]release.Hook_DeletePolicy{release.Hook_FAILED},
|
|
)
|
|
|
|
err := execHookShouldFail(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; hasResource {
|
|
t.Errorf("expected resource %s to be unexisting after hook failed", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestSuccessfulHookWithSuccededOrFailedDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{
|
|
"helm.sh/hook-delete-policy": "hook-succeeded,hook-failed",
|
|
},
|
|
[]release.Hook_DeletePolicy{release.Hook_SUCCEEDED, release.Hook_FAILED},
|
|
)
|
|
|
|
err := execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; hasResource {
|
|
t.Errorf("expected resource %s to be unexisting after hook succeeded", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestFailedHookWithSuccededOrFailedDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{
|
|
"mockHooksKubeClient/Emulate": "hook-failed",
|
|
"helm.sh/hook-delete-policy": "hook-succeeded,hook-failed",
|
|
},
|
|
[]release.Hook_DeletePolicy{release.Hook_SUCCEEDED, release.Hook_FAILED},
|
|
)
|
|
|
|
err := execHookShouldFail(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; hasResource {
|
|
t.Errorf("expected resource %s to be unexisting after hook failed", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestHookAlreadyExists(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName, nil, nil)
|
|
|
|
err := execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after hook succeeded", hook.Name)
|
|
}
|
|
|
|
err = execHookShouldFailWithError(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreUpgrade, errResourceExists)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after already exists error", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestHookDeletingWithBeforeHookCreationDeletePolicy(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{"helm.sh/hook-delete-policy": "before-hook-creation"},
|
|
[]release.Hook_DeletePolicy{release.Hook_BEFORE_HOOK_CREATION},
|
|
)
|
|
|
|
err := execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after hook succeeded", hook.Name)
|
|
}
|
|
|
|
err = execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreUpgrade)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after hook succeeded", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestSuccessfulHookWithMixedDeletePolicies(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{
|
|
"helm.sh/hook-delete-policy": "hook-succeeded,before-hook-creation",
|
|
},
|
|
[]release.Hook_DeletePolicy{release.Hook_SUCCEEDED, release.Hook_BEFORE_HOOK_CREATION},
|
|
)
|
|
|
|
err := execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; hasResource {
|
|
t.Errorf("expected resource %s to be unexisting after hook succeeded", hook.Name)
|
|
}
|
|
|
|
err = execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreUpgrade)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; hasResource {
|
|
t.Errorf("expected resource %s to be unexisting after hook succeeded", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestFailedHookWithMixedDeletePolicies(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{
|
|
"mockHooksKubeClient/Emulate": "hook-failed",
|
|
"helm.sh/hook-delete-policy": "hook-succeeded,before-hook-creation",
|
|
},
|
|
[]release.Hook_DeletePolicy{release.Hook_SUCCEEDED, release.Hook_BEFORE_HOOK_CREATION},
|
|
)
|
|
|
|
err := execHookShouldFail(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after hook failed", hook.Name)
|
|
}
|
|
|
|
err = execHookShouldFail(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreUpgrade)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after hook failed", hook.Name)
|
|
}
|
|
}
|
|
|
|
func TestFailedThenSuccessfulHookWithMixedDeletePolicies(t *testing.T) {
|
|
ctx := newDeletePolicyContext()
|
|
|
|
hook := deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{
|
|
"mockHooksKubeClient/Emulate": "hook-failed",
|
|
"helm.sh/hook-delete-policy": "hook-succeeded,before-hook-creation",
|
|
},
|
|
[]release.Hook_DeletePolicy{release.Hook_SUCCEEDED, release.Hook_BEFORE_HOOK_CREATION},
|
|
)
|
|
|
|
err := execHookShouldFail(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreInstall)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; !hasResource {
|
|
t.Errorf("expected resource %s to be existing after hook failed", hook.Name)
|
|
}
|
|
|
|
hook = deletePolicyHookStub(ctx.HookName,
|
|
map[string]string{
|
|
"helm.sh/hook-delete-policy": "hook-succeeded,before-hook-creation",
|
|
},
|
|
[]release.Hook_DeletePolicy{release.Hook_SUCCEEDED, release.Hook_BEFORE_HOOK_CREATION},
|
|
)
|
|
|
|
err = execHookShouldSucceed(ctx.ReleaseServer, hook, ctx.ReleaseName, ctx.Namespace, hooks.PreUpgrade)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if _, hasResource := ctx.KubeClient.Resources[hook.Name]; hasResource {
|
|
t.Errorf("expected resource %s to be unexisting after hook succeeded", hook.Name)
|
|
}
|
|
}
|