コード例 #1
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintChartByPath(t *testing.T) {
	home1 := test.CreateTmpHome()
	home2 := test.CreateTmpHome()

	chartName := "goodChart"
	action.Create(chartName, home1)

	output := test.CaptureOutput(func() {
		Cli().Run([]string{"helmc", "--home", home2, "lint", util.WorkspaceChartDirectory(home1, chartName)})
	})

	test.ExpectContains(t, output, fmt.Sprintf("Chart [%s] has passed all necessary checks", chartName))
}
コード例 #2
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintEmptyChartYaml(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	chartName := "badChart"

	Create(chartName, tmpHome)

	badChartYaml, _ := yaml.Marshal(make(map[string]string))

	chartYaml := util.WorkspaceChartDirectory(tmpHome, chartName, Chartfile)

	os.Remove(chartYaml)
	ioutil.WriteFile(chartYaml, badChartYaml, 0644)

	output := test.CaptureOutput(func() {
		Lint(util.WorkspaceChartDirectory(tmpHome, chartName))
	})

	test.ExpectContains(t, output, "Chart.yaml has a name field : false")
	test.ExpectContains(t, output, "Chart.yaml has a version field : false")
	test.ExpectContains(t, output, "Chart.yaml has a description field : false")
	test.ExpectContains(t, output, "Chart.yaml has a maintainers field : false")
	test.ExpectContains(t, output, fmt.Sprintf("Chart [%s] has failed some necessary checks", chartName))
}
コード例 #3
0
ファイル: doctor_test.go プロジェクト: helm/helm-classic
func TestEnsurePrereqs(t *testing.T) {
	pp := os.Getenv("PATH")
	defer os.Setenv("PATH", pp)

	os.Setenv("PATH", filepath.Join(test.HelmRoot, "testdata")+":"+pp)

	homedir := test.CreateTmpHome()
	CheckAllPrereqs(homedir)
}
コード例 #4
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintAllNone(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	output := test.CaptureOutput(func() {
		Cli().Run([]string{"helmc", "--home", tmpHome, "lint", "--all"})
	})

	test.ExpectContains(t, output, fmt.Sprintf("Could not find any charts in \"%s", tmpHome))
}
コード例 #5
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintBadPath(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	chartName := "badChart"

	output := test.CaptureOutput(func() {
		Lint(util.WorkspaceChartDirectory(tmpHome, chartName))
	})

	msg := "Chart found at " + tmpHome + "/workspace/charts/" + chartName + " : false"
	test.ExpectContains(t, output, msg)
}
コード例 #6
0
ファイル: repo_test.go プロジェクト: helm/helm-classic
func TestListRepos(t *testing.T) {
	log.IsDebugging = true

	homedir := test.CreateTmpHome()
	test.FakeUpdate(homedir)

	actual := test.CaptureOutput(func() {
		ListRepos(homedir)
	})

	test.ExpectContains(t, actual, "charts*\thttps://github.com/helm/charts")
}
コード例 #7
0
ファイル: fetch_test.go プロジェクト: helm/helm-classic
func TestFetch(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)
	chartName := "kitchensink"

	actual := test.CaptureOutput(func() {
		Fetch(chartName, "", tmpHome)
	})

	workspacePath := util.WorkspaceChartDirectory(tmpHome, chartName)
	test.ExpectContains(t, actual, "Fetched chart into workspace "+workspacePath)
}
コード例 #8
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintSingle(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	chartName := "goodChart"
	action.Create(chartName, tmpHome)

	output := test.CaptureOutput(func() {
		Cli().Run([]string{"helmc", "--home", tmpHome, "lint", chartName})
	})

	test.ExpectContains(t, output, fmt.Sprintf("Chart [%s] has passed all necessary checks", chartName))
}
コード例 #9
0
ファイル: search_test.go プロジェクト: helm/helm-classic
func TestSearchNotFound(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	// test that a "no chart found" message was printed
	expected := "No results found"

	actual := test.CaptureOutput(func() {
		Search("nonexistent", tmpHome, false)
	})

	test.ExpectContains(t, actual, expected)
}
コード例 #10
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintMismatchedChartNameAndDir(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	chartName := "chart-0"
	chartDir := "chart-1"
	chart := newSkelChartfile(chartName)
	createWithChart(chart, chartDir, tmpHome)

	output := test.CaptureOutput(func() {
		Lint(util.WorkspaceChartDirectory(tmpHome, chartDir))
	})

	test.ExpectContains(t, output, "Name declared in Chart.yaml is the same as directory name. : false")
}
コード例 #11
0
ファイル: uninstall_test.go プロジェクト: helm/helm-classic
func TestUninstall(t *testing.T) {
	tests := []struct {
		name     string // Todo: print name on fail
		chart    string
		force    bool
		expected []string
		client   kubectl.Runner
	}{
		{
			name:     "with valid input",
			chart:    "redis",
			force:    true,
			expected: []string{"Running `kubectl delete` ...", "hello from redis"},
			client: TestRunner{
				out: []byte("hello from redis"),
			},
		},
		{
			name:     "with a kubectl error",
			chart:    "redis",
			force:    true,
			expected: []string{"Running `kubectl delete` ...", "Could not delete Pod redis (Skipping): oh snap"},
			client: TestRunner{
				err: errors.New("oh snap"),
			},
		},
		{
			name:  "with a helmc annotation",
			chart: "keep",
			force: true,
			expected: []string{"Running `kubectl delete` ...", "Not uninstalling",
				"because of \"helm-keep\" annotation"},
		},
	}

	tmpHome := test.CreateTmpHome()
	defer os.RemoveAll(tmpHome)
	test.FakeUpdate(tmpHome)

	for _, tt := range tests {
		Fetch(tt.chart, "", tmpHome)

		actual := test.CaptureOutput(func() {
			Uninstall(tt.chart, tmpHome, "default", tt.force, tt.client)
		})

		for _, exp := range tt.expected {
			test.ExpectContains(t, actual, exp)
		}
	}
}
コード例 #12
0
ファイル: info_test.go プロジェクト: helm/helm-classic
func TestInfoFormat(t *testing.T) {

	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	format := `Hello {{.Name}}`
	expected := `Hello kitchensink`

	actual := test.CaptureOutput(func() {
		Info("kitchensink", tmpHome, format)
	})

	test.ExpectContains(t, actual, expected)
}
コード例 #13
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintMissingReadme(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	chartName := "badChart"

	Create(chartName, tmpHome)

	os.Remove(filepath.Join(util.WorkspaceChartDirectory(tmpHome, chartName), "README.md"))

	output := test.CaptureOutput(func() {
		Lint(util.WorkspaceChartDirectory(tmpHome, chartName))
	})

	test.ExpectContains(t, output, "README.md is present and not empty : false")
}
コード例 #14
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintSuccess(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	chartName := "goodChart"

	Create(chartName, tmpHome)

	output := test.CaptureOutput(func() {
		Lint(util.WorkspaceChartDirectory(tmpHome, chartName))
	})

	expected := "Chart [goodChart] has passed all necessary checks"

	test.ExpectContains(t, output, expected)
}
コード例 #15
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintMissingManifestDirectory(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	chartName := "brokeChart"

	Create(chartName, tmpHome)

	os.RemoveAll(filepath.Join(util.WorkspaceChartDirectory(tmpHome, chartName), "manifests"))

	output := test.CaptureOutput(func() {
		Lint(util.WorkspaceChartDirectory(tmpHome, chartName))
	})

	test.ExpectMatches(t, output, "Manifests directory is present : false")
	test.ExpectContains(t, output, "Chart ["+chartName+"] has failed some necessary checks")
}
コード例 #16
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintMissingChartYaml(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	chartName := "badChart"

	Create(chartName, tmpHome)

	os.Remove(filepath.Join(util.WorkspaceChartDirectory(tmpHome, chartName), Chartfile))

	output := test.CaptureOutput(func() {
		Lint(util.WorkspaceChartDirectory(tmpHome, chartName))
	})

	test.ExpectContains(t, output, "Chart.yaml is present : false")
	test.ExpectContains(t, output, "Chart [badChart] has failed some necessary checks.")
}
コード例 #17
0
ファイル: info_test.go プロジェクト: helm/helm-classic
func TestInfo(t *testing.T) {

	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	format := ""
	expected := `Name: kitchensink
Home: http://github.com/helm/helm
Version: 0.0.1
Description: All the things, all semantically, none working
Details: This package provides a sampling of all of the different manifest types. It can be used to test ordering and other properties of a chart.`

	actual := test.CaptureOutput(func() {
		Info("kitchensink", tmpHome, format)
	})

	test.ExpectContains(t, actual, expected)
}
コード例 #18
0
ファイル: edit_test.go プロジェクト: helm/helm-classic
func TestEdit(t *testing.T) {
	editor := os.Getenv("EDITOR")
	os.Setenv("EDITOR", "echo")
	defer os.Setenv("EDITOR", editor)

	tmpHome := test.CreateTmpHome()
	defer os.RemoveAll(tmpHome)
	test.FakeUpdate(tmpHome)

	Fetch("redis", "", tmpHome)

	expected := path.Join(tmpHome, "workspace/charts/redis")
	actual := test.CaptureOutput(func() {
		Edit("redis", tmpHome)
	})

	test.ExpectContains(t, actual, expected)
}
コード例 #19
0
ファイル: generate_test.go プロジェクト: helm/helm-classic
func TestGenerate(t *testing.T) {
	ch := "generate"
	homedir := test.CreateTmpHome()
	test.FakeUpdate(homedir)
	Fetch(ch, ch, homedir)

	Generate(ch, homedir, []string{"ignore"}, true)

	// Now we should be able to load and read the `pod.yaml` file.
	path := util.WorkspaceChartDirectory(homedir, "generate/manifests/pod.yaml")
	d, err := ioutil.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}
	pod := string(d)
	test.ExpectContains(t, pod, "image: ozo")
	test.ExpectContains(t, pod, "name: www-server")
}
コード例 #20
0
ファイル: lint_test.go プロジェクト: helm/helm-classic
func TestLintAll(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	missingReadmeChart := "missingReadme"

	action.Create(missingReadmeChart, tmpHome)
	os.Remove(util.WorkspaceChartDirectory(tmpHome, missingReadmeChart, "README.md"))

	action.Create("goodChart", tmpHome)

	output := test.CaptureOutput(func() {
		Cli().Run([]string{"helmc", "--home", tmpHome, "lint", "--all"})
	})

	test.ExpectMatches(t, output, "A README file was not found.*"+missingReadmeChart)
	test.ExpectContains(t, output, "Chart [goodChart] has passed all necessary checks")
	test.ExpectContains(t, output, "Chart [missingReadme] failed some checks")
}
コード例 #21
0
ファイル: remove_test.go プロジェクト: helm/helm-classic
func TestTRemove(t *testing.T) {
	kg := kubeGet
	defer func() { kubeGet = kg }()

	tests := []struct {
		chartName string
		getter    kubeGetter
		force     bool
		expected  string
	}{
		{"kitchensink", mockNotFoundGetter, false, "All clear! You have successfully removed kitchensink from your workspace."},

		// when manifests are installed
		{"kitchensink", mockFoundGetter, false, "Found 12 installed manifests for kitchensink.  To remove a chart that has been installed the --force flag must be set."},

		// when manifests are installed and force is set
		{"kitchensink", mockNotFoundGetter, true, "All clear! You have successfully removed kitchensink from your workspace."},

		// when kubectl cannot connect
		{"kitchensink", mockFailConnection, false, "Could not determine if kitchensink is installed.  To remove the chart --force flag must be set."},

		// when kubectl cannot connect and force is set
		{"kitchensink", mockFailConnection, true, "All clear! You have successfully removed kitchensink from your workspace."},
	}

	for _, tt := range tests {
		tmpHome := test.CreateTmpHome()
		test.FakeUpdate(tmpHome)

		Fetch("kitchensink", "", tmpHome)

		// set the mock getter
		kubeGet = tt.getter

		actual := test.CaptureOutput(func() {
			Remove(tt.chartName, tmpHome, tt.force)
		})

		test.ExpectContains(t, actual, tt.expected)

		os.Remove(tmpHome)
	}
}
コード例 #22
0
ファイル: config_test.go プロジェクト: helm/helm-classic
func TestEnsureRepo(t *testing.T) {
	tmpHome := test.CreateTmpHome()

	repo := "https://github.com/helm/charts"
	ensureRepo(repo, filepath.Join(tmpHome, "cache", "charts"))
}
コード例 #23
0
ファイル: doctor_test.go プロジェクト: helm/helm-classic
func TestEnsureHome(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	util.EnsureHome(tmpHome)
}
コード例 #24
0
ファイル: install_test.go プロジェクト: helm/helm-classic
func TestInstall(t *testing.T) {
	// Todo: add tests
	// - with an invalid chart name
	// - with failure to check dependencies
	// - with failure to check dependencies and force option
	// - with chart in current directly
	tests := []struct {
		name     string // Todo: print name on fail
		chart    string
		force    bool
		expected []string
		client   kubectl.Runner
	}{
		{
			name:     "with valid input",
			chart:    "redis",
			expected: []string{"hello from redis"},
			client: TestRunner{
				out: []byte("hello from redis"),
			},
		},
		{
			name:     "with dry-run option",
			chart:    "redis",
			expected: []string{"[CMD] kubectl create -f -"},
			client:   kubectl.PrintRunner{},
		},
		{
			name:     "with unsatisfied dependencies",
			chart:    "kitchensink",
			expected: []string{"Stopping install. Re-run with --force to install anyway."},
			client:   TestRunner{},
		},
		{
			name:     "with unsatisfied dependencies and force option",
			chart:    "kitchensink",
			force:    true,
			expected: []string{"Unsatisfied dependencies", "Running `kubectl create -f`"},
			client:   TestRunner{},
		},
		{
			name:     "with a kubectl error",
			chart:    "redis",
			expected: []string{"Failed to upload manifests: oh snap"},
			client: TestRunner{
				err: errors.New("oh snap"),
			},
		},
	}

	tmpHome := test.CreateTmpHome()
	defer os.RemoveAll(tmpHome)
	test.FakeUpdate(tmpHome)

	// Todo: get rid of this hacky mess
	pp := os.Getenv("PATH")
	defer os.Setenv("PATH", pp)
	os.Setenv("PATH", filepath.Join(test.HelmRoot, "testdata")+":"+pp)

	for _, tt := range tests {
		actual := test.CaptureOutput(func() {
			Install(tt.chart, tmpHome, "", tt.force, false, []string{}, tt.client)
		})

		for _, exp := range tt.expected {
			test.ExpectContains(t, actual, exp)
		}
	}
}
コード例 #25
0
ファイル: create_test.go プロジェクト: helm/helm-classic
func TestCreate(t *testing.T) {
	tmpHome := test.CreateTmpHome()

	Create("mychart", tmpHome)

	// assert chartfile
	chartfile, err := ioutil.ReadFile(util.WorkspaceChartDirectory(tmpHome, "mychart/Chart.yaml"))
	if err != nil {
		t.Errorf("Could not read chartfile: %s", err)
	}
	actualChartfile := string(chartfile)
	expectedChartfile := `name: mychart
home: http://example.com/your/project/home
version: 0.1.0
description: Provide a brief description of your application here.
maintainers:
- Your Name <email@address>
details: |-
  This section allows you to provide additional details about your application.
  Provide any information that would be useful to users at a glance.
`
	test.ExpectEquals(t, actualChartfile, expectedChartfile)

	// asset readme
	readme, err := ioutil.ReadFile(util.WorkspaceChartDirectory(tmpHome, "mychart/README.md"))
	if err != nil {
		t.Errorf("Could not read README.md: %s", err)
	}
	actualReadme := string(readme)
	expectedReadme := `# mychart

Describe your chart here. Link to upstream repositories, Docker images or any
external documentation.

If your application requires any specific configuration like Secrets, you may
include that information here.
`
	test.ExpectEquals(t, expectedReadme, actualReadme)

	// assert example manifest
	manifest, err := ioutil.ReadFile(util.WorkspaceChartDirectory(tmpHome, "mychart/manifests/example-pod.yaml"))
	if err != nil {
		t.Errorf("Could not read manifest: %s", err)
	}
	actualManifest := string(manifest)
	expectedManifest := `---
apiVersion: v1
kind: Pod
metadata:
  name: example-pod
  labels:
    heritage: helm
spec:
  restartPolicy: Never
  containers:
  - name: example
    image: "alpine:3.2"
    command: ["/bin/sleep","9000"]
`
	test.ExpectEquals(t, actualManifest, expectedManifest)
}
コード例 #26
0
ファイル: search_test.go プロジェクト: helm/helm-classic
func TestSearch(t *testing.T) {
	tmpHome := test.CreateTmpHome()
	test.FakeUpdate(tmpHome)

	Search("homeslice", tmpHome, false)
}