Preserve search and time arguments in copied CLI commands

cmd/logscopy_test.go

@@ -0,0 +1,141 @@
+package cmd
+
+import (
+	"context"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/tui/views"
+)
+
+// shellSplit splits a copied command into argv the way a POSIX shell does.
+func shellSplit(t *testing.T, s string) []string {
+	t.Helper()
+	sh, err := exec.LookPath("sh")
+	if err != nil {
+		t.Skip("sh not available")
+	}
+	out, err := exec.Command(sh, "-c", `eval "set -- $1"; printf '%s\0' "$@"`, "sh", s).Output()
+	require.NoError(t, err)
+	return strings.Split(strings.TrimSuffix(string(out), "\x00"), "\x00")
+}
+
+func parseLogInput(t *testing.T, argv []string) (*views.LogInput, error) {
+	t.Helper()
+	cmd := NewLogsCmd(nil)
+	format := command.Interactive
+	cmd.SetContext(command.SetFormatInContext(context.Background(), &format))
+	if err := cmd.ParseFlags(argv); err != nil {
+		return nil, err
+	}
+	var input views.LogInput
+	if err := command.ParseCommand(cmd, cmd.Flags().Args(), &input); err != nil {
+		return nil, err
+	}
+	return &input, nil
+}
+
+// TestLogsCopyCommandRoundTrip verifies that the command shown and copied for
+// a log view parses back, through the real logs flag parser, to the same input.
+func TestLogsCopyCommandRoundTrip(t *testing.T) {
+	tcs := []struct {
+		name string
+		argv []string
+	}{
+		{name: "phrase with space", argv: []string{"--resources", "srv-1", "--type", "app", "--text", "LEFT RIGHT"}},
+		{name: "literal comma", argv: []string{"--resources", "srv-1", "--type", "app", "--text", `"LEFT,RIGHT"`}},
+		{name: "relative start", argv: []string{"--resources", "srv-1", "--type", "app", "--text", "plain", "--start", "30m"}},
+		{name: "plain control", argv: []string{"--resources", "srv-1", "--type", "app", "--text", "plain"}},
+		{name: "two OR terms", argv: []string{"--resources", "srv-1", "--type", "app", "--text", "LEFT,RIGHT"}},
+		{name: "absolute bounds with nanoseconds", argv: []string{"--resources", "srv-1", "--start", "2026-10-11T08:30:05.415654123-07:00", "--end", "2026-10-11T09:00:00Z"}},
+		{name: "quotes, unicode and shell metacharacters", argv: []string{"--resources", "srv-1,srv-2", "--text", `"say ""hi""",it's,$HOME,*,日本語，テスト, lead`}},
+		{name: "empty element neighbor", argv: []string{"--resources", "srv-1", "--text", `,a`}},
+		{name: "enums and scalars", argv: []string{"--resources", "srv-1", "--level", "error,warning", "--type", "app,request", "--method", "GET,POST", "--direction", "forward", "--limit", "5", "--tail"}},
+		{name: "repeated slice flag", argv: []string{"--resources", "srv-1", "--text", "a b", "--text", "c"}},
+		{name: "path with spaces", argv: []string{"--resources", "srv-1", "--path", "/a b,/c", "--status-code", "500"}},
+		{name: "lone carriage return", argv: []string{"--resources", "srv-1", "--text", "\"a\rb\""}},
+		{name: "defaults only", argv: []string{}},
+	}
+
+	for _, tc := range tcs {
+		t.Run(tc.name, func(t *testing.T) {
+			original, err := parseLogInput(t, tc.argv)
+			require.NoError(t, err)
+
+			copied, err := command.CommandName(NewLogsCmd(nil), original)
+			require.NoError(t, err)
+			require.NotContains(t, copied, "{")
+			require.True(t, strings.HasPrefix(copied, "logs"), copied)
+
+			argv := shellSplit(t, copied)
+			require.Equal(t, "logs", argv[0])
+			replayed, err := parseLogInput(t, argv[1:])
+			require.NoError(t, err, copied)
+
+			requireSameTime(t, original.StartTime, replayed.StartTime)
+			requireSameTime(t, original.EndTime, replayed.EndTime)
+			original.StartTime, original.EndTime = nil, nil
+			replayed.StartTime, replayed.EndTime = nil, nil
+			require.Equal(t, original, replayed, copied)
+		})
+	}
+}
+
+func TestLogsCopyCommandPreservesSearchElements(t *testing.T) {
+	original, err := parseLogInput(t, []string{"--resources", "srv-1", "--text", "LEFT RIGHT", "--start", "30m"})
+	require.NoError(t, err)
+
+	copied, err := command.CommandName(NewLogsCmd(nil), original)
+	require.NoError(t, err)
+	require.Contains(t, copied, "--text='LEFT RIGHT'")
+	require.Contains(t, copied, "--start=30m")
+
+	original, err = parseLogInput(t, []string{"--resources", "srv-1", "--text", `"LEFT,RIGHT"`})
+	require.NoError(t, err)
+	require.Equal(t, []string{"LEFT,RIGHT"}, original.Text)
+
+	copied, err = command.CommandName(NewLogsCmd(nil), original)
+	require.NoError(t, err)
+	require.Contains(t, copied, `--text='"LEFT,RIGHT"'`)
+}
+
+func requireSameTime(t *testing.T, want, got *command.TimeOrRelative) {
+	t.Helper()
+	if want == nil {
+		require.Nil(t, got)
+		return
+	}
+	require.NotNil(t, got)
+	if want.Relative != nil {
+		require.NotNil(t, got.Relative)
+		require.Equal(t, *want.Relative, *got.Relative)
+		return
+	}
+	require.Nil(t, got.Relative)
+	require.True(t, want.T.Equal(*got.T), "want %s, got %s", want.T, got.T)
+}
+
+// TestTailLogsCopyCommandKeepsStartTime covers the automatic start time set by
+// TailLogsFlow, which has no relative text.
+func TestTailLogsCopyCommandKeepsStartTime(t *testing.T) {
+	start := time.Date(2026, 10, 11, 8, 30, 5, 415654123, time.FixedZone("PDT", -7*60*60))
+	input := views.LogInput{
+		ResourceIDs: []string{"srv-1"},
+		StartTime:   &command.TimeOrRelative{T: &start},
+		Tail:        true,
+	}
+
+	copied, err := command.CommandName(NewLogsCmd(nil), &input)
+	require.NoError(t, err)
+	require.Contains(t, copied, "--start=2026-10-11T08:30:05.415654123-07:00")
+
+	replayed, err := parseLogInput(t, shellSplit(t, copied)[1:])
+	require.NoError(t, err)
+	require.True(t, start.Equal(*replayed.StartTime.T))
+	require.True(t, replayed.Tail)
+}

