refactor: add usecase layer for param operations

internal/usecase/param/delete.go

@@ -0,0 +1,60 @@
+package param
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/samber/lo"
+
+	"github.com/mpyw/suve/internal/api/paramapi"
+)
+
+// DeleteClient is the interface for the delete use case.
+type DeleteClient interface {
+	paramapi.DeleteParameterAPI
+	paramapi.GetParameterAPI
+}
+
+// DeleteInput holds input for the delete use case.
+type DeleteInput struct {
+	Name string
+}
+
+// DeleteOutput holds the result of the delete use case.
+type DeleteOutput struct {
+	Name string
+}
+
+// DeleteUseCase executes delete operations.
+type DeleteUseCase struct {
+	Client DeleteClient
+}
+
+// GetCurrentValue fetches the current value for preview.
+func (u *DeleteUseCase) GetCurrentValue(ctx context.Context, name string) (string, error) {
+	out, err := u.Client.GetParameter(ctx, &paramapi.GetParameterInput{
+		Name:           lo.ToPtr(name),
+		WithDecryption: lo.ToPtr(true),
+	})
+	if err != nil {
+		var pnf *paramapi.ParameterNotFound
+		if errors.As(err, &pnf) {
+			return "", nil
+		}
+		return "", err
+	}
+	return lo.FromPtr(out.Parameter.Value), nil
+}
+
+// Execute runs the delete use case.
+func (u *DeleteUseCase) Execute(ctx context.Context, input DeleteInput) (*DeleteOutput, error) {
+	_, err := u.Client.DeleteParameter(ctx, &paramapi.DeleteParameterInput{
+		Name: lo.ToPtr(input.Name),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to delete parameter: %w", err)
+	}
+
+	return &DeleteOutput{Name: input.Name}, nil
+}

internal/usecase/param/delete_test.go

@@ -0,0 +1,112 @@
+package param_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/samber/lo"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mpyw/suve/internal/api/paramapi"
+	"github.com/mpyw/suve/internal/usecase/param"
+)
+
+type mockDeleteClient struct {
+	getParameterResult    *paramapi.GetParameterOutput
+	getParameterErr       error
+	deleteParameterResult *paramapi.DeleteParameterOutput
+	deleteParameterErr    error
+}
+
+func (m *mockDeleteClient) GetParameter(_ context.Context, _ *paramapi.GetParameterInput, _ ...func(*paramapi.Options)) (*paramapi.GetParameterOutput, error) {
+	if m.getParameterErr != nil {
+		return nil, m.getParameterErr
+	}
+	return m.getParameterResult, nil
+}
+
+func (m *mockDeleteClient) DeleteParameter(_ context.Context, _ *paramapi.DeleteParameterInput, _ ...func(*paramapi.Options)) (*paramapi.DeleteParameterOutput, error) {
+	if m.deleteParameterErr != nil {
+		return nil, m.deleteParameterErr
+	}
+	return m.deleteParameterResult, nil
+}
+
+func TestDeleteUseCase_GetCurrentValue(t *testing.T) {
+	t.Parallel()
+
+	client := &mockDeleteClient{
+		getParameterResult: &paramapi.GetParameterOutput{
+			Parameter: &paramapi.Parameter{
+				Value: lo.ToPtr("current-value"),
+			},
+		},
+	}
+
+	uc := &param.DeleteUseCase{Client: client}
+
+	value, err := uc.GetCurrentValue(context.Background(), "/app/config")
+	require.NoError(t, err)
+	assert.Equal(t, "current-value", value)
+}
+
+func TestDeleteUseCase_GetCurrentValue_NotFound(t *testing.T) {
+	t.Parallel()
+
+	client := &mockDeleteClient{
+		getParameterErr: &paramapi.ParameterNotFound{Message: lo.ToPtr("not found")},
+	}
+
+	uc := &param.DeleteUseCase{Client: client}
+
+	value, err := uc.GetCurrentValue(context.Background(), "/app/not-exists")
+	require.NoError(t, err)
+	assert.Empty(t, value)
+}
+
+func TestDeleteUseCase_GetCurrentValue_Error(t *testing.T) {
+	t.Parallel()
+
+	client := &mockDeleteClient{
+		getParameterErr: errors.New("aws error"),
+	}
+
+	uc := &param.DeleteUseCase{Client: client}
+
+	_, err := uc.GetCurrentValue(context.Background(), "/app/config")
+	assert.Error(t, err)
+}
+
+func TestDeleteUseCase_Execute(t *testing.T) {
+	t.Parallel()
+
+	client := &mockDeleteClient{
+		deleteParameterResult: &paramapi.DeleteParameterOutput{},
+	}
+
+	uc := &param.DeleteUseCase{Client: client}
+
+	output, err := uc.Execute(context.Background(), param.DeleteInput{
+		Name: "/app/to-delete",
+	})
+	require.NoError(t, err)
+	assert.Equal(t, "/app/to-delete", output.Name)
+}
+
+func TestDeleteUseCase_Execute_Error(t *testing.T) {
+	t.Parallel()
+
+	client := &mockDeleteClient{
+		deleteParameterErr: errors.New("delete failed"),
+	}
+
+	uc := &param.DeleteUseCase{Client: client}
+
+	_, err := uc.Execute(context.Background(), param.DeleteInput{
+		Name: "/app/config",
+	})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to delete parameter")
+}

internal/usecase/param/diff.go

@@ -0,0 +1,59 @@
+package param
+
+import (
+	"context"
+
+	"github.com/samber/lo"
+
+	"github.com/mpyw/suve/internal/api/paramapi"
+	"github.com/mpyw/suve/internal/version/paramversion"
+)
+
+// DiffClient is the interface for the diff use case.
+type DiffClient interface {
+	paramapi.GetParameterAPI
+	paramapi.GetParameterHistoryAPI
+}
+
+// DiffInput holds input for the diff use case.
+type DiffInput struct {
+	Spec1 *paramversion.Spec
+	Spec2 *paramversion.Spec
+}
+
+// DiffOutput holds the result of the diff use case.
+type DiffOutput struct {
+	OldName    string
+	OldVersion int64
+	OldValue   string
+	NewName    string
+	NewVersion int64
+	NewValue   string
+}
+
+// DiffUseCase executes diff operations.
+type DiffUseCase struct {
+	Client DiffClient
+}
+
+// Execute runs the diff use case.
+func (u *DiffUseCase) Execute(ctx context.Context, input DiffInput) (*DiffOutput, error) {
+	param1, err := paramversion.GetParameterWithVersion(ctx, u.Client, input.Spec1, true)
+	if err != nil {
+		return nil, err
+	}
+
+	param2, err := paramversion.GetParameterWithVersion(ctx, u.Client, input.Spec2, true)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DiffOutput{
+		OldName:    lo.FromPtr(param1.Name),
+		OldVersion: param1.Version,
+		OldValue:   lo.FromPtr(param1.Value),
+		NewName:    lo.FromPtr(param2.Name),
+		NewVersion: param2.Version,
+		NewValue:   lo.FromPtr(param2.Value),
+	}, nil
+}