325 lines · 19 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/vcs} |
| 7 | WORK=$(mktemp -d) |
| 8 | export VCS_HOME="$WORK/home" VCS_NAME="Test Person" VCS_EMAIL="test@example.com" VCS_SAVER=0 |
| 9 | trap 'rm -rf "$WORK"' EXIT |
| 10 | cd "$WORK" |
| 11 |
| 12 | pass=0 |
| 13 | fail=0 |
| 14 | check() { # name, command... |
| 15 | local name=$1 |
| 16 | shift |
| 17 | if "$@" >/dev/null 2>&1; then pass=$((pass + 1)); else fail=$((fail + 1)); echo "FAIL: $name"; fi |
| 18 | } |
| 19 | code() { # expected exit code, command... |
| 20 | local want=$1 |
| 21 | shift |
| 22 | "$@" >/dev/null 2>&1 |
| 23 | [ "$?" = "$want" ] |
| 24 | } |
| 25 | json() { "$VCS" --json "$@" 2>/dev/null; } |
| 26 |
| 27 | # A new project with a first version. |
| 28 | mkdir app && cd app |
| 29 | printf 'hello\n' > README.md |
| 30 | mkdir src && printf 'a\nb\nc\nd\ne\nf\ng\n' > src/lib.txt |
| 31 | printf '{\n "name": "app"\n}\n' > package.json |
| 32 | printf 'SECRET=1\n' > .env |
| 33 | check "init" "$VCS" init |
| 34 | check "land first version" "$VCS" land -m "First version" |
| 35 | check "main is version 1" test "$(json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 1 |
| 36 | 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 "")')" |
| 37 | check "empty land refused (exit 1)" code 1 "$VCS" land -m "Nothing" |
| 38 |
| 39 | # A second workspace gets the files and the .env. |
| 40 | cd "$WORK" |
| 41 | check "get second workspace" "$VCS" get ./app app2 |
| 42 | check "files arrived" test "$(cat app2/src/lib.txt | head -1)" = a |
| 43 | check ".env came along" test "$(cat app2/.env)" = "SECRET=1" |
| 44 |
| 45 | # Parallel edits to different files both land, in any order. |
| 46 | printf 'hello there\n' > app/README.md |
| 47 | printf 'a\nb\nc\nd\ne\nf\nG\n' > app2/src/lib.txt |
| 48 | check "land from app" "$VCS" -C app land -m "Greet better" |
| 49 | check "land from app2 without syncing" "$VCS" -C app2 land -m "Capital G" |
| 50 | check "main is version 3" test "$(json -C app log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3 |
| 51 |
| 52 | # JSON files merge by key. |
| 53 | cd "$WORK" && "$VCS" -C app sync >/dev/null 2>&1 && "$VCS" -C app2 sync >/dev/null 2>&1 |
| 54 | printf '{\n "name": "app",\n "version": "1.0.0"\n}\n' > app/package.json |
| 55 | printf '{\n "name": "app",\n "license": "MIT"\n}\n' > app2/package.json |
| 56 | check "land json key A" "$VCS" -C app land -m "Add version" |
| 57 | check "land json key B (merged by key)" "$VCS" -C app2 land -m "Add license" |
| 58 | "$VCS" -C app sync >/dev/null 2>&1 |
| 59 | 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"' |
| 60 |
| 61 | # A real conflict: land refuses, sync marks it, fixing it lands. |
| 62 | "$VCS" -C app2 sync >/dev/null 2>&1 |
| 63 | perl -pi -e 's/^b$/B from app/' app/src/lib.txt |
| 64 | perl -pi -e 's/^b$/B from app2/' app2/src/lib.txt |
| 65 | check "land A" "$VCS" -C app land -m "B from app" |
| 66 | check "land B conflicts (exit 3)" code 3 "$VCS" -C app2 land -m "B from app2" |
| 67 | check "sync leaves markers (exit 3)" code 3 "$VCS" -C app2 sync |
| 68 | check "markers in file" grep -q '<<<<<<< main' app2/src/lib.txt |
| 69 | check "land refused while markers remain" code 3 "$VCS" -C app2 land |
| 70 | python3 - "$WORK/app2/src/lib.txt" <<'EOF' |
| 71 | import sys, re |
| 72 | p = sys.argv[1] |
| 73 | t = open(p).read() |
| 74 | t = re.sub(r"<<<<<<< [^\n]*\n(.*?)=======\n(.*?)>>>>>>> [^\n]*\n", lambda m: "B from both\n", t, flags=re.S) |
| 75 | open(p, "w", newline="\n").write(t) |
| 76 | EOF |
| 77 | check "land after fixing (reuses description)" "$VCS" -C app2 land |
| 78 | check "status clean after land" test "$(json -C app2 status | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["files"]))')" = 0 |
| 79 |
| 80 | # A file's history, and the version behind each line. |
| 81 | 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 |
| 82 | check "log of a folder" sh -c "\"$VCS\" -C app log src | grep -q 'Capital G'" |
| 83 | check "log of a file from inside its folder" sh -c "cd app/src && \"$VCS\" log lib.txt | grep -q 'First version'" |
| 84 | 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 |
| 85 | check "blame of a missing file fails" sh -c "! \"$VCS\" -C app blame nope.txt" |
| 86 | check "show a file in main" sh -c "\"$VCS\" -C app show src/lib.txt | grep -q 'B from both'" |
| 87 | check "show a file at a version" test "$("$VCS" -C app show src/lib.txt --from 1 | tail -1)" = g |
| 88 | check "show a missing file fails" sh -c "! \"$VCS\" -C app show nope.txt" |
| 89 | check "completions" sh -c "\"$VCS\" completions bash | grep -q _vcs" |
| 90 |
| 91 | # Tags: names for versions. |
| 92 | check "tag main's latest" "$VCS" -C app tag v1.0 |
| 93 | check "tag an older version" "$VCS" -C app tag first 1 |
| 94 | check "the list has them" sh -c "\"$VCS\" -C app tag | grep -q 'v1.0' && \"$VCS\" -C app tag | grep -q first" |
| 95 | check "show at a tag" test "$("$VCS" -C app show src/lib.txt --from first | tail -1)" = g |
| 96 | check "log of a tag" sh -c "\"$VCS\" -C app log first | grep -q 'First version'" |
| 97 | check "a tag stays on its version (exit 3)" code 3 "$VCS" -C app tag first 2 |
| 98 | check "a number can't be a tag (exit 2)" code 2 "$VCS" -C app tag 12 |
| 99 | check "remove a tag" "$VCS" -C app tag first --remove |
| 100 | check "it's gone" sh -c "! \"$VCS\" -C app tag | grep -q first" |
| 101 |
| 102 | # Cleaning up: a dropped change's saves and objects go; what's kept still works. |
| 103 | cd "$WORK/app" |
| 104 | "$VCS" sync >/dev/null 2>&1 |
| 105 | head -c 200000 /dev/urandom > scratch.bin |
| 106 | "$VCS" status >/dev/null 2>&1 |
| 107 | "$VCS" drop >/dev/null 2>&1 |
| 108 | check "gc --dry-run says what would go" sh -c "VCS_GC_FRESH=0 '$VCS' gc --older 0s --dry-run | grep -q 'would remove'" |
| 109 | check "gc removes the dropped change's objects" test "$(VCS_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"] > 0)')" = True |
| 110 | check "main still reads" sh -c "\"$VCS\" show src/lib.txt | grep -q 'B from both'" |
| 111 | check "history still reads" sh -c "\"$VCS\" log src/lib.txt | grep -q 'First version'" |
| 112 | check "nothing is damaged" "$VCS" check |
| 113 | check "a second gc has nothing left" test "$(VCS_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"])')" = 0 |
| 114 | cd "$WORK" |
| 115 |
| 116 | # Undo a land: main gets a version that takes it back out. |
| 117 | cd "$WORK/app" |
| 118 | "$VCS" sync >/dev/null 2>&1 |
| 119 | printf 'oops\n' > oops.txt |
| 120 | check "land oops" "$VCS" land -m "Oops" |
| 121 | check "undo the land" "$VCS" undo |
| 122 | check "oops is open again" test "$(json status | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"]["state"])')" = open |
| 123 | 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" |
| 124 | check "drop it" "$VCS" drop |
| 125 | check "undo the drop" "$VCS" undo |
| 126 | check "drop again" "$VCS" drop |
| 127 |
| 128 | # Restore a file from an earlier save. |
| 129 | printf 'v1\n' > notes.txt |
| 130 | "$VCS" status >/dev/null 2>&1 |
| 131 | sleep 3 |
| 132 | printf 'broken\n' > notes.txt |
| 133 | "$VCS" status >/dev/null 2>&1 |
| 134 | check "restore --at" "$VCS" restore notes.txt --at "2s ago" |
| 135 | check "notes is v1" test "$(cat notes.txt)" = v1 |
| 136 | check "undo the restore" "$VCS" undo |
| 137 | check "notes is broken again" test "$(cat notes.txt)" = broken |
| 138 | check "restore to base (removes the new file)" "$VCS" restore notes.txt |
| 139 | check "notes gone" test ! -e notes.txt |
| 140 |
| 141 | # New, switch, stacks. |
| 142 | printf 'feature a\n' > a.txt |
| 143 | check "describe" "$VCS" describe "Feature A" |
| 144 | A=$(json status | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"]["id"])') |
| 145 | check "new stacked on A" "$VCS" new "Feature B" --on "$A" |
| 146 | printf 'feature b\n' > b.txt |
| 147 | check "a.txt visible in B" test -e a.txt |
| 148 | check "switch back to A" "$VCS" switch "${A:0:6}" |
| 149 | check "b.txt gone in A" test ! -e b.txt |
| 150 | check "undo switch" "$VCS" undo |
| 151 | check "b.txt back" test -e b.txt |
| 152 | check "land B lands A then B" "$VCS" land |
| 153 | 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" |
| 154 |
| 155 | # Secrets don't land. |
| 156 | printf 'const key = "sk_live_%s";\n' "$(printf 'x%.0s' {1..24})" > pay.js |
| 157 | check "secret refused (exit 8)" code 8 "$VCS" land -m "Payments" |
| 158 | rm pay.js |
| 159 | printf 'const key = process.env.STRIPE_KEY;\n' > pay.js |
| 160 | check "lands without the secret" "$VCS" land -m "Payments" |
| 161 |
| 162 | # vcs.toml [land] run: the workspace's own checks before it lands. |
| 163 | printf '[land]\nrun = ["exit 1"]\n' > vcs.toml |
| 164 | check "a failing [land] run stops the land (exit 4)" code 4 "$VCS" land -m "Checks" |
| 165 | check "--no-run lands anyway" "$VCS" land -m "Checks" --no-run |
| 166 | printf '[land]\nrun = ["exit 0"]\n' > vcs.toml |
| 167 | check "a passing [land] run lands" "$VCS" land -m "Checks pass" |
| 168 |
| 169 | # No description. |
| 170 | printf 'x\n' > x.txt |
| 171 | check "no description (exit 2)" code 2 "$VCS" land |
| 172 | check "describe then land" "$VCS" land -m "Add x" |
| 173 |
| 174 | # Diff and log output. |
| 175 | printf 'y\n' > x.txt |
| 176 | check "diff shows the edit" sh -c "\"$VCS\" diff | grep -q '^+y'" |
| 177 | check "log --saves" "$VCS" log --saves |
| 178 | check "log --ops" "$VCS" log --ops |
| 179 | check "log --changes" "$VCS" log --changes |
| 180 | check "guide" sh -c "\"$VCS\" guide | grep -q 'vcs land'" |
| 181 |
| 182 | # Deleting a workspace is deleting its folder; a new one can take its place. |
| 183 | cd "$WORK" |
| 184 | check "get a third workspace" "$VCS" get ./app app3 |
| 185 | rm -rf app3 |
| 186 | check "get again at the same path" "$VCS" get ./app app3 |
| 187 | cd "$WORK/app" |
| 188 |
| 189 | # Mine: vcs access <path> me. |
| 190 | printf 'token\n' > secrets.local |
| 191 | check "access me" "$VCS" access secrets.local me |
| 192 | check "mine stays out of the change" sh -c "! \"$VCS\" --json status | grep -q secrets.local" |
| 193 |
| 194 | # An agent each: workspaces added next to this one, and cleaned up once done. |
| 195 | check "add a workspace" "$VCS" workspaces add ../agent1 |
| 196 | check "it has main's files" test -f ../agent1/README.md |
| 197 | printf 'parent work\n' > parent.txt |
| 198 | check "add one on this change" "$VCS" workspaces add ../sub1 --on . |
| 199 | check "it starts from this change's work" test -f ../sub1/parent.txt |
| 200 | check "the list has them" sh -c "'$VCS' workspaces | grep -q agent1 && '$VCS' workspaces | grep -q sub1" |
| 201 | printf 'agent work\n' > ../agent1/agent.txt && printf 'sub work\n' > ../sub1/sub.txt |
| 202 | check "clean (nothing idle long enough)" "$VCS" workspaces clean |
| 203 | check "keeps them all" test -d ../agent1 -a -d ../sub1 -a -d ../app2 |
| 204 | check "clean, no idle time" "$VCS" workspaces clean --idle 0s |
| 205 | check "keeps work that hasn't landed" test -f ../agent1/agent.txt -a -f ../sub1/sub.txt |
| 206 | check "removes a workspace whose change was empty" test ! -e ../app3 |
| 207 | check "never this one" test -d .vcs |
| 208 | check "agent1 lands" "$VCS" -C ../agent1 land -m "Agent work" |
| 209 | check "clean again" "$VCS" workspaces clean --idle 0s |
| 210 | check "removes it once its work landed" test ! -e ../agent1 |
| 211 | check "and forgets it" sh -c "! '$VCS' workspaces | grep -q agent1" |
| 212 | check "main has its work" sh -c "'$VCS' sync >/dev/null && test -f agent.txt" |
| 213 |
| 214 | # Renames: a move shows as one, an edit made elsewhere follows the file to |
| 215 | # its new name when it lands, and history follows it back. |
| 216 | cd "$WORK" |
| 217 | "$VCS" get ./app ren1 >/dev/null 2>&1 |
| 218 | mkdir -p ren1/notes && for i in $(seq 1 30); do printf 'note line %s\n' "$i"; done > ren1/notes/long.txt |
| 219 | check "land a long file" "$VCS" -C ren1 land -m "Long notes" |
| 220 | "$VCS" get ./app ren2 >/dev/null 2>&1 |
| 221 | mkdir -p ren1/docs && mv ren1/notes/long.txt ren1/docs/long.md |
| 222 | check "status shows the move" sh -c "'$VCS' -C ren1 status | grep -q 'R notes/long.txt -> docs/long.md'" |
| 223 | check "land the move" "$VCS" -C ren1 land -m "Move the notes" |
| 224 | perl -pi -e 's/^note line 20$/note line twenty/' ren2/notes/long.txt |
| 225 | check "an edit to the old name lands" "$VCS" -C ren2 land -m "Edit the notes" |
| 226 | "$VCS" -C ren1 sync >/dev/null 2>&1 |
| 227 | check "the edit followed the file" grep -q 'note line twenty' ren1/docs/long.md |
| 228 | check "and the old name is gone" test ! -e ren1/notes/long.txt |
| 229 | 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'" |
| 230 | 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])') |
| 231 | 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" |
| 232 |
| 233 | # Smart merges: two new functions at the same spot both go in, and imports combine. |
| 234 | printf 'import { a } from "./a";\nimport { z } from "./z";\n\nexport function one() {}\n' > ren1/smart.ts |
| 235 | "$VCS" -C ren1 land -m "Smart base" >/dev/null 2>&1 |
| 236 | "$VCS" -C ren2 sync >/dev/null 2>&1 |
| 237 | printf 'import { a } from "./a";\nimport { b } from "./b";\nimport { z } from "./z";\n\nexport function one() {}\nexport function two() {}\n' > ren1/smart.ts |
| 238 | printf 'import { a } from "./a";\nimport { c } from "./c";\nimport { z } from "./z";\n\nexport function one() {}\nexport function three() {}\n' > ren2/smart.ts |
| 239 | check "one side lands" "$VCS" -C ren1 land -m "Two" |
| 240 | check "the other lands without a conflict" "$VCS" -C ren2 land -m "Three" |
| 241 | "$VCS" -C ren1 sync >/dev/null 2>&1 |
| 242 | 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() {}')" |
| 243 |
| 244 | # Bisect: the first version where a check fails, tried in a folder of its own. |
| 245 | mkdir "$WORK/bis" && cd "$WORK/bis" |
| 246 | printf 'fine\n' > state.txt |
| 247 | "$VCS" init >/dev/null 2>&1 && "$VCS" land -m "v1" >/dev/null 2>&1 |
| 248 | 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 |
| 249 | printf 'broken\n' > state.txt && "$VCS" land -m "Breaks it" >/dev/null 2>&1 |
| 250 | for i in 8 9 10; do printf 'broken %s\n' "$i" > state.txt; "$VCS" land -m "v$i" >/dev/null 2>&1; done |
| 251 | 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 |
| 252 | check "the workspace's files didn't change" grep -q 'broken 10' state.txt |
| 253 | 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" |
| 254 | printf 'grep -qx "fine 6" state.txt && exit 125\ngrep -q fine state.txt\n' > "$WORK/skip-check.sh" |
| 255 | 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 |
| 256 | check "a good version after the bad one is refused (exit 2)" code 2 "$VCS" bisect 10 1 --run true |
| 257 |
| 258 | # Release lines: 1.x from version 2 gets fixes of its own, and a fix from |
| 259 | # main comes over (cleanly, or as a change on the line with conflicts marked). |
| 260 | mkdir "$WORK/rel" && cd "$WORK/rel" |
| 261 | printf 'one\ntwo\nthree\n' > app.txt && printf 'v1\n' > VERSION |
| 262 | "$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1 |
| 263 | printf 'v2\n' > VERSION && "$VCS" land -m "Two" >/dev/null 2>&1 |
| 264 | check "start line 1.x from version 2" "$VCS" line 1.x --from 2 |
| 265 | check "a second line by the same name is refused" code 1 "$VCS" line 1.x |
| 266 | check "vcs line lists it" sh -c "'$VCS' line | grep -q 'from main 2'" |
| 267 | printf 'v3\n' > VERSION && printf 'ONE\ntwo\nthree\n' > app.txt && "$VCS" land -m "Three" >/dev/null 2>&1 |
| 268 | cd "$WORK" |
| 269 | check "get a workspace on the line" "$VCS" get ./rel rel-1x --line 1.x |
| 270 | check "it has the line's files" test "$(cat rel-1x/VERSION)" = v2 |
| 271 | printf 'v2.1\n' > rel-1x/VERSION |
| 272 | check "land a fix on the line" "$VCS" -C rel-1x land -m "Fix on 1.x" |
| 273 | 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 |
| 274 | check "main didn't move" test "$(json -C rel log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3 |
| 275 | check "the workspace stays on the line" sh -c "'$VCS' -C rel-1x status | grep -q 'on 1.x/1\|1.x/1'" |
| 276 | printf 'v2.2\n' > rel-1x/VERSION |
| 277 | check "the next land goes on the line too" "$VCS" -C rel-1x land -m "Second fix on 1.x" |
| 278 | check "show reads a line" test "$("$VCS" -C rel show VERSION --from 1.x)" = v2.2 |
| 279 | check "and a line's version" test "$("$VCS" -C rel show VERSION --from 1.x/1)" = v2.1 |
| 280 | printf 'ONE\ntwo\nTHREE\n' > rel/app.txt |
| 281 | "$VCS" -C rel land -m "Fix the third line" >/dev/null 2>&1 |
| 282 | FIX=$(json -C rel log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["change"])') |
| 283 | check "bring main's fix over" "$VCS" -C rel land "$FIX" --to 1.x |
| 284 | check "only the fix came over" test "$("$VCS" -C rel show app.txt --from 1.x)" = "$(printf 'one\ntwo\nTHREE')" |
| 285 | 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 |
| 286 | "$VCS" -C rel sync >/dev/null 2>&1 |
| 287 | printf 'UNO\ntwo\nTHREE\n' > rel/app.txt |
| 288 | "$VCS" -C rel land -m "Rename the first line" >/dev/null 2>&1 |
| 289 | CLASH=$(json -C rel log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["change"])') |
| 290 | check "a fix that conflicts with the line (exit 3)" code 3 "$VCS" -C rel land "$CLASH" --to 1.x |
| 291 | 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" |
| 292 | printf 'uno\ntwo\nTHREE\n' > rel/app.txt |
| 293 | check "fixed, it lands on the line" "$VCS" -C rel land |
| 294 | check "as 1.x/4" test "$("$VCS" -C rel show app.txt --from 1.x/4)" = "$(printf 'uno\ntwo\nTHREE')" |
| 295 | check "vcs new --line starts on the line's latest" sh -c "'$VCS' -C rel new --line 1.x | grep -q '1.x/4'" |
| 296 |
| 297 | # Purge: a key that landed comes out of every version and its content is |
| 298 | # deleted, but not while another path still has the same bytes. |
| 299 | mkdir "$WORK/pur" && cd "$WORK/pur" |
| 300 | printf 'app\n' > app.txt |
| 301 | "$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1 |
| 302 | mkdir keys && printf 'not-a-real-key-7f3a\n' > keys/id.pem |
| 303 | "$VCS" land -m "Oops, a key" --allow-secrets >/dev/null 2>&1 |
| 304 | printf 'app 2\n' > app.txt && cp keys/id.pem copy.pem |
| 305 | "$VCS" land -m "More, and a copy" --allow-secrets >/dev/null 2>&1 |
| 306 | KEYHEX=$(printf '\001not-a-real-key-7f3a\n' | sha256sum | cut -c1-64) |
| 307 | KEYOBJ="$VCS_HOME/objects/${KEYHEX:0:2}/${KEYHEX:2}" |
| 308 | check "the key is stored" test -f "$KEYOBJ" |
| 309 | 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" |
| 310 | check "purge it" "$VCS" purge keys/id.pem --yes |
| 311 | check "gone from the workspace" test ! -e keys |
| 312 | 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" |
| 313 | check "versions keep their numbers" test "$(json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3 |
| 314 | check "the copy still has the bytes" test -f "$KEYOBJ" -a -f copy.pem |
| 315 | check "purge the copy too" "$VCS" purge copy.pem --yes |
| 316 | check "now the bytes are gone" test ! -e "$KEYOBJ" |
| 317 | check "the rest is whole" "$VCS" check |
| 318 | check "nothing comes back on the next save" sh -c "'$VCS' status | grep -q 'no changes yet'" |
| 319 | printf 'app 3\n' > app.txt |
| 320 | check "landing goes on" "$VCS" land -m "After the purge" |
| 321 | check "a path no version has" sh -c "'$VCS' purge nothing/here.txt --yes | grep -q 'nothing in'" |
| 322 |
| 323 | echo "local: $pass passed, $fail failed" |
| 324 | [ "$fail" = 0 ] |
| 325 |