ref(tiller): refactor tests into logical files

TestListReleasesByStatus -> tiller/release_list_test.go
TestListReleasesFilter -> tiller/release_list_test.go
TestListReleasesSort -> tiller/release_list_test.go
TestListReleases -> tiller/release_list_test.go
TestUpdateRelease_ResetReuseValues -> tiller/release_update_test.go
TestUpdateRelease_ResetValues -> tiller/release_update_test.go
TestUpdateRelease_ReuseValues -> tiller/release_update_test.go
TestUpdateReleaseNoChanges -> tiller/release_update_test.go
TestUpdateReleaseFailure -> tiller/release_update_test.go
TestUpdateReleaseNoHooks -> tiller/release_update_test.go
TestUpdateRelease -> tiller/release_update_test.go
TestRollbackReleaesFailure -> tiller/release_rollback_test.go

Author: fibonacci1729

pkg/tiller/release_list_test.go

@@ -0,0 +1,233 @@
+/*
+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 tiller
+
+import (
+	"fmt"
+	"testing"
+
+	"k8s.io/helm/pkg/proto/hapi/release"
+	"k8s.io/helm/pkg/proto/hapi/services"
+)
+
+func TestListReleases(t *testing.T) {
+	rs := rsFixture()
+	num := 7
+	for i := 0; i < num; i++ {
+		rel := releaseStub()
+		rel.Name = fmt.Sprintf("rel-%d", i)
+		if err := rs.env.Releases.Create(rel); err != nil {
+			t.Fatalf("Could not store mock release: %s", err)
+		}
+	}
+
+	mrs := &mockListServer{}
+	if err := rs.ListReleases(&services.ListReleasesRequest{Offset: "", Limit: 64}, mrs); err != nil {
+		t.Fatalf("Failed listing: %s", err)
+	}
+
+	if len(mrs.val.Releases) != num {
+		t.Errorf("Expected %d releases, got %d", num, len(mrs.val.Releases))
+	}
+}
+
+func TestListReleasesByStatus(t *testing.T) {
+	rs := rsFixture()
+	stubs := []*release.Release{
+		namedReleaseStub("kamal", release.Status_DEPLOYED),
+		namedReleaseStub("astrolabe", release.Status_DELETED),
+		namedReleaseStub("octant", release.Status_FAILED),
+		namedReleaseStub("sextant", release.Status_UNKNOWN),
+	}
+	for _, stub := range stubs {
+		if err := rs.env.Releases.Create(stub); err != nil {
+			t.Fatalf("Could not create stub: %s", err)
+		}
+	}
+
+	tests := []struct {
+		statusCodes []release.Status_Code
+		names       []string
+	}{
+		{
+			names:       []string{"kamal"},
+			statusCodes: []release.Status_Code{release.Status_DEPLOYED},
+		},
+		{
+			names:       []string{"astrolabe"},
+			statusCodes: []release.Status_Code{release.Status_DELETED},
+		},
+		{
+			names:       []string{"kamal", "octant"},
+			statusCodes: []release.Status_Code{release.Status_DEPLOYED, release.Status_FAILED},
+		},
+		{
+			names: []string{"kamal", "astrolabe", "octant", "sextant"},
+			statusCodes: []release.Status_Code{
+				release.Status_DEPLOYED,
+				release.Status_DELETED,
+				release.Status_FAILED,
+				release.Status_UNKNOWN,
+			},
+		},
+	}
+
+	for i, tt := range tests {
+		mrs := &mockListServer{}
+		if err := rs.ListReleases(&services.ListReleasesRequest{StatusCodes: tt.statusCodes, Offset: "", Limit: 64}, mrs); err != nil {
+			t.Fatalf("Failed listing %d: %s", i, err)
+		}
+
+		if len(tt.names) != len(mrs.val.Releases) {
+			t.Fatalf("Expected %d releases, got %d", len(tt.names), len(mrs.val.Releases))
+		}
+
+		for _, name := range tt.names {
+			found := false
+			for _, rel := range mrs.val.Releases {
+				if rel.Name == name {
+					found = true
+				}
+			}
+			if !found {
+				t.Errorf("%d: Did not find name %q", i, name)
+			}
+		}
+	}
+}
+
+func TestListReleasesSort(t *testing.T) {
+	rs := rsFixture()
+
+	// Put them in by reverse order so that the mock doesn't "accidentally"
+	// sort.
+	num := 7
+	for i := num; i > 0; i-- {
+		rel := releaseStub()
+		rel.Name = fmt.Sprintf("rel-%d", i)
+		if err := rs.env.Releases.Create(rel); err != nil {
+			t.Fatalf("Could not store mock release: %s", err)
+		}
+	}
+
+	limit := 6
+	mrs := &mockListServer{}
+	req := &services.ListReleasesRequest{
+		Offset: "",
+		Limit:  int64(limit),
+		SortBy: services.ListSort_NAME,
+	}
+	if err := rs.ListReleases(req, mrs); err != nil {
+		t.Fatalf("Failed listing: %s", err)
+	}
+
+	if len(mrs.val.Releases) != limit {
+		t.Errorf("Expected %d releases, got %d", limit, len(mrs.val.Releases))
+	}
+
+	for i := 0; i < limit; i++ {
+		n := fmt.Sprintf("rel-%d", i+1)
+		if mrs.val.Releases[i].Name != n {
+			t.Errorf("Expected %q, got %q", n, mrs.val.Releases[i].Name)
+		}
+	}
+}
+
+func TestListReleasesFilter(t *testing.T) {
+	rs := rsFixture()
+	names := []string{
+		"axon",
+		"dendrite",
+		"neuron",
+		"neuroglia",
+		"synapse",
+		"nucleus",
+		"organelles",
+	}
+	num := 7
+	for i := 0; i < num; i++ {
+		rel := releaseStub()
+		rel.Name = names[i]
+		if err := rs.env.Releases.Create(rel); err != nil {
+			t.Fatalf("Could not store mock release: %s", err)
+		}
+	}
+
+	mrs := &mockListServer{}
+	req := &services.ListReleasesRequest{
+		Offset: "",
+		Limit:  64,
+		Filter: "neuro[a-z]+",
+		SortBy: services.ListSort_NAME,
+	}
+	if err := rs.ListReleases(req, mrs); err != nil {
+		t.Fatalf("Failed listing: %s", err)
+	}
+
+	if len(mrs.val.Releases) != 2 {
+		t.Errorf("Expected 2 releases, got %d", len(mrs.val.Releases))
+	}
+
+	if mrs.val.Releases[0].Name != "neuroglia" {
+		t.Errorf("Unexpected sort order: %v.", mrs.val.Releases)
+	}
+	if mrs.val.Releases[1].Name != "neuron" {
+		t.Errorf("Unexpected sort order: %v.", mrs.val.Releases)
+	}
+}
+
+func TestReleasesNamespace(t *testing.T) {
+	rs := rsFixture()
+
+	names := []string{
+		"axon",
+		"dendrite",
+		"neuron",
+		"ribosome",
+	}
+
+	namespaces := []string{
+		"default",
+		"test123",
+		"test123",
+		"cerebellum",
+	}
+	num := 4
+	for i := 0; i < num; i++ {
+		rel := releaseStub()
+		rel.Name = names[i]
+		rel.Namespace = namespaces[i]
+		if err := rs.env.Releases.Create(rel); err != nil {
+			t.Fatalf("Could not store mock release: %s", err)
+		}
+	}
+
+	mrs := &mockListServer{}
+	req := &services.ListReleasesRequest{
+		Offset:    "",
+		Limit:     64,
+		Namespace: "test123",
+	}
+
+	if err := rs.ListReleases(req, mrs); err != nil {
+		t.Fatalf("Failed listing: %s", err)
+	}
+
+	if len(mrs.val.Releases) != 2 {
+		t.Errorf("Expected 2 releases, got %d", len(mrs.val.Releases))
+	}
+}

pkg/tiller/release_rollback_test.go

@@ -191,3 +191,36 @@ func TestRollbackReleaseNoHooks(t *testing.T) {
 		t.Errorf("Expected that no hooks were run. Got %d", hl)
 	}
 }
+
+func TestRollbackReleaseFailure(t *testing.T) {
+	c := helm.NewContext()
+	rs := rsFixture()
+	rel := releaseStub()
+	rs.env.Releases.Create(rel)
+	upgradedRel := upgradeReleaseVersion(rel)
+	rs.env.Releases.Update(rel)
+	rs.env.Releases.Create(upgradedRel)
+
+	req := &services.RollbackReleaseRequest{
+		Name:         rel.Name,
+		DisableHooks: true,
+	}
+
+	rs.env.KubeClient = newUpdateFailingKubeClient()
+	res, err := rs.RollbackRelease(c, req)
+	if err == nil {
+		t.Error("Expected failed rollback")
+	}
+
+	if targetStatus := res.Release.Info.Status.Code; targetStatus != release.Status_FAILED {
+		t.Errorf("Expected FAILED release. Got %v", targetStatus)
+	}
+
+	oldRelease, err := rs.env.Releases.Get(rel.Name, rel.Version)
+	if err != nil {
+		t.Errorf("Expected to be able to get previous release")
+	}
+	if oldStatus := oldRelease.Info.Status.Code; oldStatus != release.Status_SUPERSEDED {
+		t.Errorf("Expected SUPERSEDED status on previous Release version. Got %v", oldStatus)
+	}
+}