/* 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 ( "testing" "github.com/stretchr/testify/assert" "k8s.io/helm/pkg/release" "k8s.io/helm/pkg/storage" ) func TestListStates(t *testing.T) { for input, expect := range map[string]ListStates{ "deployed": ListDeployed, "uninstalled": ListUninstalled, "uninstalling": ListUninstalling, "superseded": ListSuperseded, "failed": ListFailed, "pending-install": ListPendingInstall, "pending-rollback": ListPendingRollback, "pending-upgrade": ListPendingUpgrade, "unknown": ListUnknown, "totally made up key": ListUnknown, } { if expect != expect.FromName(input) { t.Errorf("Expected %d for %s", expect, input) } // This is a cheap way to verify that ListAll actually allows everything but Unknown if got := expect.FromName(input); got != ListUnknown && got&ListAll == 0 { t.Errorf("Expected %s to match the ListAll filter", input) } } filter := ListDeployed | ListPendingRollback if status := filter.FromName("deployed"); filter&status == 0 { t.Errorf("Expected %d to match mask %d", status, filter) } if status := filter.FromName("failed"); filter&status != 0 { t.Errorf("Expected %d to fail to match mask %d", status, filter) } } func TestList_Empty(t *testing.T) { lister := NewList(actionConfigFixture(t)) list, err := lister.Run() assert.NoError(t, err) assert.Len(t, list, 0) } func newListFixture(t *testing.T) *List { return NewList(actionConfigFixture(t)) } func TestList_OneNamespace(t *testing.T) { is := assert.New(t) lister := newListFixture(t) makeMeSomeReleases(lister.cfg.Releases, t) list, err := lister.Run() is.NoError(err) is.Len(list, 3) } func TestList_AllNamespaces(t *testing.T) { is := assert.New(t) lister := newListFixture(t) makeMeSomeReleases(lister.cfg.Releases, t) lister.AllNamespaces = true list, err := lister.Run() is.NoError(err) is.Len(list, 3) } func TestList_Sort(t *testing.T) { is := assert.New(t) lister := newListFixture(t) lister.Sort = ByNameDesc // Other sorts are tested elsewhere makeMeSomeReleases(lister.cfg.Releases, t) list, err := lister.Run() is.NoError(err) is.Len(list, 3) is.Equal("two", list[0].Name) is.Equal("three", list[1].Name) is.Equal("one", list[2].Name) } func TestList_Limit(t *testing.T) { is := assert.New(t) lister := newListFixture(t) lister.Limit = 2 // Sort because otherwise there is no guaranteed order lister.Sort = ByNameAsc makeMeSomeReleases(lister.cfg.Releases, t) list, err := lister.Run() is.NoError(err) is.Len(list, 2) // Lex order means one, three, two is.Equal("one", list[0].Name) is.Equal("three", list[1].Name) } func TestList_BigLimit(t *testing.T) { is := assert.New(t) lister := newListFixture(t) lister.Limit = 20 // Sort because otherwise there is no guaranteed order lister.Sort = ByNameAsc makeMeSomeReleases(lister.cfg.Releases, t) list, err := lister.Run() is.NoError(err) is.Len(list, 3) // Lex order means one, three, two is.Equal("one", list[0].Name) is.Equal("three", list[1].Name) is.Equal("two", list[2].Name) } func TestList_LimitOffset(t *testing.T) { is := assert.New(t) lister := newListFixture(t) lister.Limit = 2 lister.Offset = 1 // Sort because otherwise there is no guaranteed order lister.Sort = ByNameAsc makeMeSomeReleases(lister.cfg.Releases, t) list, err := lister.Run() is.NoError(err) is.Len(list, 2) // Lex order means one, three, two is.Equal("three", list[0].Name) is.Equal("two", list[1].Name) } func TestList_LimitOffsetOutOfBounds(t *testing.T) { is := assert.New(t) lister := newListFixture(t) lister.Limit = 2 lister.Offset = 3 // Last item is index 2 // Sort because otherwise there is no guaranteed order lister.Sort = ByNameAsc makeMeSomeReleases(lister.cfg.Releases, t) list, err := lister.Run() is.NoError(err) is.Len(list, 0) lister.Limit = 10 lister.Offset = 1 list, err = lister.Run() is.NoError(err) is.Len(list, 2) } func TestList_StateMask(t *testing.T) { is := assert.New(t) lister := newListFixture(t) // Sort because otherwise there is no guaranteed order lister.Sort = ByNameAsc makeMeSomeReleases(lister.cfg.Releases, t) one, err := lister.cfg.Releases.Get("one", 1) is.NoError(err) one.SetStatus(release.StatusUninstalled, "uninstalled") lister.cfg.Releases.Update(one) res, err := lister.Run() is.NoError(err) is.Len(res, 2) is.Equal("three", res[0].Name) is.Equal("two", res[1].Name) lister.StateMask = ListUninstalled res, err = lister.Run() is.NoError(err) is.Len(res, 1) is.Equal("one", res[0].Name) lister.StateMask |= ListDeployed res, err = lister.Run() is.NoError(err) is.Len(res, 3) } func TestList_Filter(t *testing.T) { is := assert.New(t) lister := newListFixture(t) lister.Filter = "th." lister.Sort = ByNameAsc makeMeSomeReleases(lister.cfg.Releases, t) res, err := lister.Run() is.NoError(err) is.Len(res, 1) is.Equal("three", res[0].Name) } func TestList_FilterFailsCompile(t *testing.T) { is := assert.New(t) lister := newListFixture(t) lister.Filter = "t[h.{{{" makeMeSomeReleases(lister.cfg.Releases, t) _, err := lister.Run() is.Error(err) } func makeMeSomeReleases(store *storage.Storage, t *testing.T) { t.Helper() one := releaseStub() one.Name = "one" one.Namespace = "default" one.Version = 1 two := releaseStub() two.Name = "two" two.Namespace = "default" two.Version = 2 three := releaseStub() three.Name = "three" three.Namespace = "default" three.Version = 3 for _, rel := range []*release.Release{one, two, three} { if err := store.Create(rel); err != nil { t.Fatal(err) } } all, err := store.ListReleases() assert.NoError(t, err) assert.Len(t, all, 3, "sanity test: three items added") }