Merge pull request #3025 from beeradb/fakeclient-releasestatus

Improvements to FakeClient: support all CRUD operations
pull/3129/head
Adam Reese 7 years ago committed by GitHub
commit e93b77166d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -23,6 +23,7 @@ import (
"github.com/spf13/cobra" "github.com/spf13/cobra"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
"k8s.io/helm/pkg/proto/hapi/release"
) )
func TestDelete(t *testing.T) { func TestDelete(t *testing.T) {
@ -33,28 +34,32 @@ func TestDelete(t *testing.T) {
args: []string{"aeneas"}, args: []string{"aeneas"},
flags: []string{}, flags: []string{},
expected: "", // Output of a delete is an empty string and exit 0. expected: "", // Output of a delete is an empty string and exit 0.
resp: releaseMock(&releaseOptions{name: "aeneas"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"}),
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"})},
}, },
{ {
name: "delete with timeout", name: "delete with timeout",
args: []string{"aeneas"}, args: []string{"aeneas"},
flags: []string{"--timeout", "120"}, flags: []string{"--timeout", "120"},
expected: "", expected: "",
resp: releaseMock(&releaseOptions{name: "aeneas"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"}),
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"})},
}, },
{ {
name: "delete without hooks", name: "delete without hooks",
args: []string{"aeneas"}, args: []string{"aeneas"},
flags: []string{"--no-hooks"}, flags: []string{"--no-hooks"},
expected: "", expected: "",
resp: releaseMock(&releaseOptions{name: "aeneas"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"}),
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"})},
}, },
{ {
name: "purge", name: "purge",
args: []string{"aeneas"}, args: []string{"aeneas"},
flags: []string{"--purge"}, flags: []string{"--purge"},
expected: "", expected: "",
resp: releaseMock(&releaseOptions{name: "aeneas"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"}),
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"})},
}, },
{ {
name: "delete without release", name: "delete without release",

@ -23,6 +23,7 @@ import (
"github.com/spf13/cobra" "github.com/spf13/cobra"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
"k8s.io/helm/pkg/proto/hapi/release"
) )
func TestGetHooks(t *testing.T) { func TestGetHooks(t *testing.T) {
@ -30,8 +31,9 @@ func TestGetHooks(t *testing.T) {
{ {
name: "get hooks with release", name: "get hooks with release",
args: []string{"aeneas"}, args: []string{"aeneas"},
expected: mockHookTemplate, expected: helm.MockHookTemplate,
resp: releaseMock(&releaseOptions{name: "aeneas"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"}),
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"})},
}, },
{ {
name: "get hooks without args", name: "get hooks without args",

@ -23,6 +23,7 @@ import (
"github.com/spf13/cobra" "github.com/spf13/cobra"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
"k8s.io/helm/pkg/proto/hapi/release"
) )
func TestGetManifest(t *testing.T) { func TestGetManifest(t *testing.T) {
@ -30,8 +31,9 @@ func TestGetManifest(t *testing.T) {
{ {
name: "get manifest with release", name: "get manifest with release",
args: []string{"juno"}, args: []string{"juno"},
expected: mockManifest, expected: helm.MockManifest,
resp: releaseMock(&releaseOptions{name: "juno"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "juno"}),
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "juno"})},
}, },
{ {
name: "get manifest without args", name: "get manifest without args",

@ -23,15 +23,17 @@ import (
"github.com/spf13/cobra" "github.com/spf13/cobra"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
"k8s.io/helm/pkg/proto/hapi/release"
) )
func TestGetCmd(t *testing.T) { func TestGetCmd(t *testing.T) {
tests := []releaseCase{ tests := []releaseCase{
{ {
name: "get with a release", name: "get with a release",
resp: releaseMock(&releaseOptions{name: "thomas-guide"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide"}),
args: []string{"thomas-guide"}, args: []string{"thomas-guide"},
expected: "REVISION: 1\nRELEASED: (.*)\nCHART: foo-0.1.0-beta.1\nUSER-SUPPLIED VALUES:\nname: \"value\"\nCOMPUTED VALUES:\nname: value\n\nHOOKS:\n---\n# pre-install-hook\n" + mockHookTemplate + "\nMANIFEST:", expected: "REVISION: 1\nRELEASED: (.*)\nCHART: foo-0.1.0-beta.1\nUSER-SUPPLIED VALUES:\nname: \"value\"\nCOMPUTED VALUES:\nname: value\n\nHOOKS:\n---\n# pre-install-hook\n" + helm.MockHookTemplate + "\nMANIFEST:",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide"})},
}, },
{ {
name: "get requires release name arg", name: "get requires release name arg",

@ -23,15 +23,17 @@ import (
"github.com/spf13/cobra" "github.com/spf13/cobra"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
"k8s.io/helm/pkg/proto/hapi/release"
) )
func TestGetValuesCmd(t *testing.T) { func TestGetValuesCmd(t *testing.T) {
tests := []releaseCase{ tests := []releaseCase{
{ {
name: "get values with a release", name: "get values with a release",
resp: releaseMock(&releaseOptions{name: "thomas-guide"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide"}),
args: []string{"thomas-guide"}, args: []string{"thomas-guide"},
expected: "name: \"value\"", expected: "name: \"value\"",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide"})},
}, },
{ {
name: "get values requires release name arg", name: "get values requires release name arg",

@ -21,115 +21,30 @@ import (
"fmt" "fmt"
"io" "io"
"io/ioutil" "io/ioutil"
"math/rand"
"os" "os"
"path/filepath" "path/filepath"
"regexp" "regexp"
"strings" "strings"
"testing" "testing"
"github.com/golang/protobuf/ptypes/timestamp"
"github.com/spf13/cobra" "github.com/spf13/cobra"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
"k8s.io/helm/pkg/helm/helmpath" "k8s.io/helm/pkg/helm/helmpath"
"k8s.io/helm/pkg/proto/hapi/chart"
"k8s.io/helm/pkg/proto/hapi/release" "k8s.io/helm/pkg/proto/hapi/release"
"k8s.io/helm/pkg/repo" "k8s.io/helm/pkg/repo"
) )
var mockHookTemplate = `apiVersion: v1
kind: Job
metadata:
annotations:
"helm.sh/hooks": pre-install
`
var mockManifest = `apiVersion: v1
kind: Secret
metadata:
name: fixture
`
type releaseOptions struct {
name string
version int32
chart *chart.Chart
statusCode release.Status_Code
namespace string
}
func releaseMock(opts *releaseOptions) *release.Release {
date := timestamp.Timestamp{Seconds: 242085845, Nanos: 0}
name := opts.name
if name == "" {
name = "testrelease-" + string(rand.Intn(100))
}
var version int32 = 1
if opts.version != 0 {
version = opts.version
}
namespace := opts.namespace
if namespace == "" {
namespace = "default"
}
ch := opts.chart
if opts.chart == nil {
ch = &chart.Chart{
Metadata: &chart.Metadata{
Name: "foo",
Version: "0.1.0-beta.1",
},
Templates: []*chart.Template{
{Name: "templates/foo.tpl", Data: []byte(mockManifest)},
},
}
}
scode := release.Status_DEPLOYED
if opts.statusCode > 0 {
scode = opts.statusCode
}
return &release.Release{
Name: name,
Info: &release.Info{
FirstDeployed: &date,
LastDeployed: &date,
Status: &release.Status{Code: scode},
Description: "Release mock",
},
Chart: ch,
Config: &chart.Config{Raw: `name: "value"`},
Version: version,
Namespace: namespace,
Hooks: []*release.Hook{
{
Name: "pre-install-hook",
Kind: "Job",
Path: "pre-install-hook.yaml",
Manifest: mockHookTemplate,
LastRun: &date,
Events: []release.Hook_Event{release.Hook_PRE_INSTALL},
},
},
Manifest: mockManifest,
}
}
// releaseCmd is a command that works with a FakeClient // releaseCmd is a command that works with a FakeClient
type releaseCmd func(c *helm.FakeClient, out io.Writer) *cobra.Command type releaseCmd func(c *helm.FakeClient, out io.Writer) *cobra.Command
// runReleaseCases runs a set of release cases through the given releaseCmd. // runReleaseCases runs a set of release cases through the given releaseCmd.
func runReleaseCases(t *testing.T, tests []releaseCase, rcmd releaseCmd) { func runReleaseCases(t *testing.T, tests []releaseCase, rcmd releaseCmd) {
var buf bytes.Buffer var buf bytes.Buffer
for _, tt := range tests { for _, tt := range tests {
c := &helm.FakeClient{ c := &helm.FakeClient{
Rels: []*release.Release{tt.resp}, Rels: tt.rels,
} }
cmd := rcmd(c, &buf) cmd := rcmd(c, &buf)
cmd.ParseFlags(tt.flags) cmd.ParseFlags(tt.flags)
@ -154,6 +69,8 @@ type releaseCase struct {
expected string expected string
err bool err bool
resp *release.Release resp *release.Release
// Rels are the available releases at the start of the test.
rels []*release.Release
} }
// tempHelmHome sets up a Helm Home in a temp dir. // tempHelmHome sets up a Helm Home in a temp dir.
@ -230,6 +147,7 @@ func ensureTestHome(home helmpath.Home, t *testing.T) error {
t.Logf("$HELM_HOME has been configured at %s.\n", settings.Home.String()) t.Logf("$HELM_HOME has been configured at %s.\n", settings.Home.String())
return nil return nil
} }
func TestRootCmd(t *testing.T) { func TestRootCmd(t *testing.T) {

@ -27,10 +27,10 @@ import (
func TestHistoryCmd(t *testing.T) { func TestHistoryCmd(t *testing.T) {
mk := func(name string, vers int32, code rpb.Status_Code) *rpb.Release { mk := func(name string, vers int32, code rpb.Status_Code) *rpb.Release {
return releaseMock(&releaseOptions{ return helm.ReleaseMock(&helm.MockReleaseOptions{
name: name, Name: name,
version: vers, Version: vers,
statusCode: code, StatusCode: code,
}) })
} }

@ -24,7 +24,6 @@ import (
"testing" "testing"
"github.com/spf13/cobra" "github.com/spf13/cobra"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
) )
@ -36,46 +35,46 @@ func TestInstall(t *testing.T) {
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("--name aeneas", " "), flags: strings.Split("--name aeneas", " "),
expected: "aeneas", expected: "aeneas",
resp: releaseMock(&releaseOptions{name: "aeneas"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"}),
}, },
// Install, no hooks // Install, no hooks
{ {
name: "install without hooks", name: "install without hooks",
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("--name aeneas --no-hooks", " "), flags: strings.Split("--name aeneas --no-hooks", " "),
expected: "juno", expected: "aeneas",
resp: releaseMock(&releaseOptions{name: "juno"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"}),
}, },
// Install, values from cli // Install, values from cli
{ {
name: "install with values", name: "install with values",
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("--set foo=bar", " "), flags: strings.Split("--name virgil --set foo=bar", " "),
resp: releaseMock(&releaseOptions{name: "virgil"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "virgil"}),
expected: "virgil", expected: "virgil",
}, },
// Install, values from cli via multiple --set // Install, values from cli via multiple --set
{ {
name: "install with multiple values", name: "install with multiple values",
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("--set foo=bar", "--set bar=foo"), flags: strings.Split("--name virgil --set foo=bar --set bar=foo", " "),
resp: releaseMock(&releaseOptions{name: "virgil"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "virgil"}),
expected: "virgil", expected: "virgil",
}, },
// Install, values from yaml // Install, values from yaml
{ {
name: "install with values", name: "install with values",
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("-f testdata/testcharts/alpine/extra_values.yaml", " "), flags: strings.Split("--name virgil -f testdata/testcharts/alpine/extra_values.yaml", " "),
resp: releaseMock(&releaseOptions{name: "virgil"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "virgil"}),
expected: "virgil", expected: "virgil",
}, },
// Install, values from multiple yaml // Install, values from multiple yaml
{ {
name: "install with values", name: "install with values",
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("-f testdata/testcharts/alpine/extra_values.yaml -f testdata/testcharts/alpine/more_values.yaml", " "), flags: strings.Split("--name virgil -f testdata/testcharts/alpine/extra_values.yaml -f testdata/testcharts/alpine/more_values.yaml", " "),
resp: releaseMock(&releaseOptions{name: "virgil"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "virgil"}),
expected: "virgil", expected: "virgil",
}, },
// Install, no charts // Install, no charts
@ -90,23 +89,23 @@ func TestInstall(t *testing.T) {
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("--name aeneas --replace", " "), flags: strings.Split("--name aeneas --replace", " "),
expected: "aeneas", expected: "aeneas",
resp: releaseMock(&releaseOptions{name: "aeneas"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "aeneas"}),
}, },
// Install, with timeout // Install, with timeout
{ {
name: "install with a timeout", name: "install with a timeout",
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("--timeout 120", " "), flags: strings.Split("--name foobar --timeout 120", " "),
expected: "foobar", expected: "foobar",
resp: releaseMock(&releaseOptions{name: "foobar"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "foobar"}),
}, },
// Install, with wait // Install, with wait
{ {
name: "install with a wait", name: "install with a wait",
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: strings.Split("--wait", " "), flags: strings.Split("--name apollo --wait", " "),
expected: "apollo", expected: "apollo",
resp: releaseMock(&releaseOptions{name: "apollo"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "apollo"}),
}, },
// Install, using the name-template // Install, using the name-template
{ {
@ -114,7 +113,7 @@ func TestInstall(t *testing.T) {
args: []string{"testdata/testcharts/alpine"}, args: []string{"testdata/testcharts/alpine"},
flags: []string{"--name-template", "{{upper \"foobar\"}}"}, flags: []string{"--name-template", "{{upper \"foobar\"}}"},
expected: "FOOBAR", expected: "FOOBAR",
resp: releaseMock(&releaseOptions{name: "FOOBAR"}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "FOOBAR"}),
}, },
// Install, perform chart verification along the way. // Install, perform chart verification along the way.
{ {

@ -36,7 +36,7 @@ func TestListCmd(t *testing.T) {
{ {
name: "with a release", name: "with a release",
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "thomas-guide"}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide"}),
}, },
expected: "thomas-guide", expected: "thomas-guide",
}, },
@ -44,7 +44,7 @@ func TestListCmd(t *testing.T) {
name: "list", name: "list",
args: []string{}, args: []string{},
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "atlas"}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas"}),
}, },
expected: "NAME \tREVISION\tUPDATED \tSTATUS \tCHART \tNAMESPACE\natlas\t1 \t(.*)\tDEPLOYED\tfoo-0.1.0-beta.1\tdefault \n", expected: "NAME \tREVISION\tUPDATED \tSTATUS \tCHART \tNAMESPACE\natlas\t1 \t(.*)\tDEPLOYED\tfoo-0.1.0-beta.1\tdefault \n",
}, },
@ -52,8 +52,8 @@ func TestListCmd(t *testing.T) {
name: "list, one deployed, one failed", name: "list, one deployed, one failed",
args: []string{"-q"}, args: []string{"-q"},
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "thomas-guide", statusCode: release.Status_FAILED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide", StatusCode: release.Status_FAILED}),
releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", StatusCode: release.Status_DEPLOYED}),
}, },
expected: "thomas-guide\natlas-guide", expected: "thomas-guide\natlas-guide",
}, },
@ -61,8 +61,8 @@ func TestListCmd(t *testing.T) {
name: "with a release, multiple flags", name: "with a release, multiple flags",
args: []string{"--deleted", "--deployed", "--failed", "-q"}, args: []string{"--deleted", "--deployed", "--failed", "-q"},
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "thomas-guide", statusCode: release.Status_DELETED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide", StatusCode: release.Status_DELETED}),
releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", StatusCode: release.Status_DEPLOYED}),
}, },
// Note: We're really only testing that the flags parsed correctly. Which results are returned // Note: We're really only testing that the flags parsed correctly. Which results are returned
// depends on the backend. And until pkg/helm is done, we can't mock this. // depends on the backend. And until pkg/helm is done, we can't mock this.
@ -72,8 +72,8 @@ func TestListCmd(t *testing.T) {
name: "with a release, multiple flags", name: "with a release, multiple flags",
args: []string{"--all", "-q"}, args: []string{"--all", "-q"},
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "thomas-guide", statusCode: release.Status_DELETED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide", StatusCode: release.Status_DELETED}),
releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", StatusCode: release.Status_DEPLOYED}),
}, },
// See note on previous test. // See note on previous test.
expected: "thomas-guide\natlas-guide", expected: "thomas-guide\natlas-guide",
@ -82,8 +82,8 @@ func TestListCmd(t *testing.T) {
name: "with a release, multiple flags, deleting", name: "with a release, multiple flags, deleting",
args: []string{"--all", "-q"}, args: []string{"--all", "-q"},
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "thomas-guide", statusCode: release.Status_DELETING}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide", StatusCode: release.Status_DELETING}),
releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", StatusCode: release.Status_DEPLOYED}),
}, },
// See note on previous test. // See note on previous test.
expected: "thomas-guide\natlas-guide", expected: "thomas-guide\natlas-guide",
@ -92,8 +92,8 @@ func TestListCmd(t *testing.T) {
name: "namespace defined, multiple flags", name: "namespace defined, multiple flags",
args: []string{"--all", "-q", "--namespace test123"}, args: []string{"--all", "-q", "--namespace test123"},
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "thomas-guide", namespace: "test123"}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide", Namespace: "test123"}),
releaseMock(&releaseOptions{name: "atlas-guide", namespace: "test321"}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", Namespace: "test321"}),
}, },
// See note on previous test. // See note on previous test.
expected: "thomas-guide", expected: "thomas-guide",
@ -102,8 +102,8 @@ func TestListCmd(t *testing.T) {
name: "with a pending release, multiple flags", name: "with a pending release, multiple flags",
args: []string{"--all", "-q"}, args: []string{"--all", "-q"},
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "thomas-guide", statusCode: release.Status_PENDING_INSTALL}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide", StatusCode: release.Status_PENDING_INSTALL}),
releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", StatusCode: release.Status_DEPLOYED}),
}, },
expected: "thomas-guide\natlas-guide", expected: "thomas-guide\natlas-guide",
}, },
@ -111,10 +111,10 @@ func TestListCmd(t *testing.T) {
name: "with a pending release, pending flag", name: "with a pending release, pending flag",
args: []string{"--pending", "-q"}, args: []string{"--pending", "-q"},
resp: []*release.Release{ resp: []*release.Release{
releaseMock(&releaseOptions{name: "thomas-guide", statusCode: release.Status_PENDING_INSTALL}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "thomas-guide", StatusCode: release.Status_PENDING_INSTALL}),
releaseMock(&releaseOptions{name: "wild-idea", statusCode: release.Status_PENDING_UPGRADE}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "wild-idea", StatusCode: release.Status_PENDING_UPGRADE}),
releaseMock(&releaseOptions{name: "crazy-maps", statusCode: release.Status_PENDING_ROLLBACK}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "crazy-maps", StatusCode: release.Status_PENDING_ROLLBACK}),
releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", StatusCode: release.Status_DEPLOYED}),
}, },
expected: "thomas-guide\nwild-idea\ncrazy-maps", expected: "thomas-guide\nwild-idea\ncrazy-maps",
}, },

@ -107,7 +107,7 @@ func TestReset_deployedReleases(t *testing.T) {
var buf bytes.Buffer var buf bytes.Buffer
resp := []*release.Release{ resp := []*release.Release{
releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", StatusCode: release.Status_DEPLOYED}),
} }
c := &helm.FakeClient{ c := &helm.FakeClient{
Rels: resp, Rels: resp,
@ -139,7 +139,7 @@ func TestReset_forceFlag(t *testing.T) {
var buf bytes.Buffer var buf bytes.Buffer
resp := []*release.Release{ resp := []*release.Release{
releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), helm.ReleaseMock(&helm.MockReleaseOptions{Name: "atlas-guide", StatusCode: release.Status_DEPLOYED}),
} }
c := &helm.FakeClient{ c := &helm.FakeClient{
Rels: resp, Rels: resp,

@ -28,6 +28,7 @@ import (
"k8s.io/helm/pkg/chartutil" "k8s.io/helm/pkg/chartutil"
"k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm"
"k8s.io/helm/pkg/proto/hapi/chart" "k8s.io/helm/pkg/proto/hapi/chart"
"k8s.io/helm/pkg/proto/hapi/release"
) )
func TestUpgradeCmd(t *testing.T) { func TestUpgradeCmd(t *testing.T) {
@ -43,9 +44,9 @@ func TestUpgradeCmd(t *testing.T) {
t.Errorf("Error creating chart for upgrade: %v", err) t.Errorf("Error creating chart for upgrade: %v", err)
} }
ch, _ := chartutil.Load(chartPath) ch, _ := chartutil.Load(chartPath)
_ = releaseMock(&releaseOptions{ _ = helm.ReleaseMock(&helm.MockReleaseOptions{
name: "funny-bunny", Name: "funny-bunny",
chart: ch, Chart: ch,
}) })
// update chart version // update chart version
@ -94,61 +95,68 @@ func TestUpgradeCmd(t *testing.T) {
{ {
name: "upgrade a release", name: "upgrade a release",
args: []string{"funny-bunny", chartPath}, args: []string{"funny-bunny", chartPath},
resp: releaseMock(&releaseOptions{name: "funny-bunny", version: 2, chart: ch}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "funny-bunny", Version: 2, Chart: ch}),
expected: "Release \"funny-bunny\" has been upgraded. Happy Helming!\n", expected: "Release \"funny-bunny\" has been upgraded. Happy Helming!\n",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "funny-bunny", Version: 2, Chart: ch})},
}, },
{ {
name: "upgrade a release with timeout", name: "upgrade a release with timeout",
args: []string{"funny-bunny", chartPath}, args: []string{"funny-bunny", chartPath},
flags: []string{"--timeout", "120"}, flags: []string{"--timeout", "120"},
resp: releaseMock(&releaseOptions{name: "funny-bunny", version: 3, chart: ch2}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "funny-bunny", Version: 3, Chart: ch2}),
expected: "Release \"funny-bunny\" has been upgraded. Happy Helming!\n", expected: "Release \"funny-bunny\" has been upgraded. Happy Helming!\n",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "funny-bunny", Version: 3, Chart: ch2})},
}, },
{ {
name: "upgrade a release with --reset-values", name: "upgrade a release with --reset-values",
args: []string{"funny-bunny", chartPath}, args: []string{"funny-bunny", chartPath},
flags: []string{"--reset-values", "true"}, flags: []string{"--reset-values", "true"},
resp: releaseMock(&releaseOptions{name: "funny-bunny", version: 4, chart: ch2}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "funny-bunny", Version: 4, Chart: ch2}),
expected: "Release \"funny-bunny\" has been upgraded. Happy Helming!\n", expected: "Release \"funny-bunny\" has been upgraded. Happy Helming!\n",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "funny-bunny", Version: 4, Chart: ch2})},
}, },
{ {
name: "upgrade a release with --reuse-values", name: "upgrade a release with --reuse-values",
args: []string{"funny-bunny", chartPath}, args: []string{"funny-bunny", chartPath},
flags: []string{"--reuse-values", "true"}, flags: []string{"--reuse-values", "true"},
resp: releaseMock(&releaseOptions{name: "funny-bunny", version: 5, chart: ch2}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "funny-bunny", Version: 5, Chart: ch2}),
expected: "Release \"funny-bunny\" has been upgraded. Happy Helming!\n", expected: "Release \"funny-bunny\" has been upgraded. Happy Helming!\n",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "funny-bunny", Version: 5, Chart: ch2})},
}, },
{ {
name: "install a release with 'upgrade --install'", name: "install a release with 'upgrade --install'",
args: []string{"zany-bunny", chartPath}, args: []string{"zany-bunny", chartPath},
flags: []string{"-i"}, flags: []string{"-i"},
resp: releaseMock(&releaseOptions{name: "zany-bunny", version: 1, chart: ch}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "zany-bunny", Version: 1, Chart: ch}),
expected: "Release \"zany-bunny\" has been upgraded. Happy Helming!\n", expected: "Release \"zany-bunny\" has been upgraded. Happy Helming!\n",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "zany-bunny", Version: 1, Chart: ch})},
}, },
{ {
name: "install a release with 'upgrade --install' and timeout", name: "install a release with 'upgrade --install' and timeout",
args: []string{"crazy-bunny", chartPath}, args: []string{"crazy-bunny", chartPath},
flags: []string{"-i", "--timeout", "120"}, flags: []string{"-i", "--timeout", "120"},
resp: releaseMock(&releaseOptions{name: "crazy-bunny", version: 1, chart: ch}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "crazy-bunny", Version: 1, Chart: ch}),
expected: "Release \"crazy-bunny\" has been upgraded. Happy Helming!\n", expected: "Release \"crazy-bunny\" has been upgraded. Happy Helming!\n",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "crazy-bunny", Version: 1, Chart: ch})},
}, },
{ {
name: "upgrade a release with wait", name: "upgrade a release with wait",
args: []string{"crazy-bunny", chartPath}, args: []string{"crazy-bunny", chartPath},
flags: []string{"--wait"}, flags: []string{"--wait"},
resp: releaseMock(&releaseOptions{name: "crazy-bunny", version: 2, chart: ch2}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "crazy-bunny", Version: 2, Chart: ch2}),
expected: "Release \"crazy-bunny\" has been upgraded. Happy Helming!\n", expected: "Release \"crazy-bunny\" has been upgraded. Happy Helming!\n",
rels: []*release.Release{helm.ReleaseMock(&helm.MockReleaseOptions{Name: "crazy-bunny", Version: 2, Chart: ch2})},
}, },
{ {
name: "upgrade a release with missing dependencies", name: "upgrade a release with missing dependencies",
args: []string{"bonkers-bunny", missingDepsPath}, args: []string{"bonkers-bunny", missingDepsPath},
resp: releaseMock(&releaseOptions{name: "bonkers-bunny", version: 1, chart: ch3}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "bonkers-bunny", Version: 1, Chart: ch3}),
err: true, err: true,
}, },
{ {
name: "upgrade a release with bad dependencies", name: "upgrade a release with bad dependencies",
args: []string{"bonkers-bunny", badDepsPath}, args: []string{"bonkers-bunny", badDepsPath},
resp: releaseMock(&releaseOptions{name: "bonkers-bunny", version: 1, chart: ch3}), resp: helm.ReleaseMock(&helm.MockReleaseOptions{Name: "bonkers-bunny", Version: 1, Chart: ch3}),
err: true, err: true,
}, },
} }

