install.sh built and installed five host binaries but wrote only archied.service, so a fresh install ran one of five services and the updater refused its own first update for units the installer never created (archie-core-enow). The runbook stood in as the mechanism, which is the hand-written step that let a messaging binary and unit drift apart (archie-core-1c01). - install.sh writes archie-state-store.service, archie-gateway.service, archie-ui.service and archie-messaging.service alongside archied.service, with the contents the runbook used to tell an operator to paste, and starts all five with the store first. - deployments/systemd-user-service.md no longer carries the unit contents; it names the units, explains why each exists, and points at systemctl --user cat and drop-ins for inspection and overrides. - The updater's unmanaged-unit refusal now reads as a safety net for a host that drifted rather than the normal path.
289 lines
10 KiB
Go
289 lines
10 KiB
Go
package configtemplate
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestDeployWorkflowOnlyPublishesRuntimeImageForRuntimeTag(t *testing.T) {
|
|
source := readDeploymentFile(t, ".github/workflows/deploy.yml")
|
|
|
|
// The fallback remains necessary because Dockerfile.archied accepts a
|
|
// runtime version, but it must not be used as the image-publish selector.
|
|
for _, required := range []string{
|
|
`RUNTIME_TAG="$(git tag --points-at HEAD --list 'archie/v*' | sort -V | tail -1)"`,
|
|
`echo "runtime_tag=$RUNTIME_TAG" >> "$GITHUB_OUTPUT"`,
|
|
"if: steps.versions.outputs.runtime_tag != ''",
|
|
} {
|
|
if !strings.Contains(source, required) {
|
|
t.Errorf("deploy workflow is missing runtime-image guard %q", required)
|
|
}
|
|
}
|
|
|
|
// The gateway build remains unconditional, while the runtime build is
|
|
// guarded. This verifies both sides of the gateway-only/dual-tag contract.
|
|
agentMarker := " - name: Build and push archie-agent\n"
|
|
agentStart := strings.Index(source, agentMarker)
|
|
if agentStart < 0 {
|
|
t.Fatal("deploy workflow has no archie-agent build step")
|
|
}
|
|
if !strings.Contains(source[agentStart:], agentMarker+" if: steps.versions.outputs.runtime_tag != ''\n") {
|
|
t.Fatal("archie-agent build step is not conditionally enabled")
|
|
}
|
|
|
|
gatewayMarker := " - name: Build and push archied\n"
|
|
gatewayStart := strings.Index(source, gatewayMarker)
|
|
if gatewayStart < 0 {
|
|
t.Fatal("deploy workflow has no archied build step")
|
|
}
|
|
if strings.Contains(source[gatewayStart:agentStart], "\n if:") {
|
|
t.Fatal("archied build step is unexpectedly conditional")
|
|
}
|
|
}
|
|
|
|
func TestDeployWorkflowUsesConfiguredFormatters(t *testing.T) {
|
|
source := readDeploymentFile(t, ".github/workflows/deploy.yml")
|
|
for _, required := range []string{
|
|
"github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.13.2",
|
|
"golangci-lint fmt",
|
|
"git diff --exit-code",
|
|
"golangci-lint run ./...",
|
|
} {
|
|
if !strings.Contains(source, required) {
|
|
t.Errorf("deploy workflow is missing formatter gate %q", required)
|
|
}
|
|
}
|
|
if strings.Contains(source, "gofumpt -w .") {
|
|
t.Error("deploy workflow bypasses the configured formatter set")
|
|
}
|
|
}
|
|
|
|
func TestPullRequestsRunTheDefinitiveGateWithoutPublishAccess(t *testing.T) {
|
|
source := readDeploymentFile(t, ".github/workflows/quality.yml")
|
|
for _, required := range []string{
|
|
"pull_request:",
|
|
"contents: read",
|
|
"task check",
|
|
"git diff --exit-code",
|
|
} {
|
|
if !strings.Contains(source, required) {
|
|
t.Errorf("quality workflow is missing %q", required)
|
|
}
|
|
}
|
|
for _, forbidden := range []string{
|
|
"packages: write",
|
|
"docker/login-action",
|
|
"docker/build-push-action",
|
|
} {
|
|
if strings.Contains(source, forbidden) {
|
|
t.Errorf("quality workflow has publishing capability %q", forbidden)
|
|
}
|
|
}
|
|
}
|
|
|
|
// unpackagedCommands are commands that deliberately never ship as a host binary.
|
|
// Naming each one with its reason keeps an omission a decision rather than an
|
|
// oversight -- which is exactly how archied's channels were lost.
|
|
var unpackagedCommands = map[string]string{
|
|
"archie-agent": "runs only inside the Docker image build-and-push publishes, never as a host binary",
|
|
}
|
|
|
|
// cliOnlyCommands ship in the zip but must never be restarted by the updater:
|
|
// they are not services.
|
|
var cliOnlyCommands = map[string]bool{"archie-playbooks": true}
|
|
|
|
// TestDistZipShipsEveryHostCommand is why archie-core-1c01 went unnoticed for
|
|
// two days. The v1.30.0 extraction moved Telegram, email and webhook out of
|
|
// archied into a new cmd/archie-messaging that nothing packaged: the release zip
|
|
// omitted it, scripts/archie-update-install omitted it from both of its lists,
|
|
// and install.sh's build loop omitted it too, so a host install ran on with a
|
|
// dead Telegram bot and no error logged anywhere. The daemon looked healthy
|
|
// throughout.
|
|
//
|
|
// The host component set was enumerated independently in four places (the zip's
|
|
// build loop, the zip's copy list, install.sh's build loop, and the updater's
|
|
// two lists), so two coordinated edits would have drifted again. Every list is
|
|
// pinned to cmd/ here instead: adding a command fails this test until it is
|
|
// packaged, and extracting one fails it until the previous command is removed.
|
|
// The updater's service list is separately required to have a documented unit,
|
|
// and its runtime guard refuses a host unit the list omits.
|
|
func TestDistZipShipsEveryHostCommand(t *testing.T) {
|
|
workflow := readDeploymentFile(t, ".github/workflows/deploy.yml")
|
|
installer := readDeploymentFile(t, filepath.Join("scripts", "archie-update-install"))
|
|
installSh := readDeploymentFile(t, "install.sh")
|
|
|
|
want := hostRunCommands(t)
|
|
wantBinaries := want
|
|
wantServices := withoutCLIOnly(want)
|
|
|
|
built := wordsAfter(t, workflow, "for cmd in ", "; do", nil)
|
|
// The marker consumes the prefix of the first word only, so restore it for
|
|
// whichever word the marker ended inside.
|
|
var shipped []string
|
|
for _, word := range wordsAfter(t, workflow, "cp dist/", ` "$name/"`, nil) {
|
|
if !strings.HasPrefix(word, "dist/") {
|
|
word = "dist/" + word
|
|
}
|
|
shipped = append(shipped, strings.TrimPrefix(word, "dist/"))
|
|
}
|
|
services := wordsAfter(t, installer, `GATEWAY_SERVICES="`, `"`, nil)
|
|
binaries := wordsAfter(t, installer, `GATEWAY_BINARIES="`, `"`, map[string][]string{"$GATEWAY_SERVICES": services})
|
|
installBuilt := installBuildCommands(t, installSh)
|
|
|
|
for _, list := range []struct {
|
|
name string
|
|
got []string
|
|
want []string
|
|
}{
|
|
{"deploy.yml dist-zip build loop", built, wantBinaries},
|
|
{"deploy.yml dist-zip copy list", shipped, wantBinaries},
|
|
{"install.sh build loop", installBuilt, wantBinaries},
|
|
{"archie-update-install GATEWAY_BINARIES", binaries, wantBinaries},
|
|
{"archie-update-install GATEWAY_SERVICES", services, wantServices},
|
|
} {
|
|
if diff := setDifference(list.want, list.got); diff != "" {
|
|
t.Errorf("%s does not match the host-run commands in cmd/: %s", list.name, diff)
|
|
}
|
|
}
|
|
|
|
// The installer now REFUSES an update when a service unit is missing and
|
|
// tells the operator to create it from this runbook, so a service the
|
|
// runbook never shows is a dead end rather than a documentation gap.
|
|
// The installer writes the units, so the runbook no longer carries their
|
|
// contents; it must still name each unit, or an operator cannot find one to
|
|
// inspect or override.
|
|
runbook := readDeploymentFile(t, filepath.Join("deployments", "systemd-user-service.md"))
|
|
var undocumented []string
|
|
for _, service := range wantServices {
|
|
if !strings.Contains(runbook, service+".service") {
|
|
undocumented = append(undocumented, service)
|
|
}
|
|
}
|
|
if len(undocumented) > 0 {
|
|
t.Errorf("deployments/systemd-user-service.md names no unit for: %s", strings.Join(undocumented, " "))
|
|
}
|
|
}
|
|
|
|
// installBuildCommands reads install.sh's build loop. The file has a second
|
|
// `for cmd in` (the git/go preflight), so the loop is located by the go build it
|
|
// drives rather than by the first marker -- and read from the real list, so a
|
|
// missing command is named instead of the marker merely going absent.
|
|
func installBuildCommands(t *testing.T, source string) []string {
|
|
t.Helper()
|
|
before, _, ok := strings.Cut(source, `go build -ldflags "${LDFLAGS}"`)
|
|
if !ok {
|
|
t.Fatal("install.sh has no go build loop to read")
|
|
}
|
|
prefix := before
|
|
start := strings.LastIndex(prefix, "for cmd in ")
|
|
if start < 0 {
|
|
t.Fatal("install.sh build loop has no for cmd list")
|
|
}
|
|
rest := prefix[start+len("for cmd in "):]
|
|
before0, _, ok0 := strings.Cut(rest, "; do")
|
|
if !ok0 {
|
|
t.Fatal("install.sh build loop is unterminated")
|
|
}
|
|
return strings.Fields(before0)
|
|
}
|
|
|
|
// hostRunCommands is every command under cmd/, minus the deliberately
|
|
// unpackaged ones. Deriving it is the point: a list written out here would drift
|
|
// from cmd/ exactly as the packaged lists did.
|
|
func hostRunCommands(t *testing.T) []string {
|
|
t.Helper()
|
|
entries, err := os.ReadDir("cmd")
|
|
if err != nil {
|
|
t.Fatalf("read cmd/: %v", err)
|
|
}
|
|
var commands []string
|
|
for _, entry := range entries {
|
|
if !entry.IsDir() {
|
|
continue
|
|
}
|
|
if _, skip := unpackagedCommands[entry.Name()]; skip {
|
|
continue
|
|
}
|
|
commands = append(commands, entry.Name())
|
|
}
|
|
if len(commands) == 0 {
|
|
t.Fatal("cmd/ holds no commands: this guard would assert nothing")
|
|
}
|
|
sort.Strings(commands)
|
|
return commands
|
|
}
|
|
|
|
func withoutCLIOnly(commands []string) []string {
|
|
out := make([]string, 0, len(commands))
|
|
for _, command := range commands {
|
|
if cliOnlyCommands[command] {
|
|
continue
|
|
}
|
|
out = append(out, command)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// wordsAfter returns the whitespace-separated words between two markers on the
|
|
// same line. expand maps a word to the words it stands for, which is how the
|
|
// installer's "$GATEWAY_SERVICES" reference is followed to what it names.
|
|
func wordsAfter(t *testing.T, source, marker, terminator string, expand map[string][]string) []string {
|
|
t.Helper()
|
|
start := strings.Index(source, marker)
|
|
if start < 0 {
|
|
t.Fatalf("no %q in the file under test", marker)
|
|
}
|
|
rest := source[start+len(marker):]
|
|
end := strings.Index(rest, terminator)
|
|
if end < 0 {
|
|
t.Fatalf("no %q after %q", terminator, marker)
|
|
}
|
|
var words []string
|
|
for word := range strings.FieldsSeq(rest[:end]) {
|
|
if replacement, ok := expand[word]; ok {
|
|
words = append(words, replacement...)
|
|
continue
|
|
}
|
|
words = append(words, word)
|
|
}
|
|
return words
|
|
}
|
|
|
|
// setDifference names what is missing from and extra in got, so a failure says
|
|
// which side moved rather than that two lists differ.
|
|
func setDifference(want, got []string) string {
|
|
present := make(map[string]bool, len(got))
|
|
for _, item := range got {
|
|
present[item] = true
|
|
}
|
|
var missing []string
|
|
for _, item := range want {
|
|
if !present[item] {
|
|
missing = append(missing, item)
|
|
}
|
|
}
|
|
expected := make(map[string]bool, len(want))
|
|
for _, item := range want {
|
|
expected[item] = true
|
|
}
|
|
var extra []string
|
|
for _, item := range got {
|
|
if !expected[item] {
|
|
extra = append(extra, item)
|
|
}
|
|
}
|
|
sort.Strings(missing)
|
|
sort.Strings(extra)
|
|
var problems []string
|
|
if len(missing) > 0 {
|
|
problems = append(problems, "missing "+strings.Join(missing, " "))
|
|
}
|
|
if len(extra) > 0 {
|
|
problems = append(problems, "unexpected "+strings.Join(extra, " "))
|
|
}
|
|
return strings.Join(problems, "; ")
|
|
}
|