Merge branch 'feature/extend-cli-protected' into 'master'

feat(cli): support duration suffixes (m/h/d) for --protected flag

Closes #702

See merge request postgres-ai/database-lab!1132

Author: Sarumyan

engine/cmd/cli/commands/clone/actions.go

@@ -42,17 +42,55 @@ func parseProtectedFlag(cliCtx *cli.Context) (bool, *uint, error) {
 	case "false":
 		return false, nil, nil
 	default:
-		duration, err := strconv.ParseUint(value, 10, 32)
+		minutes, err := parseDurationMinutes(value)
 		if err != nil {
-			return false, nil, errors.Errorf("invalid --protected value: %q (use 'true', 'false', or minutes)", value)
+			return false, nil, errors.Errorf("invalid --protected value: %q (use 'true', 'false', minutes, or duration like 30m/2h/7d)", value)
 		}
 
-		d := uint(duration)
+		d := uint(minutes)
 
 		return true, &d, nil
 	}
 }
 
+const (
+	minutesPerHour     = 60
+	minutesPerDay      = minutesPerHour * 24
+	maxDurationMinutes = 365 * minutesPerDay
+)
+
+// parseDurationMinutes parses a duration string into minutes.
+// Accepted formats: plain number (minutes), or number with suffix: m (minutes), h (hours), d (days).
+// Suffix matching is case-insensitive (m/M, h/H, d/D).
+func parseDurationMinutes(value string) (uint64, error) {
+	lower := strings.ToLower(value)
+
+	var multiplier uint64 = 1
+
+	switch {
+	case strings.HasSuffix(lower, "d"):
+		multiplier = minutesPerDay
+		lower = strings.TrimSuffix(lower, "d")
+	case strings.HasSuffix(lower, "h"):
+		multiplier = minutesPerHour
+		lower = strings.TrimSuffix(lower, "h")
+	case strings.HasSuffix(lower, "m"):
+		lower = strings.TrimSuffix(lower, "m")
+	}
+
+	n, err := strconv.ParseUint(lower, 10, 32)
+	if err != nil {
+		return 0, err
+	}
+
+	result := n * multiplier
+	if result > maxDurationMinutes {
+		return 0, errors.Errorf("duration too large: %d minutes exceeds maximum of %d minutes (365 days)", result, maxDurationMinutes)
+	}
+
+	return result, nil
+}
+
 // list runs a request to list clones of an instance.
 func list(cliCtx *cli.Context) error {
 	dblabClient, err := commands.ClientByCLIContext(cliCtx)

engine/cmd/cli/commands/clone/actions_test.go

@@ -0,0 +1,120 @@
+package clone
+
+import (
+	"flag"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/urfave/cli/v2"
+)
+
+func TestParseDurationMinutes(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected uint64
+		hasError bool
+	}{
+		{input: "0", expected: 0},
+		{input: "30", expected: 30},
+		{input: "120", expected: 120},
+		{input: "0m", expected: 0},
+		{input: "30m", expected: 30},
+		{input: "90m", expected: 90},
+		{input: "30M", expected: 30},
+		{input: "0h", expected: 0},
+		{input: "1h", expected: 60},
+		{input: "23h", expected: 1380},
+		{input: "2H", expected: 120},
+		{input: "0d", expected: 0},
+		{input: "1d", expected: 1440},
+		{input: "7d", expected: 10080},
+		{input: "7D", expected: 10080},
+		{input: "365d", expected: 525600},
+		{input: "abc", hasError: true},
+		{input: "10x", hasError: true},
+		{input: "m", hasError: true},
+		{input: "h", hasError: true},
+		{input: "d", hasError: true},
+		{input: "-1", hasError: true},
+		{input: "1.5h", hasError: true},
+		{input: " 30", hasError: true},
+		{input: "30 ", hasError: true},
+		{input: "366d", hasError: true},
+		{input: "8761h", hasError: true},
+		{input: "4294967295d", hasError: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			result, err := parseDurationMinutes(tt.input)
+			if tt.hasError {
+				require.Error(t, err)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func newProtectedContext(value string, isSet bool) *cli.Context {
+	fs := flag.NewFlagSet("test", flag.ContinueOnError)
+	fs.String("protected", "", "")
+
+	if isSet {
+		_ = fs.Set("protected", value)
+	}
+
+	return cli.NewContext(&cli.App{}, fs, nil)
+}
+
+func uintPtr(v uint) *uint { return &v }
+
+func TestParseProtectedFlag(t *testing.T) {
+	tests := []struct {
+		name              string
+		value             string
+		isSet             bool
+		expectedProtected bool
+		expectedDuration  *uint
+		hasError          bool
+	}{
+		{name: "not set", value: "", isSet: false, expectedProtected: false, expectedDuration: nil},
+		{name: "empty string", value: "", isSet: true, expectedProtected: true, expectedDuration: nil},
+		{name: "true", value: "true", isSet: true, expectedProtected: true, expectedDuration: nil},
+		{name: "TRUE", value: "TRUE", isSet: true, expectedProtected: true, expectedDuration: nil},
+		{name: "false", value: "false", isSet: true, expectedProtected: false, expectedDuration: nil},
+		{name: "FALSE", value: "FALSE", isSet: true, expectedProtected: false, expectedDuration: nil},
+		{name: "zero minutes", value: "0", isSet: true, expectedProtected: true, expectedDuration: uintPtr(0)},
+		{name: "plain minutes", value: "30", isSet: true, expectedProtected: true, expectedDuration: uintPtr(30)},
+		{name: "minutes suffix", value: "30m", isSet: true, expectedProtected: true, expectedDuration: uintPtr(30)},
+		{name: "hours suffix", value: "2h", isSet: true, expectedProtected: true, expectedDuration: uintPtr(120)},
+		{name: "days suffix", value: "7d", isSet: true, expectedProtected: true, expectedDuration: uintPtr(10080)},
+		{name: "invalid value", value: "abc", isSet: true, hasError: true},
+		{name: "overflow value", value: "366d", isSet: true, hasError: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cliCtx := newProtectedContext(tt.value, tt.isSet)
+
+			isProtected, duration, err := parseProtectedFlag(cliCtx)
+			if tt.hasError {
+				require.Error(t, err)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.expectedProtected, isProtected)
+
+			if tt.expectedDuration == nil {
+				assert.Nil(t, duration)
+			} else {
+				require.NotNil(t, duration)
+				assert.Equal(t, *tt.expectedDuration, *duration)
+			}
+		})
+	}
+}

engine/cmd/cli/commands/clone/command_list.go

@@ -70,7 +70,7 @@ func CommandList() []*cli.Command {
 					},
 					&cli.StringFlag{
 						Name:    "protected",
-						Usage:   "enable deletion protection: 'true' for default duration, minutes for custom, 0=forever",
+						Usage:   "deletion protection: 'true'=default, minutes or 30m/2h/7d, 0=forever",
 						Aliases: []string{"p"},
 					},
 					&cli.BoolFlag{
@@ -93,7 +93,7 @@ func CommandList() []*cli.Command {
 				Flags: []cli.Flag{
 					&cli.StringFlag{
 						Name:    "protected",
-						Usage:   "deletion protection: 'true' for default, minutes for custom, 0=forever, 'false' to disable",
+						Usage:   "deletion protection: 'true'=default, minutes or 30m/2h/7d, 0=forever, 'false'=off",
 						Aliases: []string{"p"},
 					},
 				},