memory_test.go

Documentation: helm.sh/helm/v3/pkg/storage/driver

     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 driver
    18  
    19  import (
    20  	"fmt"
    21  	"reflect"
    22  	"testing"
    23  
    24  	rspb "helm.sh/helm/v3/pkg/release"
    25  )
    26  
    27  func TestMemoryName(t *testing.T) {
    28  	if mem := NewMemory(); mem.Name() != MemoryDriverName {
    29  		t.Errorf("Expected name to be %q, got %q", MemoryDriverName, mem.Name())
    30  	}
    31  }
    32  
    33  func TestMemoryCreate(t *testing.T) {
    34  	var tests = []struct {
    35  		desc string
    36  		rls  *rspb.Release
    37  		err  bool
    38  	}{
    39  		{
    40  			"create should succeed",
    41  			releaseStub("rls-c", 1, "default", rspb.StatusDeployed),
    42  			false,
    43  		},
    44  		{
    45  			"create should fail (release already exists)",
    46  			releaseStub("rls-a", 1, "default", rspb.StatusDeployed),
    47  			true,
    48  		},
    49  		{
    50  			"create in namespace should succeed",
    51  			releaseStub("rls-a", 1, "mynamespace", rspb.StatusDeployed),
    52  			false,
    53  		},
    54  		{
    55  			"create in other namespace should fail (release already exists)",
    56  			releaseStub("rls-c", 1, "mynamespace", rspb.StatusDeployed),
    57  			true,
    58  		},
    59  	}
    60  
    61  	ts := tsFixtureMemory(t)
    62  	for _, tt := range tests {
    63  		key := testKey(tt.rls.Name, tt.rls.Version)
    64  		rls := tt.rls
    65  
    66  		if err := ts.Create(key, rls); err != nil {
    67  			if !tt.err {
    68  				t.Fatalf("failed to create %q: %s", tt.desc, err)
    69  			}
    70  		} else if tt.err {
    71  			t.Fatalf("Did not get expected error for %q\n", tt.desc)
    72  		}
    73  	}
    74  }
    75  
    76  func TestMemoryGet(t *testing.T) {
    77  	var tests = []struct {
    78  		desc      string
    79  		key       string
    80  		namespace string
    81  		err       bool
    82  	}{
    83  		{"release key should exist", "rls-a.v1", "default", false},
    84  		{"release key should not exist", "rls-a.v5", "default", true},
    85  		{"release key in namespace should exist", "rls-c.v1", "mynamespace", false},
    86  		{"release key in namespace should not exist", "rls-a.v1", "mynamespace", true},
    87  	}
    88  
    89  	ts := tsFixtureMemory(t)
    90  	for _, tt := range tests {
    91  		ts.SetNamespace(tt.namespace)
    92  		if _, err := ts.Get(tt.key); err != nil {
    93  			if !tt.err {
    94  				t.Fatalf("Failed %q to get '%s': %q\n", tt.desc, tt.key, err)
    95  			}
    96  		} else if tt.err {
    97  			t.Fatalf("Did not get expected error for %q '%s'\n", tt.desc, tt.key)
    98  		}
    99  	}
   100  }
   101  
   102  func TestMemoryList(t *testing.T) {
   103  	ts := tsFixtureMemory(t)
   104  	ts.SetNamespace("default")
   105  
   106  	// list all deployed releases
   107  	dpl, err := ts.List(func(rel *rspb.Release) bool {
   108  		return rel.Info.Status == rspb.StatusDeployed
   109  	})
   110  	// check
   111  	if err != nil {
   112  		t.Errorf("Failed to list deployed releases: %s", err)
   113  	}
   114  	if len(dpl) != 2 {
   115  		t.Errorf("Expected 2 deployed, got %d", len(dpl))
   116  	}
   117  
   118  	// list all superseded releases
   119  	ssd, err := ts.List(func(rel *rspb.Release) bool {
   120  		return rel.Info.Status == rspb.StatusSuperseded
   121  	})
   122  	// check
   123  	if err != nil {
   124  		t.Errorf("Failed to list superseded releases: %s", err)
   125  	}
   126  	if len(ssd) != 6 {
   127  		t.Errorf("Expected 6 superseded, got %d", len(ssd))
   128  	}
   129  
   130  	// list all deleted releases
   131  	del, err := ts.List(func(rel *rspb.Release) bool {
   132  		return rel.Info.Status == rspb.StatusUninstalled
   133  	})
   134  	// check
   135  	if err != nil {
   136  		t.Errorf("Failed to list deleted releases: %s", err)
   137  	}
   138  	if len(del) != 0 {
   139  		t.Errorf("Expected 0 deleted, got %d", len(del))
   140  	}
   141  }
   142  
   143  func TestMemoryQuery(t *testing.T) {
   144  	var tests = []struct {
   145  		desc      string
   146  		xlen      int
   147  		namespace string
   148  		lbs       map[string]string
   149  	}{
   150  		{
   151  			"should be 2 query results",
   152  			2,
   153  			"default",
   154  			map[string]string{"status": "deployed"},
   155  		},
   156  		{
   157  			"should be 1 query result",
   158  			1,
   159  			"mynamespace",
   160  			map[string]string{"status": "deployed"},
   161  		},
   162  	}
   163  
   164  	ts := tsFixtureMemory(t)
   165  	for _, tt := range tests {
   166  		ts.SetNamespace(tt.namespace)
   167  		l, err := ts.Query(tt.lbs)
   168  		if err != nil {
   169  			t.Fatalf("Failed to query: %s\n", err)
   170  		}
   171  
   172  		if tt.xlen != len(l) {
   173  			t.Fatalf("Expected %d results, actual %d\n", tt.xlen, len(l))
   174  		}
   175  	}
   176  }
   177  
   178  func TestMemoryUpdate(t *testing.T) {
   179  	var tests = []struct {
   180  		desc string
   181  		key  string
   182  		rls  *rspb.Release
   183  		err  bool
   184  	}{
   185  		{
   186  			"update release status",
   187  			"rls-a.v4",
   188  			releaseStub("rls-a", 4, "default", rspb.StatusSuperseded),
   189  			false,
   190  		},
   191  		{
   192  			"update release does not exist",
   193  			"rls-c.v1",
   194  			releaseStub("rls-c", 1, "default", rspb.StatusUninstalled),
   195  			true,
   196  		},
   197  		{
   198  			"update release status in namespace",
   199  			"rls-c.v4",
   200  			releaseStub("rls-c", 4, "mynamespace", rspb.StatusSuperseded),
   201  			false,
   202  		},
   203  		{
   204  			"update release in namespace does not exist",
   205  			"rls-a.v1",
   206  			releaseStub("rls-a", 1, "mynamespace", rspb.StatusUninstalled),
   207  			true,
   208  		},
   209  	}
   210  
   211  	ts := tsFixtureMemory(t)
   212  	for _, tt := range tests {
   213  		if err := ts.Update(tt.key, tt.rls); err != nil {
   214  			if !tt.err {
   215  				t.Fatalf("Failed %q: %s\n", tt.desc, err)
   216  			}
   217  			continue
   218  		} else if tt.err {
   219  			t.Fatalf("Did not get expected error for %q '%s'\n", tt.desc, tt.key)
   220  		}
   221  
   222  		ts.SetNamespace(tt.rls.Namespace)
   223  		r, err := ts.Get(tt.key)
   224  		if err != nil {
   225  			t.Fatalf("Failed to get: %s\n", err)
   226  		}
   227  
   228  		if !reflect.DeepEqual(r, tt.rls) {
   229  			t.Fatalf("Expected %v, actual %v\n", tt.rls, r)
   230  		}
   231  	}
   232  }
   233  
   234  func TestMemoryDelete(t *testing.T) {
   235  	var tests = []struct {
   236  		desc      string
   237  		key       string
   238  		namespace string
   239  		err       bool
   240  	}{
   241  		{"release key should exist", "rls-a.v4", "default", false},
   242  		{"release key should not exist", "rls-a.v5", "default", true},
   243  		{"release key from other namespace should not exist", "rls-c.v4", "default", true},
   244  		{"release key from namespace should exist", "rls-c.v4", "mynamespace", false},
   245  		{"release key from namespace should not exist", "rls-c.v5", "mynamespace", true},
   246  		{"release key from namespace2 should not exist", "rls-a.v4", "mynamespace", true},
   247  	}
   248  
   249  	ts := tsFixtureMemory(t)
   250  	ts.SetNamespace("")
   251  	start, err := ts.Query(map[string]string{"status": "deployed"})
   252  	if err != nil {
   253  		t.Errorf("Query failed: %s", err)
   254  	}
   255  	startLen := len(start)
   256  	for _, tt := range tests {
   257  		ts.SetNamespace(tt.namespace)
   258  		if rel, err := ts.Delete(tt.key); err != nil {
   259  			if !tt.err {
   260  				t.Fatalf("Failed %q to get '%s': %q\n", tt.desc, tt.key, err)
   261  			}
   262  			continue
   263  		} else if tt.err {
   264  			t.Fatalf("Did not get expected error for %q '%s'\n", tt.desc, tt.key)
   265  		} else if fmt.Sprintf("%s.v%d", rel.Name, rel.Version) != tt.key {
   266  			t.Fatalf("Asked for delete on %s, but deleted %d", tt.key, rel.Version)
   267  		}
   268  		_, err := ts.Get(tt.key)
   269  		if err == nil {
   270  			t.Errorf("Expected an error when asking for a deleted key")
   271  		}
   272  	}
   273  
   274  	// Make sure that the deleted records are gone.
   275  	ts.SetNamespace("")
   276  	end, err := ts.Query(map[string]string{"status": "deployed"})
   277  	if err != nil {
   278  		t.Errorf("Query failed: %s", err)
   279  	}
   280  	endLen := len(end)
   281  
   282  	if startLen-2 != endLen {
   283  		t.Errorf("expected end to be %d instead of %d", startLen-2, endLen)
   284  		for _, ee := range end {
   285  			t.Logf("Name: %s, Version: %d", ee.Name, ee.Version)
   286  		}
   287  	}
   288  
   289  }
   290
View as plain text