The channel-settings resource embedded internal/config types directly, so the document the Web UI edits was a JSON projection of TOML-tagged structs: encoding/json fell back to Go field names, and rate_limit.window was a bare time.Duration. An operator saw "Window" over a field expecting a nanosecond count -- 60000000000 for the window = "1m" the file example writes -- and "ListenAddr" over the email addresses, while every sibling resource in the same registry is snake_case. Define the shape here instead: emailSettings and rateLimitSettings with explicit tags, and channelDuration, which writes the string the file accepts and reads that, a nanosecond count, and the Go-cased keys an existing store holds. Reading a legacy document is deliberate, so it stays strict about everything else. decodeRenamingLegacyKeys renames the four known legacy keys and keeps DisallowUnknownFields, because swallowing an unknown key decodes as "unset", and an unset rate limit is off -- the failure this shape exists to end. A misspelling is refused. normalizeChannels, through the Definition.Normalize hook schedules already uses, rewrites a legacy document into the current shape on write, so a stored document converges the next time it is saved. Reads tolerate it until then, so no deployment has to re-save before the document can be read. Verified: the controlplane, messaging and configuration suites, archied (the loadRuntimeConfig consumer), go vet, go build ./..., golangci-lint run ./..., and docs:check. The full task check is the merge train's, on this tip. The same audit found container-runtime-policies embedding config.ContainerConfig (seven fields, no json tags); tracked separately rather than folded in here.
188 lines
7.5 KiB
Go
188 lines
7.5 KiB
Go
package controlplane
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
)
|
|
|
|
// channelSettingsDefinition returns the registered definition, so a test that
|
|
// pins the document's shape also pins its wiring: Seed, Validate and Normalize
|
|
// are the three functions the registry actually runs.
|
|
func channelSettingsDefinition(t *testing.T) Definition {
|
|
t.Helper()
|
|
for _, definition := range operationalDefinitions() {
|
|
if definition.Kind == ChannelSettingsKind {
|
|
return definition
|
|
}
|
|
}
|
|
t.Fatal("channel-settings is not registered")
|
|
return Definition{}
|
|
}
|
|
|
|
// TestChannelSettingsSeedIsTheDocumentShape pins what an operator sees in the
|
|
// Web UI: snake_case keys and a duration they can read. The Go-cased keys and
|
|
// the nanosecond count this replaced are asserted absent, because the defect was
|
|
// invisible to a test that only compared decoded values -- encoding/json
|
|
// round-trips the wrong spelling perfectly happily.
|
|
func TestChannelSettingsSeedIsTheDocumentShape(t *testing.T) {
|
|
cfg := config.Config{Chat: config.ChatConfig{
|
|
Email: config.EmailConfig{ListenAddr: "127.0.0.1:2525", RelayAddr: "smtp.example.com:587"},
|
|
RateLimit: config.RateLimitConfig{Window: time.Minute, MaxRequests: 20},
|
|
}}
|
|
encoded, err := json.Marshal(seedChannels(cfg))
|
|
if err != nil {
|
|
t.Fatalf("marshal seed: %v", err)
|
|
}
|
|
var document map[string]any
|
|
if err := json.Unmarshal(encoded, &document); err != nil {
|
|
t.Fatalf("unmarshal seed: %v", err)
|
|
}
|
|
rateLimit, ok := document["rate_limit"].(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("rate_limit = %#v, want an object", document["rate_limit"])
|
|
}
|
|
if got := rateLimit["window"]; got != "1m0s" {
|
|
t.Errorf("rate_limit.window = %#v, want %q: the document writes the string the file accepts", got, "1m0s")
|
|
}
|
|
if got := rateLimit["max_requests"]; got != float64(20) {
|
|
t.Errorf("rate_limit.max_requests = %#v, want 20", got)
|
|
}
|
|
email, ok := document["email"].(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("email = %#v, want an object", document["email"])
|
|
}
|
|
if email["listen_addr"] != "127.0.0.1:2525" || email["relay_addr"] != "smtp.example.com:587" {
|
|
t.Errorf("email = %#v, want the snake_case addresses", email)
|
|
}
|
|
for _, legacy := range []string{"Window", "MaxRequests", "ListenAddr", "RelayAddr"} {
|
|
if _, present := email[legacy]; present {
|
|
t.Errorf("email carries the Go-cased key %q", legacy)
|
|
}
|
|
if _, present := rateLimit[legacy]; present {
|
|
t.Errorf("rate_limit carries the Go-cased key %q", legacy)
|
|
}
|
|
}
|
|
}
|
|
|
|
// legacyChannelDocument is a document as an earlier revision stored it: the Go
|
|
// field names encoding/json fell back to, and a nanosecond count where the
|
|
// document now writes a string. Every store written before the reshape holds
|
|
// this, so it has to keep working.
|
|
const legacyChannelDocument = `{"rate_limit":{"Window":60000000000,"MaxRequests":20},"email":{"ListenAddr":"127.0.0.1:2525","RelayAddr":"smtp.example.com:587"}}`
|
|
|
|
// TestChannelSettingsReadsADocumentWrittenBeforeTheReshape covers the two halves
|
|
// the change needs: a legacy document still validates and still reads, and
|
|
// writing it back (Definition.Decode is what every write path runs) rewrites it
|
|
// into the current shape.
|
|
func TestChannelSettingsReadsADocumentWrittenBeforeTheReshape(t *testing.T) {
|
|
definition := channelSettingsDefinition(t)
|
|
|
|
if err := definition.Validate([]byte(legacyChannelDocument)); err != nil {
|
|
t.Fatalf("Validate(legacy) = %v, want it accepted: it is what existing stores hold", err)
|
|
}
|
|
|
|
decoded, err := definition.Decode([]byte(legacyChannelDocument))
|
|
if err != nil {
|
|
t.Fatalf("Decode(legacy) = %v", err)
|
|
}
|
|
if strings.Contains(string(decoded), `"Window"`) || strings.Contains(string(decoded), `60000000000`) {
|
|
t.Fatalf("decoded document = %s, want the canonical keys and duration", decoded)
|
|
}
|
|
var document struct {
|
|
RateLimit struct {
|
|
Window string `json:"window"`
|
|
MaxRequests int `json:"max_requests"`
|
|
} `json:"rate_limit"`
|
|
Email struct {
|
|
ListenAddr string `json:"listen_addr"`
|
|
RelayAddr string `json:"relay_addr"`
|
|
} `json:"email"`
|
|
}
|
|
if err := json.Unmarshal(decoded, &document); err != nil {
|
|
t.Fatalf("unmarshal decoded document: %v", err)
|
|
}
|
|
if document.RateLimit.Window != "1m0s" || document.RateLimit.MaxRequests != 20 {
|
|
t.Errorf("rate_limit = %+v, want the legacy values preserved in the current shape", document.RateLimit)
|
|
}
|
|
if document.Email.ListenAddr != "127.0.0.1:2525" || document.Email.RelayAddr != "smtp.example.com:587" {
|
|
t.Errorf("email = %+v, want the legacy values preserved", document.Email)
|
|
}
|
|
}
|
|
|
|
// TestChannelSettingsLayersEveryStoredFormOfTheDuration walks the forms a stored
|
|
// document may hold: the legacy Go-cased keys with a nanosecond count, the
|
|
// current keys with the string the file writes, and the current keys with a
|
|
// count. All three have to reach config.ChatConfig, or a deployment's rate limit
|
|
// silently stops applying.
|
|
func TestChannelSettingsLayersEveryStoredFormOfTheDuration(t *testing.T) {
|
|
for _, tt := range []struct {
|
|
name string
|
|
rate map[string]any
|
|
expected time.Duration
|
|
}{
|
|
{
|
|
name: "legacy keys, nanosecond count",
|
|
rate: map[string]any{"Window": int64(60000000000), "MaxRequests": 20},
|
|
expected: time.Minute,
|
|
},
|
|
{
|
|
name: "current keys, duration string",
|
|
rate: map[string]any{"window": "1m", "max_requests": 20},
|
|
expected: time.Minute,
|
|
},
|
|
{
|
|
name: "current keys, nanosecond count",
|
|
rate: map[string]any{"window": int64(60000000000), "max_requests": 20},
|
|
expected: time.Minute,
|
|
},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
client := NewRPCClient(&runtimeConfigClient{values: map[string]any{
|
|
ChannelSettingsKind: map[string]any{
|
|
"rate_limit": tt.rate,
|
|
"email": map[string]any{"ListenAddr": "127.0.0.1:2525", "RelayAddr": "smtp.example.com:587"},
|
|
},
|
|
}})
|
|
got, version, err := client.RuntimeChatConfig(t.Context(), config.ChatConfig{})
|
|
if err != nil {
|
|
t.Fatalf("RuntimeChatConfig: %v", err)
|
|
}
|
|
if version != 2 {
|
|
t.Errorf("version = %d, want the version the store answered with", version)
|
|
}
|
|
if got.RateLimit.Window != tt.expected || got.RateLimit.MaxRequests != 20 || !got.RateLimit.Enabled() {
|
|
t.Errorf("RateLimit = %+v, want window %v and 20 requests", got.RateLimit, tt.expected)
|
|
}
|
|
if got.Email.ListenAddr != "127.0.0.1:2525" || got.Email.RelayAddr != "smtp.example.com:587" {
|
|
t.Errorf("Email = %+v, want the stored addresses", got.Email)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestChannelSettingsRefusesWhatItCannotApply keeps the tolerance above from
|
|
// becoming indifference. Reading a legacy spelling is deliberate; quietly
|
|
// swallowing a misspelling is the failure this whole shape exists to prevent,
|
|
// because an unknown key decodes as an unset one and an unset rate limit is
|
|
// off.
|
|
func TestChannelSettingsRefusesWhatItCannotApply(t *testing.T) {
|
|
definition := channelSettingsDefinition(t)
|
|
for _, tt := range []struct{ name, document string }{
|
|
{"a misspelt key is not an absent setting", `{"rate_limit":{"windows":"1m","max_requests":20}}`},
|
|
{"an unknown top-level key", `{"rate_limmt":{}}`},
|
|
{"an unparseable duration", `{"rate_limit":{"window":"soon","max_requests":20}}`},
|
|
{"a fractional duration", `{"rate_limit":{"window":1.5,"max_requests":20}}`},
|
|
{"a negative budget", `{"rate_limit":{"window":"1m","max_requests":-1}}`},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if err := definition.Validate([]byte(tt.document)); err == nil {
|
|
t.Fatalf("Validate(%s) = nil, want a refusal: boot fails closed on a document it cannot apply", tt.document)
|
|
}
|
|
})
|
|
}
|
|
}
|