pkg/command/formatter.go

@@ -38,7 +38,7 @@ func StringToOutput(s string) (Output, error) {
 }
 
 func CommandName(cmd *cobra.Command, v any) (string, error) {
-	inputString, err := InputToString(v)
+	inputString, err := inputToString(v, cmd.Flags())
 	if err != nil {
 		return "", err
 	}

pkg/command/formatter_test.go

@@ -0,0 +1,128 @@
+package command_test
+
+import (
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/require"
+
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/pointers"
+)
+
+type copyInput struct {
+	Name     string                  `cli:"arg:0"`
+	Second   *string                 `cli:"arg:1"`
+	Slice    []string                `cli:"slice"`
+	Array    []string                `cli:"array"`
+	Enum     []string                `cli:"enum"`
+	Single   string                  `cli:"single"`
+	Optional *string                 `cli:"optional"`
+	Count    *int                    `cli:"count"`
+	Flag     bool                    `cli:"flag"`
+	Since    *command.TimeOrRelative `cli:"since"`
+}
+
+func newCopyCmd() *cobra.Command {
+	cmd := &cobra.Command{Use: "thing"}
+	cmd.Flags().StringSlice("slice", nil, "")
+	cmd.Flags().StringArray("array", nil, "")
+	cmd.Flags().Var(command.NewEnumInput([]string{"a", "b", "c"}, true), "enum", "")
+	cmd.Flags().Var(command.NewEnumInput([]string{"x", "y"}, false), "single", "")
+	cmd.Flags().String("optional", "", "")
+	cmd.Flags().Int("count", 0, "")
+	cmd.Flags().Bool("flag", false, "")
+	cmd.Flags().Var(command.NewTimeInput(), "since", "")
+	return cmd
+}
+
+func parseCopyInput(t *testing.T, argv []string) copyInput {
+	t.Helper()
+	cmd := newCopyCmd()
+	require.NoError(t, cmd.ParseFlags(argv))
+	var v copyInput
+	require.NoError(t, command.ParseCommand(cmd, cmd.Flags().Args(), &v))
+	return v
+}
+
+func posixSplit(t *testing.T, s string) []string {
+	t.Helper()
+	sh, err := exec.LookPath("sh")
+	if err != nil {
+		t.Skip("sh not available")
+	}
+	out, err := exec.Command(sh, "-c", `eval "set -- $1"; printf '%s\0' "$@"`, "sh", s).Output()
+	require.NoError(t, err)
+	return strings.Split(strings.TrimSuffix(string(out), "\x00"), "\x00")
+}
+
+func TestCommandNameRoundTrip(t *testing.T) {
+	tcs := []struct {
+		name string
+		argv []string
+	}{
+		{name: "positional spaces and quotes", argv: []string{"my service", `it's "x"`}},
+		{name: "string slice elements", argv: []string{"n", "--slice", `"a,b",c d,é`}},
+		{name: "string array repeated", argv: []string{"n", "--array", "K=a,b", "--array", "L=c d", "--array", ""}},
+		{name: "enum list", argv: []string{"n", "--enum", "a,c", "--single", "y"}},
+		{name: "explicit scalars", argv: []string{"n", "--optional", "v w", "--count", "3", "--flag"}},
+		{name: "relative time", argv: []string{"n", "--since", "5h"}},
+		{name: "absolute time", argv: []string{"n", "--since", "2026-10-11T08:30:05.000000001Z"}},
+		{name: "nil and defaults", argv: []string{"n"}},
+	}
+
+	for _, tc := range tcs {
+		t.Run(tc.name, func(t *testing.T) {
+			original := parseCopyInput(t, tc.argv)
+
+			copied, err := command.CommandName(newCopyCmd(), &original)
+			require.NoError(t, err)
+
+			argv := posixSplit(t, copied)
+			require.Equal(t, "thing", argv[0])
+			replayed := parseCopyInput(t, argv[1:])
+
+			if original.Since != nil {
+				require.NotNil(t, replayed.Since)
+				require.Equal(t, original.Since.Relative, replayed.Since.Relative)
+				if original.Since.Relative == nil {
+					require.True(t, original.Since.T.Equal(*replayed.Since.T))
+				}
+				original.Since, replayed.Since = nil, nil
+			}
+			require.Equal(t, original, replayed, copied)
+		})
+	}
+}
+
+func TestCommandNameFormatsFlagTypes(t *testing.T) {
+	since := time.Date(2026, 10, 11, 8, 30, 5, 415654000, time.UTC)
+	v := copyInput{
+		Name:  "a b",
+		Slice: []string{"LEFT,RIGHT"},
+		Array: []string{"x", "y z"},
+		Enum:  []string{"a", "b"},
+		Since: &command.TimeOrRelative{T: &since},
+	}
+
+	str, err := command.CommandName(newCopyCmd(), &v)
+	require.NoError(t, err)
+	require.Equal(t, `thing 'a b' --slice='"LEFT,RIGHT"' --array=x --array='y z' --enum=a,b --since=2026-10-11T08:30:05.415654Z`, str)
+}
+
+func TestInputToStringQuoting(t *testing.T) {
+	v := copyInput{
+		Name:     "a b",
+		Second:   pointers.From("c"),
+		Slice:    []string{"LEFT RIGHT", "it's"},
+		Optional: pointers.From(""),
+		Since:    &command.TimeOrRelative{Relative: pointers.From("30m")},
+	}
+
+	str, err := command.InputToString(&v)
+	require.NoError(t, err)
+	require.Equal(t, `'a b' c --slice='LEFT RIGHT,it'\''s' --since=30m`, str)
+}