Debian Codegraph @

pkg/storage/cacher/store_test.go

raw
1 /*
2 Copyright 2022 The Kubernetes 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 cacher
18
19 import (
20 "testing"
21
22 "github.com/stretchr/testify/assert"
23 "github.com/stretchr/testify/require"
24
25 "k8s.io/apimachinery/pkg/runtime"
26 "k8s.io/apimachinery/pkg/runtime/schema"
27 "k8s.io/client-go/tools/cache"
28 )
29
30 func TestStoreSingleKey(t *testing.T) {
31 t.Run("cache.Indexer", func(t *testing.T) {
32 store := newStoreIndexer(testStoreIndexers())
33 testStoreSingleKey(t, store)
34 })
35 t.Run("btree", func(t *testing.T) {
36 store := newThreadedBtreeStoreIndexer(storeElementIndexers(testStoreIndexers()), btreeDegree)
37 testStoreSingleKey(t, store)
38 })
39 }
40
41 func testStoreSingleKey(t *testing.T, store storeIndexer) {
42 assertStoreEmpty(t, store, "foo")
43
44 require.NoError(t, store.Add(testStorageElement("foo", "bar", 1)))
45 assertStoreSingleKey(t, store, "foo", "bar", 1)
46
47 require.NoError(t, store.Update(testStorageElement("foo", "baz", 2)))
48 assertStoreSingleKey(t, store, "foo", "baz", 2)
49
50 require.NoError(t, store.Update(testStorageElement("foo", "baz", 3)))
51 assertStoreSingleKey(t, store, "foo", "baz", 3)
52
53 require.NoError(t, store.Replace([]interface{}{testStorageElement("foo", "bar", 4)}, ""))
54 assertStoreSingleKey(t, store, "foo", "bar", 4)
55
56 require.NoError(t, store.Delete(testStorageElement("foo", "", 0)))
57 assertStoreEmpty(t, store, "foo")
58
59 require.NoError(t, store.Delete(testStorageElement("foo", "", 0)))
60 }
61
62 func TestStoreIndexerSingleKey(t *testing.T) {
63 t.Run("cache.Indexer", func(t *testing.T) {
64 store := newStoreIndexer(testStoreIndexers())
65 testStoreIndexerSingleKey(t, store)
66 })
67 t.Run("btree", func(t *testing.T) {
68 store := newThreadedBtreeStoreIndexer(storeElementIndexers(testStoreIndexers()), btreeDegree)
69 testStoreIndexerSingleKey(t, store)
70 })
71 }
72
73 func testStoreIndexerSingleKey(t *testing.T, store storeIndexer) {
74 items, err := store.ByIndex("by_val", "bar")
75 require.NoError(t, err)
76 assert.Empty(t, items)
77
78 require.NoError(t, store.Add(testStorageElement("foo", "bar", 1)))
79 items, err = store.ByIndex("by_val", "bar")
80 require.NoError(t, err)
81 assert.Equal(t, []interface{}{
82 testStorageElement("foo", "bar", 1),
83 }, items)
84
85 require.NoError(t, store.Update(testStorageElement("foo", "baz", 2)))
86 items, err = store.ByIndex("by_val", "bar")
87 require.NoError(t, err)
88 assert.Empty(t, items)
89 items, err = store.ByIndex("by_val", "baz")
90 require.NoError(t, err)
91 assert.Equal(t, []interface{}{
92 testStorageElement("foo", "baz", 2),
93 }, items)
94
95 require.NoError(t, store.Update(testStorageElement("foo", "baz", 3)))
96 items, err = store.ByIndex("by_val", "bar")
97 require.NoError(t, err)
98 assert.Empty(t, items)
99 items, err = store.ByIndex("by_val", "baz")
100 require.NoError(t, err)
101 assert.Equal(t, []interface{}{
102 testStorageElement("foo", "baz", 3),
103 }, items)
104
105 require.NoError(t, store.Replace([]interface{}{
106 testStorageElement("foo", "bar", 4),
107 }, ""))
108 items, err = store.ByIndex("by_val", "bar")
109 require.NoError(t, err)
110 assert.Equal(t, []interface{}{
111 testStorageElement("foo", "bar", 4),
112 }, items)
113 items, err = store.ByIndex("by_val", "baz")
114 require.NoError(t, err)
115 assert.Empty(t, items)
116
117 require.NoError(t, store.Delete(testStorageElement("foo", "", 0)))
118 items, err = store.ByIndex("by_val", "baz")
119 require.NoError(t, err)
120 assert.Empty(t, items)
121
122 require.NoError(t, store.Delete(testStorageElement("foo", "", 0)))
123 }
124
125 func assertStoreEmpty(t *testing.T, store storeIndexer, nonExistingKey string) {
126 item, ok, err := store.Get(testStorageElement(nonExistingKey, "", 0))
127 require.NoError(t, err)
128 assert.False(t, ok)
129 assert.Nil(t, item)
130
131 item, ok, err = store.GetByKey(nonExistingKey)
132 require.NoError(t, err)
133 assert.False(t, ok)
134 assert.Nil(t, item)
135
136 items := store.List()
137 assert.Empty(t, items)
138 }
139
140 func assertStoreSingleKey(t *testing.T, store storeIndexer, expectKey, expectValue string, expectRV int) {
141 item, ok, err := store.Get(testStorageElement(expectKey, "", expectRV))
142 require.NoError(t, err)
143 assert.True(t, ok)
144 assert.Equal(t, expectValue, item.(*storeElement).Object.(fakeObj).value)
145
146 item, ok, err = store.GetByKey(expectKey)
147 require.NoError(t, err)
148 assert.True(t, ok)
149 assert.Equal(t, expectValue, item.(*storeElement).Object.(fakeObj).value)
150
151 items := store.List()
152 assert.Equal(t, []interface{}{testStorageElement(expectKey, expectValue, expectRV)}, items)
153 }
154
155 func testStorageElement(key, value string, rv int) *storeElement {
156 return &storeElement{Key: key, Object: fakeObj{value: value, rv: rv}}
157 }
158
159 type fakeObj struct {
160 value string
161 rv int
162 }
163
164 func (f fakeObj) GetObjectKind() schema.ObjectKind { return nil }
165 func (f fakeObj) DeepCopyObject() runtime.Object { return nil }
166
167 var _ runtime.Object = (*fakeObj)(nil)
168
169 func testStoreIndexFunc(obj interface{}) ([]string, error) {
170 return []string{obj.(fakeObj).value}, nil
171 }
172
173 func testStoreIndexers() *cache.Indexers {
174 indexers := cache.Indexers{}
175 indexers["by_val"] = testStoreIndexFunc
176 return &indexers
177 }