github.com/grafana/pyroscope@v1.18.0/pkg/settings/bucket_test.go (about)

     1  package settings
     2  
     3  import (
     4  	"context"
     5  	"sort"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  
    10  	settingsv1 "github.com/grafana/pyroscope/api/gen/proto/go/settings/v1"
    11  )
    12  
    13  func TestMemoryBucket_Get(t *testing.T) {
    14  	ctx := context.Background()
    15  	const tenantID = "[anonymous]"
    16  
    17  	t.Run("get settings are sorted", func(t *testing.T) {
    18  		mem := newMemoryStore()
    19  
    20  		settings := []*settingsv1.Setting{
    21  			{Name: "key1", Value: "val1"},
    22  			{Name: "key2", Value: "val2"},
    23  		}
    24  		for _, s := range settings {
    25  			_, err := mem.Set(ctx, tenantID, s)
    26  			assert.NoError(t, err)
    27  		}
    28  		got, err := mem.Get(ctx, tenantID)
    29  		assert.NoError(t, err)
    30  		assert.Equal(t, settings, got)
    31  		assert.True(t, sort.SliceIsSorted(got, func(i, j int) bool {
    32  			return got[i].Name < got[j].Name
    33  		}))
    34  	})
    35  
    36  	t.Run("don't get settings from another tenant", func(t *testing.T) {
    37  		var err error
    38  		mem := newMemoryStore()
    39  
    40  		otherTenantID := "other"
    41  
    42  		tenant1Settings := []*settingsv1.Setting{
    43  			{Name: "t1_key1", Value: "val1"},
    44  			{Name: "t1_key2", Value: "val2"},
    45  		}
    46  		for _, s := range tenant1Settings {
    47  			_, err = mem.Set(ctx, tenantID, s)
    48  			assert.NoError(t, err)
    49  		}
    50  
    51  		tenant2Settings := []*settingsv1.Setting{
    52  			{Name: "t2_key1", Value: "val1"},
    53  			{Name: "t2_key2", Value: "val2"},
    54  		}
    55  		for _, s := range tenant2Settings {
    56  			_, err = mem.Set(ctx, otherTenantID, s)
    57  			assert.NoError(t, err)
    58  		}
    59  
    60  		got, err := mem.Get(ctx, otherTenantID)
    61  		assert.NoError(t, err)
    62  		assert.Equal(t, tenant2Settings, got)
    63  	})
    64  }
    65  
    66  func TestMemoryBucket_Set(t *testing.T) {
    67  	ctx := context.Background()
    68  	const tenantID = "[anonymous]"
    69  
    70  	t.Run("set a new key", func(t *testing.T) {
    71  		mem := newMemoryStore()
    72  
    73  		setting := &settingsv1.Setting{
    74  			Name:  "key1",
    75  			Value: "val1",
    76  		}
    77  		got, err := mem.Set(ctx, tenantID, setting)
    78  		assert.NoError(t, err)
    79  		assert.Equal(t, setting, got)
    80  	})
    81  
    82  	t.Run("update a key", func(t *testing.T) {
    83  		mem := newMemoryStore()
    84  
    85  		setting := &settingsv1.Setting{
    86  			Name:  "key1",
    87  			Value: "val1",
    88  		}
    89  		got, err := mem.Set(ctx, tenantID, setting)
    90  		assert.NoError(t, err)
    91  		assert.Equal(t, setting, got)
    92  
    93  		newSetting := &settingsv1.Setting{
    94  			Name:  "key1",
    95  			Value: "val2",
    96  		}
    97  		got, err = mem.Set(ctx, tenantID, newSetting)
    98  		assert.NoError(t, err)
    99  		assert.Equal(t, newSetting, got)
   100  	})
   101  
   102  	t.Run("don't update a key that's too old", func(t *testing.T) {
   103  		mem := newMemoryStore()
   104  
   105  		setting := &settingsv1.Setting{
   106  			Name:       "key1",
   107  			Value:      "val1",
   108  			ModifiedAt: 10,
   109  		}
   110  		got, err := mem.Set(ctx, tenantID, setting)
   111  		assert.NoError(t, err)
   112  		assert.Equal(t, setting, got)
   113  
   114  		newSetting := &settingsv1.Setting{
   115  			Name:       "key1",
   116  			Value:      "val2",
   117  			ModifiedAt: 5,
   118  		}
   119  		_, err = mem.Set(ctx, tenantID, newSetting)
   120  		assert.EqualError(t, err, "failed to update key1: newer update already written")
   121  	})
   122  }
   123  
   124  func TestMemoryBucket_Delete(t *testing.T) {
   125  	ctx := context.Background()
   126  	const tenantID = "[anonymous]"
   127  
   128  	t.Run("delete a key", func(t *testing.T) {
   129  		mem := newMemoryStore()
   130  
   131  		setting := &settingsv1.Setting{
   132  			Name:  "key1",
   133  			Value: "val1",
   134  		}
   135  		_, err := mem.Set(ctx, tenantID, setting)
   136  		assert.NoError(t, err)
   137  
   138  		err = mem.Delete(ctx, tenantID, setting.Name, setting.ModifiedAt)
   139  		assert.NoError(t, err)
   140  
   141  		got, err := mem.Get(ctx, tenantID)
   142  		assert.NoError(t, err)
   143  		assert.Empty(t, got)
   144  	})
   145  
   146  	t.Run("delete a non-existent key", func(t *testing.T) {
   147  		mem := newMemoryStore()
   148  
   149  		err := mem.Delete(ctx, tenantID, "key1", 0)
   150  		assert.NoError(t, err)
   151  	})
   152  
   153  	t.Run("don't delete a key that's too old", func(t *testing.T) {
   154  		mem := newMemoryStore()
   155  
   156  		setting := &settingsv1.Setting{
   157  			Name:       "key1",
   158  			Value:      "val1",
   159  			ModifiedAt: 10,
   160  		}
   161  		_, err := mem.Set(ctx, tenantID, setting)
   162  		assert.NoError(t, err)
   163  
   164  		err = mem.Delete(ctx, tenantID, setting.Name, 5)
   165  		assert.EqualError(t, err, "failed to delete key1: newer update already written")
   166  	})
   167  }