Add script/install; script/update-policy runs it and commits (closes #165)

script/install fetches the policy files from prompts over HTTP and
writes them into a repo, installing itself and script/update-policy
there. script/update-policy fetches the current script/install, runs
it on its own repo and commits without pushing. The file list and the
rules for keeping a repo's own entries move to script/install.

Model: opus-5-5

test/update-policy.sh

@@ -1,12 +1,14 @@
 #!/bin/sh
-# test/update-policy.sh: test script/update-policy on throwaway repos.
-# Each scenario gets one temp directory holding a repo, its local bare
-# origin, a local git repository of the canonical files in place of
-# prompts, and a stub curl that serves them, so nothing touches the
-# network.
+# test/update-policy.sh: test script/install and script/update-policy on
+# throwaway repos. Each scenario gets one temp directory holding a repo,
+# its local bare origin, a local git repository of the canonical files
+# in place of prompts, and a stub curl that serves them, so nothing
+# touches the network.
 set -eu
 
-UPDATE_POLICY="$(cd "$(dirname "$0")/.." && pwd -P)/script/update-policy"
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd -P)/script"
+INSTALL="$SCRIPT_DIR/install"
+UPDATE_POLICY="$SCRIPT_DIR/update-policy"
 
 dir=""
 trap 'rm -rf "$dir"' EXIT
@@ -17,6 +19,8 @@ fail() {
     exit 1
 }
 
