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  }