github.com/umeshredd/helm@v3.0.0-alpha.1+incompatible/pkg/action/list_test.go (about)

     1  /*
     2  Copyright The Helm Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package action
    18  
    19  import (
    20  	"testing"
    21  
    22  	"github.com/stretchr/testify/assert"
    23  
    24  	"helm.sh/helm/pkg/release"
    25  	"helm.sh/helm/pkg/storage"
    26  )
    27  
    28  func TestListStates(t *testing.T) {
    29  	for input, expect := range map[string]ListStates{
    30  		"deployed":            ListDeployed,
    31  		"uninstalled":         ListUninstalled,
    32  		"uninstalling":        ListUninstalling,
    33  		"superseded":          ListSuperseded,
    34  		"failed":              ListFailed,
    35  		"pending-install":     ListPendingInstall,
    36  		"pending-rollback":    ListPendingRollback,
    37  		"pending-upgrade":     ListPendingUpgrade,
    38  		"unknown":             ListUnknown,
    39  		"totally made up key": ListUnknown,
    40  	} {
    41  		if expect != expect.FromName(input) {
    42  			t.Errorf("Expected %d for %s", expect, input)
    43  		}
    44  		// This is a cheap way to verify that ListAll actually allows everything but Unknown
    45  		if got := expect.FromName(input); got != ListUnknown && got&ListAll == 0 {
    46  			t.Errorf("Expected %s to match the ListAll filter", input)
    47  		}
    48  	}
    49  
    50  	filter := ListDeployed | ListPendingRollback
    51  	if status := filter.FromName("deployed"); filter&status == 0 {
    52  		t.Errorf("Expected %d to match mask %d", status, filter)
    53  	}
    54  	if status := filter.FromName("failed"); filter&status != 0 {
    55  		t.Errorf("Expected %d to fail to match mask %d", status, filter)
    56  	}
    57  }
    58  
    59  func TestList_Empty(t *testing.T) {
    60  	lister := NewList(actionConfigFixture(t))
    61  	list, err := lister.Run()
    62  	assert.NoError(t, err)
    63  	assert.Len(t, list, 0)
    64  }
    65  
    66  func newListFixture(t *testing.T) *List {
    67  	return NewList(actionConfigFixture(t))
    68  }
    69  
    70  func TestList_OneNamespace(t *testing.T) {
    71  	is := assert.New(t)
    72  	lister := newListFixture(t)
    73  	makeMeSomeReleases(lister.cfg.Releases, t)
    74  	list, err := lister.Run()
    75  	is.NoError(err)
    76  	is.Len(list, 3)
    77  }
    78  
    79  func TestList_AllNamespaces(t *testing.T) {
    80  	is := assert.New(t)
    81  	lister := newListFixture(t)
    82  	makeMeSomeReleases(lister.cfg.Releases, t)
    83  	lister.AllNamespaces = true
    84  	list, err := lister.Run()
    85  	is.NoError(err)
    86  	is.Len(list, 3)
    87  }
    88  
    89  func TestList_Sort(t *testing.T) {
    90  	is := assert.New(t)
    91  	lister := newListFixture(t)
    92  	lister.Sort = ByNameDesc // Other sorts are tested elsewhere
    93  	makeMeSomeReleases(lister.cfg.Releases, t)
    94  	list, err := lister.Run()
    95  	is.NoError(err)
    96  	is.Len(list, 3)
    97  	is.Equal("two", list[0].Name)
    98  	is.Equal("three", list[1].Name)
    99  	is.Equal("one", list[2].Name)
   100  }
   101  
   102  func TestList_Limit(t *testing.T) {
   103  	is := assert.New(t)
   104  	lister := newListFixture(t)
   105  	lister.Limit = 2
   106  	// Sort because otherwise there is no guaranteed order
   107  	lister.Sort = ByNameAsc
   108  	makeMeSomeReleases(lister.cfg.Releases, t)
   109  	list, err := lister.Run()
   110  	is.NoError(err)
   111  	is.Len(list, 2)
   112  
   113  	// Lex order means one, three, two
   114  	is.Equal("one", list[0].Name)
   115  	is.Equal("three", list[1].Name)
   116  }
   117  
   118  func TestList_BigLimit(t *testing.T) {
   119  	is := assert.New(t)
   120  	lister := newListFixture(t)
   121  	lister.Limit = 20
   122  	// Sort because otherwise there is no guaranteed order
   123  	lister.Sort = ByNameAsc
   124  	makeMeSomeReleases(lister.cfg.Releases, t)
   125  	list, err := lister.Run()
   126  	is.NoError(err)
   127  	is.Len(list, 3)
   128  
   129  	// Lex order means one, three, two
   130  	is.Equal("one", list[0].Name)
   131  	is.Equal("three", list[1].Name)
   132  	is.Equal("two", list[2].Name)
   133  }
   134  
   135  func TestList_LimitOffset(t *testing.T) {
   136  	is := assert.New(t)
   137  	lister := newListFixture(t)
   138  	lister.Limit = 2
   139  	lister.Offset = 1
   140  	// Sort because otherwise there is no guaranteed order
   141  	lister.Sort = ByNameAsc
   142  	makeMeSomeReleases(lister.cfg.Releases, t)
   143  	list, err := lister.Run()
   144  	is.NoError(err)
   145  	is.Len(list, 2)
   146  
   147  	// Lex order means one, three, two
   148  	is.Equal("three", list[0].Name)
   149  	is.Equal("two", list[1].Name)
   150  }
   151  
   152  func TestList_LimitOffsetOutOfBounds(t *testing.T) {
   153  	is := assert.New(t)
   154  	lister := newListFixture(t)
   155  	lister.Limit = 2
   156  	lister.Offset = 3 // Last item is index 2
   157  	// Sort because otherwise there is no guaranteed order
   158  	lister.Sort = ByNameAsc
   159  	makeMeSomeReleases(lister.cfg.Releases, t)
   160  	list, err := lister.Run()
   161  	is.NoError(err)
   162  	is.Len(list, 0)
   163  
   164  	lister.Limit = 10
   165  	lister.Offset = 1
   166  	list, err = lister.Run()
   167  	is.NoError(err)
   168  	is.Len(list, 2)
   169  }
   170  func TestList_StateMask(t *testing.T) {
   171  	is := assert.New(t)
   172  	lister := newListFixture(t)
   173  	// Sort because otherwise there is no guaranteed order
   174  	lister.Sort = ByNameAsc
   175  	makeMeSomeReleases(lister.cfg.Releases, t)
   176  	one, err := lister.cfg.Releases.Get("one", 1)
   177  	is.NoError(err)
   178  	one.SetStatus(release.StatusUninstalled, "uninstalled")
   179  	lister.cfg.Releases.Update(one)
   180  
   181  	res, err := lister.Run()
   182  	is.NoError(err)
   183  	is.Len(res, 2)
   184  	is.Equal("three", res[0].Name)
   185  	is.Equal("two", res[1].Name)
   186  
   187  	lister.StateMask = ListUninstalled
   188  	res, err = lister.Run()
   189  	is.NoError(err)
   190  	is.Len(res, 1)
   191  	is.Equal("one", res[0].Name)
   192  
   193  	lister.StateMask |= ListDeployed
   194  	res, err = lister.Run()
   195  	is.NoError(err)
   196  	is.Len(res, 3)
   197  }
   198  
   199  func TestList_Filter(t *testing.T) {
   200  	is := assert.New(t)
   201  	lister := newListFixture(t)
   202  	lister.Filter = "th."
   203  	lister.Sort = ByNameAsc
   204  	makeMeSomeReleases(lister.cfg.Releases, t)
   205  
   206  	res, err := lister.Run()
   207  	is.NoError(err)
   208  	is.Len(res, 1)
   209  	is.Equal("three", res[0].Name)
   210  }
   211  
   212  func TestList_FilterFailsCompile(t *testing.T) {
   213  	is := assert.New(t)
   214  	lister := newListFixture(t)
   215  	lister.Filter = "t[h.{{{"
   216  	makeMeSomeReleases(lister.cfg.Releases, t)
   217  
   218  	_, err := lister.Run()
   219  	is.Error(err)
   220  }
   221  
   222  func makeMeSomeReleases(store *storage.Storage, t *testing.T) {
   223  	t.Helper()
   224  	one := releaseStub()
   225  	one.Name = "one"
   226  	one.Namespace = "default"
   227  	one.Version = 1
   228  	two := releaseStub()
   229  	two.Name = "two"
   230  	two.Namespace = "default"
   231  	two.Version = 2
   232  	three := releaseStub()
   233  	three.Name = "three"
   234  	three.Namespace = "default"
   235  	three.Version = 3
   236  
   237  	for _, rel := range []*release.Release{one, two, three} {
   238  		if err := store.Create(rel); err != nil {
   239  			t.Fatal(err)
   240  		}
   241  	}
   242  
   243  	all, err := store.ListReleases()
   244  	assert.NoError(t, err)
   245  	assert.Len(t, all, 3, "sanity test: three items added")
   246  }