This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
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>
2026-06-23 14:14:09 +03:00

93 lines
2.8 KiB
Go

package protocol
import (
"strings"
"testing"
)
// TestProtocol_CloseBlockedExitsNonZero verifies that closing an issue blocked
// by open dependencies returns exit code 1.
func TestProtocol_CloseBlockedExitsNonZero(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
blocker := w.create("Blocker issue")
blocked := w.create("Blocked issue")
w.run("dep", "add", blocked, blocker, "--type=blocks")
_, code := w.runExpectError("close", blocked)
if code != 1 {
t.Errorf("expected exit code 1, got %d", code)
}
}
// TestProtocol_CloseUnblockedExitsZero verifies that closing an unblocked
// issue returns exit code 0 (no regression).
func TestProtocol_CloseUnblockedExitsZero(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
id := w.create("Simple issue")
w.run("close", id)
}
// TestProtocol_UpdateNonexistentExitsNonZero verifies that updating a
// nonexistent issue returns exit code 1.
func TestProtocol_UpdateNonexistentExitsNonZero(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
_, code := w.runExpectError("update", "nonexistent-xyz", "--status", "in_progress")
if code != 1 {
t.Errorf("expected exit code 1, got %d", code)
}
}
// TestProtocol_ClosePartialFailureExitsZero verifies that when closing
// multiple issues where some succeed and some fail (e.g., blocked), the
// command exits zero (partial success counts as success) and still closes
// the closeable ones.
func TestProtocol_ClosePartialFailureExitsZero(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
closeable := w.create("Closeable issue")
blocker := w.create("Blocker issue")
blocked := w.create("Blocked issue")
w.run("dep", "add", blocked, blocker, "--type=blocks")
// Close both: closeable should succeed, blocked should fail.
// Partial success (closedCount > 0) exits 0.
w.run("close", closeable, blocked)
// Verify the closeable one was actually closed despite partial failure
out := w.run("show", closeable, "--json")
issues := parseJSONOutput(t, out)
if len(issues) == 0 {
t.Fatal("show returned no issues")
}
status, _ := issues[0]["status"].(string)
if status != "closed" {
t.Errorf("closeable issue should be closed despite partial failure, got status=%q", status)
}
// Verify the blocked one is still open
out2 := w.run("show", blocked, "--json")
issues2 := parseJSONOutput(t, out2)
if len(issues2) > 0 {
status2, _ := issues2[0]["status"].(string)
if status2 == "closed" {
t.Error("blocked issue should NOT be closed")
}
}
}
// TestProtocol_CloseNonexistentExitsNonZero verifies that closing a
// nonexistent issue returns a non-zero exit code.
func TestProtocol_CloseNonexistentExitsNonZero(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
out, _ := w.runExpectError("close", "nonexistent-xyz")
if !strings.Contains(strings.ToLower(out), "not found") {
t.Logf("output: %s", out)
}
}