records_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 // import "helm.sh/helm/v3/pkg/storage/driver"
    18  
    19  import (
    20  	"reflect"
    21  	"testing"
    22  
    23  	rspb "helm.sh/helm/v3/pkg/release"
    24  )
    25  
    26  func TestRecordsAdd(t *testing.T) {
    27  	rs := records([]*record{
    28  		newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusSuperseded)),
    29  		newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", rspb.StatusDeployed)),
    30  	})
    31  
    32  	var tests = []struct {
    33  		desc string
    34  		key  string
    35  		ok   bool
    36  		rec  *record
    37  	}{
    38  		{
    39  			"add valid key",
    40  			"rls-a.v3",
    41  			false,
    42  			newRecord("rls-a.v3", releaseStub("rls-a", 3, "default", rspb.StatusSuperseded)),
    43  		},
    44  		{
    45  			"add already existing key",
    46  			"rls-a.v1",
    47  			true,
    48  			newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusDeployed)),
    49  		},
    50  	}
    51  
    52  	for _, tt := range tests {
    53  		if err := rs.Add(tt.rec); err != nil {
    54  			if !tt.ok {
    55  				t.Fatalf("failed: %q: %s\n", tt.desc, err)
    56  			}
    57  		}
    58  	}
    59  }
    60  
    61  func TestRecordsRemove(t *testing.T) {
    62  	var tests = []struct {
    63  		desc string
    64  		key  string
    65  		ok   bool
    66  	}{
    67  		{"remove valid key", "rls-a.v1", false},
    68  		{"remove invalid key", "rls-a.v", true},
    69  		{"remove non-existent key", "rls-z.v1", true},
    70  	}
    71  
    72  	rs := records([]*record{
    73  		newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusSuperseded)),
    74  		newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", rspb.StatusDeployed)),
    75  	})
    76  
    77  	startLen := rs.Len()
    78  
    79  	for _, tt := range tests {
    80  		if r := rs.Remove(tt.key); r == nil {
    81  			if !tt.ok {
    82  				t.Fatalf("Failed to %q (key = %s). Expected nil, got %v",
    83  					tt.desc,
    84  					tt.key,
    85  					r,
    86  				)
    87  			}
    88  		}
    89  	}
    90  
    91  	// We expect the total number of records will be less now than there were
    92  	// when we started.
    93  	endLen := rs.Len()
    94  	if endLen >= startLen {
    95  		t.Errorf("expected ending length %d to be less than starting length %d", endLen, startLen)
    96  	}
    97  }
    98  
    99  func TestRecordsRemoveAt(t *testing.T) {
   100  	rs := records([]*record{
   101  		newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusSuperseded)),
   102  		newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", rspb.StatusDeployed)),
   103  	})
   104  
   105  	if len(rs) != 2 {
   106  		t.Fatal("Expected len=2 for mock")
   107  	}
   108  
   109  	rs.Remove("rls-a.v1")
   110  	if len(rs) != 1 {
   111  		t.Fatalf("Expected length of rs to be 1, got %d", len(rs))
   112  	}
   113  }
   114  
   115  func TestRecordsGet(t *testing.T) {
   116  	rs := records([]*record{
   117  		newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusSuperseded)),
   118  		newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", rspb.StatusDeployed)),
   119  	})
   120  
   121  	var tests = []struct {
   122  		desc string
   123  		key  string
   124  		rec  *record
   125  	}{
   126  		{
   127  			"get valid key",
   128  			"rls-a.v1",
   129  			newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusSuperseded)),
   130  		},
   131  		{
   132  			"get invalid key",
   133  			"rls-a.v3",
   134  			nil,
   135  		},
   136  	}
   137  
   138  	for _, tt := range tests {
   139  		got := rs.Get(tt.key)
   140  		if !reflect.DeepEqual(tt.rec, got) {
   141  			t.Fatalf("Expected %v, got %v", tt.rec, got)
   142  		}
   143  	}
   144  }
   145  
   146  func TestRecordsIndex(t *testing.T) {
   147  	rs := records([]*record{
   148  		newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusSuperseded)),
   149  		newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", rspb.StatusDeployed)),
   150  	})
   151  
   152  	var tests = []struct {
   153  		desc string
   154  		key  string
   155  		sort int
   156  	}{
   157  		{
   158  			"get valid key",
   159  			"rls-a.v1",
   160  			0,
   161  		},
   162  		{
   163  			"get invalid key",
   164  			"rls-a.v3",
   165  			-1,
   166  		},
   167  	}
   168  
   169  	for _, tt := range tests {
   170  		got, _ := rs.Index(tt.key)
   171  		if got != tt.sort {
   172  			t.Fatalf("Expected %d, got %d", tt.sort, got)
   173  		}
   174  	}
   175  }
   176  
   177  func TestRecordsExists(t *testing.T) {
   178  	rs := records([]*record{
   179  		newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusSuperseded)),
   180  		newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", rspb.StatusDeployed)),
   181  	})
   182  
   183  	var tests = []struct {
   184  		desc string
   185  		key  string
   186  		ok   bool
   187  	}{
   188  		{
   189  			"get valid key",
   190  			"rls-a.v1",
   191  			true,
   192  		},
   193  		{
   194  			"get invalid key",
   195  			"rls-a.v3",
   196  			false,
   197  		},
   198  	}
   199  
   200  	for _, tt := range tests {
   201  		got := rs.Exists(tt.key)
   202  		if got != tt.ok {
   203  			t.Fatalf("Expected %t, got %t", tt.ok, got)
   204  		}
   205  	}
   206  }
   207  
   208  func TestRecordsReplace(t *testing.T) {
   209  	rs := records([]*record{
   210  		newRecord("rls-a.v1", releaseStub("rls-a", 1, "default", rspb.StatusSuperseded)),
   211  		newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", rspb.StatusDeployed)),
   212  	})
   213  
   214  	var tests = []struct {
   215  		desc     string
   216  		key      string
   217  		rec      *record
   218  		expected *record
   219  	}{
   220  		{
   221  			"replace with existing key",
   222  			"rls-a.v2",
   223  			newRecord("rls-a.v3", releaseStub("rls-a", 3, "default", rspb.StatusSuperseded)),
   224  			newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", rspb.StatusDeployed)),
   225  		},
   226  		{
   227  			"replace with non existing key",
   228  			"rls-a.v4",
   229  			newRecord("rls-a.v4", releaseStub("rls-a", 4, "default", rspb.StatusDeployed)),
   230  			nil,
   231  		},
   232  	}
   233  
   234  	for _, tt := range tests {
   235  		got := rs.Replace(tt.key, tt.rec)
   236  		if !reflect.DeepEqual(tt.expected, got) {
   237  			t.Fatalf("Expected %v, got %v", tt.expected, got)
   238  		}
   239  	}
   240  }
   241
View as plain text