cli_test.v

1module tests23import net4import net.http5import os6import time78const root = @VMODROOT9const binary = os.join_path(root, 'build', 'koh3')1011struct Result {12mut:13	code int14	out  string15	err  string16}1718fn testsuite_begin() {19	os.mkdir_all(os.join_path(root, 'build')) or { panic(err) }20	build := os.execute('v -o ${q(binary)} ${q(os.join_path(root, 'src', 'koh3.v'))}')21	if build.exit_code != 0 {22		panic('could not build koh3: ${build.output}')23	}24}2526fn q(s string) string {27	return "'${s.replace("'", "'\\''")}'"28}2930fn temp_repo(name string) string {31	dir := os.join_path(os.temp_dir(), 'koh3-cli-${name}-${time.now().unix_nano()}')32	os.mkdir_all(dir) or { panic(err) }33	return dir34}3536fn run(repo string, args ...string) Result {37	home := temp_repo('home')38	defer { os.rmdir_all(home) or {} }39	return run_home(repo, home, ...args)40}4142fn run_home(repo string, home string, args ...string) Result {43	stamp := '${os.getpid()}-${time.now().unix_nano()}'44	base := os.join_path(os.temp_dir(), 'koh3-cli-${stamp}')45	out_path := '${base}.out'46	err_path := '${base}.err'47	code_path := '${base}.code'48	mut command := 'HOME=${q(home)} ${q(binary)}'49	for arg in args {50		command += ' ${q(arg)}'51	}52	shell := 'cd ${q(repo)} && ${command} </dev/null >${q(out_path)} 2>${q(err_path)}; printf "%s" \$? >${q(code_path)}'53	result := os.execute(shell)54	if result.exit_code != 0 {55		panic('could not run test command: ${result.output}')56	}57	code := os.read_file(code_path) or { panic(err) }58	out := os.read_file(out_path) or { '' }59	err := os.read_file(err_path) or { '' }60	os.rm(out_path) or {}61	os.rm(err_path) or {}62	os.rm(code_path) or {}63	return Result{64		code: code.int()65		out:  out66		err:  err67	}68}6970fn run_pty_home(repo string, home string, answers []string, args ...string) Result {71	stamp := '${os.getpid()}-${time.now().unix_nano()}'72	transcript := os.join_path(os.temp_dir(), 'koh3-pty-${stamp}.txt')73	script_path := os.join_path(os.temp_dir(), 'koh3-pty-${stamp}.exp')74	defer {75		os.rm(transcript) or {}76		os.rm(script_path) or {}77	}78	mut script := 'log_file -noappend {${transcript}}\nset timeout 20\nspawn -noecho env {HOME=${home}} NO_COLOR=1 {${binary}}'79	for arg in args {80		script += ' {${arg}}'81	}82	script += '\n'83	// Each answer waits for its prompt: typed ahead, it would be flushed when the pager takes the84	// terminal raw. `close` ends a run that is still asking, so `wait` can never hang the suite.85	for answer in answers {86		script += 'expect -re {› \$|message: \$|confirm: \$|\\[y/N\\] \$|q quit}\nsend -- "${answer}\\r"\n'87	}88	script += 'expect eof\ncatch close\nset status [wait]\nexit [lindex $status 3]\n'89	os.write_file(script_path, script) or { panic(err) }90	result := os.execute('cd ${q(repo)} && expect -f ${q(script_path)}')91	return Result{92		code: result.exit_code93		out:  os.read_file(transcript) or { '' }94		err:  result.output95	}96}9798fn init_repo(repo string) {99	r := run(repo, 'init')100	assert r.code == 0101	assert os.exists(os.join_path(repo, '.koh'))102	assert os.exists(os.join_path(repo, '.kohignore'))103}104105fn write(repo string, path string, text string) {106	full := os.join_path(repo, path)107	os.mkdir_all(os.dir(full)) or { panic(err) }108	os.write_file(full, text) or { panic(err) }109}110111fn read_json_has(text string, key string) {112	if !text.contains(key) {113		panic('missing JSON key ${key}: ${text}')114	}115}116117fn test_init_and_usage() {118	dir := temp_repo('init')119	defer { os.rmdir_all(dir) or {} }120	r := run(dir, 'init', '--json')121	assert r.code == 0122	read_json_has(r.out, 'repo')123	read_json_has(r.out, 'ignore_created')124	assert run(dir, 'init').code == 1125	assert run(dir, 'unknown-command').code == 2126	assert run(dir, 'unknown-command').err.contains('unknown command')127	// An agent asking for JSON gets JSON for a usage mistake too, exit 2.128	for args in [['unknown-command', '--json'], ['save', '--json'], ['save', 'x', '--nope', '--json']] {129		r2 := run(dir, ...args)130		assert r2.code == 2131		assert r2.out == ''132		assert r2.err.starts_with('{"error":'), r2.err133	}134}135136// The help screen is commands and plain words: every flag lives in `koh man`.137// this_platform is the platform name for the machine the tests run on, so a138// build test does not depend on which machine that is.139fn this_platform() string {140	machine := os.uname().machine141	arch := if machine in ['arm64', 'aarch64'] { 'aarch64' } else { 'x86_64' }142	return '${os.user_os()}-${arch}'143}144145// `koh build` builds with `koh.build`: the version and platform fill the output146// path, and each artifact is printed with its size.147fn test_build_builds_the_named_platforms() {148	dir := temp_repo('build_ok')149	defer { os.rmdir_all(dir) or {} }150	init_repo(dir)151	host := this_platform()152	write(dir, 'VERSION', '1.2.3\n')153	write(dir, 'koh.build', 'command = mkdir -p out && printf built > out/demo-1.2.3-${host}154output = out/demo-{version}-{platform}155platforms = ${host}156')157	one := run(dir, 'build')158	assert one.code == 0, one.err159	assert one.out.contains('version 1.2.3')160	assert one.out.contains('out/demo-1.2.3-${host}')161	assert os.exists(os.join_path(dir, 'out/demo-1.2.3-${host}'))162163	// --platform picks one, --all takes every platform the file names.164	write(dir, 'koh.build', 'command = mkdir -p out && printf m > out/demo-macos-aarch64 && printf l > out/demo-linux-aarch64165output = out/demo-{platform}166platforms = macos-aarch64, linux-aarch64167')168	all := run(dir, 'build', '--all', '--json')169	assert all.code == 0, all.err170	assert all.out.contains('"platform":"macos-aarch64"')171	assert all.out.contains('"platform":"linux-aarch64"')172	assert os.exists(os.join_path(dir, 'out/demo-linux-aarch64'))173	picked := run(dir, 'build', '--platform', 'linux-aarch64')174	assert picked.code == 0, picked.err175	assert picked.out.contains('out/demo-linux-aarch64')176	assert !picked.out.contains('out/demo-macos-aarch64')177}178179// The item's exit check, as a test: `koh build` builds Koh 3 itself with the180// real toolchain, in a copy, and the binary it produces runs.181// `koh update` refuses a command line that cannot be answered: JSON cannot carry182// the question, and a stray argument is a mistake. Both are settled before any183// source is read, so no network is needed here.184fn test_update_refuses_a_command_line_it_cannot_answer() {185	dir := temp_repo('update_args')186	defer { os.rmdir_all(dir) or {} }187	init_repo(dir)188	json_without_yes := run(dir, 'update', '--json')189	assert json_without_yes.code == 2190	assert json_without_yes.err.contains('needs --yes')191	assert run(dir, 'update', 'extra').code == 2192}193194fn test_build_builds_koh_itself() {195	dir := temp_repo('selfbuild')196	defer { os.rmdir_all(dir) or {} }197	// Only what a build reads: the copy needs no history and no archive.198	for item in ['src', 'vendor', 'docs', 'v.mod', 'VERSION'] {199		os.cp_all(os.join_path(root, item), os.join_path(dir, item), true) or { panic(err) }200	}201	write(dir, 'koh.build', 'command = mkdir -p zig-out/bin && v -o zig-out/bin/koh3 src/koh3.v202output = zig-out/bin/koh3203platforms = ${this_platform()}204')205	init_repo(dir)206	built := run(dir, 'build')207	assert built.code == 0, built.err208	assert built.out.contains('zig-out/bin/koh3')209	fresh := os.join_path(dir, 'zig-out/bin/koh3')210	assert os.exists(fresh)211	version := os.read_file(os.join_path(dir, 'VERSION'))!.trim_space()212	assert os.execute('${q(fresh)} --version').output.trim_space() == 'koh ${version}'213}214215fn test_build_refuses_what_it_cannot_do() {216	dir := temp_repo('build_bad')217	defer { os.rmdir_all(dir) or {} }218	init_repo(dir)219	missing := run(dir, 'build')220	assert missing.code == 1221	assert missing.err.contains('koh.build')222223	write(dir, 'koh.build', 'command = true224output = out/demo225platforms = macos-aarch64226')227	no_version := run(dir, 'build')228	assert no_version.code == 1229	assert no_version.err.contains('VERSION')230231	write(dir, 'VERSION', '1.2.3\n')232	not_listed := run(dir, 'build', '--platform', 'linux-aarch64')233	assert not_listed.code == 1234	assert not_listed.err.contains('does not build for')235236	unknown := run(dir, 'build', '--platform', 'amiga')237	assert unknown.code == 1238	assert unknown.err.contains('amiga')239240	both := run(dir, 'build', '--all', '--platform', 'macos-aarch64')241	assert both.code == 2242	assert both.err.contains('cannot be combined')243244	write(dir, 'koh.build', 'command = true245output = out/demo246platforms = macos-aarch64, amiga247')248	bad_platform := run(dir, 'build')249	assert bad_platform.code == 1250	assert bad_platform.err.contains('amiga')251252	write(dir, 'koh.build', 'command = sh -c \'echo "no toolchain" >&2; exit 1\'253output = out/demo254platforms = ${this_platform()}255')256	failed := run(dir, 'build')257	assert failed.code == 1258	assert failed.err.contains('no toolchain')259}260261fn test_the_help_screen_lists_commands_and_no_flags() {262	dir := temp_repo('help')263	defer { os.rmdir_all(dir) or {} }264	help := run(dir, '--help')265	assert help.code == 0266	names := ['save', 'checkpoint', 'status', 'view', 'diff', 'undo', 'revert', 'load', 'offer',267		'steal']268	for name in names {269		assert help.out.contains('  ${name} '), name270	}271	assert help.out.contains('koh man <command>')272	// No flag text anywhere on the screen.273	assert !help.out.contains('--'), help.out274	lines := help.out.split_into_lines()275	for line in lines {276		assert line.runes().len <= 80, line277	}278	// Each command has its own paragraph, a blank line above it.279	for name in names {280		for i, line in lines {281			if line.starts_with('  ${name} ') {282				assert i > 0 && lines[i - 1] == '', line283			}284		}285	}286	// A bare `koh` keeps its stream and exit code; `-h` shows the same screen.287	bare := run(dir)288	assert bare.code == 2289	assert bare.out == ''290	assert bare.err.contains('koh man <command>')291	short := run(dir, '-h')292	assert short.code == 0293	assert short.out == help.out294}295296// Colour on the screen follows NO_COLOR, as it does everywhere else.297fn test_the_help_screen_has_no_colour_when_it_is_off() {298	dir := temp_repo('help_plain')299	defer { os.rmdir_all(dir) or {} }300	home := temp_repo('help_plain_home')301	defer { os.rmdir_all(home) or {} }302	out_path := os.join_path(os.temp_dir(), 'koh3-help-${os.getpid()}-${time.now().unix_nano()}')303	defer { os.rm(out_path) or {} }304	code := os.system('cd ${q(dir)} && HOME=${q(home)} NO_COLOR=1 ${q(binary)} --help > ${q(out_path)}')305	assert code == 0306	text := os.read_file(out_path) or { panic(err) }307	assert !text.contains('\x1b'), text308	assert text.contains('  save        snapshot your work')309}310311// The binary embeds VERSION while saves bump v.mod; they drifted once.312fn test_version_matches_the_manifest() {313	dir := temp_repo('version')314	defer { os.rmdir_all(dir) or {} }315	version := run(dir, '--version').out.trim_space().all_after('koh ')316	manifest := os.read_file(os.join_path(root, 'v.mod')) or { panic(err) }317	assert manifest.contains("version: '${version}'"), version318}319320fn test_save_checkpoint_and_status() {321	dir := temp_repo('save')322	defer { os.rmdir_all(dir) or {} }323	init_repo(dir)324	write(dir, 'tracked.txt', 'one\n')325	r := run(dir, 'save', 'first message', '--agent', 'agent-7', '--session', 'session-a', '--json')326	assert r.code == 0327	for key in ['id', 'parent', 'message', 'created_at', 'machine', 'is_checkpoint', 'agent', 'session',328		'files', 'size_bytes'] {329		read_json_has(r.out, key)330	}331	assert r.out.contains('"message":"first message"')332	assert r.out.contains('"agent":"agent-7"')333	assert r.out.contains('"session":"session-a"')334	assert r.out.contains('"is_checkpoint":false')335	assert run(dir, 'save', 'again').code == 1336	assert run(dir, 'save', 'again').err.contains('nothing has changed since the last save')337	assert run(dir, 'save').code == 2338	assert run(dir, 'save', 'x', '--bogus').code == 2339	cp := run(dir, 'checkpoint', 'still first', '--json')340	assert cp.code == 0341	assert cp.out.contains('"is_checkpoint":true')342	assert cp.out.contains('"parent":')343	clean := run(dir, 'status')344	assert clean.code == 0345	assert clean.out.contains('no changes')346	write(dir, 'tracked.txt', 'two\n')347	write(dir, 'new.txt', 'new\n')348	os.rm(os.join_path(dir, 'tracked.txt')) or { panic(err) }349	write(dir, '.kohignore', '*.log\n')350	status := run(dir, 'status')351	assert status.code == 0352	assert status.out.contains('+')353	assert status.out.contains('~') || status.out.contains('-')354	assert status.out.contains('added')355	js := run(dir, 'status', '--json')356	assert js.code == 0357	for key in ['head_id', 'head_msg', 'dirty', 'modified', 'added', 'deleted', 'ignore_changed',358		'saves', 'size_bytes', 'head_flagged'] {359		read_json_has(js.out, key)360	}361	assert js.out.contains('"ignore_changed":true')362	// What the shell prompt shows: saves on the line, the .koh size, the flag.363	assert js.out.contains('"saves":2')364	assert js.out.contains('"size_bytes":${os.file_size(os.join_path(dir, '.koh'))}')365	assert js.out.contains('"head_flagged":false')366	head := js.out.all_after('"head_id":"').all_before('"')367	assert run(dir, 'flag', head, '--reason', 'bad').code == 0368	assert run(dir, 'status', '--json').out.contains('"head_flagged":true')369}370371fn test_status_requires_repo_and_ignore_rules() {372	dir := temp_repo('status')373	defer { os.rmdir_all(dir) or {} }374	assert run(dir, 'status').code == 1375	init_repo(dir)376	write(dir, '.kohignore', '*.log\nbuild/\n')377	write(dir, 'keep.txt', 'keep\n')378	write(dir, 'ignored.log', 'ignore\n')379	write(dir, 'build/output.txt', 'ignore\n')380	assert run(dir, 'save', 'keep').code == 0381	assert run(dir, 'status').out.contains('no changes')382	assert !run(dir, 'status').out.contains('ignored.log')383	assert !run(dir, 'status').out.contains('build/output.txt')384	assert !run(dir, 'status').out.contains('LOG.md')385}386387// LOG.md is a convenience written after the save lands. If it cannot be388// written, the save still happened, and an agent that retried on a failure389// would only be told nothing had changed.390fn test_a_save_succeeds_when_log_md_cannot_be_written() {391	dir := temp_repo('logmd')392	defer { os.rmdir_all(dir) or {} }393	init_repo(dir)394	os.mkdir_all(os.join_path(dir, 'LOG.md')) or { panic(err) }395	write(dir, 'a.txt', 'one\n')396	r := run(dir, 'save', 'first', '--json')397	assert r.code == 0398	assert r.out.starts_with('{')399	assert r.err.contains('LOG.md')400	assert run(dir, 'view', '--json').out.contains('"message":"first"')401}402403// A folder of ignored files can sit where a restored file should go. Koh404// never touches ignored files, so the restore must stop and say so, not drop405// the file inside the folder under a temporary name.406fn test_a_restore_refuses_a_folder_of_ignored_files_in_the_way() {407	dir := temp_repo('dir-in-way')408	defer { os.rmdir_all(dir) or {} }409	init_repo(dir)410	write(dir, 'out', 'a file\n')411	first := run(dir, 'save', 'out is a file', '--json').out.all_after('"id":"')[..12]412	os.rm(os.join_path(dir, 'out')) or { panic(err) }413	write(dir, 'out/build.log', 'ignored\n')414	assert run(dir, 'save', 'out is gone').code == 0415	r := run(dir, 'load', first, '--yes')416	assert r.code == 1417	assert r.err.contains('out')418	assert os.ls(os.join_path(dir, 'out'))! == ['build.log']419}420421// Koh never follows a symlink, so a folder replaced by a link to somewhere422// else is not the repo's to write into: restoring through it would overwrite423// files outside the repo. The refusal comes before anything is recorded.424fn test_a_restore_never_writes_through_a_symlinked_folder() {425	dir := temp_repo('link-in-way')426	outside := temp_repo('link-target')427	defer {428		os.rmdir_all(dir) or {}429		os.rmdir_all(outside) or {}430	}431	init_repo(dir)432	write(dir, 'docs/a.md', 'saved\n')433	first := run(dir, 'save', 'docs', '--json').out.all_after('"id":"')[..12]434	os.rmdir_all(os.join_path(dir, 'docs')) or { panic(err) }435	write(outside, 'a.md', 'precious\n')436	os.symlink(outside, os.join_path(dir, 'docs')) or { panic(err) }437	assert run(dir, 'save', 'docs is a link now').code == 0438	head := run(dir, 'status', '--json').out439	r := run(dir, 'load', first, '--yes')440	assert r.code == 1441	assert r.err.contains('docs')442	assert os.read_file(os.join_path(outside, 'a.md'))! == 'precious\n'443	assert run(dir, 'status', '--json').out == head444}445446// A restore records its save first, then writes files. When the writing stops447// part way, the half-written tree is not somebody's work: saving it would448// record (and offer) a tree that undoes changes nobody asked to undo. Every449// command that would build on it points at revert, which finishes the job.450fn test_a_restore_cut_short_points_at_revert() {451	dir := temp_repo('cut-short')452	defer {453		os.chmod(os.join_path(dir, 'zz'), 0o755) or {}454		os.rmdir_all(dir) or {}455	}456	init_repo(dir)457	write(dir, 'zero', '0\n')458	assert run(dir, 'save', 'zero').code == 0459	write(dir, 'a.txt', 'v1\n')460	write(dir, 'zz/f', 'v1\n')461	assert run(dir, 'save', 'first').code == 0462	write(dir, 'a.txt', 'v2\n')463	write(dir, 'zz/f', 'v2\n')464	assert run(dir, 'save', 'second').code == 0465	// a.txt is written, then the read-only folder stops the restore: the466	// tree is genuinely half one save and half the other.467	os.chmod(os.join_path(dir, 'zz'), 0o555)!468	stopped := run(dir, 'undo', '--yes')469	assert stopped.code == 1470	assert stopped.err.contains('koh revert')471	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'v1\n'472	assert os.read_file(os.join_path(dir, 'zz/f'))! == 'v2\n'473	// Even a status that cannot read the tree says what happened.474	os.chmod(os.join_path(dir, 'zz'), 0o000)!475	assert run(dir, 'status').err.contains('koh revert')476	os.chmod(os.join_path(dir, 'zz'), 0o755)!477478	assert run(dir, 'status', '--json').out.contains('"restore_unfinished":true')479	for args in [['save', 'half'], ['checkpoint', 'half'], ['undo', '--yes']] {480		r := run(dir, ...args)481		assert r.code == 1482		assert r.err.contains('koh revert')483	}484	assert run(dir, 'revert', '--yes').code == 0485	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'v1\n'486	assert os.read_file(os.join_path(dir, 'zz/f'))! == 'v1\n'487	assert run(dir, 'status', '--json').out.contains('"restore_unfinished":false')488	write(dir, 'a.txt', 'v3\n')489	assert run(dir, 'save', 'carry on').code == 0490}491492// Doctor clears peek folders left from earlier days, never one somebody may493// be reading right now.494fn test_doctor_sweeps_only_old_peek_folders() {495	dir := temp_repo('peek-sweep')496	// V's temp_dir is /tmp on macOS whatever TMPDIR says, so these live in497	// the real temp directory under names no save could have.498	fresh := os.join_path(os.temp_dir(), 'koh-peek-fresh${os.getpid()}')499	old := os.join_path(os.temp_dir(), 'koh-peek-old${os.getpid()}')500	defer {501		os.rmdir_all(dir) or {}502		os.rmdir_all(fresh) or {}503		os.rmdir_all(old) or {}504	}505	init_repo(dir)506	write(dir, 'a.txt', 'one\n')507	assert run(dir, 'save', 'one').code == 0508	os.mkdir_all(fresh) or { panic(err) }509	os.mkdir_all(old) or { panic(err) }510	two_days_ago := time.now().unix() - 2 * 86400511	os.utime(old, two_days_ago, two_days_ago) or { panic(err) }512	assert run(dir, 'doctor', '--json').code == 0513	assert os.exists(fresh)514	assert !os.exists(old)515}516517// A file saved long ago and ignored since holds work no save has. Loading the518// old save must not write over it; the document says a restore never touches519// ignored files.520fn test_a_restore_never_overwrites_an_ignored_file() {521	dir := temp_repo('ignored-restore')522	defer { os.rmdir_all(dir) or {} }523	init_repo(dir)524	write(dir, '.env', 'KEY=saved long ago\n')525	first := run(dir, 'save', 'with env', '--json').out.all_after('"id":"')[..12]526	write(dir, '.kohignore', '.env\n')527	assert run(dir, 'save', 'ignore env').code == 0528	write(dir, '.env', 'KEY=never saved\n')529	assert run(dir, 'load', first, '--yes').code == 0530	assert os.read_file(os.join_path(dir, '.env'))! == 'KEY=never saved\n'531532	// Where the ignored file is missing, the restore still brings it back.533	other := temp_repo('ignored-restore-missing')534	defer { os.rmdir_all(other) or {} }535	init_repo(other)536	write(other, '.env', 'KEY=saved long ago\n')537	again := run(other, 'save', 'with env', '--json').out.all_after('"id":"')[..12]538	write(other, '.kohignore', '.env\n')539	assert run(other, 'save', 'ignore env').code == 0540	os.rm(os.join_path(other, '.env')) or { panic(err) }541	assert run(other, 'load', again, '--yes').code == 0542	assert os.read_file(os.join_path(other, '.env'))! == 'KEY=saved long ago\n'543}544545// A going-back preview lists paths only. Running diff(1) per file to draw it546// cost 27 s for 5,000 changed files, so it must not run diff at all.547fn test_a_going_back_preview_does_not_run_diff() {548	dir := temp_repo('preview-nodiff')549	home := temp_repo('preview-nodiff-home')550	defer {551		os.rmdir_all(dir) or {}552		os.rmdir_all(home) or {}553	}554	init_repo(dir)555	write(dir, 'a.txt', 'one\n')556	assert run_home(dir, home, 'save', 'one').code == 0557	write(dir, 'a.txt', 'two\n')558	assert run_home(dir, home, 'save', 'two').code == 0559	fake := os.join_path(home, 'bin')560	os.mkdir_all(fake) or { panic(err) }561	marker := os.join_path(home, 'diff-ran')562	os.write_file(os.join_path(fake, 'diff'), '#!/bin/sh\ntouch ${q(marker)}\nexit 2\n') or {563		panic(err)564	}565	os.chmod(os.join_path(fake, 'diff'), 0o755) or { panic(err) }566	assert run_home_with_path(dir, home, fake, 'undo', '--yes').code == 0567	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'one\n'568	assert !os.exists(marker)569}570571// A restore rewrites only what differs. Rewriting every file resets every572// mtime, so the next status has to hash the whole tree again.573fn test_a_restore_leaves_unchanged_files_alone() {574	dir := temp_repo('restore-skip')575	defer { os.rmdir_all(dir) or {} }576	init_repo(dir)577	write(dir, 'a.txt', 'one\n')578	write(dir, 'same.txt', 'never changes\n')579	assert run(dir, 'save', 'one').code == 0580	write(dir, 'a.txt', 'two\n')581	assert run(dir, 'save', 'two').code == 0582	long_ago := i64(1700000000)583	os.utime(os.join_path(dir, 'same.txt'), long_ago, long_ago) or { panic(err) }584	assert run(dir, 'undo', '--yes').code == 0585	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'one\n'586	assert os.file_last_mod_unix(os.join_path(dir, 'same.txt')) == long_ago587}588589// `save` records the executable bit, so `status` has to see it too, or a590// chmod would be invisible until it turned up in a save.591fn test_status_sees_an_executable_bit_change() {592	dir := temp_repo('chmod')593	defer { os.rmdir_all(dir) or {} }594	init_repo(dir)595	write(dir, 'run.sh', 'echo hi\n')596	assert run(dir, 'save', 'script').code == 0597	os.chmod(os.join_path(dir, 'run.sh'), 0o755) or { panic(err) }598	status := run(dir, 'status', '--json')599	assert status.out.contains('"dirty":true')600	assert status.out.contains('"modified":["run.sh"]')601}602603fn test_view_and_diff() {604	dir := temp_repo('history')605	defer { os.rmdir_all(dir) or {} }606	init_repo(dir)607	write(dir, 'a.txt', 'one\n')608	first := run(dir, 'save', 'one', '--session', 'alpha', '--json')609	id1 := first.out.all_after('"id":"')[..12]610	write(dir, 'a.txt', 'two\n')611	second := run(dir, 'save', 'two', '--session', 'beta', '--json')612	id2 := second.out.all_after('"id":"')[..12]613	cp := run(dir, 'checkpoint', 'checkpoint', '--json')614	assert cp.code == 0615	printed := run(dir, 'view')616	assert printed.code == 0617	assert printed.out.contains('▸')618	assert printed.out.contains('◐')619	lj := run(dir, 'view', '--json')620	assert lj.code == 0621	assert lj.out.contains('"head_id"')622	assert lj.out.contains('"saves"')623	assert run(dir, 'view', '--since', 'today').out.contains('two')624	session := run(dir, 'view', '--session', 'alpha')625	assert session.out.contains('one')626	assert !session.out.contains('two')627	assert run(dir, 'view', '--since', '9999-01-01').out.contains('no saves in that range')628	write(dir, 'a.txt', 'three\n')629	d := run(dir, 'diff')630	assert d.code == 0631	assert d.out.contains('--- a/')632	assert d.out.contains('+++ b/')633	assert run(dir, 'diff', id1).code == 0634	assert run(dir, 'diff', id1, id2).code == 0635	dj := run(dir, 'diff', '--json')636	assert dj.code == 0637	assert dj.out.contains('"from"')638	assert dj.out.contains('"to"')639	assert dj.out.contains('"files"')640	assert dj.out.contains('"change":"modified"')641	assert run(dir, 'diff', 'not-a-real-id').code == 1642	assert run(dir, 'diff', id1, id2, 'third').code == 1643	write(dir, 'blob.bin', '\x00\x01\x02')644	diff_binary := run(dir, 'diff', '--json')645	assert diff_binary.out.contains('"binary":true')646	assert diff_binary.out.contains('Binary files differ')647}648649fn test_undo_revert_and_load() {650	dir := temp_repo('restore')651	defer { os.rmdir_all(dir) or {} }652	init_repo(dir)653	write(dir, 'a.txt', 'one\n')654	one := run(dir, 'save', 'one', '--json').out655	id1 := one.all_after('"id":"')[..12]656	write(dir, 'a.txt', 'two\n')657	write(dir, 'gone.txt', 'gone\n')658	second := run(dir, 'save', 'two', '--json').out659	id2 := second.all_after('"id":"')[..12]660	write(dir, 'a.txt', 'three\n')661	third := run(dir, 'save', 'three', '--json').out662	id3 := third.all_after('"id":"')[..12]663	// Unsaved work — here a file never saved — blocks every going-back but664	// revert, as in Koh 2: a restore must never overwrite what only the disk has.665	write(dir, 'never.txt', 'keep me\n')666	view_before := run(dir, 'view').out667	for args in [['undo', '--yes'], ['load', id1, '--yes'], ['pluck', id2, '--yes']] {668		blocked := run(dir, ...args)669		assert blocked.code == 1670		assert blocked.err.contains('unsaved changes')671	}672	assert run(dir, 'view').out == view_before673	os.rm(os.join_path(dir, 'never.txt')) or { panic(err) }674	write(dir, 'a.txt', 'edited, never saved\n')675	assert run(dir, 'undo', '--yes').err.contains('unsaved changes')676	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'edited, never saved\n'677	write(dir, 'a.txt', 'three\n')678	os.rm(os.join_path(dir, 'gone.txt')) or { panic(err) }679	assert run(dir, 'load', id1, '--yes').err.contains('unsaved changes')680	write(dir, 'gone.txt', 'gone\n')681	undo := run(dir, 'undo', '--yes', '--json')682	assert undo.code == 0683	if !undo.out.contains(id2) {684		panic('undo JSON did not name ${id2}: ${undo.out}')685	}686	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'two\n'687	assert os.exists(os.join_path(dir, 'gone.txt'))688	assert run(dir, 'load', id3, '--yes').code == 0689	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'three\n'690	assert run(dir, 'undo', '2', '--yes').code == 0691	assert run(dir, 'load', id2, '--yes').code == 0692	assert run(dir, 'undo', '99', '--yes').err.contains('nothing before')693	write(dir, 'a.txt', 'dirty\n')694	before := run(dir, 'view')695	refuse := run(dir, 'revert')696	assert refuse.code == 1697	assert refuse.err.contains('needs --yes when not interactive')698	assert run(dir, 'view').out == before.out699	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'dirty\n'700	write(dir, 'untracked.txt', 'remove\n')701	rv := run(dir, 'revert', '--yes', '--json')702	assert rv.code == 0703	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'two\n'704	assert !os.exists(os.join_path(dir, 'untracked.txt'))705	// The way back to the discarded work is named, not left to be found.706	kept := rv.out.all_after('"checkpoint":"')[..12]707	assert run(dir, 'load', kept, '--yes').code == 0708	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'dirty\n'709	assert os.read_file(os.join_path(dir, 'untracked.txt'))! == 'remove\n'710	write(dir, 'a.txt', 'dirty again\n')711	assert run(dir, 'revert', '--yes').out.contains('koh load ')712	assert run(dir, 'revert', '--yes').out.contains('working tree already matches')713	assert run(dir, 'load', '--checkpoint', '--yes').code == 0714	assert run(dir, 'load', id2, '--json').code == 1715	assert run(dir, 'load', id2, '--json').err.contains('error')716	assert run(dir, 'load').code == 2717	assert run(dir, 'load', 'unknown-id', '--yes').code == 1718}719720fn test_flag_and_flagged_view() {721	dir := temp_repo('flag')722	defer { os.rmdir_all(dir) or {} }723	init_repo(dir)724	write(dir, 'flag.txt', 'one\n')725	saved := run(dir, 'save', 'flag me', '--json')726	id := saved.out.all_after('"id":"')[..12]727	flagged := run(dir, 'flag', id, '--reason', 'unsafe', '--json')728	assert flagged.code == 0729	assert flagged.out.contains('"flagged":true')730	assert flagged.out.contains('"reason":"unsafe"')731	list := run(dir, 'flag', '--json')732	assert list.code == 0733	assert list.out.contains(id)734	assert list.out.contains('unsafe')735	assert run(dir, 'view').out.contains('⚑')736	assert run(dir, 'flag', '--clear', id).code == 0737	assert run(dir, 'flag').out.contains('nothing is flagged')738	assert run(dir, 'flag', 'unknown-id').code == 1739	assert run(dir, 'flag').code == 0740}741742fn test_pluck_forward_reverse_dry_run_and_conflict() {743	dir := temp_repo('pluck')744	defer { os.rmdir_all(dir) or {} }745	init_repo(dir)746	write(dir, 'a.txt', 'one\n')747	first := run(dir, 'save', 'one', '--json').out748	id1 := first.all_after('"id":"')[..12]749	write(dir, 'a.txt', 'two\n')750	second := run(dir, 'save', 'two', '--json').out751	id2 := second.all_after('"id":"')[..12]752	assert run(dir, 'load', id1, '--yes').code == 0753	dry := run(dir, 'pluck', id2, '--dry-run')754	assert dry.code == 0755	assert dry.out.contains('a.txt')756	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'one\n'757	assert run(dir, 'pluck', id2, '--yes').code == 0758	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'two\n'759	assert run(dir, 'pluck', '--reverse', id2, '--yes').code == 0760	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'one\n'761	write(dir, 'a.txt', 'different\n')762	assert run(dir, 'pluck', id2, '--dry-run').code == 1763	assert run(dir, 'save', 'different').code == 0764	conflict := run(dir, 'pluck', id2, '--yes')765	assert conflict.code == 1766	assert conflict.err.contains('a.txt')767	assert run(dir, 'pluck').code == 2768	assert run(dir, 'pluck', 'unknown-id').code == 1769}770771fn test_peek_and_doctor() {772	dir := temp_repo('peek-doctor')773	defer { os.rmdir_all(dir) or {} }774	init_repo(dir)775	write(dir, 'peek.txt', 'peek me\n')776	assert run(dir, 'save', 'peekable').code == 0777	id := run(dir, 'view', '--json').out.all_after('"id":"')[..12]778	before_view := run(dir, 'view', '--json').out779	peek := run(dir, 'peek', id, '--json')780	assert peek.code == 0781	peek_path := peek.out.all_after('"path":"').before('"')782	assert peek.out.contains('"id":"${id}"')783	assert os.read_file(os.join_path(peek_path, 'peek.txt'))! == 'peek me\n'784	assert run(dir, 'status').out.contains('no changes')785	assert run(dir, 'view', '--json').out == before_view786	assert run(dir, 'peek').code == 2787	assert run(dir, 'peek', 'unknown-id').code == 1788	backup := os.join_path(dir, 'doctor.backup')789	healthy := run(dir, 'doctor')790	assert healthy.code == 0791	assert healthy.out.contains('is sound')792	report := run(dir, 'doctor', '--json')793	assert report.code == 0794	for key in ['problems', 'objects', 'saves', 'checkpoints', 'cached_files', 'peek_folders_removed',795		'backup'] {796		read_json_has(report.out, key)797	}798	backed := run(dir, 'doctor', '--backup', backup)799	assert backed.code == 0800	assert os.exists(backup)801	assert backed.out.contains(backup)802	assert run(dir, 'doctor', '--backup', backup).code == 1803	assert run(dir, 'peek', id, '--json').code == 0804	// A peek made today is left for whoever is reading it.805	kept := run(dir, 'doctor', '--json')806	assert kept.code == 0807	assert os.exists(peek_path)808	os.rmdir_all(peek_path) or {}809}810811fn test_strip_refuses_without_terminal() {812	dir := temp_repo('strip')813	defer { os.rmdir_all(dir) or {} }814	init_repo(dir)815	write(dir, 'secret.txt', 'keep\n')816	assert run(dir, 'save', 'secret').code == 0817	before_view := run(dir, 'view', '--json').out818	refused := run(dir, 'strip', 'secret.txt')819	assert refused.code == 1820	assert refused.err.contains('needs a terminal')821	assert run(dir, 'view', '--json').out == before_view822	assert os.read_file(os.join_path(dir, 'secret.txt'))! == 'keep\n'823	assert run(dir, 'view', '--json').out.contains('secret')824}825826// A whole-history strip bans the path: `.kohignore` names it, once, and the file left on disk827// is never unsaved work or part of a save again.828fn test_strip_adds_the_path_to_kohignore_and_it_stays_out() {829	dir := temp_repo('strip-ignore')830	home := temp_repo('strip-ignore-home')831	defer { os.rmdir_all(dir) or {} }832	defer { os.rmdir_all(home) or {} }833	init_repo(dir)834	write(dir, 'secret.txt', 'leaked\n')835	write(dir, 'keep.txt', 'fine\n')836	assert run_home(dir, home, 'save', 'leak').code == 0837	stripped := run_pty_home(dir, home, ['y', 'secret.txt'], 'strip', 'secret.txt')838	assert stripped.code == 0, stripped.out839	assert stripped.out.contains('added /secret.txt to .kohignore')840	ignore_path := os.join_path(dir, '.kohignore')841	assert os.read_file(ignore_path)!.split_into_lines().filter(it == '/secret.txt').len == 1842	assert run_home(dir, home, 'save', 'ignore the stripped secret').code == 0843	write(dir, 'secret.txt', 'leaked again\n')844	assert run_home(dir, home, 'status', '--json').out.contains('"dirty":false')845	// Running the strip again (with no remote, it stays pending) adds no second line.846	again := run_pty_home(dir, home, [], 'strip', 'secret.txt')847	assert again.code == 0, again.out848	assert os.read_file(ignore_path)!.split_into_lines().filter(it == '/secret.txt').len == 1849}850851// `koh view` is the one way into the history: the whole line by default,852// checkpoints alone with the flag, and the two lists never overlap.853fn test_view_shows_the_line_and_checkpoints_apart() {854	dir := temp_repo('view')855	defer { os.rmdir_all(dir) or {} }856	init_repo(dir)857	write(dir, 'view.txt', 'one\n')858	assert run(dir, 'save', 'plain save').code == 0859	assert run(dir, 'checkpoint', 'checkpoint save').code == 0860	line := run(dir, 'view')861	assert line.code == 0862	assert line.out.contains('plain save')863	assert line.out.contains('checkpoint save')864	checkpoints := run(dir, 'view', '--checkpoints')865	assert checkpoints.code == 0866	assert checkpoints.out.contains('checkpoint save')867	assert !checkpoints.out.contains('plain save')868	json_line := run(dir, 'view', '--json')869	assert json_line.code == 0870	assert json_line.out.contains('"is_checkpoint":false')871	assert json_line.out.contains('"is_checkpoint":true')872	json_checkpoints := run(dir, 'view', '--checkpoints', '--json')873	assert json_checkpoints.code == 0874	assert json_checkpoints.out.contains('"is_checkpoint":true')875	assert !json_checkpoints.out.contains('"is_checkpoint":false')876	// `view` takes no arguments, so a stray one is a usage error, and the names877	// it replaced are gone rather than hidden: the diagnostic says which.878	assert run(dir, 'view', 'extra').code == 2879	for gone in ['log', 'saves', 'checkpoints'] {880		refused := run(dir, gone)881		assert refused.code == 2882		assert refused.err.contains('unknown command "${gone}"')883	}884	// Every save is on the whole line exactly once, as the JSON says.885	assert line.out.split_into_lines().len == json_line.out.count('"id":"')886}887888fn test_remote_configuration_is_isolated_and_atomic() {889	dir := temp_repo('remote')890	home := temp_repo('remote-home')891	defer {892		os.rmdir_all(dir) or {}893		os.rmdir_all(home) or {}894	}895	empty := run_home(dir, home, 'remote', '--json')896	assert empty.code == 0897	assert empty.out.contains('"configured":false')898	target := os.join_path(home, 'remote-store')899	set := run_home(dir, home, 'remote', 'folder', target)900	assert set.code == 0901	assert os.is_dir(target)902	state := run_home(dir, home, 'remote', '--json')903	assert state.code == 0904	assert state.out.contains('"kind":"folder"')905	assert state.out.contains(target)906	assert run_home(dir, home, 'remote', 's3', 'http://127.0.0.1:1', 'bucket', 'region').code == 1907	assert run_home(dir, home, 'remote', '--json').out.contains(target)908	assert run_home(dir, home, 'remote', 's3', 'http://127.0.0.1:1', 'bucket', 'region').err.contains('KOH_ACCESS_KEY')909	assert run_home(dir, home, 'remote', '--forget').code == 0910	assert run_home(dir, home, 'remote', '--json').out.contains('"configured":false')911}912913// The files under ~/.config/koh can be written by hand instead of by914// `koh remote`, and are then read the same way.915fn test_remote_written_by_hand() {916	dir := temp_repo('remote-by-hand')917	home := temp_repo('remote-by-hand-home')918	defer {919		os.rmdir_all(dir) or {}920		os.rmdir_all(home) or {}921	}922	config := os.join_path(home, '.config', 'koh')923	os.mkdir_all(config) or { panic(err) }924	target := os.join_path(home, 'remote-store')925	os.mkdir_all(target) or { panic(err) }926	os.write_file(os.join_path(config, 'remote'), 'kind = folder\npath = ${target}\n') or {927		panic(err)928	}929	assert run_home(dir, home, 'init').code == 0930	os.write_file(os.join_path(dir, 'a.txt'), 'a\n') or { panic(err) }931	assert run_home(dir, home, 'save', 'first').code == 0932	offered := run_home(dir, home, 'offer', '--json')933	assert offered.code == 0934	assert offered.out.contains('"head"')935936	// Keys anyone else can read are refused before they are ever sent.937	os.write_file(os.join_path(config, 'remote'), 'kind=s3\nendpoint=http://127.0.0.1:1\nbucket=b\nregion=r\n') or {938		panic(err)939	}940	credentials := os.join_path(config, 'credentials')941	os.write_file(credentials, 'access_key=AK\nsecret_key=SK\n') or { panic(err) }942	os.chmod(credentials, 0o644) or { panic(err) }943	loose := run_home(dir, home, 'offer')944	assert loose.code == 1945	assert loose.err.contains('chmod 600')946947	// A setting koh cannot read is replaced by setting the remote again.948	os.write_file(os.join_path(config, 'remote'), 'kind=ftp\n') or { panic(err) }949	unreadable := run_home(dir, home, 'offer')950	assert unreadable.code == 1951	assert unreadable.err.contains('not readable')952	assert run_home(dir, home, 'remote', 'folder', target).code == 0953	assert run_home(dir, home, 'offer').code == 0954}955956// A stolen repo belongs to the repo it was stolen from, whatever its folder is957// called later: renaming it must not start a second repo on the remote.958fn test_a_renamed_stolen_repo_keeps_offering_to_its_repo() {959	syncroot := temp_repo('rename-steal')960	home := temp_repo('rename-steal-home')961	defer {962		os.rmdir_all(syncroot) or {}963		os.rmdir_all(home) or {}964	}965	remote := os.join_path(syncroot, 'remote')966	a := os.join_path(syncroot, 'A', 'proj')967	b_parent := os.join_path(syncroot, 'B')968	os.mkdir_all(a) or { panic(err) }969	os.mkdir_all(b_parent) or { panic(err) }970	init_repo(a)971	write(a, 'a.txt', 'from A\n')972	assert run_home(a, home, 'remote', 'folder', remote).code == 0973	assert run_home(a, home, 'save', 'A first').code == 0974	assert run_home(b_parent, home, 'steal', 'proj').code == 0975	renamed := os.join_path(b_parent, 'renamed')976	os.mv(os.join_path(b_parent, 'proj'), renamed) or { panic(err) }977	write(renamed, 'b.txt', 'from B\n')978	assert run_home(renamed, home, 'save', 'B first').code == 0979	assert !os.exists(os.join_path(remote, 'renamed'))980	assert run_home(a, home, 'steal').code == 0981	assert os.read_file(os.join_path(a, 'b.txt'))! == 'from B\n'982}983984// A damaged object on the remote stops a steal, names the object, and leaves985// no half-made folder that would make the retry refuse.986fn test_steal_of_a_damaged_remote_leaves_nothing() {987	syncroot := temp_repo('damaged')988	home := temp_repo('damaged-home')989	defer {990		os.rmdir_all(syncroot) or {}991		os.rmdir_all(home) or {}992	}993	remote := os.join_path(syncroot, 'remote')994	a := os.join_path(syncroot, 'A', 'proj')995	b_parent := os.join_path(syncroot, 'B')996	os.mkdir_all(a) or { panic(err) }997	os.mkdir_all(b_parent) or { panic(err) }998	init_repo(a)999	write(a, 'a.txt', 'from A\n')1000	assert run_home(a, home, 'remote', 'folder', remote).code == 01001	assert run_home(a, home, 'save', 'A first').code == 01002	objects := os.join_path(remote, 'proj', 'objects')1003	for name in os.ls(objects) or { panic(err) } {1004		os.chmod(os.join_path(objects, name), 0o644) or {}1005		os.write_file(os.join_path(objects, name), 'junk') or { panic(err) }1006	}1007	stolen := run_home(b_parent, home, 'steal', 'proj')1008	assert stolen.code == 11009	assert stolen.err.contains('is damaged')1010	assert !os.exists(os.join_path(b_parent, 'proj'))1011}10121013fn test_offer_steal_folder_remote() {1014	syncroot := temp_repo('sync')1015	home := temp_repo('sync-home')1016	defer {1017		os.rmdir_all(syncroot) or {}1018		os.rmdir_all(home) or {}1019	}1020	remote := os.join_path(syncroot, 'remote')1021	a := os.join_path(syncroot, 'A', 'proj')1022	b_parent := os.join_path(syncroot, 'B')1023	os.mkdir_all(a) or { panic(err) }1024	os.mkdir_all(b_parent) or { panic(err) }1025	init_repo(a)1026	write(a, 'a.txt', 'from A\n')1027	assert run_home(a, home, 'remote', 'folder', remote).code == 01028	assert run_home(a, home, 'save', 'A first').code == 01029	stolen := run_home(b_parent, home, 'steal', 'proj')1030	assert stolen.code == 01031	b := os.join_path(b_parent, 'proj')1032	assert os.read_file(os.join_path(b, 'a.txt'))! == 'from A\n'1033	write(b, 'b.txt', 'from B\n')1034	assert run_home(b, home, 'save', 'B first').code == 01035	write(a, 'a2.txt', 'second\n')1036	assert run_home(a, home, 'save', 'A second').code == 01037	assert run_home(a, home, 'steal').code == 01038	assert os.exists(os.join_path(a, 'b.txt'))1039	assert run_home(b_parent, home, 'steal', '--list').out.contains('proj')1040	write(a, 'clash.txt', 'base\n')1041	assert run_home(a, home, 'save', 'clash base').code == 01042	assert run_home(b, home, 'steal').code == 01043	write(a, 'clash.txt', 'A version\n')1044	assert run_home(a, home, 'save', 'A clash').code == 01045	write(b, 'clash.txt', 'B version\n')1046	assert run_home(b, home, 'save', 'B clash').code == 01047	refused := run_home(b, home, 'steal')1048	assert refused.code == 11049	assert refused.err.contains('--mine') || refused.err.contains('--theirs')1050	b_head := run_home(b, home, 'status', '--json').out.all_after('"head_id":"')[..12]1051	theirs := run_home(b, home, 'steal', '--theirs', '--json')1052	assert theirs.code == 01053	// The pre-combine tree is off the line now; the way back must be named,1054	// or an agent without the history view cannot find it.1055	assert theirs.out.contains('"previous_head":"${b_head}"')1056	assert theirs.out.contains('"kept_versions":["clash.txt:${b_head}"]')1057	assert os.read_file(os.join_path(b, 'clash.txt'))! == 'A version\n'1058	assert run_home(b, home, 'load', b_head, '--yes').code == 01059	assert os.read_file(os.join_path(b, 'clash.txt'))! == 'B version\n'1060	assert run_home(b, home, 'load', theirs.out.all_after('"head":"')[..12], '--yes').code == 01061	assert os.read_file(os.join_path(b, 'clash.txt'))! == 'A version\n'1062	write(a, 'clash.txt', 'A second\n')1063	assert run_home(a, home, 'save', 'A second clash').code == 01064	write(b, 'clash.txt', 'B second\n')1065	assert run_home(b, home, 'save', 'B second clash').code == 01066	assert run_home(b, home, 'steal', '--mine').code == 01067	assert os.read_file(os.join_path(b, 'clash.txt'))! == 'B second\n'1068	assert run_home(b, home, 'view').out.contains('combine: kept mine for')1069}10701071fn test_guided_steal_walks_the_terminal_and_can_cancel() {1072	syncroot := temp_repo('guided-steal')1073	home := temp_repo('guided-steal-home')1074	defer {1075		os.rmdir_all(syncroot) or {}1076		os.rmdir_all(home) or {}1077	}1078	remote := os.join_path(syncroot, 'remote')1079	a := os.join_path(syncroot, 'A', 'proj')1080	b_parent := os.join_path(syncroot, 'B')1081	os.mkdir_all(a) or { panic(err) }1082	os.mkdir_all(b_parent) or { panic(err) }1083	init_repo(a)1084	write(a, 'clash.txt', 'base\n')1085	write(a, 'other.txt', 'base\n')1086	write(a, 'same.txt', 'base\n')1087	write(a, 'remote-only.txt', 'base\n')1088	write(a, 'local-only.txt', 'base\n')1089	assert run_home(a, home, 'remote', 'folder', remote).code == 01090	assert run_home(a, home, 'save', 'base').code == 01091	assert run_home(b_parent, home, 'steal', 'proj').code == 01092	b := os.join_path(b_parent, 'proj')10931094	write(b, 'dirty.txt', 'mine\n')1095	before := run_home(b, home, 'status', '--json').out1096	quit := run_pty_home(b, home, ['q'], 'steal')1097	assert quit.out.contains('steal proj')1098	assert quit.out.contains('you have 1 unsaved file')1099	assert quit.out.contains('dirty.txt')1100	assert run_home(b, home, 'status', '--json').out == before1101	// A save needs a message; an empty one stops, says so, and saves nothing.1102	unsaid := run_pty_home(b, home, ['s', ''], 'steal')1103	assert unsaid.code == 11104	assert unsaid.out.contains('no message — nothing was saved')1105	assert run_home(b, home, 'status', '--json').out == before1106	checkpoint := run_pty_home(b, home, ['c'], 'steal')1107	assert checkpoint.code == 0, checkpoint.err1108	assert run_home(b, home, 'view', '--checkpoints').out.contains('before steal')11091110	assert run_home(a, home, 'steal').code == 01111	write(a, 'forward.txt', 'new\n')1112	assert run_home(a, home, 'save', 'fast forward').code == 01113	forward := run_pty_home(b, home, []string{}, 'steal')1114	assert forward.out.contains('proj is up to date · 1 new save')1115	assert forward.out.split_into_lines().filter(it.trim_space() != '').len == 11116	write(a, 'clash.txt', 'remote\n')1117	write(a, 'other.txt', 'remote\n')1118	write(a, 'same.txt', 'identical\n')1119	write(a, 'remote-only.txt', 'remote\n')1120	assert run_home(a, home, 'save', 'remote change').code == 01121	write(b, 'clash.txt', 'mine\n')1122	write(b, 'other.txt', 'mine\n')1123	write(b, 'same.txt', 'identical\n')1124	write(b, 'local-only.txt', 'mine\n')1125	assert run_home(b, home, 'save', 'local change').code == 01126	local_head := run_home(b, home, 'status', '--json').out.all_after('"head_id":"')[..12]1127	// `d` opens both changes in the pager, which Enter leaves; `?` explains the two sides.1128	cancel := run_pty_home(b, home, ['d', '', '?', 'm', 'b', 't', 't', 'n'], 'steal')1129	assert cancel.out.contains('your changes')1130	assert cancel.out.contains('remote changes')1131	assert cancel.out.contains('Nothing is lost either way')1132	// The shared save's age, relative: seconds old here, so `now` unless the machine is slow.1133	since := cancel.out.split_into_lines().filter(it.contains('both moved since'))1134	assert since.len == 11135	assert since[0].trim_space().ends_with(' · now') || since[0].trim_space().ends_with(' ago'), since[0]1136	assert cancel.out.contains('5 files changed')1137	assert cancel.out.contains('2 combine by themselves')1138	assert cancel.out.contains('1 changed the same way')1139	assert cancel.out.contains('2 need you')1140	assert cancel.out.contains('ready to combine')1141	assert run_home(b, home, 'status', '--json').out.contains('"head_id":"${local_head}"')1142	assert os.read_file(os.join_path(b, 'clash.txt'))! == 'mine\n'11431144	done := run_pty_home(b, home, ['y'], 'steal', '--theirs')1145	assert done.out.contains('combined · offered to proj')1146	assert done.out.contains('took theirs: clash.txt · other.txt')1147	assert !done.out.contains('kept mine')1148	assert done.out.contains('to undo all of it: koh load ${local_head}')1149	assert done.out.contains('your clash.txt is in ${local_head}')1150	assert !done.out.contains('\x1b')1151	for line in done.out.split_into_lines() {1152		assert line.runes().len <= 80, line1153	}1154}11551156// A steal brings in the whole history, flags included; both output forms must1157// say which saves came in flagged, and why.1158fn test_a_steal_reports_flagged_saves() {1159	syncroot := temp_repo('steal-flags')1160	home := temp_repo('steal-flags-home')1161	defer {1162		os.rmdir_all(syncroot) or {}1163		os.rmdir_all(home) or {}1164	}1165	a := os.join_path(syncroot, 'A', 'proj')1166	os.mkdir_all(a) or { panic(err) }1167	init_repo(a)1168	assert run_home(a, home, 'remote', 'folder', os.join_path(syncroot, 'remote')).code == 01169	write(a, 'a.txt', 'one\n')1170	id := run_home(a, home, 'save', 'risky', '--json').out.all_after('"id":"')[..12]1171	assert run_home(a, home, 'flag', id, '--reason', 'broke the build').code == 01172	assert run_home(a, home, 'offer').code == 01173	for name in ['B', 'C'] {1174		os.mkdir_all(os.join_path(syncroot, name)) or { panic(err) }1175	}1176	json_stolen := run_home(os.join_path(syncroot, 'B'), home, 'steal', 'proj', '--json')1177	assert json_stolen.code == 01178	assert json_stolen.out.contains('"flagged":["${id}"]')1179	text_stolen := run_home(os.join_path(syncroot, 'C'), home, 'steal', 'proj')1180	assert text_stolen.code == 01181	assert text_stolen.out.contains('[${id}] came in flagged — broke the build')1182}11831184// A folder remote on a disk or share that is not mounted is simply not there.1185// Creating it would put the saves in a stand-in folder the other machine never1186// sees; the offer must say what is wrong instead.1187fn test_an_unmounted_folder_remote_is_not_recreated() {1188	syncroot := temp_repo('unmounted')1189	home := temp_repo('unmounted-home')1190	defer {1191		os.rmdir_all(syncroot) or {}1192		os.rmdir_all(home) or {}1193	}1194	mount := os.join_path(syncroot, 'nas')1195	remote := os.join_path(mount, 'koh')1196	a := os.join_path(syncroot, 'proj')1197	os.mkdir_all(a) or { panic(err) }1198	init_repo(a)1199	assert run_home(a, home, 'remote', 'folder', remote).code == 01200	write(a, 'a.txt', 'one\n')1201	assert run_home(a, home, 'save', 'first').code == 01202	os.rename(mount, os.join_path(syncroot, 'nas-unplugged')) or { panic(err) }1203	os.mkdir(mount) or { panic(err) }1204	offered := run_home(a, home, 'offer')1205	assert offered.code == 11206	assert offered.err.contains('mounted')1207	assert !os.exists(remote)1208	write(a, 'a.txt', 'two\n')1209	saved := run_home(a, home, 'save', 'second')1210	assert saved.code == 01211	assert saved.out.contains('mounted')1212	assert !os.exists(remote)1213}12141215fn test_man_and_koh2_handoff() {1216	dir := temp_repo('man')1217	home := temp_repo('man-home')1218	defer {1219		os.rmdir_all(dir) or {}1220		os.rmdir_all(home) or {}1221	}1222	whole := run_home(dir, home, 'man')1223	assert whole.code == 01224	assert whole.out.contains('NAME')1225	assert whole.out.contains('COMMANDS')1226	assert whole.out.contains('STRICT KOH DISCIPLINE')1227	assert !whole.out.contains('\x1b') && !whole.out.contains('◆')1228	strip := run_home(dir, home, 'man', 'strip')1229	assert strip.code == 01230	assert strip.out.contains('strip')1231	assert !strip.out.contains('koh save ')1232	steal := run_home(dir, home, 'man', 'steal').out1233	assert steal.starts_with('    koh steal') && steal.contains('koh steal my-project')1234	assert run_home(dir, home, 'man', 'init').out.trim_space() == "koh init\n        Create `.koh` here, and a starter `.kohignore` if there isn't one."1235	assert run_home(dir, home, 'man', 'nonsense').code == 21236	legacy := temp_repo('legacy')1237	defer { os.rmdir_all(legacy) or {} }1238	os.mkdir_all(os.join_path(legacy, '.koh')) or { panic(err) }1239	fake := os.join_path(home, 'bin')1240	os.mkdir_all(fake) or { panic(err) }1241	fake_koh := os.join_path(fake, 'koh2')1242	os.write_file(fake_koh, '#!/bin/sh\nprintf "handoff:%s\\n" "$*"\nexit 7\n') or { panic(err) }1243	os.chmod(fake_koh, 0o755) or { panic(err) }1244	handoff := run_home_with_path(legacy, home, fake, 'status', '--json')1245	assert handoff.code == 71246	assert handoff.out.contains('handoff:status --json')1247	// One notice line, on stderr, so koh2's own output stays as it was.1248	assert handoff.err.contains('Koh 2 repo')1249	assert handoff.err.trim_space().split_into_lines().len == 11250	assert handoff.out.trim_space() == 'handoff:status --json'1251}12521253fn run_home_with_path(repo string, home string, bin_dir string, args ...string) Result {1254	stamp := '${os.getpid()}-${time.now().unix_nano()}'1255	base := os.join_path(os.temp_dir(), 'koh3-cli-${stamp}')1256	out_path := '${base}.out'1257	err_path := '${base}.err'1258	code_path := '${base}.code'1259	mut command := 'HOME=${q(home)} PATH=${q(bin_dir + ':' + os.getenv('PATH'))} ${q(binary)}'1260	for arg in args {1261		command += ' ${q(arg)}'1262	}1263	shell := 'cd ${q(repo)} && ${command} </dev/null >${q(out_path)} 2>${q(err_path)}; printf "%s" \$? >${q(code_path)}'1264	result := os.execute(shell)1265	if result.exit_code != 0 {1266		panic('could not run test command: ${result.output}')1267	}1268	code := os.read_file(code_path) or { panic(err) }1269	out := os.read_file(out_path) or { '' }1270	err := os.read_file(err_path) or { '' }1271	os.rm(out_path) or {}1272	os.rm(err_path) or {}1273	os.rm(code_path) or {}1274	return Result{1275		code: code.int()1276		out:  out1277		err:  err1278	}1279}12801281// --- migration -------------------------------------------------------------12821283fn koh2_binary() string {1284	return os.find_abs_path_of_executable('koh') or { '' }1285}12861287// run_koh2 runs the Koh 2 binary in a fixture; its own output is not under1288// test here.1289fn run_koh2(dir string, command string) {1290	os.execute('cd ${q(dir)} && ${command} >/dev/null 2>&1')1291}12921293fn save_ids(dir string) []string {1294	mut ids := []string{}1295	for name in os.ls(os.join_path(dir, '.koh', 'snapshots')) or { []string{} } {1296		if name.ends_with('.json') {1297			ids << name.trim_right('.json')1298		}1299	}1300	ids.sort()1301	return ids1302}13031304fn test_migrate_converts_a_koh2_repo_and_keeps_every_save() {1305	koh2 := koh2_binary()1306	if koh2 == '' {1307		println('skipping the migration tests: koh (Koh 2) is not on PATH')1308		return1309	}1310	dir := temp_repo('migrate')1311	defer { os.rmdir_all(dir) or {} }1312	home := temp_repo('migrate-home')1313	defer { os.rmdir_all(home) or {} }1314	run_koh2(dir, '${q(koh2)} init')1315	// One file large enough to be an object, one small enough to be inlined.1316	write(dir, 'code.txt', 'x'.repeat(700))1317	write(dir, 'tiny.txt', 'tiny\n')1318	run_koh2(dir, '${q(koh2)} save "first save"')1319	run_koh2(dir, '${q(koh2)} checkpoint "before something"')1320	write(dir, 'code.txt', 'y'.repeat(700))1321	run_koh2(dir, '${q(koh2)} save "second save"')1322	original := save_ids(dir)1323	assert original.len == 313241325	report := run_home(dir, home, 'migrate')1326	assert report.code == 01327	assert report.out.contains('migrated 3 saves')1328	// The swap: `.koh` is a file, the old data is archived, nothing is left in the draft.1329	assert os.is_file(os.join_path(dir, '.koh'))1330	assert os.is_dir(os.join_path(dir, '.koh-v2'))1331	assert os.is_file(os.join_path(dir, '.kohignore'))1332	assert !os.exists(os.join_path(dir, '.koh-migrate'))13331334	// Every save kept its original ID, and the new repo is sound.1335	listed := run_home(dir, home, 'view', '--json')1336	assert listed.code == 01337	for id in original {1338		assert listed.out.contains(id)1339	}1340	assert run_home(dir, home, 'doctor').code == 01341	assert run_home(dir, home, 'status').code == 013421343	// Migrating again has nothing to convert.1344	assert run_home(dir, home, 'migrate').code == 11345}13461347fn test_migrate_refuses_a_tree_that_does_not_match_the_last_save() {1348	koh2 := koh2_binary()1349	if koh2 == '' {1350		return1351	}1352	dir := temp_repo('migrate-dirty')1353	defer { os.rmdir_all(dir) or {} }1354	home := temp_repo('migrate-dirty-home')1355	defer { os.rmdir_all(home) or {} }1356	run_koh2(dir, '${q(koh2)} init')1357	write(dir, 'code.txt', 'x'.repeat(700))1358	run_koh2(dir, '${q(koh2)} save "only save"')1359	write(dir, 'code.txt', 'unsaved change\n')13601361	refused := run_home(dir, home, 'migrate')1362	assert refused.code == 11363	assert refused.err.contains('save with koh2 first')1364	// Nothing moved: still Koh 2, no archive, no draft file.1365	assert os.is_dir(os.join_path(dir, '.koh'))1366	assert !os.exists(os.join_path(dir, '.koh-v2'))1367	assert !os.exists(os.join_path(dir, '.koh-migrate'))1368}13691370// Koh 2 never saved a root `.kohconfig`, root `.kohignore.<remote>` rules or1371// `*.bundle` files, so a clean Koh 2 repo may hold them. Most real repos have1372// a `.kohconfig`; migrate must not call them unsaved work.1373fn test_migrate_passes_over_the_files_koh2_never_saved() {1374	koh2 := koh2_binary()1375	if koh2 == '' {1376		return1377	}1378	dir := temp_repo('migrate-koh2-ignores')1379	defer { os.rmdir_all(dir) or {} }1380	home := temp_repo('migrate-koh2-ignores-home')1381	defer { os.rmdir_all(home) or {} }1382	run_koh2(dir, '${q(koh2)} init')1383	write(dir, 'code.txt', 'x'.repeat(700))1384	run_koh2(dir, '${q(koh2)} save "only save"')1385	write(dir, '.kohconfig', 'stable_days = 14\n')1386	write(dir, '.kohignore.public', 'private/\n')1387	write(dir, 'lib/app.bundle', 'bundle\n')1388	write(dir, 'ios/Settings.bundle/Root.plist', 'settings\n')1389	// Koh 2 keeps saving a file under a folder pattern added later, where1390	// Koh 3 reads the same rule as covering the folder: the saved file is on1391	// disk and matches, so the tree is clean.1392	write(dir, 'native/t.dSYM/Info.plist', 'plist\n')1393	run_koh2(dir, '${q(koh2)} save --agent test --session test "add the dsym"')1394	// Koh 2 skips *.bundle even when its rules no longer list it.1395	ignore_path := os.join_path(dir, '.koh', 'ignore')1396	rules := os.read_file(ignore_path)!.split_into_lines().filter(it != '*.bundle')1397	os.write_file(ignore_path, rules.join('\n') + '\nnative/*.dSYM\n')!1398	// A saved file the walk skips still has to match what was saved.1399	write(dir, 'native/t.dSYM/Info.plist', 'changed\n')1400	changed := run_home(dir, home, 'migrate')1401	assert changed.code == 11402	assert changed.err.contains('native/t.dSYM/Info.plist does not match')1403	write(dir, 'native/t.dSYM/Info.plist', 'plist\n')1404	assert os.execute('cd ${q(dir)} && ${q(koh2)} status --json').output.contains('"dirty":false')14051406	migrated := run_home(dir, home, 'migrate')1407	assert migrated.code == 0, migrated.err1408	// They stay where they were, for the user to keep or delete.1409	assert os.read_file(os.join_path(dir, '.kohconfig'))! == 'stable_days = 14\n'1410}14111412struct FakeKepr {1413	no_access bool1414	// One reply the redemption must cope with: '500', 'garbage' or 'incomplete'.1415	fail string1416	// When set, /api/connect answers 307 here instead of a code reply.1417	redirect_to string1418mut:1419	objects map[string][]u81420	// What the client asked for. A map, because the server holds its own copy of this struct.1421	seen map[string]string1422}14231424fn (mut h FakeKepr) handle(req http.Request) http.Response {1425	if req.method == .post && req.url == '/api/connect' {1426		h.seen['code'] = req.data1427		if h.redirect_to != '' {1428			return http.Response{1429				status_code: 3071430				status_msg:  'Temporary Redirect'1431				header:      http.new_header(1432					key:   .location1433					value: h.redirect_to1434				)1435			}1436		}1437		if h.fail == '500' {1438			return http.Response{ status_code: 500, status_msg: 'Internal Server Error' }1439		}1440		if h.fail == 'garbage' {1441			return http.Response{ status_code: 200, status_msg: 'OK', body: 'not json at all' }1442		}1443		if h.fail == 'incomplete' {1444			return http.Response{ status_code: 200, status_msg: 'OK', body: '{"endpoint":"http://x","bucket":"","region":"","access_key_id":"","secret_access_key":""}' }1445		}1446		if req.data == 'code=good' && !h.no_access {1447			return http.Response{ status_code: 200, status_msg: 'OK', body: '{"endpoint":"http://${req.header.get_custom('Host', http.HeaderQueryConfig{}) or { '' }}","bucket":"bucket","region":"test","access_key_id":"access","secret_access_key":"secret"}' }1448		}1449		return http.Response{ status_code: 404, status_msg: 'Not Found', body: '{"error":"no_code","message":"no code"}' }1450	}1451	if req.method == .get && req.url.starts_with('/connect') {1452		h.seen['connect'] = req.url1453		return http.Response{ status_code: if h.no_access { 404 } else { 302 }, status_msg: 'Found' }1454	}1455	key := req.url1456	if key.starts_with('/bucket/') {1457		match req.method {1458			.put {1459				if req.header.get_custom('If-None-Match', http.HeaderQueryConfig{}) or { '' } == '*' && key in h.objects {1460					return http.Response{ status_code: 412, status_msg: 'Precondition Failed' }1461				}1462				h.objects[key] = req.data.bytes()1463				return http.Response{ status_code: 200, status_msg: 'OK' }1464			}1465			.get {1466				if body := h.objects[key] {1467					return http.Response{1468						status_code: 2001469						status_msg:  'OK'1470						body:        body.bytestr()1471						header:      http.new_header(1472							key:   .etag1473							value: '"tag"'1474						)1475					}1476				}1477				return http.Response{ status_code: 404, status_msg: 'Not Found' }1478			}1479			.delete {1480				h.objects.delete(key)1481				return http.Response{ status_code: 204, status_msg: 'No Content' }1482			}1483			else {}1484		}1485	}1486	return http.Response{ status_code: 404, status_msg: 'Not Found' }1487}14881489fn start_fake_kepr(no_access bool, fail string, redirect_to string) !(int, &http.Server, &FakeKepr) {1490	for port in 19401 .. 19411 {1491		listener := net.listen_tcp(.ip, '127.0.0.1:${port}') or { continue }1492		fake := &FakeKepr{1493			no_access:   no_access1494			fail:        fail1495			redirect_to: redirect_to1496			seen:        map[string]string{}1497		}1498		mut server := &http.Server{1499			listener:             listener1500			handler:              fake1501			show_startup_message: false1502		}1503		spawn server.listen_and_serve()1504		server.wait_till_running()!1505		return port, server, fake1506	}1507	return error('no free fake Kepr port')1508}15091510// A slash makes an argument an address, so half an address is an error and never a repo name.1511fn test_steal_refuses_an_address_that_is_not_one() {1512	outside := temp_repo('steal-address')1513	home := temp_repo('steal-address-home')1514	defer { os.rmdir_all(outside) or {} }1515	defer { os.rmdir_all(home) or {} }1516	// The repo half becomes a URL path segment and a folder here, so it is a name Kepr serves.1517	for bad in ['kepr.uk/', '/shipped', 'kepr.uk/..', 'kepr.uk/.', 'kepr.uk/a b', 'kepr.uk/nina?x',1518		'kepr.uk/nina#x', 'kepr.uk/nína'] {1519		refused := run_home(outside, home, 'steal', bad)1520		assert refused.code == 1, bad1521		assert refused.err.contains('is not <host>/<repo>'), '${bad}: ${refused.err}'1522	}1523	assert run_home(outside, home, 'steal', 'one', 'two').code == 21524	assert run_home(outside, home, 'steal', '--list', 'extra').code == 21525}15261527fn test_remote_kepr_saves_and_refuses_without_changes() {1528	repo := temp_repo('kepr')1529	home := temp_repo('kepr-home')1530	defer { os.rmdir_all(repo) or {} }1531	defer { os.rmdir_all(home) or {} }1532	init_repo(repo)1533	port, mut server, fake := start_fake_kepr(false, '', '')!1534	defer { server.stop() }1535	host := 'http://127.0.0.1:${port}'1536	// A trailing slash is the same host, and the saved line keeps the normalised form.1537	good := run_home(repo, home, 'remote', '${host}/', '--code', 'good')1538	assert good.code == 0, good.err1539	remote_path := os.join_path(home, '.config', 'koh', 'remote')1540	credentials_path := os.join_path(home, '.config', 'koh', 'credentials')1541	assert os.read_file(remote_path)! == '# written by koh remote — the remote for every repo on this machine\nkind=s3\nendpoint=${host}\nbucket=bucket\nregion=test\nkepr=${host}\n'1542	assert os.read_file(credentials_path)! == '# written by koh remote — keep this file private\naccess_key=access\nsecret_key=secret\n'1543	// The code went as a form field, and the connect page was never asked for: there was a code.1544	assert (fake.seen['code'] or { '' }) == 'code=good'1545	assert (fake.seen['connect'] or { '' }) == ''1546	// A refused code, a missing terminal and a wrong reply all leave both files as they were.1547	before := os.read_file(remote_path)!1548	before_keys := os.read_file(credentials_path)!1549	bad := run_home(repo, home, 'remote', host, '--code', 'bad')1550	assert bad.code == 11551	assert bad.err.contains('wrong or has expired')1552	// The 404 could also mean a Kepr that hands out nothing, so the connect page is asked for1553	// with this machine's name. (This machine's name holds no character needing an escape, so1554	// that part of the query cannot be exercised here.)1555	// `machine.name()` is `os.hostname() or { 'unknown' }`, so the query carries the same text.1556	assert (fake.seen['connect'] or { '' }).contains('machine=${os.hostname() or { 'unknown' }}')1557	no_terminal := run_home(repo, home, 'remote', host)1558	assert no_terminal.code == 11559	assert no_terminal.err.contains('needs a terminal')1560	assert os.read_file(remote_path)! == before1561	assert os.read_file(credentials_path)! == before_keys1562}15631564fn test_remote_kepr_refuses_hosts_that_are_not_hosts() {1565	repo := temp_repo('kepr-host')1566	home := temp_repo('kepr-host-home')1567	defer { os.rmdir_all(repo) or {} }1568	defer { os.rmdir_all(home) or {} }1569	init_repo(repo)1570	for host in ['kepr.uk/foo', 'https://kepr.uk?x=1', 'kepr.uk#frag', '[email protected]', 'kepr uk',1571		'http://127.0.0.1:1/foo', 'https://'] {1572		refused := run_home(repo, home, 'remote', host, '--code', 'good')1573		assert refused.code == 1, host1574		assert refused.err.contains('is not a Kepr address'), '${host}: ${refused.err}'1575	}1576	// The reply carries the bucket's secret key, so plain http is only for this machine's own Kepr.1577	for host in ['http://kepr.uk', 'http://10.0.0.2:3000', 'http://KEPR.uk:80'] {1578		refused := run_home(repo, home, 'remote', host, '--code', 'good')1579		assert refused.code == 1, host1580		assert refused.err.contains('needs https'), '${host}: ${refused.err}'1581		stolen := run_home(home, home, 'steal', '${host}/nina')1582		assert stolen.code == 1, host1583		assert stolen.err.contains('needs https'), '${host}: ${stolen.err}'1584	}1585	// --code belongs to the host form alone.1586	assert run_home(repo, home, 'remote', 's3', 'https://x', 'b', 'r', '--code', 'good').code == 21587	assert run_home(repo, home, 'remote', 'folder', '/tmp', '--code', 'good').code == 21588	assert run_home(repo, home, 'remote', '--code', 'good').code == 21589	assert !os.exists(os.join_path(home, '.config', 'koh', 'remote'))1590}15911592fn test_remote_kepr_refuses_what_is_not_a_code_reply() {1593	repo := temp_repo('kepr-reply')1594	home := temp_repo('kepr-reply-home')1595	defer { os.rmdir_all(repo) or {} }1596	defer { os.rmdir_all(home) or {} }1597	init_repo(repo)1598	remote_path := os.join_path(home, '.config', 'koh', 'remote')1599	for mode in ['500', 'garbage', 'incomplete'] {1600		port, mut server, _ := start_fake_kepr(false, mode, '')!1601		refused := run_home(repo, home, 'remote', 'http://127.0.0.1:${port}', '--code', 'good')1602		server.stop()1603		assert refused.code == 1, mode1604		assert refused.err.contains('nothing was changed'), '${mode}: ${refused.err}'1605		assert !os.exists(remote_path)1606	}1607	// A redirect would hand the code to wherever it points, so it is refused and never followed.1608	target_port, mut target, target_fake := start_fake_kepr(false, '', '')!1609	port, mut server, _ := start_fake_kepr(false, '', 'http://127.0.0.1:${target_port}/api/connect')!1610	redirected := run_home(repo, home, 'remote', 'http://127.0.0.1:${port}', '--code', 'good')1611	server.stop()1612	target.stop()1613	assert redirected.code == 11614	assert redirected.err.contains('refused the code')1615	assert target_fake.seen.len == 0, 'the code was forwarded: ${target_fake.seen}'1616	assert !os.exists(remote_path)1617}16181619// An unreachable Kepr is a refusal too, and the settings are still untouched.1620fn test_remote_kepr_that_cannot_be_reached_changes_nothing() {1621	repo := temp_repo('kepr-down')1622	home := temp_repo('kepr-down-home')1623	defer { os.rmdir_all(repo) or {} }1624	defer { os.rmdir_all(home) or {} }1625	init_repo(repo)1626	refused := run_home(repo, home, 'remote', 'http://127.0.0.1:1', '--code', 'good')1627	assert refused.code == 11628	assert refused.err.contains('could not reach Kepr')1629	assert !os.exists(os.join_path(home, '.config', 'koh', 'remote'))1630}16311632fn test_remote_kepr_without_bucket_access_is_explained() {1633	repo := temp_repo('kepr-no-access')1634	home := temp_repo('kepr-no-access-home')1635	defer { os.rmdir_all(repo) or {} }1636	defer { os.rmdir_all(home) or {} }1637	init_repo(repo)1638	port, mut server, _ := start_fake_kepr(true, '', '')!1639	defer { server.stop() }1640	r := run_home(repo, home, 'remote', 'http://127.0.0.1:${port}', '--code', 'bad')1641	assert r.code == 11642	assert r.err.contains("doesn't hand out bucket access")1643	assert !os.exists(os.join_path(home, '.config', 'koh', 'remote'))1644}