github.com/hashicorp/vault/sdk@v0.13.0/physical/inmem/cache_test.go (about) 1 // Copyright (c) HashiCorp, Inc. 2 // SPDX-License-Identifier: MPL-2.0 3 4 package inmem 5 6 import ( 7 "context" 8 "testing" 9 10 "github.com/armon/go-metrics" 11 log "github.com/hashicorp/go-hclog" 12 "github.com/hashicorp/vault/sdk/helper/logging" 13 "github.com/hashicorp/vault/sdk/physical" 14 ) 15 16 func TestCache(t *testing.T) { 17 logger := logging.NewVaultLogger(log.Debug) 18 19 inm, err := NewInmem(nil, logger) 20 if err != nil { 21 t.Fatal(err) 22 } 23 24 cache := physical.NewCache(inm, 0, logger, &metrics.BlackholeSink{}) 25 cache.SetEnabled(true) 26 physical.ExerciseBackend(t, cache) 27 physical.ExerciseBackend_ListPrefix(t, cache) 28 } 29 30 func TestCache_Purge(t *testing.T) { 31 logger := logging.NewVaultLogger(log.Debug) 32 33 inm, err := NewInmem(nil, logger) 34 if err != nil { 35 t.Fatal(err) 36 } 37 cache := physical.NewCache(inm, 0, logger, &metrics.BlackholeSink{}) 38 cache.SetEnabled(true) 39 40 ent := &physical.Entry{ 41 Key: "foo", 42 Value: []byte("bar"), 43 } 44 err = cache.Put(context.Background(), ent) 45 if err != nil { 46 t.Fatalf("err: %v", err) 47 } 48 49 // Delete from under 50 inm.Delete(context.Background(), "foo") 51 if err != nil { 52 t.Fatal(err) 53 } 54 55 // Read should work 56 out, err := cache.Get(context.Background(), "foo") 57 if err != nil { 58 t.Fatalf("err: %v", err) 59 } 60 if out == nil { 61 t.Fatalf("should have key") 62 } 63 64 // Clear the cache 65 cache.Purge(context.Background()) 66 67 // Read should fail 68 out, err = cache.Get(context.Background(), "foo") 69 if err != nil { 70 t.Fatalf("err: %v", err) 71 } 72 if out != nil { 73 t.Fatalf("should not have key") 74 } 75 } 76 77 func TestCache_Disable(t *testing.T) { 78 logger := logging.NewVaultLogger(log.Debug) 79 80 inm, err := NewInmem(nil, logger) 81 if err != nil { 82 t.Fatal(err) 83 } 84 cache := physical.NewCache(inm, 0, logger, &metrics.BlackholeSink{}) 85 86 disabledTests := func() { 87 ent := &physical.Entry{ 88 Key: "foo", 89 Value: []byte("bar"), 90 } 91 err = inm.Put(context.Background(), ent) 92 if err != nil { 93 t.Fatalf("err: %v", err) 94 } 95 96 // Read should work 97 out, err := cache.Get(context.Background(), "foo") 98 if err != nil { 99 t.Fatalf("err: %v", err) 100 } 101 if out == nil { 102 t.Fatalf("should have key") 103 } 104 105 err = inm.Delete(context.Background(), ent.Key) 106 if err != nil { 107 t.Fatal(err) 108 } 109 110 // Should not work 111 out, err = cache.Get(context.Background(), "foo") 112 if err != nil { 113 t.Fatalf("err: %v", err) 114 } 115 if out != nil { 116 t.Fatalf("should not have key") 117 } 118 119 // Put through the cache and try again 120 err = cache.Put(context.Background(), ent) 121 if err != nil { 122 t.Fatalf("err: %v", err) 123 } 124 125 // Read should work in both 126 out, err = inm.Get(context.Background(), "foo") 127 if err != nil { 128 t.Fatalf("err: %v", err) 129 } 130 if out == nil { 131 t.Fatalf("should have key") 132 } 133 out, err = cache.Get(context.Background(), "foo") 134 if err != nil { 135 t.Fatalf("err: %v", err) 136 } 137 if out == nil { 138 t.Fatalf("should have key") 139 } 140 141 err = inm.Delete(context.Background(), ent.Key) 142 if err != nil { 143 t.Fatal(err) 144 } 145 146 // Should not work 147 out, err = cache.Get(context.Background(), "foo") 148 if err != nil { 149 t.Fatalf("err: %v", err) 150 } 151 if out != nil { 152 t.Fatalf("should not have key") 153 } 154 } 155 156 enabledTests := func() { 157 ent := &physical.Entry{ 158 Key: "foo", 159 Value: []byte("bar"), 160 } 161 err = inm.Put(context.Background(), ent) 162 if err != nil { 163 t.Fatalf("err: %v", err) 164 } 165 166 // Read should work 167 out, err := cache.Get(context.Background(), "foo") 168 if err != nil { 169 t.Fatalf("err: %v", err) 170 } 171 if out == nil { 172 t.Fatalf("should have key") 173 } 174 175 err = inm.Delete(context.Background(), ent.Key) 176 if err != nil { 177 t.Fatal(err) 178 } 179 180 // Should work 181 out, err = cache.Get(context.Background(), "foo") 182 if err != nil { 183 t.Fatalf("err: %v", err) 184 } 185 if out == nil { 186 t.Fatalf("should have key") 187 } 188 189 // Put through the cache and try again 190 err = cache.Put(context.Background(), ent) 191 if err != nil { 192 t.Fatalf("err: %v", err) 193 } 194 195 // Read should work for both 196 out, err = inm.Get(context.Background(), "foo") 197 if err != nil { 198 t.Fatalf("err: %v", err) 199 } 200 if out == nil { 201 t.Fatalf("should have key") 202 } 203 out, err = cache.Get(context.Background(), "foo") 204 if err != nil { 205 t.Fatalf("err: %v", err) 206 } 207 if out == nil { 208 t.Fatalf("should have key") 209 } 210 211 err = inm.Delete(context.Background(), ent.Key) 212 if err != nil { 213 t.Fatal(err) 214 } 215 216 // Should work 217 out, err = cache.Get(context.Background(), "foo") 218 if err != nil { 219 t.Fatalf("err: %v", err) 220 } 221 if out == nil { 222 t.Fatalf("should have key") 223 } 224 225 // Put through the cache 226 err = cache.Put(context.Background(), ent) 227 if err != nil { 228 t.Fatalf("err: %v", err) 229 } 230 231 // Read should work for both 232 out, err = inm.Get(context.Background(), "foo") 233 if err != nil { 234 t.Fatalf("err: %v", err) 235 } 236 if out == nil { 237 t.Fatalf("should have key") 238 } 239 out, err = cache.Get(context.Background(), "foo") 240 if err != nil { 241 t.Fatalf("err: %v", err) 242 } 243 if out == nil { 244 t.Fatalf("should have key") 245 } 246 247 // Delete via cache 248 err = cache.Delete(context.Background(), ent.Key) 249 if err != nil { 250 t.Fatal(err) 251 } 252 253 // Read should not work for either 254 out, err = inm.Get(context.Background(), "foo") 255 if err != nil { 256 t.Fatalf("err: %v", err) 257 } 258 if out != nil { 259 t.Fatalf("should not have key") 260 } 261 out, err = cache.Get(context.Background(), "foo") 262 if err != nil { 263 t.Fatalf("err: %v", err) 264 } 265 if out != nil { 266 t.Fatalf("should not have key") 267 } 268 } 269 270 disabledTests() 271 cache.SetEnabled(true) 272 enabledTests() 273 cache.SetEnabled(false) 274 disabledTests() 275 } 276 277 func TestCache_Refresh(t *testing.T) { 278 logger := logging.NewVaultLogger(log.Debug) 279 280 inm, err := NewInmem(nil, logger) 281 if err != nil { 282 t.Fatal(err) 283 } 284 cache := physical.NewCache(inm, 0, logger, &metrics.BlackholeSink{}) 285 cache.SetEnabled(true) 286 287 ent := &physical.Entry{ 288 Key: "foo", 289 Value: []byte("bar"), 290 } 291 err = cache.Put(context.Background(), ent) 292 if err != nil { 293 t.Fatalf("err: %v", err) 294 } 295 296 ent2 := &physical.Entry{ 297 Key: "foo", 298 Value: []byte("baz"), 299 } 300 // Update below cache 301 err = inm.Put(context.Background(), ent2) 302 if err != nil { 303 t.Fatalf("err: %v", err) 304 } 305 306 r, err := cache.Get(context.Background(), "foo") 307 if err != nil { 308 t.Fatalf("err: %v", err) 309 } 310 311 if string(r.Value) != "bar" { 312 t.Fatalf("expected value bar, got %s", string(r.Value)) 313 } 314 315 // Refresh the cache 316 r, err = cache.Get(physical.CacheRefreshContext(context.Background(), true), "foo") 317 if err != nil { 318 t.Fatalf("err: %v", err) 319 } 320 321 if string(r.Value) != "baz" { 322 t.Fatalf("expected value baz, got %s", string(r.Value)) 323 } 324 325 // Make sure new value is in cache 326 r, err = cache.Get(context.Background(), "foo") 327 if err != nil { 328 t.Fatalf("err: %v", err) 329 } 330 if string(r.Value) != "baz" { 331 t.Fatalf("expected value baz, got %s", string(r.Value)) 332 } 333 }