mirror of https://github.com/helm/helm
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
361 lines
8.8 KiB
361 lines
8.8 KiB
/*
|
|
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 action
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
fakeclientset "k8s.io/client-go/kubernetes/fake"
|
|
|
|
"helm.sh/helm/v3/pkg/chart"
|
|
"helm.sh/helm/v3/pkg/chartutil"
|
|
kubefake "helm.sh/helm/v3/pkg/kube/fake"
|
|
"helm.sh/helm/v3/pkg/registry"
|
|
"helm.sh/helm/v3/pkg/release"
|
|
"helm.sh/helm/v3/pkg/storage"
|
|
"helm.sh/helm/v3/pkg/storage/driver"
|
|
"helm.sh/helm/v3/pkg/time"
|
|
)
|
|
|
|
var verbose = flag.Bool("test.log", false, "enable test logging")
|
|
|
|
func actionConfigFixture(t *testing.T) *Configuration {
|
|
t.Helper()
|
|
|
|
registryClient, err := registry.NewClient()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
return &Configuration{
|
|
Releases: storage.Init(driver.NewMemory()),
|
|
KubeClient: &kubefake.FailingKubeClient{PrintingKubeClient: kubefake.PrintingKubeClient{Out: io.Discard}},
|
|
Capabilities: chartutil.DefaultCapabilities,
|
|
RegistryClient: registryClient,
|
|
Log: func(format string, v ...interface{}) {
|
|
t.Helper()
|
|
if *verbose {
|
|
t.Logf(format, v...)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
var manifestWithHook = `kind: ConfigMap
|
|
metadata:
|
|
name: test-cm
|
|
annotations:
|
|
"helm.sh/hook": post-install,pre-delete,post-upgrade
|
|
data:
|
|
name: value`
|
|
|
|
var manifestWithTestHook = `kind: Pod
|
|
metadata:
|
|
name: finding-nemo,
|
|
annotations:
|
|
"helm.sh/hook": test
|
|
spec:
|
|
containers:
|
|
- name: nemo-test
|
|
image: fake-image
|
|
cmd: fake-command
|
|
`
|
|
|
|
var rbacManifests = `apiVersion: rbac.authorization.k8s.io/v1
|
|
kind: Role
|
|
metadata:
|
|
name: schedule-agents
|
|
rules:
|
|
- apiGroups: [""]
|
|
resources: ["pods", "pods/exec", "pods/log"]
|
|
verbs: ["*"]
|
|
|
|
---
|
|
|
|
apiVersion: rbac.authorization.k8s.io/v1
|
|
kind: RoleBinding
|
|
metadata:
|
|
name: schedule-agents
|
|
namespace: {{ default .Release.Namespace}}
|
|
roleRef:
|
|
apiGroup: rbac.authorization.k8s.io
|
|
kind: Role
|
|
name: schedule-agents
|
|
subjects:
|
|
- kind: ServiceAccount
|
|
name: schedule-agents
|
|
namespace: {{ .Release.Namespace }}
|
|
`
|
|
|
|
type chartOptions struct {
|
|
*chart.Chart
|
|
}
|
|
|
|
type chartOption func(*chartOptions)
|
|
|
|
func buildChart(opts ...chartOption) *chart.Chart {
|
|
c := &chartOptions{
|
|
Chart: &chart.Chart{
|
|
// TODO: This should be more complete.
|
|
Metadata: &chart.Metadata{
|
|
APIVersion: "v1",
|
|
Name: "hello",
|
|
Version: "0.1.0",
|
|
},
|
|
// This adds a basic template and hooks.
|
|
Templates: []*chart.File{
|
|
{Name: "templates/hello", Data: []byte("hello: world")},
|
|
{Name: "templates/hooks", Data: []byte(manifestWithHook)},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, opt := range opts {
|
|
opt(c)
|
|
}
|
|
|
|
return c.Chart
|
|
}
|
|
|
|
func withName(name string) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Metadata.Name = name
|
|
}
|
|
}
|
|
|
|
func withSampleValues() chartOption {
|
|
values := map[string]interface{}{
|
|
"someKey": "someValue",
|
|
"nestedKey": map[string]interface{}{
|
|
"simpleKey": "simpleValue",
|
|
"anotherNestedKey": map[string]interface{}{
|
|
"yetAnotherNestedKey": map[string]interface{}{
|
|
"youReadyForAnotherNestedKey": "No",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
return func(opts *chartOptions) {
|
|
opts.Values = values
|
|
}
|
|
}
|
|
|
|
func withValues(values map[string]interface{}) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Values = values
|
|
}
|
|
}
|
|
|
|
func withNotes(notes string) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Templates = append(opts.Templates, &chart.File{
|
|
Name: "templates/NOTES.txt",
|
|
Data: []byte(notes),
|
|
})
|
|
}
|
|
}
|
|
|
|
func withDependency(dependencyOpts ...chartOption) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.AddDependency(buildChart(dependencyOpts...))
|
|
}
|
|
}
|
|
|
|
func withMetadataDependency(dependency chart.Dependency) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Metadata.Dependencies = append(opts.Metadata.Dependencies, &dependency)
|
|
}
|
|
}
|
|
|
|
func withSampleTemplates() chartOption {
|
|
return func(opts *chartOptions) {
|
|
sampleTemplates := []*chart.File{
|
|
// 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...)
|
|
}
|
|
}
|
|
|
|
func withSampleSecret() chartOption {
|
|
return func(opts *chartOptions) {
|
|
sampleSecret := &chart.File{Name: "templates/secret.yaml", Data: []byte("apiVersion: v1\nkind: Secret\n")}
|
|
opts.Templates = append(opts.Templates, sampleSecret)
|
|
}
|
|
}
|
|
|
|
func withSampleIncludingIncorrectTemplates() chartOption {
|
|
return func(opts *chartOptions) {
|
|
sampleTemplates := []*chart.File{
|
|
// This adds basic templates and partials.
|
|
{Name: "templates/goodbye", Data: []byte("goodbye: world")},
|
|
{Name: "templates/empty", Data: []byte("")},
|
|
{Name: "templates/incorrect", Data: []byte("{{ .Values.bad.doh }}")},
|
|
{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...)
|
|
}
|
|
}
|
|
|
|
func withMultipleManifestTemplate() chartOption {
|
|
return func(opts *chartOptions) {
|
|
sampleTemplates := []*chart.File{
|
|
{Name: "templates/rbac", Data: []byte(rbacManifests)},
|
|
}
|
|
opts.Templates = append(opts.Templates, sampleTemplates...)
|
|
}
|
|
}
|
|
|
|
func withKube(version string) chartOption {
|
|
return func(opts *chartOptions) {
|
|
opts.Metadata.KubeVersion = version
|
|
}
|
|
}
|
|
|
|
// releaseStub creates a release stub, complete with the chartStub as its chart.
|
|
func releaseStub() *release.Release {
|
|
return namedReleaseStub("angry-panda", release.StatusDeployed)
|
|
}
|
|
|
|
func namedReleaseStub(name string, status release.Status) *release.Release {
|
|
now := time.Now()
|
|
return &release.Release{
|
|
Name: name,
|
|
Info: &release.Info{
|
|
FirstDeployed: now,
|
|
LastDeployed: now,
|
|
Status: status,
|
|
Description: "Named Release Stub",
|
|
},
|
|
Chart: buildChart(withSampleTemplates()),
|
|
Config: map[string]interface{}{"name": "value"},
|
|
Version: 1,
|
|
Hooks: []*release.Hook{
|
|
{
|
|
Name: "test-cm",
|
|
Kind: "ConfigMap",
|
|
Path: "test-cm",
|
|
Manifest: manifestWithHook,
|
|
Events: []release.HookEvent{
|
|
release.HookPostInstall,
|
|
release.HookPreDelete,
|
|
},
|
|
},
|
|
{
|
|
Name: "finding-nemo",
|
|
Kind: "Pod",
|
|
Path: "finding-nemo",
|
|
Manifest: manifestWithTestHook,
|
|
Events: []release.HookEvent{
|
|
release.HookTest,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func TestConfiguration_Init(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
helmDriver string
|
|
expectedDriverType interface{}
|
|
expectErr bool
|
|
errMsg string
|
|
}{
|
|
{
|
|
name: "Test secret driver",
|
|
helmDriver: "secret",
|
|
expectedDriverType: &driver.Secrets{},
|
|
},
|
|
{
|
|
name: "Test secrets driver",
|
|
helmDriver: "secrets",
|
|
expectedDriverType: &driver.Secrets{},
|
|
},
|
|
{
|
|
name: "Test empty driver",
|
|
helmDriver: "",
|
|
expectedDriverType: &driver.Secrets{},
|
|
},
|
|
{
|
|
name: "Test configmap driver",
|
|
helmDriver: "configmap",
|
|
expectedDriverType: &driver.ConfigMaps{},
|
|
},
|
|
{
|
|
name: "Test configmaps driver",
|
|
helmDriver: "configmaps",
|
|
expectedDriverType: &driver.ConfigMaps{},
|
|
},
|
|
{
|
|
name: "Test memory driver",
|
|
helmDriver: "memory",
|
|
expectedDriverType: &driver.Memory{},
|
|
},
|
|
{
|
|
name: "Test sql driver",
|
|
helmDriver: "sql",
|
|
expectErr: true,
|
|
errMsg: "unable to instantiate SQL driver",
|
|
},
|
|
{
|
|
name: "Test unknown driver",
|
|
helmDriver: "someDriver",
|
|
expectErr: true,
|
|
errMsg: fmt.Sprintf("unknown driver %q", "someDriver"),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := &Configuration{}
|
|
|
|
actualErr := cfg.Init(nil, "default", tt.helmDriver, nil)
|
|
if tt.expectErr {
|
|
assert.Error(t, actualErr)
|
|
assert.Contains(t, actualErr.Error(), tt.errMsg)
|
|
} else {
|
|
assert.NoError(t, actualErr)
|
|
assert.IsType(t, tt.expectedDriverType, cfg.Releases.Driver)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetVersionSet(t *testing.T) {
|
|
client := fakeclientset.NewSimpleClientset()
|
|
|
|
vs, err := GetVersionSet(client.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.")
|
|
}
|
|
}
|