1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
package askcli
import (
"bytes"
"context"
"io"
"strings"
"testing"
)
func TestDispatcher_Help(t *testing.T) {
d := NewDispatcher(nil)
var stdout bytes.Buffer
code, err := d.Dispatch(context.Background(), []string{"help"}, nil, &stdout, io.Discard)
if code != 0 {
t.Fatalf("help exit code = %d, want 0", code)
}
if err != nil {
t.Fatalf("help returned error: %v", err)
}
output := stdout.String()
if !strings.Contains(output, "ask - task management CLI") {
t.Fatalf("help missing title: %s", output)
}
if !strings.Contains(output, "ask list") {
t.Fatalf("help missing list subcommand: %s", output)
}
if !strings.Contains(output, "ask all") {
t.Fatalf("help missing all subcommand: %s", output)
}
}
func TestDispatcher_UnknownSubcommand(t *testing.T) {
d := NewDispatcher(nil)
var stderr bytes.Buffer
code, err := d.Dispatch(context.Background(), []string{"foobar"}, nil, io.Discard, &stderr)
if code != 1 {
t.Fatalf("unknown subcommand exit code = %d, want 1", code)
}
if err != nil {
t.Fatalf("unknown subcommand returned unexpected error: %v", err)
}
output := stderr.String()
if !strings.Contains(output, "unknown subcommand") {
t.Fatalf("unknown subcommand output missing: %s", output)
}
}
func TestDispatcher_CompleteUUIDsSubcommand(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
if strings.Join(args, " ") != "status:pending export" {
t.Fatalf("args = %v, want pending export", args)
}
_, _ = io.WriteString(stdout, `[{"uuid":"uuid-1"}]`)
return 0, nil
}})
var stdout, stderr bytes.Buffer
code, err := d.Dispatch(context.Background(), []string{"complete-uuids"}, nil, &stdout, &stderr)
if err != nil {
t.Fatalf("complete-uuids returned error: %v", err)
}
if code != 0 {
t.Fatalf("complete-uuids code = %d, want 0", code)
}
if got := stdout.String(); got != "uuid-1\n" {
t.Fatalf("stdout = %q, want UUID list", got)
}
}
func TestDispatcher_LongHelp(t *testing.T) {
d := NewDispatcher(nil)
var stdout bytes.Buffer
d.Dispatch(context.Background(), []string{"help"}, nil, &stdout, io.Discard)
output := stdout.String()
for _, sub := range []string{"add", "list", "all", "ready", "info", "annotate", "start", "stop", "done", "priority", "tag", "dep", "urgency", "modify", "denotate", "delete"} {
if !strings.Contains(output, "ask "+sub) {
t.Errorf("help missing subcommand: ask %s", sub)
}
}
}
func TestDispatcher_AllSubcommandsReachExecutor(t *testing.T) {
subcommands := []string{}
subcommandArgs := map[string][]string{
"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"},
"dep": {"dep", "list", "test-uuid"},
"list": {"list"},
"all": {"all"},
"ready": {"ready"},
"urgency": {"urgency"},
"info": {"info", "test-uuid"},
"add": {"add", "new task description"},
}
for _, sub := range subcommands {
var stdout, stderr bytes.Buffer
calls := 0
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout_, stderr_ io.Writer) (int, error) {
calls++
if args[0] == "export" || args[0] == "uuid" {
io.WriteString(stdout_, `[{"uuid":"test-uuid","description":"Test","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
}
if args[0] == "add" {
io.WriteString(stdout_, "Created task 123.\nUUID: test-uuid-abc")
}
return 0, nil
}})
args := []string{sub}
if extra, ok := subcommandArgs[sub]; ok {
args = extra
}
code, _ := d.Dispatch(context.Background(), args, nil, &stdout, &stderr)
if code != 0 {
t.Errorf("subcommand %q code = %d, want 0", sub, code)
}
}
}
type spyRunner struct {
runFn func(context.Context, []string, io.Reader, io.Writer, io.Writer) (int, error)
}
func (s *spyRunner) Run(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
return s.runFn(ctx, args, stdin, stdout, stderr)
}
|