@ -17,9 +17,12 @@ limitations under the License.
package helm // import "k8s.io/helm/pkg/helm" package helm // import "k8s.io/helm/pkg/helm"
import ( import (
"errors"
"fmt" "fmt"
"math/rand"
"sync" "sync"
"github.com/golang/protobuf/ptypes/timestamp"
"k8s.io/helm/pkg/proto/hapi/chart" "k8s.io/helm/pkg/proto/hapi/chart"
"k8s.io/helm/pkg/proto/hapi/release" "k8s.io/helm/pkg/proto/hapi/release"
rls "k8s.io/helm/pkg/proto/hapi/services" rls "k8s.io/helm/pkg/proto/hapi/services"
@ -30,7 +33,15 @@ import (
type FakeClient struct { type FakeClient struct {
Rels []*release.Release Rels []*release.Release
Responses map[string]release.TestRun_Status Responses map[string]release.TestRun_Status
Err error Opts options
}
// Option returns the fake release client
func (c *FakeClient) Option(opts ...Option) Interface {
for _, opt := range opts {
opt(&c.Opts)
}
return c
} }
var _ Interface = &FakeClient{} var _ Interface = &FakeClient{}
@ -42,31 +53,49 @@ func (c *FakeClient) ListReleases(opts ...ReleaseListOption) (*rls.ListReleasesR
Count: int64(len(c.Rels)), Count: int64(len(c.Rels)),
Releases: c.Rels, Releases: c.Rels,
} }
return resp, c.Err return resp, nil
} }
// InstallRelease returns a response with the first Release on the fake release client // InstallRelease creates a new release and returns a InstallReleaseResponse containing that release
func (c *FakeClient) InstallRelease(chStr, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) { func (c *FakeClient) InstallRelease(chStr, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) {
return &rls.InstallReleaseResponse{ chart := &chart.Chart{}
Release: c.Rels[0], return c.InstallReleaseFromChart(chart, ns, opts...)
}, nil
} }
// InstallReleaseFromChart returns a response with the first Release on the fake release client // InstallReleaseFromChart adds a new MockRelease to the fake client and returns a InstallReleaseResponse containing that release
func (c *FakeClient) InstallReleaseFromChart(chart *chart.Chart, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) { func (c *FakeClient) InstallReleaseFromChart(chart *chart.Chart, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) {
for _, opt := range opts {
opt(&c.Opts)
}
releaseName := c.Opts.instReq.Name
// Check to see if the release already exists.
rel, err := c.ReleaseStatus(releaseName, nil)
if err == nil && rel != nil {
return nil, errors.New("cannot re-use a name that is still in use")
}
release := ReleaseMock(&MockReleaseOptions{Name: releaseName, Namespace: ns})
c.Rels = append(c.Rels, release)
return &rls.InstallReleaseResponse{ return &rls.InstallReleaseResponse{
Release: c.Rels[0], Release: release,
}, nil }, nil
} }
// DeleteRelease returns nil, nil // DeleteRelease deletes a release from the FakeClient
func (c *FakeClient) DeleteRelease(rlsName string, opts ...DeleteOption) (*rls.UninstallReleaseResponse, error) { func (c *FakeClient) DeleteRelease(rlsName string, opts ...DeleteOption) (*rls.UninstallReleaseResponse, error) {
return nil, nil for i, rel := range c.Rels {
} if rel.Name == rlsName {
c.Rels = append(c.Rels[:i], c.Rels[i+1:]...)
return &rls.UninstallReleaseResponse{
Release: rel,
}, nil
}
}
// UpdateRelease returns nil, nil return nil, fmt.Errorf("No such release: %s", rlsName)
func (c *FakeClient) UpdateRelease(rlsName string, chStr string, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) {
return nil, nil
} }
// GetVersion returns a fake version // GetVersion returns a fake version
@ -78,9 +107,20 @@ func (c *FakeClient) GetVersion(opts ...VersionOption) (*rls.GetVersionResponse,
}, nil }, nil
} }
// UpdateReleaseFromChart returns nil, nil // UpdateRelease returns an UpdateReleaseResponse containing the updated release, if it exists
func (c *FakeClient) UpdateRelease(rlsName string, chStr string, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) {
return c.UpdateReleaseFromChart(rlsName, &chart.Chart{}, opts...)
}
// UpdateReleaseFromChart returns an UpdateReleaseResponse containing the updated release, if it exists
func (c *FakeClient) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) { func (c *FakeClient) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) {
return nil, nil // Check to see if the release already exists.
rel, err := c.ReleaseContent(rlsName, nil)
if err != nil {
return nil, err
}
return &rls.UpdateReleaseResponse{Release: rel.Release}, nil
} }
// RollbackRelease returns nil, nil // RollbackRelease returns nil, nil
@ -88,32 +128,35 @@ func (c *FakeClient) RollbackRelease(rlsName string, opts ...RollbackOption) (*r
return nil, nil return nil, nil
} }
// ReleaseStatus returns a release status response with info from the first release in the fake // ReleaseStatus returns a release status response with info from the matching release name.
// release client
func (c *FakeClient) ReleaseStatus(rlsName string, opts ...StatusOption) (*rls.GetReleaseStatusResponse, error) { func (c *FakeClient) ReleaseStatus(rlsName string, opts ...StatusOption) (*rls.GetReleaseStatusResponse, error) {
if c.Rels[0] != nil { for _, rel := range c.Rels {
return &rls.GetReleaseStatusResponse{ if rel.Name == rlsName {
Name: c.Rels[0].Name, return &rls.GetReleaseStatusResponse{
Info: c.Rels[0].Info, Name: rel.Name,
Namespace: c.Rels[0].Namespace, Info: rel.Info,
}, nil Namespace: rel.Namespace,
}, nil
}
} }
return nil, fmt.Errorf("No such release: %s", rlsName) return nil, fmt.Errorf("No such release: %s", rlsName)
} }
// ReleaseContent returns the configuration for the first release in the fake release client // ReleaseContent returns the configuration for the matching release name in the fake release client.
func (c *FakeClient) ReleaseContent(rlsName string, opts ...ContentOption) (resp *rls.GetReleaseContentResponse, err error) { func (c *FakeClient) ReleaseContent(rlsName string, opts ...ContentOption) (resp *rls.GetReleaseContentResponse, err error) {
if len(c.Rels) > 0 { for _, rel := range c.Rels {
resp = &rls.GetReleaseContentResponse{ if rel.Name == rlsName {
Release: c.Rels[0], return &rls.GetReleaseContentResponse{
Release: rel,
}, nil
} }
} }
return resp, c.Err return resp, fmt.Errorf("No such release: %s", rlsName)
} }
// ReleaseHistory returns a release's revision history. // ReleaseHistory returns a release's revision history.
func (c *FakeClient) ReleaseHistory(rlsName string, opts ...HistoryOption) (*rls.GetHistoryResponse, error) { func (c *FakeClient) ReleaseHistory(rlsName string, opts ...HistoryOption) (*rls.GetHistoryResponse, error) {
return &rls.GetHistoryResponse{Releases: c.Rels}, c.Err return &rls.GetHistoryResponse{Releases: c.Rels}, nil
} }
// RunReleaseTest executes a pre-defined tests on a release // RunReleaseTest executes a pre-defined tests on a release
@ -141,7 +184,89 @@ func (c *FakeClient) RunReleaseTest(rlsName string, opts ...ReleaseTestOption) (
return results, errc return results, errc
} }
// Option returns the fake release client // MockHookTemplate is the hook template used for all mock release objects.
func (c *FakeClient) Option(opt ...Option) Interface { var MockHookTemplate = `apiVersion: v1
return c kind: Job
metadata:
annotations:
"helm.sh/hooks": pre-install
`
// MockManifest is the manifest used for all mock release objects.
var MockManifest = `apiVersion: v1
kind: Secret
metadata:
name: fixture
`
// MockReleaseOptions allows for user-configurable options on mock release objects.
type MockReleaseOptions struct {
Name string
Version int32
Chart *chart.Chart
StatusCode release.Status_Code
Namespace string
}
// ReleaseMock creates a mock release object based on options set by MockReleaseOptions. This function should typically not be used outside of testing.
func ReleaseMock(opts *MockReleaseOptions) *release.Release {
date := timestamp.Timestamp{Seconds: 242085845, Nanos: 0}
name := opts.Name
if name == "" {
name = "testrelease-" + string(rand.Intn(100))
}
var version int32 = 1
if opts.Version != 0 {
version = opts.Version
}
namespace := opts.Namespace
if namespace == "" {
namespace = "default"
}
ch := opts.Chart
if opts.Chart == nil {
ch = &chart.Chart{
Metadata: &chart.Metadata{
Name: "foo",
Version: "0.1.0-beta.1",
},
Templates: []*chart.Template{
{Name: "templates/foo.tpl", Data: []byte(MockManifest)},
},
}
}
scode := release.Status_DEPLOYED
if opts.StatusCode > 0 {
scode = opts.StatusCode
}
return &release.Release{
Name: name,
Info: &release.Info{
FirstDeployed: &date,
LastDeployed: &date,
Status: &release.Status{Code: scode},
Description: "Release mock",
},
Chart: ch,
Config: &chart.Config{Raw: `name: "value"`},
Version: version,
Namespace: namespace,
Hooks: []*release.Hook{
{
Name: "pre-install-hook",
Kind: "Job",
Path: "pre-install-hook.yaml",
Manifest: MockHookTemplate,
LastRun: &date,
Events: []release.Hook_Event{release.Hook_PRE_INSTALL},
},
},
Manifest: MockManifest,
}
} }

