chore: improve pkg dataprotection coverage (#10383)

Author: leon-ape

pkg/dataprotection/action/action_stateful_test.go

@@ -0,0 +1,138 @@
+/*
+Copyright (C) 2022-2026 ApeCloud Co., Ltd
+
+This file is part of KubeBlocks project
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package action
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	vsv1 "github.com/kubernetes-csi/external-snapshotter/client/v6/apis/volumesnapshot/v1"
+	"github.com/stretchr/testify/assert"
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/utils/pointer"
+	"sigs.k8s.io/controller-runtime/pkg/client/fake"
+
+	dpv1alpha1 "github.com/apecloud/kubeblocks/apis/dataprotection/v1alpha1"
+	dptypes "github.com/apecloud/kubeblocks/pkg/dataprotection/types"
+)
+
+func TestStatefulSetActionHelpers(t *testing.T) {
+	action := &StatefulSetAction{Name: "continuous"}
+
+	assert.Equal(t, "continuous", action.GetName())
+	assert.Equal(t, dpv1alpha1.ActionTypeStatefulSet, action.Type())
+	assert.Equal(t, "60s", action.getIntervalSeconds("@hourly"))
+	assert.Equal(t, "300s", action.getIntervalSeconds("*/5 * * * *"))
+	assert.Equal(t, "7200s", action.getIntervalSeconds("CRON_TZ=UTC 0 */2 * * *"))
+}
+
+func TestCreateVolumeSnapshotSmallHelpers(t *testing.T) {
+	pvc := corev1.PersistentVolumeClaim{ObjectMeta: metav1.ObjectMeta{Name: "data-pvc"}}
+	wrapper := NewPersistentVolumeClaimWrapper(pvc, "data")
+	assert.Equal(t, "data", wrapper.VolumeName)
+	assert.Equal(t, "data-pvc", wrapper.PersistentVolumeClaim.Name)
+
+	message := "Failed to get snapshot class with error: missing default"
+	assert.True(t, isVolumeSnapshotConfigError(&vsv1.VolumeSnapshot{Status: &vsv1.VolumeSnapshotStatus{Error: &vsv1.VolumeSnapshotError{Message: &message}}}))
+	other := "transient api error"
+	assert.False(t, isVolumeSnapshotConfigError(&vsv1.VolumeSnapshot{Status: &vsv1.VolumeSnapshotStatus{Error: &vsv1.VolumeSnapshotError{Message: &other}}}))
+	assert.False(t, isVolumeSnapshotConfigError(&vsv1.VolumeSnapshot{}))
+}
+
+func TestStatusBuilderFluentFields(t *testing.T) {
+	start := metav1.NewTime(time.Now())
+	end := metav1.NewTime(start.Add(time.Hour))
+	status := newStatusBuilder(&StatefulSetAction{Name: "continuous"}).
+		phase(dpv1alpha1.ActionPhaseCompleted).
+		reason("done").
+		startTimestamp(&start).
+		completionTimestamp(&end).
+		totalSize("10Gi").
+		timeRange(&start, &end).
+		volumeSnapshots([]dpv1alpha1.VolumeSnapshotStatus{{Name: "snap", VolumeName: "data"}}).
+		objectRef(&corev1.ObjectReference{Name: "sts"}).
+		build()
+
+	assert.Equal(t, dpv1alpha1.ActionPhaseCompleted, status.Phase)
+	assert.Equal(t, "done", status.FailureReason)
+	assert.Equal(t, "10Gi", status.TotalSize)
+	assert.Equal(t, "snap", status.VolumeSnapshots[0].Name)
+	assert.Equal(t, "sts", status.ObjectRef.Name)
+	assert.Equal(t, start, *status.TimeRange.Start)
+
+	status = newStatusBuilder(&StatefulSetAction{Name: "continuous"}).withErr(errors.New("failed")).build()
+	assert.Equal(t, dpv1alpha1.ActionPhaseFailed, status.Phase)
+	assert.Equal(t, "failed", status.FailureReason)
+}
+
+func TestStatefulSetActionExecuteCreatesAndUpdates(t *testing.T) {
+	scheme := runtime.NewScheme()
+	assert.NoError(t, corev1.AddToScheme(scheme))
+	assert.NoError(t, appsv1.AddToScheme(scheme))
+	assert.NoError(t, dpv1alpha1.AddToScheme(scheme))
+
+	backup := &dpv1alpha1.Backup{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "backup",
+			Namespace: "ns",
+			Labels: map[string]string{
+				dptypes.BackupScheduleLabelKey: "schedule",
+			},
+		},
+		Spec: dpv1alpha1.BackupSpec{BackupMethod: "continuous", RetentionPeriod: "2h"},
+	}
+	schedule := &dpv1alpha1.BackupSchedule{
+		ObjectMeta: metav1.ObjectMeta{Name: "schedule", Namespace: "ns"},
+		Spec:       dpv1alpha1.BackupScheduleSpec{Schedules: []dpv1alpha1.SchedulePolicy{{BackupMethod: "continuous", CronExpression: "*/10 * * * *"}}},
+	}
+	cli := fake.NewClientBuilder().WithScheme(scheme).WithObjects(backup, schedule).Build()
+	action := &StatefulSetAction{
+		Name:       "continuous",
+		Backup:     backup,
+		ObjectMeta: metav1.ObjectMeta{Name: "backup-sts", Namespace: "ns", Labels: map[string]string{"app": "backup"}},
+		Replicas:   pointer.Int32(1),
+		PodSpec:    &corev1.PodSpec{Containers: []corev1.Container{{Name: "manager", Image: "busybox"}}},
+	}
+
+	status, err := action.Execute(ActionContext{Ctx: context.Background(), Client: cli, Scheme: scheme})
+	assert.NoError(t, err)
+	assert.Equal(t, dpv1alpha1.ActionPhaseRunning, status.Phase)
+
+	sts := &appsv1.StatefulSet{}
+	assert.NoError(t, cli.Get(context.Background(), types.NamespacedName{Name: "backup-sts", Namespace: "ns"}, sts))
+	assert.Equal(t, corev1.RestartPolicyAlways, sts.Spec.Template.Spec.RestartPolicy)
+	env := sts.Spec.Template.Spec.Containers[0].Env
+	assert.Contains(t, env, corev1.EnvVar{Name: dptypes.DPArchiveInterval, Value: "600s"})
+	assert.Contains(t, env, corev1.EnvVar{Name: dptypes.DPContinuousTTLSeconds, Value: "7200"})
+
+	sts.Status.AvailableReplicas = 1
+	assert.NoError(t, cli.Status().Update(context.Background(), sts))
+	status, err = action.Execute(ActionContext{Ctx: context.Background(), Client: cli, Scheme: scheme})
+	assert.NoError(t, err)
+	assert.Equal(t, dpv1alpha1.ActionPhaseRunning, status.Phase)
+	assert.Equal(t, int32(1), *status.AvailableReplicas)
+	assert.Equal(t, dpv1alpha1.BackupPhaseRunning, backup.Status.Phase)
+}

