summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--internal/askcli/command_write.go165
-rw-r--r--internal/askcli/command_write_test.go233
-rw-r--r--internal/askcli/dispatch.go19
-rw-r--r--internal/askcli/dispatch_test.go12
4 files changed, 425 insertions, 4 deletions
diff --git a/internal/askcli/command_write.go b/internal/askcli/command_write.go
new file mode 100644
index 0000000..b39b64a
--- /dev/null
+++ b/internal/askcli/command_write.go
@@ -0,0 +1,165 @@
+package askcli
+
+import (
+ "bytes"
+ "context"
+ "io"
+ "strings"
+)
+
+func (d Dispatcher) handleDenotate(ctx context.Context, args []string, stdout, stderr io.Writer) (int, error) {
+ if len(args) < 3 {
+ io.WriteString(stderr, "error: ask denotate requires a UUID and text argument\n")
+ return 1, nil
+ }
+ uuid := args[1]
+ if IsNumericID(uuid) {
+ io.WriteString(stderr, RejectNumericID())
+ return 1, nil
+ }
+ text := args[2]
+ var outBuf bytes.Buffer
+ code, err := d.runner.Run(ctx, []string{"denotate", uuid, text}, nil, &outBuf, io.Discard)
+ if code != 0 {
+ return code, err
+ }
+ io.WriteString(stdout, FormatSuccess(uuid))
+ return 0, nil
+}
+
+func (d Dispatcher) handleModify(ctx context.Context, args []string, stdout, stderr io.Writer) (int, error) {
+ if len(args) < 3 {
+ io.WriteString(stderr, "error: ask modify requires a UUID and modification args\n")
+ return 1, nil
+ }
+ uuid := args[1]
+ if IsNumericID(uuid) {
+ io.WriteString(stderr, RejectNumericID())
+ return 1, nil
+ }
+ modArgs := args[2:]
+ var outBuf bytes.Buffer
+ code, err := d.runner.Run(ctx, append([]string{"modify", uuid}, modArgs...), nil, &outBuf, io.Discard)
+ if code != 0 {
+ return code, err
+ }
+ io.WriteString(stdout, FormatSuccess(uuid))
+ return 0, nil
+}
+
+func (d Dispatcher) handleAnnotate(ctx context.Context, args []string, stdout, stderr io.Writer) (int, error) {
+ if len(args) < 3 {
+ io.WriteString(stderr, "error: ask annotate requires a UUID and note argument\n")
+ return 1, nil
+ }
+ uuid := args[1]
+ if IsNumericID(uuid) {
+ io.WriteString(stderr, RejectNumericID())
+ return 1, nil
+ }
+ note := strings.Join(args[2:], " ")
+ var outBuf bytes.Buffer
+ code, err := d.runner.Run(ctx, []string{"annotate", uuid, note}, nil, &outBuf, io.Discard)
+ if code != 0 {
+ return code, err
+ }
+ io.WriteString(stdout, FormatSuccess(uuid))
+ return 0, nil
+}
+
+func (d Dispatcher) handleStart(ctx context.Context, args []string, stdout, stderr io.Writer) (int, error) {
+ if len(args) < 2 {
+ io.WriteString(stderr, "error: ask start requires a UUID argument\n")
+ return 1, nil
+ }
+ uuid := args[1]
+ if IsNumericID(uuid) {
+ io.WriteString(stderr, RejectNumericID())
+ return 1, nil
+ }
+ var outBuf bytes.Buffer
+ code, err := d.runner.Run(ctx, []string{"start", uuid}, nil, &outBuf, io.Discard)
+ if code != 0 {
+ return code, err
+ }
+ io.WriteString(stdout, FormatSuccess(uuid))
+ return 0, nil
+}
+
+func (d Dispatcher) handleStop(ctx context.Context, args []string, stdout, stderr io.Writer) (int, error) {
+ if len(args) < 2 {
+ io.WriteString(stderr, "error: ask stop requires a UUID argument\n")
+ return 1, nil
+ }
+ uuid := args[1]
+ if IsNumericID(uuid) {
+ io.WriteString(stderr, RejectNumericID())
+ return 1, nil
+ }
+ var outBuf bytes.Buffer
+ code, err := d.runner.Run(ctx, []string{"stop", uuid}, nil, &outBuf, io.Discard)
+ if code != 0 {
+ return code, err
+ }
+ io.WriteString(stdout, FormatSuccess(uuid))
+ return 0, nil
+}
+
+func (d Dispatcher) handleDone(ctx context.Context, args []string, stdout, stderr io.Writer) (int, error) {
+ if len(args) < 2 {
+ io.WriteString(stderr, "error: ask done requires a UUID argument\n")
+ return 1, nil
+ }
+ uuid := args[1]
+ if IsNumericID(uuid) {
+ io.WriteString(stderr, RejectNumericID())
+ return 1, nil
+ }
+ var outBuf bytes.Buffer
+ code, err := d.runner.Run(ctx, []string{"done", uuid}, nil, &outBuf, io.Discard)
+ if code != 0 {
+ return code, err
+ }
+ io.WriteString(stdout, FormatSuccess(uuid))
+ return 0, nil
+}
+
+func (d Dispatcher) handlePriority(ctx context.Context, args []string, stdout, stderr io.Writer) (int, error) {
+ if len(args) < 3 {
+ io.WriteString(stderr, "error: ask priority requires a UUID and priority (H/M/L)\n")
+ return 1, nil
+ }
+ uuid := args[1]
+ if IsNumericID(uuid) {
+ io.WriteString(stderr, RejectNumericID())
+ return 1, nil
+ }
+ priority := args[2]
+ var outBuf bytes.Buffer
+ code, err := d.runner.Run(ctx, []string{"priority", uuid, priority}, nil, &outBuf, io.Discard)
+ if code != 0 {
+ return code, err
+ }
+ io.WriteString(stdout, FormatSuccess(uuid))
+ return 0, nil
+}
+
+func (d Dispatcher) handleTag(ctx context.Context, args []string, stdout, stderr io.Writer) (int, error) {
+ if len(args) < 3 {
+ io.WriteString(stderr, "error: ask tag requires a UUID and +/-tag\n")
+ return 1, nil
+ }
+ uuid := args[1]
+ if IsNumericID(uuid) {
+ io.WriteString(stderr, RejectNumericID())
+ return 1, nil
+ }
+ tag := args[2]
+ var outBuf bytes.Buffer
+ code, err := d.runner.Run(ctx, []string{"tag", uuid, tag}, nil, &outBuf, io.Discard)
+ if code != 0 {
+ return code, err
+ }
+ io.WriteString(stdout, FormatSuccess(uuid))
+ return 0, nil
+}
diff --git a/internal/askcli/command_write_test.go b/internal/askcli/command_write_test.go
new file mode 100644
index 0000000..3b9d937
--- /dev/null
+++ b/internal/askcli/command_write_test.go
@@ -0,0 +1,233 @@
+package askcli
+
+import (
+ "bytes"
+ "context"
+ "io"
+ "strings"
+ "testing"
+)
+
+func TestHandleDenotate_Success(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, err := d.Dispatch(context.Background(), []string{"denotate", "test-uuid", "old annotation"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("denotate code = %d, want 0", code)
+ }
+ if err != nil {
+ t.Fatalf("denotate returned error: %v", err)
+ }
+ if !strings.Contains(stdout.String(), "ok") || !strings.Contains(stdout.String(), "test-uuid") {
+ t.Fatalf("stdout = %q, want ok + uuid", stdout.String())
+ }
+}
+
+func TestHandleDenotate_NumericID(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ t.Fatal("runFn should not be called for numeric ID")
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"denotate", "123", "text"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 1 {
+ t.Fatalf("denotate code = %d, want 1 for numeric ID", code)
+ }
+}
+
+func TestHandleDenotate_MissingArgs(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ t.Fatal("runFn should not be called for missing args")
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"denotate", "uuid"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 1 {
+ t.Fatalf("denotate code = %d, want 1 for missing args", code)
+ }
+}
+
+func TestHandleModify_Success(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"modify", "test-uuid", "priority:H"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("modify code = %d, want 0", code)
+ }
+ if !strings.Contains(stdout.String(), "ok") || !strings.Contains(stdout.String(), "test-uuid") {
+ t.Fatalf("stdout = %q, want ok + uuid", stdout.String())
+ }
+}
+
+func TestHandleModify_NumericID(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ t.Fatal("runFn should not be called for numeric ID")
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"modify", "123", "priority:H"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 1 {
+ t.Fatalf("modify code = %d, want 1 for numeric ID", code)
+ }
+}
+
+func TestHandleAnnotate_Success(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"annotate", "test-uuid", "new note"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("annotate code = %d, want 0", code)
+ }
+ if !strings.Contains(stdout.String(), "ok") || !strings.Contains(stdout.String(), "test-uuid") {
+ t.Fatalf("stdout = %q, want ok + uuid", stdout.String())
+ }
+}
+
+func TestHandleAnnotate_MissingArgs(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ t.Fatal("runFn should not be called for missing args")
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"annotate", "uuid"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 1 {
+ t.Fatalf("annotate code = %d, want 1 for missing args", code)
+ }
+}
+
+func TestHandleStart_Success(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"start", "test-uuid"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("start code = %d, want 0", code)
+ }
+ if !strings.Contains(stdout.String(), "ok") {
+ t.Fatalf("stdout = %q, want ok", stdout.String())
+ }
+}
+
+func TestHandleStart_MissingUUID(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ t.Fatal("runFn should not be called for missing UUID")
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"start"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 1 {
+ t.Fatalf("start code = %d, want 1 for missing UUID", code)
+ }
+}
+
+func TestHandleStop_Success(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"stop", "test-uuid"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("stop code = %d, want 0", code)
+ }
+}
+
+func TestHandleDone_Success(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"done", "test-uuid"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("done code = %d, want 0", code)
+ }
+}
+
+func TestHandlePriority_Success(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"priority", "test-uuid", "H"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("priority code = %d, want 0", code)
+ }
+}
+
+func TestHandlePriority_MissingArgs(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ t.Fatal("runFn should not be called for missing args")
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"priority", "uuid"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 1 {
+ t.Fatalf("priority code = %d, want 1 for missing args", code)
+ }
+}
+
+func TestHandleTag_Success(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"tag", "test-uuid", "+cli"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("tag code = %d, want 0", code)
+ }
+}
+
+func TestHandleTag_NumericID(t *testing.T) {
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ t.Fatal("runFn should not be called for numeric ID")
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"tag", "123", "+cli"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 1 {
+ t.Fatalf("tag code = %d, want 1 for numeric ID", code)
+ }
+}
+
+func TestAllWriteHandlers_PassCorrectArgs(t *testing.T) {
+ testCases := []struct {
+ subcommand string
+ args []string
+ wantArgs []string
+ }{
+ {"denotate", []string{"denotate", "my-uuid", "text"}, []string{"denotate", "my-uuid", "text"}},
+ {"modify", []string{"modify", "my-uuid", "priority:H"}, []string{"modify", "my-uuid", "priority:H"}},
+ {"annotate", []string{"annotate", "my-uuid", "note"}, []string{"annotate", "my-uuid", "note"}},
+ {"start", []string{"start", "my-uuid"}, []string{"start", "my-uuid"}},
+ {"stop", []string{"stop", "my-uuid"}, []string{"stop", "my-uuid"}},
+ {"done", []string{"done", "my-uuid"}, []string{"done", "my-uuid"}},
+ {"priority", []string{"priority", "my-uuid", "H"}, []string{"priority", "my-uuid", "H"}},
+ {"tag", []string{"tag", "my-uuid", "+cli"}, []string{"tag", "my-uuid", "+cli"}},
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.subcommand, func(t *testing.T) {
+ var capturedArgs []string
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ capturedArgs = args
+ return 0, nil
+ }})
+ var stdout, stderr bytes.Buffer
+ d.Dispatch(context.Background(), tc.args, &bytes.Buffer{}, &stdout, &stderr)
+ if len(capturedArgs) != len(tc.wantArgs) {
+ t.Fatalf("capturedArgs = %v, want %v", capturedArgs, tc.wantArgs)
+ }
+ for i, want := range tc.wantArgs {
+ if capturedArgs[i] != want {
+ t.Fatalf("capturedArgs[%d] = %q, want %q", i, capturedArgs[i], want)
+ }
+ }
+ })
+ }
+}
diff --git a/internal/askcli/dispatch.go b/internal/askcli/dispatch.go
index fc1c67b..1c08aa5 100644
--- a/internal/askcli/dispatch.go
+++ b/internal/askcli/dispatch.go
@@ -28,9 +28,24 @@ func (d Dispatcher) Dispatch(ctx context.Context, args []string, stdin io.Reader
}
subcommand := args[0]
switch subcommand {
- case "add", "list", "info", "annotate", "start", "stop", "done",
- "priority", "tag", "dep", "urgency", "modify", "denotate", "export":
+ case "add", "list", "info", "dep", "urgency", "export":
return d.runner.Run(ctx, args, stdin, stdout, stderr)
+ case "annotate":
+ return d.handleAnnotate(ctx, args, stdout, stderr)
+ case "start":
+ return d.handleStart(ctx, args, stdout, stderr)
+ case "stop":
+ return d.handleStop(ctx, args, stdout, stderr)
+ case "done":
+ return d.handleDone(ctx, args, stdout, stderr)
+ case "priority":
+ return d.handlePriority(ctx, args, stdout, stderr)
+ case "tag":
+ return d.handleTag(ctx, args, stdout, stderr)
+ case "modify":
+ return d.handleModify(ctx, args, stdout, stderr)
+ case "denotate":
+ return d.handleDenotate(ctx, args, stdout, stderr)
case "delete":
return d.handleDelete(ctx, args, stdout, stderr)
default:
diff --git a/internal/askcli/dispatch_test.go b/internal/askcli/dispatch_test.go
index d2a4e52..0d06299 100644
--- a/internal/askcli/dispatch_test.go
+++ b/internal/askcli/dispatch_test.go
@@ -59,9 +59,17 @@ func TestDispatcher_LongHelp(t *testing.T) {
}
func TestDispatcher_AllSubcommandsReachExecutor(t *testing.T) {
- subcommands := []string{"add", "list", "info", "annotate", "start", "stop", "done", "priority", "tag", "dep", "urgency", "modify", "denotate", "export"}
+ subcommands := []string{"add", "list", "info", "dep", "urgency", "export"}
subcommandArgs := map[string][]string{
- "delete": {"delete", "test-uuid"},
+ "delete": {"delete", "test-uuid"},
+ "denotate": {"denotate", "test-uuid", "text"},
+ "modify": {"modify", "test-uuid", "priority:H"},
+ "annotate": {"annotate", "test-uuid", "note"},
+ "start": {"start", "test-uuid"},
+ "stop": {"stop", "test-uuid"},
+ "done": {"done", "test-uuid"},
+ "priority": {"priority", "test-uuid", "H"},
+ "tag": {"tag", "test-uuid", "+cli"},
}
for _, sub := range subcommands {
var stdout, stderr bytes.Buffer
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-17 13:32:18 +0000