@ -0,0 +1,283 @@
/*
Copyright 2016 The Kubernetes Authors All rights reserved.
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 helm
import (
"reflect"
"testing"
"k8s.io/helm/pkg/proto/hapi/chart"
"k8s.io/helm/pkg/proto/hapi/release"
rls "k8s.io/helm/pkg/proto/hapi/services"
)
func TestFakeClient_ReleaseStatus(t *testing.T) {
releasePresent := ReleaseMock(&MockReleaseOptions{Name: "release-present"})
releaseNotPresent := ReleaseMock(&MockReleaseOptions{Name: "release-not-present"})
type fields struct {
Rels []*release.Release
}
type args struct {
rlsName string
opts []StatusOption
}
tests := []struct {
name string
fields fields
args args
want *rls.GetReleaseStatusResponse
wantErr bool
}{
{
name: "Get a single release that exists",
fields: fields{
Rels: []*release.Release{
releasePresent,
},
},
args: args{
rlsName: releasePresent.Name,
opts: nil,
},
want: &rls.GetReleaseStatusResponse{
Name: releasePresent.Name,
Info: releasePresent.Info,
Namespace: releasePresent.Namespace,
},
wantErr: false,
},
{
name: "Get a release that does not exist",
fields: fields{
Rels: []*release.Release{
releasePresent,
},
},
args: args{
rlsName: releaseNotPresent.Name,
opts: nil,
},
want: nil,
wantErr: true,
},
{
name: "Get a single release that exists from list",
fields: fields{
Rels: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "angry-dolphin", Namespace: "default"}),
ReleaseMock(&MockReleaseOptions{Name: "trepid-tapir", Namespace: "default"}),
releasePresent,
},
},
args: args{
rlsName: releasePresent.Name,
opts: nil,
},
want: &rls.GetReleaseStatusResponse{
Name: releasePresent.Name,
Info: releasePresent.Info,
Namespace: releasePresent.Namespace,
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := &FakeClient{
Rels: tt.fields.Rels,
}
got, err := c.ReleaseStatus(tt.args.rlsName, tt.args.opts...)
if (err != nil) != tt.wantErr {
t.Errorf("FakeClient.ReleaseStatus() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("FakeClient.ReleaseStatus() = %v, want %v", got, tt.want)
}
})
}
}
func TestFakeClient_InstallReleaseFromChart(t *testing.T) {
installChart := &chart.Chart{}
type fields struct {
Rels []*release.Release
}
type args struct {
ns string
opts []InstallOption
}
tests := []struct {
name string
fields fields
args args
want *rls.InstallReleaseResponse
relsAfter []*release.Release
wantErr bool
}{
{
name: "Add release to an empty list.",
fields: fields{
Rels: []*release.Release{},
},
args: args{
ns: "default",
opts: []InstallOption{ReleaseName("new-release")},
},
want: &rls.InstallReleaseResponse{
Release: ReleaseMock(&MockReleaseOptions{Name: "new-release"}),
},
relsAfter: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "new-release"}),
},
wantErr: false,
},
{
name: "Try to add a release where the name already exists.",
fields: fields{
Rels: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "new-release"}),
},
},
args: args{
ns: "default",
opts: []InstallOption{ReleaseName("new-release")},
},
relsAfter: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "new-release"}),
},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := &FakeClient{
Rels: tt.fields.Rels,
}
got, err := c.InstallReleaseFromChart(installChart, tt.args.ns, tt.args.opts...)
if (err != nil) != tt.wantErr {
t.Errorf("FakeClient.InstallReleaseFromChart() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("FakeClient.InstallReleaseFromChart() = %v, want %v", got, tt.want)
}
if !reflect.DeepEqual(c.Rels, tt.relsAfter) {
t.Errorf("FakeClient.InstallReleaseFromChart() rels = %v, expected %v", got, tt.relsAfter)
}
})
}
}
func TestFakeClient_DeleteRelease(t *testing.T) {
type fields struct {
Rels []*release.Release
}
type args struct {
rlsName string
opts []DeleteOption
}
tests := []struct {
name string
fields fields
args args
want *rls.UninstallReleaseResponse
relsAfter []*release.Release
wantErr bool
}{
{
name: "Delete a release that exists.",
fields: fields{
Rels: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "angry-dolphin"}),
ReleaseMock(&MockReleaseOptions{Name: "trepid-tapir"}),
},
},
args: args{
rlsName: "trepid-tapir",
opts: []DeleteOption{},
},
relsAfter: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "angry-dolphin"}),
},
want: &rls.UninstallReleaseResponse{
Release: ReleaseMock(&MockReleaseOptions{Name: "trepid-tapir"}),
},
wantErr: false,
},
{
name: "Delete a release that does not exist.",
fields: fields{
Rels: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "angry-dolphin"}),
ReleaseMock(&MockReleaseOptions{Name: "trepid-tapir"}),
},
},
args: args{
rlsName: "release-that-does-not-exists",
opts: []DeleteOption{},
},
relsAfter: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "angry-dolphin"}),
ReleaseMock(&MockReleaseOptions{Name: "trepid-tapir"}),
},
want: nil,
wantErr: true,
},
{
name: "Delete when only 1 item exists.",
fields: fields{
Rels: []*release.Release{
ReleaseMock(&MockReleaseOptions{Name: "trepid-tapir"}),
},
},
args: args{
rlsName: "trepid-tapir",
opts: []DeleteOption{},
},
relsAfter: []*release.Release{},
want: &rls.UninstallReleaseResponse{
Release: ReleaseMock(&MockReleaseOptions{Name: "trepid-tapir"}),
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := &FakeClient{
Rels: tt.fields.Rels,
}
got, err := c.DeleteRelease(tt.args.rlsName, tt.args.opts...)
if (err != nil) != tt.wantErr {
t.Errorf("FakeClient.DeleteRelease() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("FakeClient.DeleteRelease() = %v, want %v", got, tt.want)
}
if !reflect.DeepEqual(c.Rels, tt.relsAfter) {
t.Errorf("FakeClient.InstallReleaseFromChart() rels = %v, expected %v", got, tt.relsAfter)
}
})
}
}
Loading…
Cancel
Save