507 lines · 31 KBtext/plain; charset=utf-8
Onset: version control where nobody waits and nothing gets lost. The on command, its core and onset-server.
| 6 | VCS=${1:-$(cd "$(dirname "$0")/.." && pwd)/target/debug/on} |
| 7 | WORK=$(mktemp -d) |
| 8 | export ONSET_HOME="$WORK/home" ONSET_NAME="Test Person" ONSET_EMAIL="test@example.com" ONSET_SAVER=0 |
| 9 | # Run from inside an agent, its own session would be kept with the tests' lands. |
| 10 | unset CLAUDE_CODE_SESSION_ID CLAUDECODE CLAUDE_CONFIG_DIR ONSET_SESSION_FILE ONSET_SESSIONS VCS_SESSION_FILE VCS_SESSIONS VCS_HOME VCS_TOKEN |
| 11 | export CODEX_HOME="$WORK/no-codex" |
| 12 | trap 'rm -rf "$WORK"' EXIT |
| 13 | cd "$WORK" |
| 14 |
| 15 | pass=0 |
| 16 | fail=0 |
| 17 | check() { # name, command... |
| 18 | local name=$1 |
| 19 | shift |
| 20 | if "$@" >/dev/null 2>&1; then pass=$((pass + 1)); else fail=$((fail + 1)); echo "FAIL: $name"; fi |
| 21 | } |
| 22 | code() { # expected exit code, command... |
| 23 | local want=$1 |
| 24 | shift |
| 25 | "$@" >/dev/null 2>&1 |
| 26 | [ "$?" = "$want" ] |
| 27 | } |
| 28 | json() { "$VCS" --json "$@" 2>/dev/null; } |
| 29 | # A path as on and other native programs see it: on Windows, bash's /d/a/x is D:/a/x. |
| 30 | native() { if command -v cygpath >/dev/null 2>&1; then cygpath -m "$1"; else printf '%s' "$1"; fi; } |
| 31 |
| 32 | # A new project with a first version. |
| 33 | mkdir app && cd app |
| 34 | printf 'hello\n' > README.md |
| 35 | mkdir src && printf 'a\nb\nc\nd\ne\nf\ng\n' > src/lib.txt |
| 36 | printf '{\n "name": "app"\n}\n' > package.json |
| 37 | printf 'SECRET=1\n' > .env |
| 38 | check "init" "$VCS" init |
| 39 | check "land first version" "$VCS" land -m "First version" |
| 40 | check "main is version 1" test "$(json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 1 |
| 41 | check ".env never landed" test -z "$(json log 1 | python3 -c 'import json,sys; print([f for f in json.load(sys.stdin)["files"] if ".env" in f] or "")')" |
| 42 | check "empty land refused (exit 1)" code 1 "$VCS" land -m "Nothing" |
| 43 |
| 44 | # A second workspace gets the files and the .env. |
| 45 | cd "$WORK" |
| 46 | check "get second workspace" "$VCS" get ./app app2 |
| 47 | check "files arrived" test "$(cat app2/src/lib.txt | head -1)" = a |
| 48 | check ".env came along" test "$(cat app2/.env)" = "SECRET=1" |
| 49 |
| 50 | # Parallel edits to different files both land, in any order. |
| 51 | printf 'hello there\n' > app/README.md |
| 52 | printf 'a\nb\nc\nd\ne\nf\nG\n' > app2/src/lib.txt |
| 53 | check "land from app" "$VCS" -C app land -m "Greet better" |
| 54 | check "land from app2 without syncing" "$VCS" -C app2 land -m "Capital G" |
| 55 | check "main is version 3" test "$(json -C app log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3 |
| 56 |
| 57 | # JSON files merge by key. |
| 58 | cd "$WORK" && "$VCS" -C app sync >/dev/null 2>&1 && "$VCS" -C app2 sync >/dev/null 2>&1 |
| 59 | printf '{\n "name": "app",\n "version": "1.0.0"\n}\n' > app/package.json |
| 60 | printf '{\n "name": "app",\n "license": "MIT"\n}\n' > app2/package.json |
| 61 | check "land json key A" "$VCS" -C app land -m "Add version" |
| 62 | check "land json key B (merged by key)" "$VCS" -C app2 land -m "Add license" |
| 63 | "$VCS" -C app sync >/dev/null 2>&1 |
| 64 | check "both keys on main" python3 -c 'import json; d=json.load(open("app/package.json")); assert d["version"]=="1.0.0" and d["license"]=="MIT"' |
| 65 |
| 66 | # A real conflict: land refuses, sync marks it, fixing it lands. |
| 67 | "$VCS" -C app2 sync >/dev/null 2>&1 |
| 68 | perl -pi -e 's/^b$/B from app/' app/src/lib.txt |
| 69 | perl -pi -e 's/^b$/B from app2/' app2/src/lib.txt |
| 70 | check "land A" "$VCS" -C app land -m "B from app" |
| 71 | check "land B conflicts (exit 3)" code 3 "$VCS" -C app2 land -m "B from app2" |
| 72 | check "sync leaves markers (exit 3)" code 3 "$VCS" -C app2 sync |
| 73 | check "markers in file" grep -q '<<<<<<< main' app2/src/lib.txt |
| 74 | check "land refused while markers remain" code 3 "$VCS" -C app2 land |
| 75 | python3 - "$WORK/app2/src/lib.txt" <<'EOF' |
| 76 | import sys, re |
| 77 | p = sys.argv[1] |
| 78 | t = open(p).read() |
| 79 | t = re.sub(r"<<<<<<< [^\n]*\n(.*?)=======\n(.*?)>>>>>>> [^\n]*\n", lambda m: "B from both\n", t, flags=re.S) |
| 80 | open(p, "w", newline="\n").write(t) |
| 81 | EOF |
| 82 | check "land after fixing (reuses description)" "$VCS" -C app2 land |
| 83 | check "status clean after land" test "$(json -C app2 status | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["files"]))')" = 0 |
| 84 |
| 85 | # A file's history, and the version behind each line. |
| 86 | check "log of a file" test "$(json -C app log src/lib.txt | python3 -c 'import json,sys; print(",".join(str(v["n"]) for v in json.load(sys.stdin)["versions"]))')" = 7,6,3,1 |
| 87 | check "log of a folder" sh -c "\"$VCS\" -C app log src | grep -q 'Capital G'" |
| 88 | check "log of a file from inside its folder" sh -c "cd app/src && \"$VCS\" log lib.txt | grep -q 'First version'" |
| 89 | check "blame" test "$(json -C app2 blame src/lib.txt | python3 -c 'import json,sys; print(",".join(str(l["version"]) for l in json.load(sys.stdin)["lines"]))')" = 1,7,1,1,1,1,3 |
| 90 | check "blame of a missing file fails" sh -c "! \"$VCS\" -C app blame nope.txt" |
| 91 | check "show a file in main" sh -c "\"$VCS\" -C app show src/lib.txt | grep -q 'B from both'" |
| 92 | check "show a file at a version" test "$("$VCS" -C app show src/lib.txt --from 1 | tail -1)" = g |
| 93 | check "show a missing file fails" sh -c "! \"$VCS\" -C app show nope.txt" |
| 94 | check "completions" sh -c "\"$VCS\" completions bash | grep -q _on" |
| 95 |
| 96 | # Tags: names for versions. |
| 97 | check "tag main's latest" "$VCS" -C app tag v1.0 |
| 98 | check "tag an older version" "$VCS" -C app tag first 1 |
| 99 | check "the list has them" sh -c "\"$VCS\" -C app tag | grep -q 'v1.0' && \"$VCS\" -C app tag | grep -q first" |
| 100 | check "show at a tag" test "$("$VCS" -C app show src/lib.txt --from first | tail -1)" = g |
| 101 | check "log of a tag" sh -c "\"$VCS\" -C app log first | grep -q 'First version'" |
| 102 | check "a tag stays on its version (exit 3)" code 3 "$VCS" -C app tag first 2 |
| 103 | check "a number can't be a tag (exit 2)" code 2 "$VCS" -C app tag 12 |
| 104 | check "remove a tag" "$VCS" -C app tag first --remove |
| 105 | check "it's gone" sh -c "! \"$VCS\" -C app tag | grep -q first" |
| 106 |
| 107 | # Cleaning up: a dropped change's saves and objects go; what's kept still works. |
| 108 | cd "$WORK/app" |
| 109 | "$VCS" sync >/dev/null 2>&1 |
| 110 | head -c 200000 /dev/urandom > scratch.bin |
| 111 | "$VCS" status >/dev/null 2>&1 |
| 112 | "$VCS" drop >/dev/null 2>&1 |
| 113 | check "gc --dry-run says what would go" sh -c "ONSET_GC_FRESH=0 '$VCS' gc --older 0s --dry-run | grep -q 'would remove'" |
| 114 | check "gc removes the dropped change's objects" test "$(ONSET_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"] > 0)')" = True |
| 115 | check "main still reads" sh -c "\"$VCS\" show src/lib.txt | grep -q 'B from both'" |
| 116 | check "history still reads" sh -c "\"$VCS\" log src/lib.txt | grep -q 'First version'" |
| 117 | check "nothing is damaged" "$VCS" check |
| 118 | check "a second gc has nothing left" test "$(ONSET_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"])')" = 0 |
| 119 | cd "$WORK" |
| 120 |
| 121 | # Undo a land: main gets a version that takes it back out. |
| 122 | cd "$WORK/app" |
| 123 | "$VCS" sync >/dev/null 2>&1 |
| 124 | printf 'oops\n' > oops.txt |
| 125 | check "land oops" "$VCS" land -m "Oops" |
| 126 | check "undo the land" "$VCS" undo |
| 127 | check "oops is open again" test "$(json status | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"]["state"])')" = open |
| 128 | check "main took it back" test "$(json log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["title"][:13])')" = "Take back mai" |
| 129 | check "drop it" "$VCS" drop |
| 130 | check "undo the drop" "$VCS" undo |
| 131 | check "drop again" "$VCS" drop |
| 132 |
| 133 | # Restore a file from an earlier save. |
| 134 | printf 'v1\n' > notes.txt |
| 135 | "$VCS" status >/dev/null 2>&1 |
| 136 | sleep 3 |
| 137 | printf 'broken\n' > notes.txt |
| 138 | "$VCS" status >/dev/null 2>&1 |
| 139 | check "restore --at" "$VCS" restore notes.txt --at "2s ago" |
| 140 | check "notes is v1" test "$(cat notes.txt)" = v1 |
| 141 | check "undo the restore" "$VCS" undo |
| 142 | check "notes is broken again" test "$(cat notes.txt)" = broken |
| 143 | check "restore to base (removes the new file)" "$VCS" restore notes.txt |
| 144 | check "notes gone" test ! -e notes.txt |
| 145 |
| 146 | # New, switch, stacks. |
| 147 | printf 'feature a\n' > a.txt |
| 148 | check "describe" "$VCS" describe "Feature A" |
| 149 | A=$(json status | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"]["id"])') |
| 150 | check "new stacked on A" "$VCS" new "Feature B" --on "$A" |
| 151 | printf 'feature b\n' > b.txt |
| 152 | check "a.txt visible in B" test -e a.txt |
| 153 | check "switch back to A" "$VCS" switch "${A:0:6}" |
| 154 | check "b.txt gone in A" test ! -e b.txt |
| 155 | check "undo switch" "$VCS" undo |
| 156 | check "b.txt back" test -e b.txt |
| 157 | check "land B lands A then B" "$VCS" land |
| 158 | check "main has both" test "$(json log -n 2 | python3 -c 'import json,sys; print(",".join(v["title"] for v in json.load(sys.stdin)["versions"]))')" = "Feature B,Feature A" |
| 159 |
| 160 | # Secrets don't land. |
| 161 | printf 'const key = "sk_live_%s";\n' "$(printf 'x%.0s' {1..24})" > pay.js |
| 162 | check "secret refused (exit 8)" code 8 "$VCS" land -m "Payments" |
| 163 | rm pay.js |
| 164 | printf 'const key = process.env.STRIPE_KEY;\n' > pay.js |
| 165 | check "lands without the secret" "$VCS" land -m "Payments" |
| 166 |
| 167 | # onset.toml [land] run: the workspace's own checks before it lands. |
| 168 | printf '[land]\nrun = ["exit 1"]\n' > onset.toml |
| 169 | check "a failing [land] run stops the land (exit 4)" code 4 "$VCS" land -m "Checks" |
| 170 | check "--no-run lands anyway" "$VCS" land -m "Checks" --no-run |
| 171 | printf '[land]\nrun = ["exit 0"]\n' > onset.toml |
| 172 | check "a passing [land] run lands" "$VCS" land -m "Checks pass" |
| 173 |
| 174 | # No description. |
| 175 | printf 'x\n' > x.txt |
| 176 | check "no description (exit 2)" code 2 "$VCS" land |
| 177 | check "describe then land" "$VCS" land -m "Add x" |
| 178 |
| 179 | # Diff and log output. |
| 180 | printf 'y\n' > x.txt |
| 181 | check "diff shows the edit" sh -c "\"$VCS\" diff | grep -q '^+y'" |
| 182 | check "log --saves" "$VCS" log --saves |
| 183 | check "log --ops" "$VCS" log --ops |
| 184 | check "log --changes" "$VCS" log --changes |
| 185 | check "guide" sh -c "\"$VCS\" guide | grep -q 'on land'" |
| 186 |
| 187 | # Deleting a workspace is deleting its folder; a new one can take its place. |
| 188 | cd "$WORK" |
| 189 | check "get a third workspace" "$VCS" get ./app app3 |
| 190 | rm -rf app3 |
| 191 | check "get again at the same path" "$VCS" get ./app app3 |
| 192 | cd "$WORK/app" |
| 193 |
| 194 | # Mine: vcs access <path> me. |
| 195 | printf 'token\n' > secrets.local |
| 196 | check "access me" "$VCS" access secrets.local me |
| 197 | check "mine stays out of the change" sh -c "! \"$VCS\" --json status | grep -q secrets.local" |
| 198 |
| 199 | # An agent each: workspaces added next to this one, and cleaned up once done. |
| 200 | check "add a workspace" "$VCS" workspaces add ../agent1 |
| 201 | check "it has main's files" test -f ../agent1/README.md |
| 202 | printf 'parent work\n' > parent.txt |
| 203 | check "add one on this change" "$VCS" workspaces add ../sub1 --on . |
| 204 | check "it starts from this change's work" test -f ../sub1/parent.txt |
| 205 | check "the list has them" sh -c "'$VCS' workspaces | grep -q agent1 && '$VCS' workspaces | grep -q sub1" |
| 206 | printf 'agent work\n' > ../agent1/agent.txt && printf 'sub work\n' > ../sub1/sub.txt |
| 207 | check "clean (nothing idle long enough)" "$VCS" workspaces clean |
| 208 | check "keeps them all" test -d ../agent1 -a -d ../sub1 -a -d ../app2 |
| 209 | check "clean, no idle time" "$VCS" workspaces clean --idle 0s |
| 210 | check "keeps work that hasn't landed" test -f ../agent1/agent.txt -a -f ../sub1/sub.txt |
| 211 | check "removes a workspace whose change was empty" test ! -e ../app3 |
| 212 | check "never this one" test -d .onset |
| 213 | check "agent1 lands" "$VCS" -C ../agent1 land -m "Agent work" |
| 214 | check "clean again" "$VCS" workspaces clean --idle 0s |
| 215 | check "removes it once its work landed" test ! -e ../agent1 |
| 216 | check "and forgets it" sh -c "! '$VCS' workspaces | grep -q agent1" |
| 217 | check "main has its work" sh -c "'$VCS' sync >/dev/null && test -f agent.txt" |
| 218 |
| 219 | # Renames: a move shows as one, an edit made elsewhere follows the file to |
| 220 | # its new name when it lands, and history follows it back. |
| 221 | cd "$WORK" |
| 222 | "$VCS" get ./app ren1 >/dev/null 2>&1 |
| 223 | mkdir -p ren1/notes && for i in $(seq 1 30); do printf 'note line %s\n' "$i"; done > ren1/notes/long.txt |
| 224 | check "land a long file" "$VCS" -C ren1 land -m "Long notes" |
| 225 | "$VCS" get ./app ren2 >/dev/null 2>&1 |
| 226 | mkdir -p ren1/docs && mv ren1/notes/long.txt ren1/docs/long.md |
| 227 | check "status shows the move" sh -c "'$VCS' -C ren1 status | grep -q 'R notes/long.txt -> docs/long.md'" |
| 228 | check "land the move" "$VCS" -C ren1 land -m "Move the notes" |
| 229 | perl -pi -e 's/^note line 20$/note line twenty/' ren2/notes/long.txt |
| 230 | check "an edit to the old name lands" "$VCS" -C ren2 land -m "Edit the notes" |
| 231 | "$VCS" -C ren1 sync >/dev/null 2>&1 |
| 232 | check "the edit followed the file" grep -q 'note line twenty' ren1/docs/long.md |
| 233 | check "and the old name is gone" test ! -e ren1/notes/long.txt |
| 234 | check "log follows the move" sh -c "'$VCS' -C ren1 log docs/long.md | grep -q 'from notes/long.txt' && '$VCS' -C ren1 log docs/long.md | grep -q 'Long notes'" |
| 235 | LONG=$(json -C ren1 log docs/long.md | python3 -c 'import json,sys; print([v["n"] for v in json.load(sys.stdin)["versions"] if v["title"] == "Long notes"][0])') |
| 236 | check "blame goes back past the move" test "$(json -C ren1 blame docs/long.md | python3 -c 'import json,sys; print(json.load(sys.stdin)["lines"][0]["version"])')" = "$LONG" |
| 237 |
| 238 | # Smart merges: two new functions at the same spot both go in, and imports combine. |
| 239 | printf 'import { a } from "./a";\nimport { z } from "./z";\n\nexport function one() {}\n' > ren1/smart.ts |
| 240 | "$VCS" -C ren1 land -m "Smart base" >/dev/null 2>&1 |
| 241 | "$VCS" -C ren2 sync >/dev/null 2>&1 |
| 242 | printf 'import { a } from "./a";\nimport { b } from "./b";\nimport { z } from "./z";\n\nexport function one() {}\nexport function two() {}\n' > ren1/smart.ts |
| 243 | printf 'import { a } from "./a";\nimport { c } from "./c";\nimport { z } from "./z";\n\nexport function one() {}\nexport function three() {}\n' > ren2/smart.ts |
| 244 | check "one side lands" "$VCS" -C ren1 land -m "Two" |
| 245 | check "the other lands without a conflict" "$VCS" -C ren2 land -m "Three" |
| 246 | "$VCS" -C ren1 sync >/dev/null 2>&1 |
| 247 | check "both functions and all imports, in order" test "$(cat ren1/smart.ts)" = "$(printf 'import { a } from "./a";\nimport { b } from "./b";\nimport { c } from "./c";\nimport { z } from "./z";\n\nexport function one() {}\nexport function two() {}\nexport function three() {}')" |
| 248 |
| 249 | # Bisect: the first version where a check fails, tried in a folder of its own. |
| 250 | mkdir "$WORK/bis" && cd "$WORK/bis" |
| 251 | printf 'fine\n' > state.txt |
| 252 | "$VCS" init >/dev/null 2>&1 && "$VCS" land -m "v1" >/dev/null 2>&1 |
| 253 | for i in 2 3 4 5 6; do printf 'fine %s\n' "$i" > state.txt; "$VCS" land -m "v$i" >/dev/null 2>&1; done |
| 254 | printf 'broken\n' > state.txt && "$VCS" land -m "Breaks it" >/dev/null 2>&1 |
| 255 | for i in 8 9 10; do printf 'broken %s\n' "$i" > state.txt; "$VCS" land -m "v$i" >/dev/null 2>&1; done |
| 256 | check "bisect finds the version that broke it" test "$(json bisect 1 10 --run 'grep -q fine state.txt' | python3 -c 'import json,sys; print(json.load(sys.stdin)["first_bad"])')" = 7 |
| 257 | check "the workspace's files didn't change" grep -q 'broken 10' state.txt |
| 258 | check "with --in it keeps the folder" sh -c "'$VCS' bisect 1 main --run 'grep -q fine state.txt' --in ../bis-try >/dev/null && test -f ../bis-try/state.txt" |
| 259 | printf 'grep -qx "fine 6" state.txt && exit 125\ngrep -q fine state.txt\n' > "$WORK/skip-check.sh" |
| 260 | check "exit 125 skips a version" test "$(json bisect 1 10 --run "sh $WORK/skip-check.sh" | python3 -c 'import json,sys; print(json.load(sys.stdin)["first_bad"])')" = 7 |
| 261 | check "a good version after the bad one is refused (exit 2)" code 2 "$VCS" bisect 10 1 --run true |
| 262 |
| 263 | # Release lines: 1.x from version 2 gets fixes of its own, and a fix from |
| 264 | # main comes over (cleanly, or as a change on the line with conflicts marked). |
| 265 | mkdir "$WORK/rel" && cd "$WORK/rel" |
| 266 | printf 'one\ntwo\nthree\n' > app.txt && printf 'v1\n' > VERSION |
| 267 | "$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1 |
| 268 | printf 'v2\n' > VERSION && "$VCS" land -m "Two" >/dev/null 2>&1 |
| 269 | check "start line 1.x from version 2" "$VCS" line 1.x --from 2 |
| 270 | check "a second line by the same name is refused" code 1 "$VCS" line 1.x |
| 271 | check "vcs line lists it" sh -c "'$VCS' line | grep -q 'from main 2'" |
| 272 | printf 'v3\n' > VERSION && printf 'ONE\ntwo\nthree\n' > app.txt && "$VCS" land -m "Three" >/dev/null 2>&1 |
| 273 | cd "$WORK" |
| 274 | check "get a workspace on the line" "$VCS" get ./rel rel-1x --line 1.x |
| 275 | check "it has the line's files" test "$(cat rel-1x/VERSION)" = v2 |
| 276 | printf 'v2.1\n' > rel-1x/VERSION |
| 277 | check "land a fix on the line" "$VCS" -C rel-1x land -m "Fix on 1.x" |
| 278 | check "it's 1.x/1" test "$(json -C rel-1x log --line 1.x | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 1 |
| 279 | check "main didn't move" test "$(json -C rel log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3 |
| 280 | check "the workspace stays on the line" sh -c "'$VCS' -C rel-1x status | grep -q 'on 1.x/1\|1.x/1'" |
| 281 | printf 'v2.2\n' > rel-1x/VERSION |
| 282 | check "the next land goes on the line too" "$VCS" -C rel-1x land -m "Second fix on 1.x" |
| 283 | check "show reads a line" test "$("$VCS" -C rel show VERSION --from 1.x)" = v2.2 |
| 284 | check "and a line's version" test "$("$VCS" -C rel show VERSION --from 1.x/1)" = v2.1 |
| 285 | printf 'ONE\ntwo\nTHREE\n' > rel/app.txt |
| 286 | "$VCS" -C rel land -m "Fix the third line" >/dev/null 2>&1 |
| 287 | FIX=$(json -C rel log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["change"])') |
| 288 | check "bring main's fix over" "$VCS" -C rel land "$FIX" --to 1.x |
| 289 | check "only the fix came over" test "$("$VCS" -C rel show app.txt --from 1.x)" = "$(printf 'one\ntwo\nTHREE')" |
| 290 | check "as 1.x/3" test "$(json -C rel log --line 1.x | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3 |
| 291 | "$VCS" -C rel sync >/dev/null 2>&1 |
| 292 | printf 'UNO\ntwo\nTHREE\n' > rel/app.txt |
| 293 | "$VCS" -C rel land -m "Rename the first line" >/dev/null 2>&1 |
| 294 | CLASH=$(json -C rel log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["change"])') |
| 295 | check "a fix that conflicts with the line (exit 3)" code 3 "$VCS" -C rel land "$CLASH" --to 1.x |
| 296 | check "the workspace is on the line with it marked" sh -c "'$VCS' -C rel status | grep -q '1.x/3' && grep -q '<<<<<<<' rel/app.txt" |
| 297 | printf 'uno\ntwo\nTHREE\n' > rel/app.txt |
| 298 | check "fixed, it lands on the line" "$VCS" -C rel land |
| 299 | check "as 1.x/4" test "$("$VCS" -C rel show app.txt --from 1.x/4)" = "$(printf 'uno\ntwo\nTHREE')" |
| 300 | check "vcs new --line starts on the line's latest" sh -c "'$VCS' -C rel new --line 1.x | grep -q '1.x/4'" |
| 301 | printf 'uno\ntwo\nTHREE\nfour\n' > rel/app.txt |
| 302 | check "land 1.x/5" sh -c "'$VCS' -C rel land -m 'Add four' | grep -q '1.x/5'" |
| 303 | check "vcs undo takes a line's landing back" sh -c "'$VCS' -C rel undo | grep -q '1.x/6 takes 1.x/5 back out'" |
| 304 | check "the line is as it was" test "$("$VCS" -C rel show app.txt --from 1.x)" = "$(printf 'uno\ntwo\nTHREE')" |
| 305 | check "and the change is open again" sh -c "'$VCS' -C rel status | grep -q 'open'" |
| 306 | check "vcs undo 1.x/3 takes an older one back" sh -c "'$VCS' -C rel undo 1.x/3 | grep -q 'takes it back out'" |
| 307 | check "keeping what came after it" test "$("$VCS" -C rel show app.txt --from 1.x)" = "$(printf 'uno\ntwo\nthree')" |
| 308 |
| 309 | # Purge: a key that landed comes out of every version and its content is |
| 310 | # deleted, but not while another path still has the same bytes. |
| 311 | mkdir "$WORK/pur" && cd "$WORK/pur" |
| 312 | printf 'app\n' > app.txt |
| 313 | "$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1 |
| 314 | mkdir keys && printf 'not-a-real-key-7f3a\n' > keys/id.pem |
| 315 | "$VCS" land -m "Oops, a key" --allow-secrets >/dev/null 2>&1 |
| 316 | printf 'app 2\n' > app.txt && cp keys/id.pem copy.pem |
| 317 | "$VCS" land -m "More, and a copy" --allow-secrets >/dev/null 2>&1 |
| 318 | KEYHEX=$(printf '\001not-a-real-key-7f3a\n' | sha256sum | cut -c1-64) |
| 319 | KEYOBJ="$ONSET_HOME/objects/${KEYHEX:0:2}/${KEYHEX:2}" |
| 320 | check "the key is stored" test -f "$KEYOBJ" |
| 321 | check "without --yes it only says what it would do" sh -c "'$VCS' purge keys/id.pem | grep -q 'would' && test -f keys/id.pem" |
| 322 | check "purge it" "$VCS" purge keys/id.pem --yes |
| 323 | check "gone from the workspace" test ! -e keys |
| 324 | check "and from every version" sh -c "! '$VCS' show keys/id.pem --from 2 >/dev/null 2>&1 && ! '$VCS' show keys/id.pem --from 3 >/dev/null 2>&1" |
| 325 | check "versions keep their numbers" test "$(json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3 |
| 326 | check "the copy still has the bytes" test -f "$KEYOBJ" -a -f copy.pem |
| 327 | check "purge the copy too" "$VCS" purge copy.pem --yes |
| 328 | check "now the bytes are gone" test ! -e "$KEYOBJ" |
| 329 | check "the rest is whole" "$VCS" check |
| 330 | check "nothing comes back on the next save" sh -c "'$VCS' status | grep -q 'no changes yet'" |
| 331 | printf 'app 3\n' > app.txt |
| 332 | check "landing goes on" "$VCS" land -m "After the purge" |
| 333 | check "a path no version has" sh -c "'$VCS' purge nothing/here.txt --yes | grep -q 'nothing in'" |
| 334 |
| 335 | # Agent sessions: what the agent was asked, said and ran since its last land |
| 336 | # is kept with the change it lands, secrets removed; off stops it, delete |
| 337 | # removes it. |
| 338 | mkdir "$WORK/ses" && cd "$WORK/ses" |
| 339 | printf 'x\n' > a.txt |
| 340 | "$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1 |
| 341 | mkdir -p "$WORK/claude/projects/-elsewhere" |
| 342 | SES="$WORK/claude/projects/-elsewhere/abc-123.jsonl" |
| 343 | printf '%s\n' '{"type":"user","message":{"role":"user","content":"add b, the key is ghp_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"}}' \ |
| 344 | '{"type":"assistant","message":{"content":[{"type":"text","text":"Adding b."},{"type":"tool_use","name":"Bash","input":{"command":"on land -m B"}}]}}' > "$SES" |
| 345 | agent() { CLAUDE_CONFIG_DIR="$WORK/claude" CLAUDE_CODE_SESSION_ID=abc-123 "$@"; } |
| 346 | last() { json log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["change"])'; } |
| 347 | printf 'b\n' > b.txt |
| 348 | check "an agent's land keeps its session" sh -c "CLAUDE_CONFIG_DIR=$WORK/claude CLAUDE_CODE_SESSION_ID=abc-123 '$VCS' land -m B | grep -q 'Claude Code, 2 messages'" |
| 349 | B=$(last) |
| 350 | check "show prints it" sh -c "'$VCS' sessions show $B | grep -q 'agent: Adding b.' && '$VCS' sessions show $B | grep -q 'ran Bash on land'" |
| 351 | check "with the secret removed" sh -c "'$VCS' sessions show $B --raw | grep -q 'secret removed' && ! '$VCS' sessions show $B --raw | grep -q ghp_AAAA" |
| 352 | printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"Now c."}]}}' >> "$SES" |
| 353 | printf 'c\n' > c.txt |
| 354 | agent "$VCS" land -m "C" >/dev/null 2>&1 |
| 355 | C=$(last) |
| 356 | check "the next land keeps only what came after" sh -c "'$VCS' sessions show $C | grep -q 'Now c.' && ! '$VCS' sessions show $C | grep -q 'Adding b.'" |
| 357 | check "a land by hand keeps nothing" sh -c "printf 'h\n' > h.txt && ! '$VCS' land -m Hand | grep -q '^session'" |
| 358 | check "vcs sessions lists them" test "$("$VCS" sessions | grep -c 'Claude Code')" = 2 |
| 359 | check "vcs gc keeps them" sh -c "ONSET_GC_FRESH=0 '$VCS' gc >/dev/null && '$VCS' sessions show $B | grep -q 'Adding b.'" |
| 360 | check "off" "$VCS" sessions off |
| 361 | printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"Now d."}]}}' >> "$SES" |
| 362 | printf 'd\n' > d.txt |
| 363 | check "nothing is kept while it's off" sh -c "! CLAUDE_CONFIG_DIR=$WORK/claude CLAUDE_CODE_SESSION_ID=abc-123 '$VCS' land -m D | grep -q '^session'" |
| 364 | check "on again" "$VCS" sessions on |
| 365 | printf 'e\n' > e.txt |
| 366 | check "ONSET_SESSIONS=0 skips one land" sh -c "! ONSET_SESSIONS=0 CLAUDE_CONFIG_DIR=$WORK/claude CLAUDE_CODE_SESSION_ID=abc-123 '$VCS' land -m E | grep -q '^session'" |
| 367 | mkdir -p "$WORK/codex/sessions/2026/10/28" |
| 368 | printf '%s\n' "{\"type\":\"session_meta\",\"payload\":{\"id\":\"cx-1\",\"cwd\":\"$(native "$(pwd -P)")\"}}" \ |
| 369 | '{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"make f"}]}}' \ |
| 370 | '{"type":"response_item","payload":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"Made f."}]}}' > "$WORK/codex/sessions/2026/10/28/rollout-cx-1.jsonl" |
| 371 | printf 'f\n' > f.txt |
| 372 | check "a Codex session in this folder is kept" sh -c "CODEX_HOME=$WORK/codex '$VCS' land -m F | grep -q 'Codex, 2 messages'" |
| 373 | check "delete one change's" "$VCS" sessions delete "$B" |
| 374 | check "it's gone" sh -c "'$VCS' sessions show $B | grep -q 'none kept'" |
| 375 | check "delete --all" "$VCS" sessions delete --all |
| 376 | check "none left" test "$("$VCS" sessions | grep -c 'Claude Code')" = 0 |
| 377 |
| 378 | # Submodules: a pointer to a commit, added, pointed at another commit (or the |
| 379 | # one checked out in its folder), checked out with git, and removed. |
| 380 | cd "$WORK" |
| 381 | gc_() { git -c user.name=T -c user.email=t@example.com "$@"; } |
| 382 | git init -q sublib && (cd sublib && printf 'v1\n' > lib.txt && git add -A && gc_ commit -qm one && printf 'v2\n' > lib.txt && gc_ commit -qam two) |
| 383 | L1=$(git -C sublib rev-parse HEAD~1) |
| 384 | L2=$(git -C sublib rev-parse HEAD) |
| 385 | mkdir "$WORK/subs" && cd "$WORK/subs" |
| 386 | printf 'app\n' > app.txt |
| 387 | "$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1 |
| 388 | SUBURL=$(native "$WORK/sublib") |
| 389 | check "add a submodule" "$VCS" submodule vendor/lib "$L1" --url "$SUBURL" |
| 390 | check ".gitmodules names it" grep -q "url = $SUBURL" .gitmodules |
| 391 | check "it lands" "$VCS" land -m "Add lib" |
| 392 | check "vcs submodule lists it" sh -c "'$VCS' submodule | grep -q 'vendor/lib ${L1:0:12}'" |
| 393 | check "check it out" "$VCS" submodule --checkout |
| 394 | check "at its commit" test "$(cat vendor/lib/lib.txt)" = v1 |
| 395 | check "nothing in it is saved" sh -c "'$VCS' status | grep -q 'no changes yet'" |
| 396 | git -C vendor/lib checkout -q "$L2" 2>/dev/null |
| 397 | check "it says the checkout moved" sh -c "'$VCS' submodule | grep -q 'records it'" |
| 398 | check "record the commit checked out" sh -c "'$VCS' submodule vendor/lib | grep -q 'now points at ${L2:0:12}'" |
| 399 | check "status shows it" sh -c "'$VCS' status | grep -q 'M vendor/lib'" |
| 400 | check "it lands too" "$VCS" land -m "Lib two" |
| 401 | check "main has the new commit" sh -c "'$VCS' --json submodule | grep -q $L2" |
| 402 | check "a commit that isn't one (exit 2)" code 2 "$VCS" submodule vendor/lib nothex |
| 403 | check "removing one with a checkout in it is refused (exit 2)" code 2 "$VCS" submodule vendor/lib --remove |
| 404 | rm -rf vendor/lib |
| 405 | check "remove it" "$VCS" submodule vendor/lib --remove |
| 406 | check "and its .gitmodules entry" test ! -e .gitmodules |
| 407 | check "that lands" "$VCS" land -m "No lib" |
| 408 | check "none left" sh -c "'$VCS' submodule | grep -q 'none in this project'" |
| 409 |
| 410 | # A SHA-256 git repository imports like any other, and its branches come in as changes. |
| 411 | cd "$WORK" |
| 412 | git init -q --object-format=sha256 sha256repo |
| 413 | (cd sha256repo && printf 'one\n' > a.txt && git add -A && gc_ commit -qm "First" && printf 'two\n' > a.txt && gc_ commit -qam "Second") |
| 414 | check "import a SHA-256 repository" "$VCS" import sha256repo sha256proj |
| 415 | check "with its history" test "$(json -C sha256proj log | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["versions"]))')" = 2 |
| 416 | check "and its files" test "$(cat sha256proj/a.txt)" = two |
| 417 | check "its versions name their 64-digit commits" sh -c "'$VCS' --json -C sha256proj log -n 1 | grep -q \"$(git -C sha256repo rev-parse HEAD)\"" |
| 418 | (cd sha256repo && git checkout -qb feature && printf 'three\n' > b.txt && git add -A && gc_ commit -qm "Feature") |
| 419 | check "a branch of it comes in as a change" "$VCS" -C sha256proj import ../sha256repo --change feature |
| 420 | check "and lands" "$VCS" -C sha256proj land |
| 421 | check "with the branch's file" test "$(cat sha256proj/b.txt)" = three |
| 422 | check "a SHA-256 submodule commit" "$VCS" -C sha256proj submodule lib "$(git -C sha256repo rev-parse HEAD)" --url https://example.com/lib.git |
| 423 |
| 424 | # Onset was called vcs before it had its name: what a machine set up then |
| 425 | # has keeps working. A workspace's .vcs folder becomes .onset, a project's |
| 426 | # vcs.toml is read, VCS_* settings count, and the data folder stays. |
| 427 | cd "$WORK" |
| 428 | "$VCS" init oldname >/dev/null 2>&1 && printf 'old\n' > oldname/a.txt && "$VCS" -C oldname land -m "Before the name" >/dev/null 2>&1 |
| 429 | mv oldname/.onset oldname/.vcs |
| 430 | check "a .vcs workspace is still one" sh -c "'$VCS' -C oldname status | grep -q 'no changes yet'" |
| 431 | check "and its folder is .onset now" test -d oldname/.onset -a ! -e oldname/.vcs |
| 432 | printf '[land]\nrun = ["exit 3"]\n' > oldname/vcs.toml |
| 433 | printf 'more\n' >> oldname/a.txt |
| 434 | check "vcs.toml is read" code 4 "$VCS" -C oldname land -m "Checked" |
| 435 | rm oldname/vcs.toml |
| 436 | check "VCS_ settings count" sh -c "VCS_JSON=1 '$VCS' -C oldname status | grep -q '\"ok\"'" |
| 437 | check "and it lands" "$VCS" -C oldname land -m "By the old name" |
| 438 | # Where each system keeps app data; the folder from then is named vcs. |
| 439 | case "$(uname -s)" in |
| 440 | Darwin) OLDDATA="$WORK/fakehome/Library/Application Support" ;; |
| 441 | MINGW* | MSYS* | CYGWIN*) OLDDATA="$WORK/fakelocal" ;; |
| 442 | *) OLDDATA="$WORK/fakehome/.local/share" ;; |
| 443 | esac |
| 444 | mkdir -p "$OLDDATA/vcs" |
| 445 | cp -R "$ONSET_HOME/." "$OLDDATA/vcs/" |
| 446 | check "a data folder named vcs is used" sh -c "env -u ONSET_HOME -u XDG_DATA_HOME HOME='$WORK/fakehome' LOCALAPPDATA='$(native "$WORK/fakelocal")' '$VCS' --json -C oldname log -n 1 | grep -q 'By the old name' && test ! -e '$OLDDATA/onset'" |
| 447 |
| 448 | # A .git in each workspace, for editors and tools: at the change's base, so |
| 449 | # git shows the change's own edits; git's commit and push say what to run. |
| 450 | if command -v git >/dev/null 2>&1; then |
| 451 | cd "$WORK" |
| 452 | mkdir gv && cd gv |
| 453 | printf 'one\n' > a.txt |
| 454 | printf 'SECRET=2\n' > .env |
| 455 | export ONSET_GIT_WAIT=1 |
| 456 | "$VCS" init >/dev/null 2>&1 |
| 457 | "$VCS" land -m "Git view one" >/dev/null 2>&1 |
| 458 | check "a workspace has a .git" test -f .git |
| 459 | check "git sees no changes" test -z "$(git status --porcelain)" |
| 460 | printf 'two\n' >> a.txt |
| 461 | check "git sees the edit" sh -c "git status --porcelain | grep -q ' M a.txt'" |
| 462 | check "git diff shows it" sh -c "git diff | grep -q '^+two'" |
| 463 | check "git commit says to land" sh -c "git commit -qam x 2>&1 | grep -q 'on land'" |
| 464 | "$VCS" land -m "Git view two" >/dev/null 2>&1 |
| 465 | check "after a land, git is at main's latest" sh -c "git log -1 --format=%s | grep -q 'main [0-9]*: Git view two'" |
| 466 | check "and git log reads as main's versions" sh -c "git log --format=%s | sed -n 2p | grep -q 'Git view one'" |
| 467 | check "git sees no changes again" test -z "$(git status --porcelain)" |
| 468 | check "Onset's own folder and .env aren't changes to git" sh -c "! git status --porcelain --untracked-files=all | grep -q -e '.onset' -e '.env'" |
| 469 | check "a second workspace shares the objects" sh -c "cd '$WORK' && '$VCS' get ./gv gv2 >/dev/null 2>&1 && test \"\$(git -C gv2 rev-parse HEAD)\" = \"\$(git -C gv rev-parse HEAD)\"" |
| 470 | check "ONSET_GIT=0 makes none" sh -c "cd '$WORK' && ONSET_GIT=0 '$VCS' get ./gv gv3 >/dev/null 2>&1 && test ! -e gv3/.git" |
| 471 | unset ONSET_GIT_WAIT |
| 472 | cd "$WORK" |
| 473 | fi |
| 474 |
| 475 | # on watch: a check on each new version of main; the version that breaks it |
| 476 | # is found by bisecting and taken back, and its change is open again. |
| 477 | cd "$WORK" |
| 478 | mkdir wt && cd wt |
| 479 | printf 'test ! -e broken\n' > check.sh |
| 480 | printf 'one\n' > a.txt |
| 481 | "$VCS" init >/dev/null 2>&1 |
| 482 | "$VCS" land -m "Watch one" >/dev/null 2>&1 |
| 483 | latest() { json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])'; } |
| 484 | GOOD=$(latest) |
| 485 | for i in 2 3; do printf '%s\n' "$i" >> a.txt; "$VCS" land -m "Fine $i" >/dev/null 2>&1; done |
| 486 | printf 'x\n' > broken |
| 487 | "$VCS" land -m "Breaks it" >/dev/null 2>&1 |
| 488 | BROKE=$(latest) |
| 489 | BROKE_CHANGE=$(json log "$BROKE" | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"])') |
| 490 | printf '5\n' >> a.txt |
| 491 | "$VCS" land -m "Fine after" >/dev/null 2>&1 |
| 492 | check "watch takes back the version that broke the check" sh -c "'$VCS' watch --run 'sh check.sh' --from $GOOD --once | grep -q 'main $BROKE (\"Breaks it\"'" |
| 493 | check "main passes the check again" sh -c "! '$VCS' show broken >/dev/null 2>&1" |
| 494 | check "what landed after it stays" sh -c "'$VCS' show a.txt | grep -q '^5$'" |
| 495 | check "its change is open again" sh -c "'$VCS' --json status $BROKE_CHANGE | grep -q '\"state\": *\"open\"'" |
| 496 | check "the take-back says what failed" sh -c "'$VCS' log \$('$VCS' --json log | python3 -c 'import json,sys; print(json.load(sys.stdin)[\"versions\"][0][\"n\"])') | grep -q 'failed on it'" |
| 497 | check "a second watch has nothing new to check" test -z "$("$VCS" watch --run 'sh check.sh' --once 2>/dev/null | grep -v '^$')" |
| 498 | printf '6\n' >> a.txt |
| 499 | rm -f broken |
| 500 | "$VCS" land -m "Fine later" >/dev/null 2>&1 |
| 501 | check "and checks only what landed since" sh -c "'$VCS' watch --run 'sh check.sh' --once | grep -q 'passed *main $((BROKE + 3))'" |
| 502 | check "a check that fails with nothing known to pass says so (exit 4)" code 4 sh -c "cd '$WORK/wt' && '$VCS' watch --run 'false' --once" |
| 503 | cd "$WORK" |
| 504 |
| 505 | echo "local: $pass passed, $fail failed" |
| 506 | [ "$fail" = 0 ] |
| 507 |