pkg/dataprotection/backup/deleter_test.go

@@ -20,22 +20,72 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package backup
 
 import (
+	"context"
+	"testing"
+
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 
+	"github.com/stretchr/testify/assert"
 	batchv1 "k8s.io/api/batch/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/utils/pointer"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 
 	dpv1alpha1 "github.com/apecloud/kubeblocks/apis/dataprotection/v1alpha1"
 	"github.com/apecloud/kubeblocks/pkg/constant"
 	ctrlutil "github.com/apecloud/kubeblocks/pkg/controllerutil"
+	dptypes "github.com/apecloud/kubeblocks/pkg/dataprotection/types"
 	"github.com/apecloud/kubeblocks/pkg/generics"
 	testapps "github.com/apecloud/kubeblocks/pkg/testutil/apps"
 	testdp "github.com/apecloud/kubeblocks/pkg/testutil/dataprotection"
 	viper "github.com/apecloud/kubeblocks/pkg/viperx"
 )
 
+func TestDeleterDoPreDeleteActionCreatesAndReusesJob(t *testing.T) {
+	scheme := runtime.NewScheme()
+	assert.NoError(t, corev1.AddToScheme(scheme))
+	assert.NoError(t, batchv1.AddToScheme(scheme))
+	assert.NoError(t, dpv1alpha1.AddToScheme(scheme))
+
+	cli := fake.NewClientBuilder().WithScheme(scheme).Build()
+	backup := &dpv1alpha1.Backup{
+		ObjectMeta: metav1.ObjectMeta{Name: "backup", Namespace: "ns", UID: types.UID("backup-uid")},
+		Status:     dpv1alpha1.BackupStatus{BackupMethod: &dpv1alpha1.BackupMethod{Env: []corev1.EnvVar{{Name: "IMAGE_TAG", Value: "1.0"}}}},
+	}
+	repo := &dpv1alpha1.BackupRepo{Spec: dpv1alpha1.BackupRepoSpec{}, Status: dpv1alpha1.BackupRepoStatus{BackupPVCName: "repo-pvc"}}
+	deleter := &Deleter{
+		RequestCtx:           ctrlutil.RequestCtx{Ctx: context.Background()},
+		Client:               cli,
+		Scheme:               scheme,
+		WorkerServiceAccount: "worker",
+		actionSet:            &dpv1alpha1.ActionSet{Spec: dpv1alpha1.ActionSetSpec{Env: []corev1.EnvVar{{Name: "ACTION_ENV", Value: "set"}}}},
+	}
+
+	job, err := deleter.doPreDeleteAction(backup, repo, &dpv1alpha1.BaseJobActionSpec{Image: "deleter:$(IMAGE_TAG)", Command: []string{"delete"}}, "", "/backup/path")
+	assert.NoError(t, err)
+	assert.Empty(t, job.Name)
+
+	got := &batchv1.Job{}
+	assert.NoError(t, cli.Get(context.Background(), BuildDeleteBackupFilesJobKey(backup, true), got))
+	assert.Contains(t, got.Spec.Template.Spec.Containers[0].Image, "deleter:1.0")
+	assert.Equal(t, "worker", got.Spec.Template.Spec.ServiceAccountName)
+	envMap := map[string]string{}
+	for _, env := range got.Spec.Template.Spec.Containers[0].Env {
+		envMap[env.Name] = env.Value
+	}
+	assert.Equal(t, "/backup/path", envMap[dptypes.DPBackupBasePath])
+	assert.Equal(t, "set", envMap["ACTION_ENV"])
+
+	job, err = deleter.doPreDeleteAction(backup, repo, &dpv1alpha1.BaseJobActionSpec{Image: "deleter:$(IMAGE_TAG)", Command: []string{"delete"}}, "", "/backup/path")
+	assert.NoError(t, err)
+	assert.Equal(t, got.Name, job.Name)
+}
+
 var _ = Describe("Backup Deleter Test", func() {
 	const (
 		backupRepoPVCName = "backup-repo-pvc"

pkg/dataprotection/backup/request_test.go

@@ -20,21 +20,147 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package backup
 
 import (
+	"context"
+	"testing"
+
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 
+	"github.com/stretchr/testify/assert"
 	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 
 	dpv1alpha1 "github.com/apecloud/kubeblocks/apis/dataprotection/v1alpha1"
 	"github.com/apecloud/kubeblocks/pkg/constant"
 	ctrlutil "github.com/apecloud/kubeblocks/pkg/controllerutil"
+	"github.com/apecloud/kubeblocks/pkg/dataprotection/action"
+	dptypes "github.com/apecloud/kubeblocks/pkg/dataprotection/types"
 	"github.com/apecloud/kubeblocks/pkg/dataprotection/utils/boolptr"
 	"github.com/apecloud/kubeblocks/pkg/generics"
 	testapps "github.com/apecloud/kubeblocks/pkg/testutil/apps"
 	testdp "github.com/apecloud/kubeblocks/pkg/testutil/dataprotection"
+	viper "github.com/apecloud/kubeblocks/pkg/viperx"
 )
 
+func newRequestTestFixture(t *testing.T) (*Request, *corev1.Pod) {
+	scheme := runtime.NewScheme()
+	assert.NoError(t, corev1.AddToScheme(scheme))
+	assert.NoError(t, dpv1alpha1.AddToScheme(scheme))
+	pod := &corev1.Pod{
+		ObjectMeta: metav1.ObjectMeta{Name: "pod-0", Namespace: "ns", Labels: map[string]string{constant.RoleLabelKey: "leader"}},
+		Spec: corev1.PodSpec{
+			NodeName: "node-0",
+			Containers: []corev1.Container{{
+				Name:  "db",
+				Env:   []corev1.EnvVar{{Name: "EXISTING", Value: "old"}},
+				Ports: []corev1.ContainerPort{{Name: "mysql", ContainerPort: 3306}},
+			}},
+			Volumes: []corev1.Volume{{Name: "data", VolumeSource: corev1.VolumeSource{PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{ClaimName: "data-pvc"}}}},
+		},
+	}
+	req := &Request{
+		RequestCtx: ctrlutil.RequestCtx{Ctx: context.Background(), Req: ctrl.Request{}},
+		Client:     fake.NewClientBuilder().WithScheme(scheme).Build(),
+		Backup: &dpv1alpha1.Backup{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: "backup", Namespace: "ns", UID: types.UID("1234567890abcdef"),
+				Labels: map[string]string{dptypes.ClusterUIDLabelKey: "uid", constant.AppInstanceLabelKey: "cluster", constant.KBAppComponentLabelKey: "mysql"},
+			},
+			Spec: dpv1alpha1.BackupSpec{RetentionPeriod: "7d"},
+		},
+		BackupPolicy: &dpv1alpha1.BackupPolicy{Spec: dpv1alpha1.BackupPolicySpec{BackoffLimit: func() *int32 { v := int32(1); return &v }(), PathPrefix: "policy-path"}},
+		BackupRepo:   &dpv1alpha1.BackupRepo{Spec: dpv1alpha1.BackupRepoSpec{PathPrefix: "repo-path"}, Status: dpv1alpha1.BackupRepoStatus{BackupPVCName: "repo-pvc"}},
+		BackupMethod: &dpv1alpha1.BackupMethod{Env: []corev1.EnvVar{{Name: "EXISTING", Value: "method"}}},
+		Target: &dpv1alpha1.BackupTarget{
+			Name:        "target",
+			PodSelector: &dpv1alpha1.PodSelector{Strategy: dpv1alpha1.PodSelectionStrategyAll},
+		},
+		TargetPods:           []*corev1.Pod{pod},
+		WorkerServiceAccount: "worker",
+	}
+	return req, pod
+}
+
+func TestRequestGetBackupType(t *testing.T) {
+	req, _ := newRequestTestFixture(t)
+	assert.Empty(t, req.GetBackupType())
+
+	req.BackupMethod.SnapshotVolumes = func() *bool { v := true; return &v }()
+	assert.Equal(t, string(dpv1alpha1.BackupTypeFull), req.GetBackupType())
+
+	req.ActionSet = &dpv1alpha1.ActionSet{Spec: dpv1alpha1.ActionSetSpec{BackupType: dpv1alpha1.BackupTypeIncremental}}
+	assert.Equal(t, string(dpv1alpha1.BackupTypeIncremental), req.GetBackupType())
+}
+
+func TestRequestBuildActionBranches(t *testing.T) {
+	oldNamespace := viper.GetString(constant.CfgKeyCtrlrMgrNS)
+	oldServiceAccount := viper.GetString(dptypes.CfgKeyExecWorkerServiceAccountName)
+	defer func() {
+		viper.Set(constant.CfgKeyCtrlrMgrNS, oldNamespace)
+		viper.Set(dptypes.CfgKeyExecWorkerServiceAccountName, oldServiceAccount)
+	}()
+	viper.Set(constant.CfgKeyCtrlrMgrNS, "kb-system")
+	viper.Set(dptypes.CfgKeyExecWorkerServiceAccountName, "exec-worker")
+
+	req, pod := newRequestTestFixture(t)
+	_, err := req.buildAction(pod, "invalid", &dpv1alpha1.ActionSpec{})
+	assert.Error(t, err)
+	_, err = req.buildAction(pod, "invalid", &dpv1alpha1.ActionSpec{Exec: &dpv1alpha1.ExecActionSpec{}, Job: &dpv1alpha1.JobActionSpec{}})
+	assert.Error(t, err)
+
+	execAction, err := req.buildAction(pod, "exec", &dpv1alpha1.ActionSpec{Exec: &dpv1alpha1.ExecActionSpec{Command: []string{"echo", "ok"}}})
+	assert.NoError(t, err)
+	assert.IsType(t, &action.ExecAction{}, execAction)
+	assert.Equal(t, "exec", execAction.GetName())
+
+	jobAction, err := req.buildAction(pod, "job", &dpv1alpha1.ActionSpec{Job: &dpv1alpha1.JobActionSpec{BaseJobActionSpec: dpv1alpha1.BaseJobActionSpec{Image: "busybox:$(EXISTING)", Command: []string{"backup"}}}})
+	assert.NoError(t, err)
+	assert.IsType(t, &action.JobAction{}, jobAction)
+	assert.Equal(t, dpv1alpha1.ActionTypeJob, jobAction.Type())
+}
+
+func TestRequestBuildBackupDataActions(t *testing.T) {
+	req, pod := newRequestTestFixture(t)
+	req.ActionSet = &dpv1alpha1.ActionSet{Spec: dpv1alpha1.ActionSetSpec{BackupType: dpv1alpha1.BackupTypeFull, Backup: &dpv1alpha1.BackupActionSpec{BackupData: &dpv1alpha1.BackupDataActionSpec{JobActionSpec: dpv1alpha1.JobActionSpec{BaseJobActionSpec: dpv1alpha1.BaseJobActionSpec{Image: "busybox"}}}}}}
+	backupDataAction, err := req.buildBackupDataAction(pod, "backup-data")
+	assert.NoError(t, err)
+	assert.IsType(t, &action.JobAction{}, backupDataAction)
+
+	req.ActionSet.Spec.BackupType = dpv1alpha1.BackupTypeContinuous
+	backupDataAction, err = req.buildBackupDataAction(pod, "continuous")
+	assert.NoError(t, err)
+	assert.IsType(t, &action.StatefulSetAction{}, backupDataAction)
+	assert.Contains(t, req.buildContinuousSyncProgressCommand(), "retryTimes")
+
+	req.ActionSet.Spec.BackupType = dpv1alpha1.BackupType("Unknown")
+	_, err = req.buildBackupDataAction(pod, "unsupported")
+	assert.Error(t, err)
+}
+
+func TestRequestBuildActionsIncludesPreAndPostHooks(t *testing.T) {
+	req, pod := newRequestTestFixture(t)
+	req.ActionSet = &dpv1alpha1.ActionSet{Spec: dpv1alpha1.ActionSetSpec{
+		BackupType: dpv1alpha1.BackupTypeFull,
+		Backup: &dpv1alpha1.BackupActionSpec{
+			PreBackup:  []dpv1alpha1.ActionSpec{{Exec: &dpv1alpha1.ExecActionSpec{Command: []string{"pre"}}}},
+			BackupData: &dpv1alpha1.BackupDataActionSpec{JobActionSpec: dpv1alpha1.JobActionSpec{BaseJobActionSpec: dpv1alpha1.BaseJobActionSpec{Image: "busybox", Command: []string{"backup"}}}},
+			PostBackup: []dpv1alpha1.ActionSpec{{Job: &dpv1alpha1.JobActionSpec{BaseJobActionSpec: dpv1alpha1.BaseJobActionSpec{Image: "busybox", Command: []string{"post"}}}}},
+		},
+	}}
+
+	actions, err := req.BuildActions()
+	assert.NoError(t, err)
+	assert.Len(t, actions[pod.Name], 3)
+	assert.Equal(t, dpv1alpha1.ActionTypeJob, actions[pod.Name][0].Type())
+	assert.Equal(t, dpv1alpha1.ActionTypeJob, actions[pod.Name][1].Type())
+	assert.Equal(t, dpv1alpha1.ActionTypeJob, actions[pod.Name][2].Type())
+}
+
 var _ = Describe("Request Test", func() {
 	buildRequest := func() *Request {
 		return &Request{