rename settingstore to metadatastore

pkg/storage/unified/resource/metadatastore.go

@@ -10,24 +10,24 @@ import (
 )
 
 const (
-	settingsSection = "unified/settings"
+	metadatasSection = "unified/metadata"
 )
 
-type settingStore struct {
+type metadataStore struct {
 	kv KV
 }
 
-type SettingKey struct {
+type MetadataKey struct {
 	Namespace string
 	Group     string
 	Resource  string
 }
 
-func (k SettingKey) String() string {
+func (k MetadataKey) String() string {
 	return fmt.Sprintf("%s/%s/%s", k.Group, k.Resource, k.Namespace)
 }
 
-func (k SettingKey) Validate() error {
+func (k MetadataKey) Validate() error {
 	if k.Namespace == "" {
 		return NewValidationError("namespace", k.Namespace, ErrNamespaceRequired)
 	}
@@ -40,53 +40,53 @@ func (k SettingKey) Validate() error {
 	return nil
 }
 
-type Setting struct {
+type Metadata struct {
 	Namespace      string    `json:"namespace"`
 	Group          string    `json:"group"`
 	Resource       string    `json:"resource"`
 	LastImportTime time.Time `json:"lastImportTime"`
 }
 
-func newSettingStore(kv KV) *settingStore {
-	return &settingStore{
+func newMetadataStore(kv KV) *metadataStore {
+	return &metadataStore{
 		kv: kv,
 	}
 }
 
-func (d *settingStore) Get(ctx context.Context, key SettingKey) (Setting, error) {
+func (d *metadataStore) Get(ctx context.Context, key MetadataKey) (Metadata, error) {
 	if err := key.Validate(); err != nil {
-		return Setting{}, fmt.Errorf("invalid setting key: %w", err)
+		return Metadata{}, fmt.Errorf("invalid metadata key: %w", err)
 	}
 
-	reader, err := d.kv.Get(ctx, settingsSection, key.String())
+	reader, err := d.kv.Get(ctx, metadatasSection, key.String())
 	if err != nil {
-		return Setting{}, err
+		return Metadata{}, err
 	}
 	defer func() { _ = reader.Close() }()
-	var setting Setting
-	if err = json.NewDecoder(reader).Decode(&setting); err != nil {
-		return Setting{}, err
+	var metadata Metadata
+	if err = json.NewDecoder(reader).Decode(&metadata); err != nil {
+		return Metadata{}, err
 	}
-	return setting, nil
+	return metadata, nil
 }
 
-func (d *settingStore) Save(ctx context.Context, setting Setting) error {
-	settingKey := SettingKey{
-		Namespace: setting.Namespace,
-		Group:     setting.Group,
-		Resource:  setting.Resource,
+func (d *metadataStore) Save(ctx context.Context, metadata Metadata) error {
+	metadataKey := MetadataKey{
+		Namespace: metadata.Namespace,
+		Group:     metadata.Group,
+		Resource:  metadata.Resource,
 	}
 
-	if err := settingKey.Validate(); err != nil {
-		return fmt.Errorf("invalid settingKey key: %w", err)
+	if err := metadataKey.Validate(); err != nil {
+		return fmt.Errorf("invalid metadataKey key: %w", err)
 	}
 
-	writer, err := d.kv.Save(ctx, settingsSection, settingKey.String())
+	writer, err := d.kv.Save(ctx, metadatasSection, metadataKey.String())
 	if err != nil {
 		return err
 	}
 	encoder := json.NewEncoder(writer)
-	if err := encoder.Encode(setting); err != nil {
+	if err := encoder.Encode(metadata); err != nil {
 		_ = writer.Close()
 		return err
 	}

pkg/storage/unified/resource/metadatastore_test.go

@@ -10,30 +10,30 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func setupTestSettingStore(t *testing.T) *settingStore {
+func setupTestMetadataStore(t *testing.T) *metadataStore {
 	db := setupTestBadgerDB(t)
 	t.Cleanup(func() {
 		err := db.Close()
 		require.NoError(t, err)
 	})
 	kv := NewBadgerKV(db)
-	return newSettingStore(kv)
+	return newMetadataStore(kv)
 }
 
-func TestNewSettingStore(t *testing.T) {
-	store := setupTestSettingStore(t)
+func TestNewMetadataStore(t *testing.T) {
+	store := setupTestMetadataStore(t)
 	assert.NotNil(t, store.kv)
 }
 
-func TestSettingStore_SettingKey_String(t *testing.T) {
+func TestMetadataStore_MetadataKey_String(t *testing.T) {
 	tests := []struct {
 		name       string
-		settingKey SettingKey
+		metadataKey MetadataKey
 		expected   string
 	}{
 		{
 			name: "basic event key",
-			settingKey: SettingKey{
+			metadataKey: MetadataKey{
 				Namespace: "default",
 				Group:     "apps",
 				Resource:  "resource",
@@ -42,7 +42,7 @@ func TestSettingStore_SettingKey_String(t *testing.T) {
 		},
 		{
 			name: "empty namespace",
-			settingKey: SettingKey{
+			metadataKey: MetadataKey{
 				Namespace: "",
 				Group:     "apps",
 				Resource:  "resource",
@@ -53,21 +53,21 @@ func TestSettingStore_SettingKey_String(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := tt.settingKey.String()
+			result := tt.metadataKey.String()
 			assert.Equal(t, tt.expected, result)
 		})
 	}
 }
 
-func TestSettingStore_SettingKey_Validate(t *testing.T) {
+func TestMetadataStore_MetadataKey_Validate(t *testing.T) {
 	tests := []struct {
 		name  string
-		key   SettingKey
+		key   MetadataKey
 		error error
 	}{
 		{
 			name: "valid key",
-			key: SettingKey{
+			key: MetadataKey{
 				Namespace: "default",
 				Group:     "apps",
 				Resource:  "resource",
@@ -76,7 +76,7 @@ func TestSettingStore_SettingKey_Validate(t *testing.T) {
 		},
 		{
 			name: "empty namespace",
-			key: SettingKey{
+			key: MetadataKey{
 				Namespace: "",
 				Group:     "apps",
 				Resource:  "resource",
@@ -85,7 +85,7 @@ func TestSettingStore_SettingKey_Validate(t *testing.T) {
 		},
 		{
 			name: "empty group",
-			key: SettingKey{
+			key: MetadataKey{
 				Namespace: "default",
 				Group:     "",
 				Resource:  "resource",
@@ -94,7 +94,7 @@ func TestSettingStore_SettingKey_Validate(t *testing.T) {
 		},
 		{
 			name: "empty resource",
-			key: SettingKey{
+			key: MetadataKey{
 				Namespace: "default",
 				Group:     "apps",
 				Resource:  "",
@@ -116,27 +116,27 @@ func TestSettingStore_SettingKey_Validate(t *testing.T) {
 	}
 }
 
-func TestSettingStore_Save_Get(t *testing.T) {
+func TestMetadataStore_Save_Get(t *testing.T) {
 	ctx := context.Background()
-	store := setupTestSettingStore(t)
+	store := setupTestMetadataStore(t)
 
-	setting := Setting{
+	metadata := Metadata{
 		Namespace:      "default",
 		Group:          "apps",
 		Resource:       "resource",
 		LastImportTime: time.Now().Truncate(time.Microsecond),
 	}
 
-	err := store.Save(ctx, setting)
+	err := store.Save(ctx, metadata)
 	require.NoError(t, err)
 
-	settingKey := SettingKey{
+	metadataKey := MetadataKey{
 		Namespace: "default",
 		Group:     "apps",
 		Resource:  "resource",
 	}
 
-	retrievedSetting, err := store.Get(ctx, settingKey)
+	retrievedMetadata, err := store.Get(ctx, metadataKey)
 	require.NoError(t, err)
-	assert.Equal(t, setting, retrievedSetting)
+	assert.Equal(t, metadata, retrievedMetadata)
 }