PBM-1649 Basic agent tests for cleanup and delete-backup

Author: jcechace

cmd/pbm-agent/delete_test.go

@@ -0,0 +1,384 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/percona/percona-backup-mongodb/pbm/backup"
+	"github.com/percona/percona-backup-mongodb/pbm/config"
+	"github.com/percona/percona-backup-mongodb/pbm/connect"
+	"github.com/percona/percona-backup-mongodb/pbm/ctrl"
+	"github.com/percona/percona-backup-mongodb/pbm/defs"
+	pbmlog "github.com/percona/percona-backup-mongodb/pbm/log"
+	"github.com/percona/percona-backup-mongodb/pbm/storage"
+	"github.com/percona/percona-backup-mongodb/pbm/storage/fs"
+	"github.com/percona/percona-backup-mongodb/pbm/topo"
+	"github.com/stretchr/testify/assert"
+	"github.com/testcontainers/testcontainers-go/modules/mongodb"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"golang.org/x/sync/errgroup"
+)
+
+type TestEnvironment struct {
+	Mongo         *TestMongo
+	Agent         *Agent
+	StoragePath   string
+	stopAgentFunc context.CancelFunc
+	eg            errgroup.Group
+}
+
+type TestMongo struct {
+	Container *mongodb.MongoDBContainer
+	ReplSet   string
+	CS        string
+	Client    connect.Client
+	image     string
+	csParams  string
+}
+
+var TestEnv = newTestEnv()
+
+func newTestEnv() *TestEnvironment {
+	mongo := &TestMongo{
+		ReplSet:  "rs0",
+		image:    "perconalab/percona-server-mongodb:8.0.4-multi",
+		csParams: "directConnection=true",
+	}
+	tenv := &TestEnvironment{
+		Mongo: mongo,
+	}
+
+	err := tenv.InitStorage()
+	if err != nil {
+		log.Fatalf("failed to create temp dir: %s", err)
+	}
+
+	return tenv
+}
+
+func (tenv *TestEnvironment) InitStorage() error {
+	stg, err := os.MkdirTemp("", "pbm_tests_*")
+	if err != nil {
+		return err
+	}
+	tenv.StoragePath = stg
+	return nil
+}
+
+func (tenv *TestEnvironment) GetSorageTmpDir(name string) (string, error) {
+	if name == "" {
+		name = "default"
+	}
+	return os.MkdirTemp(tenv.StoragePath, name+"_*")
+}
+
+func (tenv *TestEnvironment) StartMongo(ctx context.Context) error {
+	cnt, err := mongodb.Run(ctx, tenv.Mongo.image, mongodb.WithReplicaSet(tenv.Mongo.ReplSet))
+	if err != nil {
+		return err
+	}
+
+	cs, err := cnt.ConnectionString(ctx)
+	if err != nil {
+		return err
+	}
+	cs += "&" + tenv.Mongo.csParams
+
+	client, err := connect.Connect(ctx, cs, "test")
+	if err != nil {
+		return err
+	}
+
+	tenv.Mongo.CS = cs
+	tenv.Mongo.Client = client
+	tenv.Mongo.Container = cnt
+
+	return nil
+}
+
+func (tm *TestMongo) StopMongo(ctx context.Context) error {
+	return tm.Container.Terminate(ctx)
+}
+
+func (tenv *TestEnvironment) CreateAgent(ctx context.Context) error {
+	if tenv.Agent != nil {
+		return fmt.Errorf("agent already created")
+	}
+	a, err := newAgent(ctx, tenv.Mongo.Client, tenv.Mongo.CS, 1)
+	if err != nil {
+		return err
+	}
+	tenv.Agent = a
+	return nil
+}
+
+func (tenv *TestEnvironment) StartAgent(ctx context.Context) error {
+	if tenv.Agent == nil {
+		if err := tenv.CreateAgent(ctx); err != nil {
+			return err
+		}
+	}
+	c, cancel := context.WithCancel(ctx)
+	tenv.stopAgentFunc = cancel
+
+	// create config
+	err := TestEnv.setConfigWithStorage(nil)
+	if err != nil {
+		return err
+	}
+
+	// start the agent
+	tenv.eg.Go(func() error {
+		tenv.Agent.HbStatus(c)
+		return nil
+	})
+	tenv.eg.Go(func() error {
+		return tenv.Agent.Start(c)
+	})
+
+	return nil
+}
+
+func (tenv *TestEnvironment) Cleanup(ctx context.Context) error {
+	agentErr := tenv.StopAgent()
+	mongoErr := tenv.Mongo.StopMongo(ctx)
+	stgErr := os.RemoveAll(tenv.StoragePath)
+
+	return errors.Join(agentErr, mongoErr, stgErr)
+}
+
+func (tenv *TestEnvironment) ResetStorage() error {
+	err := os.RemoveAll(tenv.StoragePath)
+	if err != nil {
+		return err
+	}
+	return tenv.InitStorage()
+}
+
+func (tenv *TestEnvironment) ResetAgent(t *testing.T) {
+	err := tenv.StopAgent()
+	if err != nil {
+		assert.FailNow(t, "failed to stop agent: %v", err)
+	}
+	err = tenv.ResetStorage()
+	if err != nil {
+		assert.FailNow(t, "failed to reset storage: %v", err)
+	}
+
+	// clear admin.pbm* collections
+	db := tenv.Mongo.Client.MongoClient().Database(defs.DB)
+	collections, err := db.ListCollectionNames(t.Context(), bson.D{{Key: "name", Value: primitive.Regex{Pattern: "^pbm"}}})
+	if err != nil {
+		assert.FailNow(t, "failed to list admin.pbm* collections: %v", err)
+	}
+	for _, coll := range collections {
+		err = db.Collection(coll).Drop(t.Context())
+		if err != nil {
+			assert.FailNow(t, "failed to drop admin.pbm* collection %q: %v", coll, err)
+		}
+	}
+
+	err = tenv.StartAgent(t.Context())
+	if err != nil {
+		assert.FailNow(t, "failed to start agent: %v", err)
+	}
+}
+
+func (tenv *TestEnvironment) StopAgent() error {
+	if tenv.stopAgentFunc == nil {
+		return nil
+	}
+	tenv.stopAgentFunc()
+	err := tenv.eg.Wait()
+	tenv.stopAgentFunc = nil
+
+	return err
+}
+
+func (tenv *TestEnvironment) AddStorageProfile(t *testing.T, name string) {
+	err := tenv.setConfigWithStorage(&config.Config{IsProfile: true, Name: name})
+	if err != nil {
+		assert.FailNow(t, "failed to add storage profile: %v", err)
+	}
+}
+
+func (tenv *TestEnvironment) setConfigWithStorage(cfg *config.Config) error {
+	if cfg == nil {
+		cfg = &config.Config{}
+	}
+
+	path, err := tenv.GetSorageTmpDir(cfg.Name)
+	if err != nil {
+		return err
+	}
+
+	cfg.Storage = config.StorageConf{
+		Type: storage.Filesystem,
+		Filesystem: &fs.Config{
+			Path: path,
+		},
+	}
+
+	if cfg.IsProfile {
+		err = config.AddProfile(context.Background(), tenv.Mongo.Client, cfg)
+	} else {
+		err = config.SetConfig(context.Background(), tenv.Mongo.Client, cfg)
+	}
+
+	return err
+}
+
+func TestMain(m *testing.M) {
+	ctx := context.Background()
+
+	err := TestEnv.StartMongo(ctx)
+	if err != nil {
+		log.Fatalf("failed to start test MongoDB: %s", err)
+	}
+
+	defer func() {
+		err = TestEnv.Cleanup(ctx)
+		if err != nil {
+			log.Fatalf("failed to cleanup test environment: %s", err)
+		}
+	}()
+
+	code := m.Run()
+	os.Exit(code)
+}
+
+func TestDeleteBackup(t *testing.T) {
+	TestEnv.ResetAgent(t)
+	TestEnv.AddStorageProfile(t, "secondary")
+
+	// run backups
+	runBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent.brief, "")
+	runBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent.brief, "secondary")
+	assertBackupCount(t, TestEnv.Mongo.Client, 1, "")
+	assertBackupCount(t, TestEnv.Mongo.Client, 1, "secondary")
+
+	t.Run("delete-default", func(t *testing.T) {
+		runDeleteBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent, "")
+		assertBackupCount(t, TestEnv.Mongo.Client, 0, "")
+		assertBackupCount(t, TestEnv.Mongo.Client, 1, "secondary")
+
+	})
+
+	runBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent.brief, "")
+	assertBackupCount(t, TestEnv.Mongo.Client, 1, "")
+
+	t.Run("delete-profile", func(t *testing.T) {
+		runDeleteBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent, "secondary")
+		assertBackupCount(t, TestEnv.Mongo.Client, 1, "")
+		assertBackupCount(t, TestEnv.Mongo.Client, 0, "secondary")
+	})
+}
+
+func TestCleanupBackups(t *testing.T) {
+	TestEnv.ResetAgent(t)
+	TestEnv.AddStorageProfile(t, "secondary")
+
+	// run backups
+	runBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent.brief, "")
+	runBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent.brief, "secondary")
+	assertBackupCount(t, TestEnv.Mongo.Client, 1, "")
+	assertBackupCount(t, TestEnv.Mongo.Client, 1, "secondary")
+
+	t.Run("cleanup-default", func(t *testing.T) {
+		runCleanupBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent, "")
+		assertBackupCount(t, TestEnv.Mongo.Client, 0, "")
+		assertBackupCount(t, TestEnv.Mongo.Client, 1, "secondary")
+
+	})
+
+	runBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent.brief, "")
+	assertBackupCount(t, TestEnv.Mongo.Client, 1, "")
+
+	t.Run("cleanup-profile", func(t *testing.T) {
+		runCleanupBackup(t, t.Context(), TestEnv.Mongo.Client, TestEnv.Agent, "secondary")
+		assertBackupCount(t, TestEnv.Mongo.Client, 1, "")
+		assertBackupCount(t, TestEnv.Mongo.Client, 0, "secondary")
+	})
+}
+
+func runCleanupBackup(t *testing.T, ctx context.Context, client connect.Client, agent *Agent, profile string) {
+	opid := ctrl.OPID(primitive.NilObjectID)
+	ts := time.Now().UTC().Unix()
+	ep, err := config.GetEpoch(ctx, client)
+	assert.Nil(t, err)
+
+	cmd := ctrl.CleanupCmd{
+		OlderThan: primitive.Timestamp{T: uint32(ts), I: 0},
+		Profile:   profile,
+	}
+	agent.Cleanup(ctx, &cmd, opid, ep)
+}
+
+func runDeleteBackup(t *testing.T, ctx context.Context, client connect.Client, agent *Agent, profile string) {
+	ts := time.Now().UTC().Unix()
+	opid := ctrl.OPID(primitive.NilObjectID)
+	ep, err := config.GetEpoch(ctx, client)
+	assert.Nil(t, err)
+
+	cmd := ctrl.DeleteBackupCmd{
+		OlderThan: ts,
+		Profile:   profile,
+	}
+	agent.Delete(ctx, &cmd, opid, ep)
+}
+
+func runBackup(t *testing.T, ctx context.Context, client connect.Client, brief topo.NodeBrief, profile string) {
+	ts := time.Now().UTC().Format(time.RFC3339)
+	opid := ctrl.OPID(primitive.NilObjectID)
+	cmd := ctrl.BackupCmd{
+		Type: defs.LogicalBackup,
+		Name: ts,
+	}
+
+	cfgFull, err := config.GetProfiledConfig(ctx, client, profile)
+	assert.Nil(t, err)
+
+	bcp := backup.New(client, client.MongoClient(), brief, 1)
+	bcp.SetConfig(cfgFull)
+
+	err = bcp.Init(ctx, &cmd, opid, topo.BalancerModeOff)
+	assert.Nil(t, err)
+
+	err = bcp.Run(ctx, &cmd, opid, pbmlog.DiscardEvent)
+	assert.Nil(t, err)
+}
+
+func assertBackupCount(t *testing.T, client connect.Client, count int, profile string) {
+	cfg, err := config.GetProfiledConfig(context.Background(), client, profile)
+	assert.Nil(t, err)
+
+	f := bson.D{{Key: "store.profile", Value: nil}}
+	if profile != "" {
+		f = bson.D{
+			{Key: "store.profile", Value: true},
+			{Key: "store.name", Value: profile},
+		}
+	}
+	cur, err := client.BcpCollection().Find(context.Background(), f)
+	assert.Nil(t, err)
+
+	var bcps []backup.BackupMeta
+	err = cur.All(context.Background(), &bcps)
+	assert.Nil(t, err)
+	assert.Len(t, bcps, count, "expected %d backups, got %d", count, len(bcps))
+
+	stg, err := fs.New(cfg.Storage.Filesystem)
+	assert.Nil(t, err)
+
+	for _, bcp := range bcps {
+		name := bcp.Name
+		err := backup.CheckBackupFiles(context.Background(), stg, name)
+		assert.Nil(t, err, "backup %q files check failed", name)
+	}
+}