internal/infrastructure/configuration/setup.Run drives operator identity, LLM provider, models, forge, and Telegram chat channel prompts and returns TOML edits -- not a config.Config. Building a parallel in-memory representation to validate against was rejected during design review: it's a second source of truth about the exact thing (text vs. struct disagreeing) this whole feature exists to stop. Tests instead render the edits against the real embedded template and load the result through a real configuration.Loader, proving the actual defaults/decode/validate path accepts it. Two boot-time landmines in config.example.toml surfaced by that approach, both fixed here: - [providers.openai] ships active with api_key pointed at the bws engine. cmd/archied/provider_secrets.go resolves every entry in cfg.Providers at startup, not just the ones [models] references, and refuses to start the daemon if any fails -- so picking any other provider (or picking openai but skipping the key) left a config that wouldn't boot on a machine without the bws CLI installed (the common case). stepProvider now neutralises providers.openai.api_key to the zero-value secret ref whenever openai wasn't the actual choice. - [[repos]] shipped active with a placeholder owner/name that validates cleanly (owner/name are only checked non-empty) and would have archied silently polling a repo that doesn't exist. Commented out in the template with an explanation; setup does not write this section since tomlwrite cannot target array-of-tables. TestExampleConfigLoads updated to expect zero repos. Also: forge and provider secret env-var names are each defined in one table (forgeToken, cloudProviders) read by both the config edit and the secret sink, so the two can't name a secret differently -- the exact bug class this feature exists to close for the installer, tested directly (TestRun_ForgeTokenKeyMatchesStoredSecretKey compares the decoded key against the key the secret was actually stored under, not a hardcoded literal on both sides). Telegram writes chat.telegram. token_env, not a secret.SecretRef -- TelegramConfig has no such field. Telegram also requires at least one allowed_user_id: AllowedUserIDs is deny-by-default, so a bot token with none configured answers nobody, which reads as broken rather than as the safe default it is. SecretSink is a caller-supplied sink (Put buffers, Commit persists), not a return value: Run never hands back plaintext secrets, and the caller is expected to call Commit only after proving the generated config loads -- so a validation failure never leaves a secret written without the config that references it. Refs archie-core-cbk
493 lines
16 KiB
Go
493 lines
16 KiB
Go
package setup
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"maps"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
configtemplate "github.com/samcharles93/archie-core"
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/configuration/tomlwrite"
|
|
"github.com/samcharles93/archie-core/internal/secret"
|
|
)
|
|
|
|
// fakePrompter drives Run from typed scripted answers rather than raw
|
|
// terminal bytes. It mirrors Prompter's real contract (an empty ReadLine
|
|
// answer resolves to the caller's default; Select/Confirm/ReadSecret return
|
|
// their scripted value directly) so a test reads as "what would the
|
|
// operator have typed", not as a simulation of terminal parsing --
|
|
// terminalprompt's own tests already cover that parsing.
|
|
type fakePrompter struct {
|
|
selects []int
|
|
lines []string
|
|
secrets []string
|
|
confirms []bool
|
|
}
|
|
|
|
func (f *fakePrompter) pop(name string, q *[]string) (string, error) {
|
|
if len(*q) == 0 {
|
|
return "", fmt.Errorf("fakePrompter: no more scripted %s answers", name)
|
|
}
|
|
v := (*q)[0]
|
|
*q = (*q)[1:]
|
|
return v, nil
|
|
}
|
|
|
|
func (f *fakePrompter) Select(_ context.Context, _ string, options []string) (int, error) {
|
|
if len(f.selects) == 0 {
|
|
return -1, fmt.Errorf("fakePrompter: no more scripted selects")
|
|
}
|
|
n := f.selects[0]
|
|
f.selects = f.selects[1:]
|
|
if n < 0 || n >= len(options) {
|
|
return -1, fmt.Errorf("fakePrompter: scripted select %d out of range for %d options", n, len(options))
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func (f *fakePrompter) ReadLine(_ context.Context, _, defaultValue string) (string, error) {
|
|
v, err := f.pop("line", &f.lines)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if v == "" {
|
|
return defaultValue, nil
|
|
}
|
|
return v, nil
|
|
}
|
|
|
|
func (f *fakePrompter) ReadSecret(_ context.Context, _ string) (string, error) {
|
|
return f.pop("secret", &f.secrets)
|
|
}
|
|
|
|
func (f *fakePrompter) Confirm(_ context.Context, _ string, defaultYes bool) (bool, error) {
|
|
if len(f.confirms) == 0 {
|
|
return false, fmt.Errorf("fakePrompter: no more scripted confirms")
|
|
}
|
|
v := f.confirms[0]
|
|
f.confirms = f.confirms[1:]
|
|
return v, nil
|
|
}
|
|
|
|
// fakeSecrets records Put calls without committing until Commit is called,
|
|
// mirroring the real buffer-then-commit contract Run relies on.
|
|
type fakeSecrets struct {
|
|
pending map[string]string // "engine:key" -> value
|
|
committed map[string]string
|
|
}
|
|
|
|
func newFakeSecrets() *fakeSecrets {
|
|
return &fakeSecrets{pending: map[string]string{}, committed: map[string]string{}}
|
|
}
|
|
|
|
func (f *fakeSecrets) Put(engine, key, value string) error {
|
|
f.pending[engine+":"+key] = value
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeSecrets) Commit() error {
|
|
maps.Copy(f.committed, f.pending)
|
|
return nil
|
|
}
|
|
|
|
// generateAndLoad renders edits against the real embedded template and
|
|
// loads the result through a real configuration.Loader -- the same check
|
|
// Run's own doc comment says the caller must perform. This is what "every
|
|
// config setup writes passes configuration.Validate, verified by a test
|
|
// that runs setup non-interactively and validates the output" means in
|
|
// practice: proving the real load path (defaults, decode, validate, in
|
|
// their real order) accepts it, not asserting against a second,
|
|
// hand-rolled representation.
|
|
func generateAndLoad(t *testing.T, edits []tomlwrite.Edit) config.Config {
|
|
t.Helper()
|
|
out, err := tomlwrite.Generate(configtemplate.Example, edits)
|
|
if err != nil {
|
|
t.Fatalf("tomlwrite.Generate: %v", err)
|
|
}
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "config.toml")
|
|
if err := os.WriteFile(path, out, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
doc, err := configuration.New(nil).File(path)
|
|
if err != nil {
|
|
t.Fatalf("generated config does not load: %v\n%s", err, out)
|
|
}
|
|
return doc.Config
|
|
}
|
|
|
|
func TestRun_GitHubCloudProvider(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", "Ada Lovelace", "gpt-5.4"},
|
|
selects: []int{0, 0}, // OpenAI, GitHub
|
|
secrets: []string{"sk-openai-token", "ghp-github-token"},
|
|
confirms: []bool{false}, // no telegram
|
|
}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, nil, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
if err := secrets.Commit(); err != nil {
|
|
t.Fatalf("Commit: %v", err)
|
|
}
|
|
|
|
cfg := generateAndLoad(t, edits)
|
|
if cfg.BotUser != "acme-archie" {
|
|
t.Errorf("bot_user = %q, want acme-archie", cfg.BotUser)
|
|
}
|
|
if cfg.Chat.Operator != "Ada Lovelace" {
|
|
t.Errorf("chat.operator = %q, want Ada Lovelace", cfg.Chat.Operator)
|
|
}
|
|
if cfg.Forge.Type != "github" {
|
|
t.Errorf("forge.type = %q, want github", cfg.Forge.Type)
|
|
}
|
|
if cfg.Forge.Token.Key != "ARCHIE_GITHUB_TOKEN" {
|
|
t.Errorf("forge.token.key = %q, want ARCHIE_GITHUB_TOKEN", cfg.Forge.Token.Key)
|
|
}
|
|
if got, want := secrets.committed["env:ARCHIE_GITHUB_TOKEN"], "ghp-github-token"; got != want {
|
|
t.Errorf("committed github token = %q, want %q", got, want)
|
|
}
|
|
if cfg.Providers["openai"].Class != "openai" {
|
|
t.Errorf("providers.openai.class = %q, want openai", cfg.Providers["openai"].Class)
|
|
}
|
|
if cfg.Providers["openai"].APIKey.Key != "OPENAI_API_KEY" {
|
|
t.Errorf("providers.openai.api_key.key = %q, want OPENAI_API_KEY", cfg.Providers["openai"].APIKey.Key)
|
|
}
|
|
if got, want := secrets.committed["env:OPENAI_API_KEY"], "sk-openai-token"; got != want {
|
|
t.Errorf("committed openai key = %q, want %q", got, want)
|
|
}
|
|
for _, role := range []string{"triage", "planner", "builder"} {
|
|
if cfg.Models[role] != "openai/gpt-5.4" {
|
|
t.Errorf("models[%s] = %q, want openai/gpt-5.4", role, cfg.Models[role])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRun_GiteaForge(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", "", "gpt-5.4", "https://git.acme.internal"},
|
|
selects: []int{0, 1}, // OpenAI, Gitea
|
|
secrets: []string{"sk-openai-token", "gitea-token"},
|
|
confirms: []bool{false},
|
|
}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, nil, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
if err := secrets.Commit(); err != nil {
|
|
t.Fatalf("Commit: %v", err)
|
|
}
|
|
|
|
cfg := generateAndLoad(t, edits)
|
|
if cfg.Forge.Type != "gitea" {
|
|
t.Errorf("forge.type = %q, want gitea", cfg.Forge.Type)
|
|
}
|
|
if cfg.Forge.Host != "https://git.acme.internal" {
|
|
t.Errorf("forge.host = %q, want https://git.acme.internal", cfg.Forge.Host)
|
|
}
|
|
if cfg.Forge.Token.Key != "ARCHIE_GITEA_TOKEN" {
|
|
t.Errorf("forge.token.key = %q, want ARCHIE_GITEA_TOKEN", cfg.Forge.Token.Key)
|
|
}
|
|
if got, want := secrets.committed["env:ARCHIE_GITEA_TOKEN"], "gitea-token"; got != want {
|
|
t.Errorf("committed gitea token = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRun_ForgeNone(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", "", "gpt-5.4"},
|
|
selects: []int{0, 2}, // OpenAI, None
|
|
secrets: []string{"sk-openai-token"},
|
|
confirms: []bool{false},
|
|
}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, nil, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
if err := secrets.Commit(); err != nil {
|
|
t.Fatalf("Commit: %v", err)
|
|
}
|
|
|
|
cfg := generateAndLoad(t, edits)
|
|
if cfg.Forge.Type != "none" {
|
|
t.Errorf("forge.type = %q, want none", cfg.Forge.Type)
|
|
}
|
|
if cfg.Forge.Token.Key != "" {
|
|
t.Errorf("forge.token.key = %q, want empty: no token was ever collected for forge type none", cfg.Forge.Token.Key)
|
|
}
|
|
if len(secrets.committed) != 1 { // just the openai key
|
|
t.Errorf("committed secrets = %v, want only the openai key", secrets.committed)
|
|
}
|
|
}
|
|
|
|
type fakeDiscovery struct {
|
|
models []string
|
|
err error
|
|
}
|
|
|
|
func (f *fakeDiscovery) ListOllamaModels(context.Context) ([]string, error) {
|
|
return f.models, f.err
|
|
}
|
|
|
|
func TestRun_SelfHostedWithDiscoveredModels(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", ""},
|
|
selects: []int{len(cloudProviders), 0, 2}, // provider: self-hosted; ollama model list: index 0; forge: none
|
|
confirms: []bool{false},
|
|
}
|
|
discovery := &fakeDiscovery{models: []string{"llama3", "qwen2.5:7b"}}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, discovery, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
|
|
cfg := generateAndLoad(t, edits)
|
|
for _, role := range []string{"triage", "planner", "builder"} {
|
|
if cfg.Models[role] != "ollama/llama3" {
|
|
t.Errorf("models[%s] = %q, want ollama/llama3", role, cfg.Models[role])
|
|
}
|
|
}
|
|
if cfg.Providers["ollama"].Class != "ollama" {
|
|
t.Errorf("providers.ollama.class = %q, want ollama", cfg.Providers["ollama"].Class)
|
|
}
|
|
if len(secrets.committed) != 0 {
|
|
t.Errorf("committed secrets = %v, want none: self-hosted needs no API key", secrets.committed)
|
|
}
|
|
}
|
|
|
|
func TestRun_SelfHostedDiscoveryUnavailableFallsBackToFreeText(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", "", "custom-model:latest"},
|
|
selects: []int{len(cloudProviders), 2}, // self-hosted, forge none
|
|
confirms: []bool{false},
|
|
}
|
|
discovery := &fakeDiscovery{err: fmt.Errorf("ollama not found")}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, discovery, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
cfg := generateAndLoad(t, edits)
|
|
if cfg.Models["triage"] != "ollama/custom-model:latest" {
|
|
t.Errorf("models[triage] = %q, want ollama/custom-model:latest", cfg.Models["triage"])
|
|
}
|
|
}
|
|
|
|
func TestRun_TelegramRequiresAllowedUserIDs(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", "", "gpt-5.4", ""}, // last "" is the empty allowed-ids answer
|
|
selects: []int{0, 2}, // openai, forge none
|
|
secrets: []string{"sk-openai-token", "tg-token"},
|
|
confirms: []bool{true}, // yes, configure telegram
|
|
}
|
|
secrets := newFakeSecrets()
|
|
_, err := Run(context.Background(), p, nil, secrets, ExistingValues{})
|
|
if err == nil {
|
|
t.Fatal("Run() = nil error, want a failure: telegram configured with no allowed user IDs answers nobody")
|
|
}
|
|
if secrets.committed["env:ARCHIE_TELEGRAM_TOKEN"] != "" {
|
|
t.Error("telegram token must not be committed when the flow aborts on missing allowed user IDs")
|
|
}
|
|
}
|
|
|
|
func TestRun_TelegramWithAllowedUserIDs(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", "", "gpt-5.4", "111, 222"},
|
|
selects: []int{0, 2},
|
|
secrets: []string{"sk-openai-token", "tg-token"},
|
|
confirms: []bool{true},
|
|
}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, nil, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
if err := secrets.Commit(); err != nil {
|
|
t.Fatalf("Commit: %v", err)
|
|
}
|
|
cfg := generateAndLoad(t, edits)
|
|
if cfg.Chat.Telegram.TokenEnv != "ARCHIE_TELEGRAM_TOKEN" {
|
|
t.Errorf("chat.telegram.token_env = %q, want ARCHIE_TELEGRAM_TOKEN", cfg.Chat.Telegram.TokenEnv)
|
|
}
|
|
if len(cfg.Chat.Telegram.AllowedUserIDs) != 2 || cfg.Chat.Telegram.AllowedUserIDs[0] != 111 || cfg.Chat.Telegram.AllowedUserIDs[1] != 222 {
|
|
t.Errorf("chat.telegram.allowed_user_ids = %v, want [111 222]", cfg.Chat.Telegram.AllowedUserIDs)
|
|
}
|
|
if got, want := secrets.committed["env:ARCHIE_TELEGRAM_TOKEN"], "tg-token"; got != want {
|
|
t.Errorf("committed telegram token = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
// config.example.toml ships [providers.openai] active by default with an
|
|
// api_key pointing at the bws engine, which errors when the bws CLI isn't
|
|
// installed. cmd/archied/provider_secrets.go resolves every entry in
|
|
// cfg.Providers at startup, not just the ones [models] references, so an
|
|
// operator who picks any other provider must not be left with that entry
|
|
// still pointing at bws -- the daemon would refuse to boot on a config
|
|
// setup itself produced.
|
|
func TestRun_NonOpenAIProviderNeutralisesTemplateDefaultOpenAIKey(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", "", "claude-opus"},
|
|
selects: []int{1, 2}, // Anthropic, forge none
|
|
secrets: []string{"sk-anthropic-token"},
|
|
confirms: []bool{false},
|
|
}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, nil, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
cfg := generateAndLoad(t, edits)
|
|
if cfg.Providers["openai"].APIKey != (secret.SecretRef{}) {
|
|
t.Fatalf("providers.openai.api_key = %+v, want the zero value: it must not still point at the "+
|
|
"template's default bws reference once a different provider is chosen, or the daemon refuses to boot",
|
|
cfg.Providers["openai"].APIKey)
|
|
}
|
|
}
|
|
|
|
func TestRun_OpenAISkippedKeyNeutralisesTemplateDefault(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: []string{"acme-archie", "", "gpt-5.4"},
|
|
selects: []int{0, 2}, // OpenAI, forge none
|
|
secrets: []string{""},
|
|
confirms: []bool{false},
|
|
}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, nil, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
cfg := generateAndLoad(t, edits)
|
|
if cfg.Providers["openai"].APIKey != (secret.SecretRef{}) {
|
|
t.Fatalf("providers.openai.api_key = %+v, want the zero value when the key prompt was left blank, "+
|
|
"not the template's default bws reference", cfg.Providers["openai"].APIKey)
|
|
}
|
|
}
|
|
|
|
// The drift-bug regression test: for every forge type that writes a token,
|
|
// the key decoded from the generated TOML must equal the key the secret was
|
|
// actually stored under -- not merely equal some hardcoded literal on the
|
|
// assertion side, which would pass even if both sides had independently
|
|
// drifted to the same wrong value.
|
|
func TestRun_ForgeTokenKeyMatchesStoredSecretKey(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
forgeIndex int
|
|
lines []string
|
|
secret string
|
|
}{
|
|
{name: "github", forgeIndex: 0, lines: []string{"acme-archie", "", "gpt-5.4"}, secret: "ghp-token"},
|
|
{name: "gitea", forgeIndex: 1, lines: []string{"acme-archie", "", "gpt-5.4", "https://gitea.acme.internal"}, secret: "gitea-token"},
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
p := &fakePrompter{
|
|
lines: tc.lines,
|
|
selects: []int{0, tc.forgeIndex},
|
|
secrets: []string{"sk-openai-token", tc.secret},
|
|
confirms: []bool{false},
|
|
}
|
|
secrets := newFakeSecrets()
|
|
edits, err := Run(context.Background(), p, nil, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
if err := secrets.Commit(); err != nil {
|
|
t.Fatalf("Commit: %v", err)
|
|
}
|
|
cfg := generateAndLoad(t, edits)
|
|
|
|
storedUnderKey := ""
|
|
for k, v := range secrets.committed {
|
|
if v == tc.secret {
|
|
storedUnderKey = k
|
|
}
|
|
}
|
|
if storedUnderKey == "" {
|
|
t.Fatalf("secret %q was never committed: %v", tc.secret, secrets.committed)
|
|
}
|
|
wantKey := "env:" + cfg.Forge.Token.Key
|
|
if storedUnderKey != wantKey {
|
|
t.Errorf("forge.token.key decodes to %q, but the secret was stored under %q -- these must match", cfg.Forge.Token.Key, storedUnderKey)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// A second run against an already-generated config, changing one answer,
|
|
// must not disturb the rest of the file -- tomlwrite's own guarantee
|
|
// (archie-core-rs9), exercised here through setup's edits specifically.
|
|
func TestRun_SecondRunAgainstOwnOutputChangesOnlyOneField(t *testing.T) {
|
|
p1 := &fakePrompter{
|
|
lines: []string{"acme-archie", "", "gpt-5.4"},
|
|
selects: []int{0, 2},
|
|
secrets: []string{"sk-openai-token"},
|
|
confirms: []bool{false},
|
|
}
|
|
secrets := newFakeSecrets()
|
|
edits1, err := Run(context.Background(), p1, nil, secrets, ExistingValues{})
|
|
if err != nil {
|
|
t.Fatalf("first Run: %v", err)
|
|
}
|
|
first, err := tomlwrite.Generate(configtemplate.Example, edits1)
|
|
if err != nil {
|
|
t.Fatalf("Generate: %v", err)
|
|
}
|
|
|
|
p2 := &fakePrompter{
|
|
lines: []string{"acme-archie-renamed", "", "gpt-5.4"},
|
|
selects: []int{0, 2},
|
|
secrets: []string{"sk-openai-token"},
|
|
confirms: []bool{false},
|
|
}
|
|
edits2, err := Run(context.Background(), p2, nil, secrets, ExistingValues{BotUser: "acme-archie"})
|
|
if err != nil {
|
|
t.Fatalf("second Run: %v", err)
|
|
}
|
|
second, err := tomlwrite.Apply(first, edits2)
|
|
if err != nil {
|
|
t.Fatalf("Apply: %v", err)
|
|
}
|
|
|
|
firstLines := splitLines(t, first)
|
|
secondLines := splitLines(t, second)
|
|
if len(firstLines) != len(secondLines) {
|
|
t.Fatalf("line count changed: %d -> %d", len(firstLines), len(secondLines))
|
|
}
|
|
changed := 0
|
|
for i := range firstLines {
|
|
if firstLines[i] != secondLines[i] {
|
|
changed++
|
|
if firstLines[i] != `bot_user = "acme-archie"` {
|
|
t.Errorf("unexpected line changed on re-run: %q -> %q", firstLines[i], secondLines[i])
|
|
}
|
|
}
|
|
}
|
|
if changed != 1 {
|
|
t.Errorf("expected exactly one changed line (bot_user), got %d", changed)
|
|
}
|
|
}
|
|
|
|
func splitLines(t *testing.T, b []byte) []string {
|
|
t.Helper()
|
|
var lines []string
|
|
start := 0
|
|
for i, c := range b {
|
|
if c == '\n' {
|
|
lines = append(lines, string(b[start:i]))
|
|
start = i + 1
|
|
}
|
|
}
|
|
if start < len(b) {
|
|
lines = append(lines, string(b[start:]))
|
|
}
|
|
return lines
|
|
}
|