Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as opaque submodule gitlinks on GitHub) into fully-tracked first-party content. AITM now merges its 7 vendored repos as first-party engines: - memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts - git: vendored C git (bundled binary) + gitnexus (in-process code intelligence) - agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess) Includes the full session's product build: Gitgram web/mobile/backend features, AITM website/CLI/MCP, the unified memory layer, engine build tooling (scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md), and extensive test suites. Build artifacts, node_modules, external/, and gemini-cli are gitignored. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
286 lines
6.9 KiB
Go
286 lines
6.9 KiB
Go
package main
|
|
|
|
import (
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestTokenizeBatchLine(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
in string
|
|
want []string
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "simple",
|
|
in: "close bd-1 done",
|
|
want: []string{"close", "bd-1", "done"},
|
|
},
|
|
{
|
|
name: "tabs and spaces",
|
|
in: "close\tbd-1 done",
|
|
want: []string{"close", "bd-1", "done"},
|
|
},
|
|
{
|
|
name: "quoted with spaces",
|
|
in: `update bd-2 title="hello world"`,
|
|
want: []string{"update", "bd-2", "title=hello world"},
|
|
},
|
|
{
|
|
name: "escaped quote",
|
|
in: `create bug 1 "say \"hi\""`,
|
|
want: []string{"create", "bug", "1", `say "hi"`},
|
|
},
|
|
{
|
|
name: "escaped backslash",
|
|
in: `create bug 1 "back\\slash"`,
|
|
want: []string{"create", "bug", "1", `back\slash`},
|
|
},
|
|
{
|
|
name: "unterminated quote",
|
|
in: `close bd-1 "oops`,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "empty string",
|
|
in: "",
|
|
want: nil,
|
|
},
|
|
{
|
|
name: "empty quoted",
|
|
in: `update bd-1 title=""`,
|
|
want: []string{"update", "bd-1", "title="},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := tokenizeBatchLine(tt.in)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Fatalf("tokenizeBatchLine(%q) err = %v, wantErr %v", tt.in, err, tt.wantErr)
|
|
}
|
|
if tt.wantErr {
|
|
return
|
|
}
|
|
if !reflect.DeepEqual(got, tt.want) {
|
|
t.Errorf("tokenizeBatchLine(%q) = %v, want %v", tt.in, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseBatchScript(t *testing.T) {
|
|
script := `# leading comment
|
|
# another
|
|
close bd-1 stale
|
|
|
|
update bd-2 status=in_progress priority=1
|
|
create task 2 "triage the backlog"
|
|
dep add bd-3 bd-4
|
|
dep add bd-3 bd-5 related
|
|
dep remove bd-6 bd-7
|
|
dep rm bd-8 bd-9
|
|
`
|
|
ops, err := parseBatchScript(strings.NewReader(script))
|
|
if err != nil {
|
|
t.Fatalf("parseBatchScript: %v", err)
|
|
}
|
|
wantCmds := []string{
|
|
"close",
|
|
"update",
|
|
"create",
|
|
"dep.add",
|
|
"dep.add",
|
|
"dep.remove",
|
|
"dep.remove",
|
|
}
|
|
if len(ops) != len(wantCmds) {
|
|
t.Fatalf("got %d ops, want %d: %+v", len(ops), len(wantCmds), ops)
|
|
}
|
|
for i, op := range ops {
|
|
if op.cmd != wantCmds[i] {
|
|
t.Errorf("op %d: cmd = %q, want %q", i, op.cmd, wantCmds[i])
|
|
}
|
|
if op.line == 0 {
|
|
t.Errorf("op %d: line number not set", i)
|
|
}
|
|
}
|
|
|
|
// Spot check: create title is one token via quoting
|
|
create := ops[2]
|
|
if create.cmd != "create" {
|
|
t.Fatalf("expected create, got %q", create.cmd)
|
|
}
|
|
if len(create.args) != 3 {
|
|
t.Fatalf("create args = %v, want 3 tokens", create.args)
|
|
}
|
|
if create.args[2] != "triage the backlog" {
|
|
t.Errorf("create title = %q, want %q", create.args[2], "triage the backlog")
|
|
}
|
|
|
|
// dep.add with type
|
|
depWithType := ops[4]
|
|
if depWithType.cmd != "dep.add" || len(depWithType.args) != 3 || depWithType.args[2] != "related" {
|
|
t.Errorf("dep.add with type mismatch: %+v", depWithType)
|
|
}
|
|
}
|
|
|
|
func TestParseBatchScript_Empty(t *testing.T) {
|
|
ops, err := parseBatchScript(strings.NewReader(""))
|
|
if err != nil {
|
|
t.Fatalf("parseBatchScript empty: %v", err)
|
|
}
|
|
if len(ops) != 0 {
|
|
t.Errorf("expected 0 ops, got %d", len(ops))
|
|
}
|
|
}
|
|
|
|
func TestParseBatchScript_OnlyCommentsAndBlank(t *testing.T) {
|
|
ops, err := parseBatchScript(strings.NewReader("# comment\n\n \n# another\n"))
|
|
if err != nil {
|
|
t.Fatalf("parseBatchScript: %v", err)
|
|
}
|
|
if len(ops) != 0 {
|
|
t.Errorf("expected 0 ops, got %d", len(ops))
|
|
}
|
|
}
|
|
|
|
func TestParseBatchScript_UnsupportedCommand(t *testing.T) {
|
|
_, err := parseBatchScript(strings.NewReader("show bd-1\n"))
|
|
if err == nil {
|
|
t.Fatal("expected error for unsupported command")
|
|
}
|
|
if !strings.Contains(err.Error(), "unsupported batch command") {
|
|
t.Errorf("error should mention unsupported command, got: %v", err)
|
|
}
|
|
if !strings.Contains(err.Error(), "line 1") {
|
|
t.Errorf("error should include line number, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestParseBatchScript_UnsupportedCommandOnLaterLine(t *testing.T) {
|
|
script := "close bd-1\nshow bd-2\n"
|
|
_, err := parseBatchScript(strings.NewReader(script))
|
|
if err == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
if !strings.Contains(err.Error(), "line 2") {
|
|
t.Errorf("error should include line 2, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestParseBatchScript_DepRequiresSubcommand(t *testing.T) {
|
|
_, err := parseBatchScript(strings.NewReader("dep\n"))
|
|
if err == nil {
|
|
t.Fatal("expected error for bare 'dep'")
|
|
}
|
|
if !strings.Contains(err.Error(), "subcommand") {
|
|
t.Errorf("error should mention subcommand, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestParseBatchScript_DepUnknownSubcommand(t *testing.T) {
|
|
_, err := parseBatchScript(strings.NewReader("dep list bd-1\n"))
|
|
if err == nil {
|
|
t.Fatal("expected error for unknown dep subcommand")
|
|
}
|
|
if !strings.Contains(err.Error(), "dep subcommand") {
|
|
t.Errorf("error should mention dep subcommand, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestParseBatchScript_UnterminatedQuote(t *testing.T) {
|
|
_, err := parseBatchScript(strings.NewReader(`create task 1 "oops`))
|
|
if err == nil {
|
|
t.Fatal("expected error for unterminated quote")
|
|
}
|
|
}
|
|
|
|
func TestParseUpdateKVs(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
in []string
|
|
want map[string]interface{}
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "status and priority",
|
|
in: []string{"status=in_progress", "priority=1"},
|
|
want: map[string]interface{}{"status": "in_progress", "priority": 1},
|
|
},
|
|
{
|
|
name: "title",
|
|
in: []string{"title=new title"},
|
|
want: map[string]interface{}{"title": "new title"},
|
|
},
|
|
{
|
|
name: "assignee blank allowed (unassign)",
|
|
in: []string{"assignee="},
|
|
want: map[string]interface{}{"assignee": ""},
|
|
},
|
|
{
|
|
name: "unsupported key",
|
|
in: []string{"description=foo"},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "missing equals",
|
|
in: []string{"status"},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "invalid priority",
|
|
in: []string{"priority=high"},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "empty status",
|
|
in: []string{"status="},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "empty title",
|
|
in: []string{"title="},
|
|
wantErr: true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := parseUpdateKVs(tt.in)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Fatalf("parseUpdateKVs err = %v, wantErr %v", err, tt.wantErr)
|
|
}
|
|
if tt.wantErr {
|
|
return
|
|
}
|
|
if !reflect.DeepEqual(got, tt.want) {
|
|
t.Errorf("parseUpdateKVs = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBatchCmd_Registered(t *testing.T) {
|
|
// Ensure 'bd batch' is wired into rootCmd with the correct group.
|
|
cmd, _, err := rootCmd.Find([]string{"batch"})
|
|
if err != nil {
|
|
t.Fatalf("rootCmd.Find batch: %v", err)
|
|
}
|
|
if cmd == nil || cmd.Name() != "batch" {
|
|
t.Fatalf("expected batch command, got %+v", cmd)
|
|
}
|
|
if cmd.GroupID != "maint" {
|
|
t.Errorf("batch GroupID = %q, want %q", cmd.GroupID, "maint")
|
|
}
|
|
if cmd.Flags().Lookup("file") == nil {
|
|
t.Error("batch missing --file flag")
|
|
}
|
|
if cmd.Flags().Lookup("dry-run") == nil {
|
|
t.Error("batch missing --dry-run flag")
|
|
}
|
|
if cmd.Flags().Lookup("message") == nil {
|
|
t.Error("batch missing --message flag")
|
|
}
|
|
}
|