+# The stub stops with curl's HTTP error status on any URL containing
+# FAIL_URL, and answers with no commit hash when BAD_BRANCH_JSON is set.
 write_stub_curl() {
     mkdir "$dir/bin"
     cat > "$dir/bin/curl" << 'EOF'
@@ -29,21 +33,53 @@ for argument in "$@"; do
     previous="$argument"
 done
 url="$previous"
-base="https://git.eeqj.de/sneak/prompts/raw/commit/$HASH/"
-path="${url#"$base"}"
-source="$(dirname "$0")/../canonical/$path"
-if [ "$path" = "$url" ] || [ ! -f "$source" ]; then
+canonical="$(dirname "$0")/../canonical"
+site="https://git.eeqj.de/sneak/prompts"
+first="af257bef63f162a681bddc80d9b941c47a44b748"
+
+not_found() {
     [ -n "$fail_flag" ] && exit 22
     echo "404 page not found" > "$output"
     exit 0
-fi
-cp "$source" "$output"
+}
+
+serve_file() {
+    [ -f "$canonical/$1" ] || not_found
+    cp "$canonical/$1" "$output"
+}
+
+case "$url" in
+    *"${FAIL_URL:-no url contains this}"*)
+        not_found
+        ;;
+    "https://git.eeqj.de/api/v1/repos/sneak/prompts/branches/main")
+        if [ -n "${BAD_BRANCH_JSON:-}" ]; then
+            echo '{"message":"no such branch"}' > "$output"
+        else
+            printf '{"name":"main","commit":{"id":"%s"},"x":{"id":"%s"}}\n' \
+                "$HASH" 0000000000000000000000000000000000000000 > "$output"
+        fi
+        ;;
+    "$site/raw/branch/main/script/install")
+        serve_file script/install
+        ;;
+    "$site/compare/$first...$HASH.patch")
+        git -C "$canonical" format-patch --stdout --root "$HASH" > "$output"
+        ;;
+    "$site/raw/commit/$HASH/"*)
+        serve_file "${url#"$site/raw/commit/$HASH/"}"
+        ;;
+    *)
+        not_found
+        ;;
+esac
 EOF
     chmod +x "$dir/bin/curl"
 }
 
 write_canonical_files() {
-    mkdir -p "$dir/canonical/prompts"
+    mkdir -p "$dir/canonical/prompts" "$dir/canonical/script"
+    cp "$INSTALL" "$UPDATE_POLICY" "$dir/canonical/script/"
     cat > "$dir/canonical/.gitignore" << 'EOF'
 *.log
 *.tmp
@@ -87,7 +123,7 @@ EOF
 # curl serves only the newest commit; every other commit gets a 404.
 commit_canonical() {
     git -C "$dir/canonical" add .gitignore .dockerignore .editorconfig \
-        .golangci.yml .prettierrc prompts
+        .golangci.yml .prettierrc prompts script
     git -C "$dir/canonical" commit -q -m "Canonical"
     HASH="$(git -C "$dir/canonical" rev-parse HEAD)"
 }
@@ -144,16 +180,16 @@ start_scenario() {
     rm -rf "$dir"
     dir="$(mktemp -d)"
     : > "$dir/output"
+    mkdir "$dir/tmp"
     write_stub_curl
     write_canonical_files
 
-    # git clone reads no repo's own config, so the setting that points
-    # git at the local canonical repository has to be in this file.
     export GIT_CONFIG_GLOBAL="$dir/gitconfig"
     git config --global user.name "Test"
     git config --global user.email "test@example.com"
-    git config --global "url.$dir/canonical.insteadOf" \
-        "https://git.eeqj.de/sneak/prompts.git"
+
+    export FAIL_URL=""
+    export BAD_BRANCH_JSON=""
 
     git init -q -b main "$dir/canonical"
     export HASH
@@ -164,7 +200,7 @@ start_scenario() {
     git -C "$dir/repo" remote add origin "$dir/origin.git"
 
     mkdir "$dir/repo/script"
-    cp "$UPDATE_POLICY" "$dir/repo/script/update-policy"
+    cp "$INSTALL" "$UPDATE_POLICY" "$dir/repo/script/"
     printf '#!/bin/sh\necho example\n' > "$dir/repo/script/projectname"
     chmod +x "$dir/repo/script/projectname"
     write_outdated_files
@@ -185,17 +221,16 @@ commit_and_push_fixture() {
 
 run_update_policy() {
     status=0
-    (cd "$dir/repo" && PATH="$dir/bin:$PATH" script/update-policy "$@") \
-        > "$dir/output" 2>&1 || status=$?
+    (cd "$dir/repo" && PATH="$dir/bin:$PATH" TMPDIR="$dir/tmp" \
+        script/update-policy "$@") > "$dir/output" 2>&1 || status=$?
 }
 
-reject_pushes() {
-    printf '#!/bin/sh\nexit 1\n' > "$dir/origin.git/hooks/pre-receive"
-    chmod +x "$dir/origin.git/hooks/pre-receive"
-}
-
-accept_pushes() {
-    rm "$dir/origin.git/hooks/pre-receive"
+# run_install <arguments>: run the script in this source tree, from
+# outside the repo it updates.
+run_install() {
+    status=0
+    (cd "$dir" && PATH="$dir/bin:$PATH" TMPDIR="$dir/tmp" \
+        "$INSTALL" "$@") > "$dir/output" 2>&1 || status=$?
 }
 
 head_of_repo() {
@@ -206,6 +241,10 @@ head_of_origin() {
     git -C "$dir/origin.git" rev-parse refs/heads/main
 }
 
+files_in_commit() {
+    git -C "$dir/repo" show --name-only --format= HEAD | tr '\n' ' '
+}
+
 expect_success() {
     [ "$status" -eq 0 ] || fail "exited $status"
 }
@@ -230,22 +269,44 @@ expect_file() {
     diff "$dir/expected" "$dir/repo/$1" >&2 || fail "$1 is wrong"
 }
 
+expect_same_as_canonical() {
+    diff "$dir/canonical/$1" "$dir/repo/$1" >&2 || fail "$1 is not canonical"
+}
+
 expect_absent() {
     [ ! -e "$dir/repo/$1" ] || fail "$1 exists"
 }
 
+expect_executable() {
+    [ "$(stat -c %a "$dir/repo/$1")" = 755 ] || fail "$1 is not mode 755"
+}
+
+expect_committed_executable() {
+    git -C "$dir/repo" ls-files -s -- "$1" | grep -q '^100755 ' ||
+        fail "$1 is not committed as executable"
+}
+
+expect_new_commit_not_pushed() {
+    [ "$(head_of_repo)" != "$before" ] || fail "no commit was made"
+    [ "$(head_of_origin)" = "$before" ] || fail "the commit was pushed"
+}
+
+expect_no_commit() {
+    [ "$(head_of_repo)" = "$before" ] || fail "the repo has a new commit"
+    [ "$(head_of_origin)" = "$before" ] || fail "origin has a new commit"
+}
+
 expect_nothing_written() {
     [ -z "$(git -C "$dir/repo" status --porcelain)" ] ||
         fail "the working tree changed"
-    [ "$(head_of_repo)" = "$before" ] || fail "the repo has a new commit"
-    [ "$(head_of_origin)" = "$before" ] || fail "origin has a new commit"
+    expect_no_commit
 }
 
 test_own_entries_kept() {
     start_scenario "own entries kept in all four files"
     commit_and_push_fixture .gitignore .dockerignore .editorconfig \
         .golangci.yml .prettierrc REPO_POLICIES.md
-    run_update_policy "$HASH"
+    run_update_policy
     expect_success
 
     expect_file .gitignore << 'EOF'
@@ -296,11 +357,12 @@ EOF
 new policy
 EOF
 
-    [ "$(head_of_origin)" = "$(head_of_repo)" ] ||
-        fail "the commit was not pushed"
-    [ "$(head_of_repo)" != "$before" ] || fail "no commit was made"
+    expect_new_commit_not_pushed
     git -C "$dir/repo" log -1 --format=%s | grep -q -F -e "$HASH" ||
-        fail "the commit message does not name the hash"
+        fail "the commit message does not name the head of main"
+    [ "$(files_in_commit)" = ".dockerignore .editorconfig .gitignore .golangci.yml .prettierrc REPO_POLICIES.md " ] ||
+        fail "the commit holds other files: $(files_in_commit)"
+    [ -z "$(ls -A "$dir/tmp")" ] || fail "a temporary directory is left"
 }
 
 test_files_not_carried_are_skipped() {
@@ -308,7 +370,7 @@ test_files_not_carried_are_skipped() {
     mkdir "$dir/repo/docs"
     mv "$dir/repo/REPO_POLICIES.md" "$dir/repo/docs/REPO_POLICIES.md"
     commit_and_push_fixture docs/REPO_POLICIES.md
-    run_update_policy "$HASH"
+    run_update_policy
     expect_success
 
     expect_file docs/REPO_POLICIES.md << 'EOF'
@@ -322,40 +384,145 @@ EOF
     expect_absent .editorconfig
     expect_absent .golangci.yml
     expect_absent .prettierrc
-    [ "$(head_of_origin)" = "$(head_of_repo)" ] ||
-        fail "the commit was not pushed"
+    expect_new_commit_not_pushed
 }
 
 test_nothing_changed() {
     start_scenario "nothing changed"
     cp "$dir/canonical/.prettierrc" "$dir/repo/.prettierrc"
     commit_and_push_fixture .prettierrc
-    run_update_policy "$HASH"
+    run_update_policy
     expect_success
     expect_output "nothing to commit"
     expect_nothing_written
 }
 
-test_bad_commit_hash() {
-    for hash in not-a-hash 0000000000000000000000000000000000000000; do
-        start_scenario "bad commit hash $hash stops with nothing written"
-        commit_and_push_fixture .gitignore .prettierrc REPO_POLICIES.md
-        run_update_policy "$hash"
-        expect_failure
-        expect_nothing_written
-    done
-    # The last hash has the right form, so it is the one that reaches curl.
-    expect_output "cannot fetch"
+test_target_lacking_install_gets_both_scripts() {
+    start_scenario "a repo lacking script/install gets it, and the current script/update-policy, in the commit"
+    rm "$dir/repo/script/install"
+    echo "# An older version." >> "$dir/repo/script/update-policy"
+    commit_and_push_fixture .prettierrc
+    run_update_policy
+    expect_success
+    expect_same_as_canonical script/install
+    expect_same_as_canonical script/update-policy
+    expect_committed_executable script/install
+    expect_committed_executable script/update-policy
+    expect_new_commit_not_pushed
+    [ "$(files_in_commit)" = ".prettierrc script/install script/update-policy " ] ||
+        fail "the commit holds other files: $(files_in_commit)"
 }
 
-test_push_failure() {
-    start_scenario "push failure exits non-zero"
+# The shell reads a script in blocks, so the padding makes it read the
+# last line only after main has returned. It finds that line only if
+# script/install left the old file in place under a new name.
+test_update_policy_replaces_itself() {
+    start_scenario "script/update-policy replaces its own file and still exits 0"
+    {
+        cat "$dir/repo/script/update-policy"
+        i=0
+        while [ "$i" -lt 2000 ]; do
+            echo "# Padding."
+            i=$((i + 1))
+        done
+        echo "echo 'the old file ran to its end'"
+    } > "$dir/merged"
+    mv "$dir/merged" "$dir/repo/script/update-policy"
+    chmod 755 "$dir/repo/script/update-policy"
+    commit_and_push_fixture
+    run_update_policy
+    expect_success
+    expect_output "the old file ran to its end"
+    expect_same_as_canonical script/update-policy
+    expect_executable script/update-policy
+    expect_new_commit_not_pushed
+}
+
+test_install_with_path_commits_nothing() {
+    start_scenario "script/install with a path writes into that clone and commits nothing"
+    rm "$dir/repo/script/install" "$dir/repo/script/update-policy"
     commit_and_push_fixture .prettierrc
-    reject_pushes
-    run_update_policy "$HASH"
+    run_install "$dir/repo"
+    expect_success
+    expect_file .prettierrc << 'EOF'
+{ "tabWidth": 4 }
+EOF
+    expect_same_as_canonical script/install
+    expect_same_as_canonical script/update-policy
+    expect_executable script/install
+    expect_executable script/update-policy
+    expect_no_commit
+    [ "$(head -n 1 "$dir/output")" = "$HASH" ] ||
+        fail "the first line of output is not the hash"
+    expect_output "script/install"
+    [ -z "$(ls -A "$dir/tmp")" ] || fail "a temporary directory is left"
+}
+
+test_install_without_argument_updates_own_repo() {
+    start_scenario "script/install with no argument updates the repo it sits in"
+    commit_and_push_fixture .prettierrc
+    status=0
+    (cd "$dir" && PATH="$dir/bin:$PATH" repo/script/install) \
+        > "$dir/output" 2>&1 || status=$?
+    expect_success
+    expect_file .prettierrc << 'EOF'
+{ "tabWidth": 4 }
+EOF
+    expect_no_commit
+}
+
+test_install_bad_target() {
+    start_scenario "script/install refuses a path that is not the top of a clone"
+    commit_and_push_fixture .prettierrc
+    run_install "$dir/repo/script"
     expect_failure
-    expect_output "push failed"
-    [ "$(head_of_origin)" = "$before" ] || fail "origin has a new commit"
+    expect_output "not the top of a git clone"
+    run_install "$dir/bin"
+    expect_failure
+    expect_output "not the top of a git clone"
+    run_install "$dir/no-such-directory"
+    expect_failure
+    expect_output "no such directory"
+    run_install "$dir/repo" extra
+    expect_failure
+    expect_output "usage:"
+    expect_nothing_written
+}
+
+test_failed_fetch_stops() {
+    for url in \
+        "/api/v1/repos/sneak/prompts/branches/main" \
+        "/raw/branch/main/script/install" \
+        "/compare/" \
+        "/raw/commit/"; do
+        start_scenario "a failed fetch of $url stops with nothing written"
+        commit_and_push_fixture .gitignore .prettierrc REPO_POLICIES.md
+        FAIL_URL="$url"
+        run_update_policy
+        expect_failure
+        expect_output "cannot fetch"
+        expect_nothing_written
+    done
+}
+
+test_one_missing_file_stops_all() {
+    start_scenario "one file missing from prompts stops before any file is written"
+    rm "$dir/canonical/prompts/REPO_POLICIES.md"
+    commit_and_push_fixture .prettierrc REPO_POLICIES.md
+    run_update_policy
+    expect_failure
+    expect_output "cannot fetch"
+    expect_nothing_written
+}
+
+test_branch_response_without_hash_stops() {
+    start_scenario "a branch response with no commit hash stops"
+    commit_and_push_fixture .prettierrc
+    BAD_BRANCH_JSON=yes
+    run_update_policy
+    expect_failure
+    expect_output "no commit hash"
+    expect_nothing_written
 }
 
 # Each of these files, with the repo's own entries above the closing
@@ -370,7 +537,7 @@ test_own_entry_above_closing_comment() {
         mv "$dir/merged" "$dir/repo/$file"
         commit_and_push_fixture .gitignore .dockerignore .editorconfig \
             .prettierrc REPO_POLICIES.md
-        run_update_policy "$HASH"
+        run_update_policy
         expect_failure
         expect_output "$file has entries"
         expect_output "/myapp"
@@ -380,44 +547,39 @@ test_own_entry_above_closing_comment() {
     done
 }
 
-test_retry_after_failed_push() {
-    start_scenario "a retry after a failed push delivers the commit"
-    commit_and_push_fixture .prettierrc
-    reject_pushes
-    run_update_policy "$HASH"
-    expect_failure
-    committed="$(head_of_repo)"
-    [ "$committed" != "$before" ] || fail "no commit was made"
-    [ "$(head_of_origin)" = "$before" ] || fail "origin has a new commit"
-
-    accept_pushes
-    run_update_policy "$HASH"
-    expect_success
-    [ "$(head_of_repo)" = "$committed" ] || fail "the retry made a new commit"
-    [ "$(head_of_origin)" = "$committed" ] ||
-        fail "the retry did not deliver the commit"
-}
-
 test_uncommitted_change_stops() {
     start_scenario "a carried file with uncommitted changes stops"
     commit_and_push_fixture .prettierrc REPO_POLICIES.md
     echo "uncommitted" >> "$dir/repo/REPO_POLICIES.md"
-    run_update_policy "$HASH"
+    run_update_policy
     expect_failure
     expect_output "REPO_POLICIES.md has uncommitted changes"
     expect_file REPO_POLICIES.md << 'EOF'
 old policy
 uncommitted
 EOF
-    [ "$(head_of_repo)" = "$before" ] || fail "the repo has a new commit"
-    [ "$(head_of_origin)" = "$before" ] || fail "origin has a new commit"
+    expect_no_commit
+}
+
+test_untracked_script_stops() {
+    start_scenario "an untracked script/install is not overwritten"
+    rm "$dir/repo/script/install"
+    commit_and_push_fixture .prettierrc
+    echo "our own script" > "$dir/repo/script/install"
+    run_install "$dir/repo"
+    expect_failure
+    expect_output "script/install has uncommitted changes"
+    expect_file script/install << 'EOF'
+our own script
+EOF
+    expect_no_commit
 }
 
 test_gitignore_lacks_canonical_last_line() {
     start_scenario ".gitignore lacking the canonical last line stops"
     printf '*.log\n/myapp\n' > "$dir/repo/.gitignore"
     commit_and_push_fixture .gitignore .prettierrc
-    run_update_policy "$HASH"
+    run_update_policy
     expect_failure
     expect_output ".gitignore lacks this line"
     expect_nothing_written
@@ -438,7 +600,7 @@ linters:
             - pkg: example.com/other
 EOF
     commit_and_push_fixture .golangci.yml .prettierrc
-    run_update_policy "$HASH"
+    run_update_policy
     expect_failure
     expect_output "no deny list in its test-support rule"
     expect_nothing_written
@@ -453,7 +615,7 @@ test_own_golangci_setting_stops() {
         - pattern: model.Operator
 EOF
     commit_and_push_fixture .golangci.yml .prettierrc
-    run_update_policy "$HASH"
+    run_update_policy
     expect_failure
     expect_output ".golangci.yml has lines"
     expect_output "forbidigo:"
@@ -464,9 +626,10 @@ EOF
 
 test_source_repo_stops() {
     start_scenario "the repo the policy files come from stops"
-    printf '#!/bin/sh\necho prompts\n' > "$dir/repo/script/projectname"
-    commit_and_push_fixture .prettierrc REPO_POLICIES.md
-    run_update_policy "$HASH"
+    mkdir "$dir/repo/prompts"
+    echo "policy" > "$dir/repo/prompts/REPO_POLICIES.md"
+    commit_and_push_fixture .prettierrc prompts/REPO_POLICIES.md
+    run_update_policy
     expect_failure
     expect_output "this repo is the source of the policy files"
     expect_nothing_written
@@ -477,42 +640,26 @@ test_staged_file_stays_out_of_commit() {
     commit_and_push_fixture .prettierrc
     echo "notes" > "$dir/repo/notes.txt"
     git -C "$dir/repo" add notes.txt
-    run_update_policy "$HASH"
+    run_update_policy
     expect_success
-    [ "$(git -C "$dir/repo" show --name-only --format= HEAD)" = ".prettierrc" ] ||
+    [ "$(files_in_commit)" = ".prettierrc " ] ||
         fail "the commit holds more than the policy file"
     [ "$(git -C "$dir/repo" diff --cached --name-only)" = "notes.txt" ] ||
         fail "notes.txt is no longer staged"
 }
 
-test_short_commit_hash_refused() {
-    start_scenario "a hexadecimal hash shorter than 40 characters is refused"
+test_update_policy_takes_no_argument() {
+    start_scenario "script/update-policy refuses an argument"
     commit_and_push_fixture .prettierrc
-    run_update_policy "${HASH%?}"
+    run_update_policy "$HASH"
     expect_failure
-    expect_output "not a full commit hash"
+    expect_output "usage:"
     expect_nothing_written
 }
 
-# git asks the local canonical repository for the head of main, and the
-# stub curl serves only that commit.
-test_no_hash_uses_head_of_main() {
-    start_scenario "with no hash the script uses the head of main"
-    commit_and_push_fixture .prettierrc
-    run_update_policy
-    expect_success
-    expect_file .prettierrc << 'EOF'
-{ "tabWidth": 4 }
-EOF
-    git -C "$dir/repo" log -1 --format=%s | grep -q -F -e "$HASH" ||
-        fail "the commit message does not name the head of main"
-    [ "$(head_of_origin)" = "$(head_of_repo)" ] ||
-        fail "the commit was not pushed"
-}
-
 # expect_former_canonical_line_replaced <file> <line>: an earlier
 # canonical commit held the line and the newest does not. This repo's
-# file still has it, and the script replaces it and pushes.
+# file still has it, and the script replaces it.
 expect_former_canonical_line_replaced() {
     cp "$dir/canonical/$1" "$dir/newest"
     { echo "$2"; cat "$dir/newest"; } > "$dir/canonical/$1"
@@ -523,14 +670,12 @@ expect_former_canonical_line_replaced() {
     mv "$dir/merged" "$dir/repo/$1"
     commit_and_push_fixture "$1" .prettierrc
 
-    run_update_policy "$HASH"
+    run_update_policy
     expect_success
     if grep -q -F -x -e "$2" "$dir/repo/$1"; then
         fail "$1 still has: $2"
     fi
-    [ "$(head_of_repo)" != "$before" ] || fail "no commit was made"
-    [ "$(head_of_origin)" = "$(head_of_repo)" ] ||
-        fail "the commit was not pushed"
+    expect_new_commit_not_pushed
 }
 
 test_former_canonical_golangci_line_replaced() {
@@ -543,24 +688,49 @@ test_former_canonical_gitignore_line_replaced() {
     expect_former_canonical_line_replaced .gitignore "*.old"
 }
 
+# A line another file's history removed does not count as held by this
+# one.
+test_line_removed_from_another_file_still_stops() {
+    start_scenario "a line only another canonical file once held stops"
+    { echo "*.old"; cat "$dir/canonical/.dockerignore"; } > "$dir/merged"
+    cp "$dir/merged" "$dir/canonical/.dockerignore"
+    commit_canonical
+    tail -n +2 "$dir/merged" > "$dir/canonical/.dockerignore"
+    commit_canonical
+    { echo "*.old"; cat "$dir/repo/.gitignore"; } > "$dir/merged"
+    mv "$dir/merged" "$dir/repo/.gitignore"
+    commit_and_push_fixture .gitignore .prettierrc
+    run_update_policy
+    expect_failure
+    expect_output ".gitignore has entries"
+    expect_output "*.old"
+    expect_nothing_written
+}
+
 main() {
     test_own_entries_kept
     test_files_not_carried_are_skipped
     test_nothing_changed
-    test_bad_commit_hash
-    test_push_failure
+    test_target_lacking_install_gets_both_scripts
+    test_update_policy_replaces_itself
+    test_install_with_path_commits_nothing
+    test_install_without_argument_updates_own_repo
+    test_install_bad_target
+    test_failed_fetch_stops
+    test_one_missing_file_stops_all
+    test_branch_response_without_hash_stops
     test_own_entry_above_closing_comment
-    test_retry_after_failed_push
     test_uncommitted_change_stops
+    test_untracked_script_stops
     test_gitignore_lacks_canonical_last_line
     test_fetched_golangci_without_deny_list
     test_own_golangci_setting_stops
     test_source_repo_stops
     test_staged_file_stays_out_of_commit
-    test_short_commit_hash_refused
-    test_no_hash_uses_head_of_main
+    test_update_policy_takes_no_argument
     test_former_canonical_golangci_line_replaced
     test_former_canonical_gitignore_line_replaced
+    test_line_removed_from_another_file_still_stops
     echo "update-policy tests passed"
 }