PBM-1649 Tests for DeleteBackupUnsafe

Author: jcechace

pbm/backup/delete_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"log"
 	"os"
 	"testing"
@@ -26,27 +27,10 @@ import (
 	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
-type TestStorageEnv struct {
-	Config  *config.Config
-	Storage storage.Storage
-}
-
-func (tse *TestStorageEnv) IsProfile() bool {
-	return tse.Config.IsProfile
-}
-
-func (tse *TestStorageEnv) Name() string {
-	return tse.Config.Name
-}
-
-func (tse *TestStorageEnv) StgConf() config.StorageConf {
-	return tse.Config.Storage
-}
-
 type TestEnvironment struct {
 	Mongo       *TestMongo
 	StorageBase string
-	StorageEnv  *TestStorageEnv
+	StorageEnv  Storage
 	Brief       topo.NodeBrief
 }
 
@@ -159,13 +143,10 @@ func (tenv *TestEnvironment) Reset(t *testing.T) {
 	if err != nil {
 		assert.FailNow(t, "failed to reset config: %v", err)
 	}
-	stg, err := tenv.storage(&cfg.Storage)
-	if err != nil {
-		assert.FailNow(t, "failed to create storage: %v", err)
-	}
-	tenv.StorageEnv = &TestStorageEnv{
-		Config:  cfg,
-		Storage: stg,
+	tenv.StorageEnv = Storage{
+		IsProfile:   false,
+		Name:        "",
+		StorageConf: cfg.Storage,
 	}
 }
 
@@ -195,16 +176,19 @@ func (tenv *TestEnvironment) SetConfigWithStorage(cfg *config.Config) (*config.C
 	return cfg, err
 }
 
-func (tenv *TestEnvironment) AddStorageProfile(t *testing.T, name string) *TestStorageEnv {
+func (tenv *TestEnvironment) AddStorageProfile(t *testing.T, name string) Storage {
 	cfg, err := tenv.SetConfigWithStorage(&config.Config{IsProfile: true, Name: name})
 	if err != nil {
 		assert.FailNow(t, "failed to add storage profile: %v", err)
 	}
-	stg, err := tenv.storage(&cfg.Storage)
 	if err != nil {
 		assert.FailNow(t, "failed to create storage: %v", err)
 	}
-	return &TestStorageEnv{Config: cfg, Storage: stg}
+	return Storage{
+		IsProfile:   true,
+		Name:        name,
+		StorageConf: cfg.Storage,
+	}
 }
 
 func (tenv *TestEnvironment) cleanupStorage() error {
@@ -280,6 +264,7 @@ func TestMain(m *testing.M) {
 
 type bcps = map[string][]bcp
 type bcp struct {
+	Name    string
 	LwT     time.Time
 	Delete  bool
 	BcpType defs.BackupType
@@ -298,16 +283,87 @@ func NewRelativeTime(t time.Time, unit time.Duration) func(int) time.Time {
 	}
 }
 
-func Test_DeleteBackupUnsafe(t *testing.T) {
+type TestStorage struct {
+	stgType storage.Type
+	deletes []string
+}
 
+func (ts *TestStorage) AssertDeleted(t *testing.T, name string) {
+	t.Helper()
+	assert.Contains(t, ts.deletes, name)
 }
 
-func assertBackupDeleted(t *testing.T, client connect.Client, storage storage.Storage, name string) {
+func (ts *TestStorage) AssertDeleteCalls(t *testing.T, count int) {
 	t.Helper()
+	assert.Len(t, ts.deletes, count, "expected %d delete calls, got %d", count, len(ts.deletes))
+}
 
-	count, err := client.BcpCollection().CountDocuments(t.Context(), bson.M{"name": name})
-	assert.NoError(t, err)
-	assert.Equal(t, int64(0), count, "backup metadata %s should be deleted", name)
+func (ts *TestStorage) Type() storage.Type {
+	return ts.stgType
+}
+
+func (ts *TestStorage) Save(name string, _ io.Reader, _ ...storage.Option) error {
+	return nil
+}
+
+func (ts *TestStorage) SourceReader(name string) (io.ReadCloser, error) {
+	return nil, errors.New("not implemented")
+}
+
+func (ts *TestStorage) FileStat(name string) (storage.FileInfo, error) {
+	return storage.FileInfo{Name: name, Size: 0}, nil
+}
+
+func (ts *TestStorage) List(prefix, suffix string) ([]storage.FileInfo, error) {
+	return nil, nil
+}
+
+func (ts *TestStorage) Delete(name string) error {
+	ts.deletes = append(ts.deletes, name)
+	return nil
+}
+
+func (ts *TestStorage) Copy(src, dst string) error {
+	return nil
+}
+
+func (ts *TestStorage) DownloadStat() storage.DownloadStat {
+	return storage.DownloadStat{}
+}
+
+func NewTestStorage(stgType storage.Type) *TestStorage {
+	return &TestStorage{stgType: stgType}
+}
+
+func Test_DeleteBackupUnsafe(t *testing.T) {
+	tests := []struct {
+		name   string
+		backup bcp
+		stg    *TestStorage
+	}{
+		{
+			name:   "metadata and FS storage",
+			backup: bcp{Name: "my-test-bcp", LwT: time.Now()},
+			stg:    NewTestStorage(storage.Filesystem),
+		},
+		{
+			name:   "metadata and object storage",
+			backup: bcp{Name: "my-test-bcp", LwT: time.Now()},
+			stg:    NewTestStorage(storage.S3),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			TestEnv.Reset(t)
+
+			b := insertTestBcpMeta(t, TestEnv, TestEnv.StorageEnv, tt.backup)
+
+			err := DeleteBackupUnsafe(t.Context(), TestEnv.Mongo.Client, tt.stg, b.Name)
+			assert.NoError(t, err)
+			assertBackupDeleted(t, TestEnv.Mongo.Client, tt.stg, b.Name)
+		})
+	}
 }
 
 func Test_ListDeleteBackups(t *testing.T) {
@@ -655,6 +711,22 @@ func extractChunkStarts(chunks []oplog.OplogChunk) []uint32 {
 	return starts
 }
 
+func assertBackupDeleted(t *testing.T, client connect.Client, stg *TestStorage, name string) {
+	t.Helper()
+	count, err := client.BcpCollection().CountDocuments(t.Context(), bson.M{"name": name})
+	assert.NoError(t, err)
+	assert.Equal(t, int64(0), count, "backup metadata %s should be deleted", name)
+
+	if stg.Type() == storage.Filesystem {
+		stg.AssertDeleteCalls(t, 2)
+		stg.AssertDeleted(t, name)
+		stg.AssertDeleted(t, name+defs.MetadataFileSuffix)
+	} else {
+		//  only metadata should be deleted as test storage doesn't list files
+		stg.AssertDeleteCalls(t, 1)
+	}
+}
+
 func assertChunkList(t *testing.T, expectedChunks []oplog.OplogChunk, actualChunks []oplog.OplogChunk, profile string) {
 	t.Helper()
 
@@ -704,8 +776,8 @@ func assertBackupList(t *testing.T, expectedBackups []BackupMeta, actualBackups
 	)
 }
 
-func stgsFromTestBackups(t *testing.T, env *TestEnvironment, backups bcps) map[string]*TestStorageEnv {
-	storages := make(map[string]*TestStorageEnv)
+func stgsFromTestBackups(t *testing.T, env *TestEnvironment, backups bcps) map[string]Storage {
+	storages := make(map[string]Storage)
 	storages[""] = env.StorageEnv
 
 	// initialize storage profiles
@@ -721,16 +793,16 @@ func stgsFromTestBackups(t *testing.T, env *TestEnvironment, backups bcps) map[s
 func insertTestBackups(
 	t *testing.T,
 	env *TestEnvironment,
-	storages map[string]*TestStorageEnv,
+	storages map[string]Storage,
 	profileBcps bcps,
 ) map[string][]BackupMeta {
 	t.Helper()
 
 	tbd := make(map[string][]BackupMeta)
 	for profile, bcps := range profileBcps {
 		for i, bcp := range bcps {
-			name := fmt.Sprintf("backup-%s-%d", profile, i)
-			inserted := insertTestBcpMeta(t, env, storages[profile], name, bcp)
+			bcp.Name = fmt.Sprintf("backup-%s-%d", profile, i)
+			inserted := insertTestBcpMeta(t, env, storages[profile], bcp)
 
 			if bcp.Delete {
 				tbd[profile] = append(tbd[profile], inserted)
@@ -753,7 +825,7 @@ func insertTestChunks(t *testing.T, env *TestEnvironment, cs chunks) []oplog.Opl
 	return tbd
 }
 
-func insertTestBcpMeta(t *testing.T, env *TestEnvironment, stgEnv *TestStorageEnv, name string, b bcp) BackupMeta {
+func insertTestBcpMeta(t *testing.T, env *TestEnvironment, stg Storage, b bcp) BackupMeta {
 	t.Helper()
 
 	firstWrite := b.LwT.Add(-10 * time.Minute)
@@ -762,16 +834,12 @@ func insertTestBcpMeta(t *testing.T, env *TestEnvironment, stgEnv *TestStorageEn
 	}
 
 	meta := &BackupMeta{
-		Type:        b.BcpType,
-		OPID:        ctrl.OPID(primitive.NilObjectID).String(),
-		Name:        name,
-		Namespaces:  make([]string, 0),
-		Compression: compress.CompressionTypeS2,
-		Store: Storage{
-			Name:        stgEnv.Config.Name,
-			IsProfile:   stgEnv.IsProfile(),
-			StorageConf: stgEnv.Config.Storage,
-		},
+		Type:           b.BcpType,
+		OPID:           ctrl.OPID(primitive.NilObjectID).String(),
+		Name:           b.Name,
+		Namespaces:     make([]string, 0),
+		Compression:    compress.CompressionTypeS2,
+		Store:          stg,
 		StartTS:        time.Now().Unix(),
 		Status:         defs.StatusDone,
 		Replsets:       []BackupReplset{},