The schedules document stored interval as a bare time.Duration, so its JSON was
the nanosecond count -- 1800000000000 for thirty minutes -- and the Web UI, which
now derives field metadata from the document type, correctly rendered a number
input. Same defect 02rm fixed for rate_limit.window, in the second stored time
this tree has. Nobody should be asked for a count of nanoseconds to configure a
schedule.
cronstore.Duration writes the string time.ParseDuration reads and reads that, a
nanosecond count, and nothing else: every schedule stored before this shape
existed carries a count, in both the control plane's schedules resource and this
package's own jobs table, which persists the spec as JSON. A value that parses as
neither is refused rather than decoding as zero, because a zero interval is a job
that never fires.
The derived schema needed no change and gets it for free -- which exposed a fix
the derivation itself needed: it classified durations by NAME, so cronstore.Duration
derived as an integer. durationLike now asks the type instead -- does it expose the
standard duration, and does it marshal as a quoted string -- so the next duration
type is classified correctly rather than silently rendering as a number box. That
failure mode was invisible until a live daemon showed it.
normalizeSchedules already re-marshals, so a stored document converges on its next
write while reads keep tolerating the count.
Verified: cronstore, crondelivery, controlplane, scheduling, webui and archied
suites, go vet ./..., go build ./..., golangci-lint run ./... (0 issues),
docs:check. Against a live daemon (8484): the catalog serves schedule.interval as
{type: string, format: duration}.
229 lines
8.6 KiB
Go
229 lines
8.6 KiB
Go
package controlplane
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
)
|
|
|
|
type schemaFixtureNested struct {
|
|
Prompt string `json:"prompt"`
|
|
}
|
|
|
|
type schemaFixtureEmbedded struct {
|
|
Shared string `json:"shared"`
|
|
}
|
|
|
|
type schemaFixture struct {
|
|
schemaFixtureEmbedded
|
|
Name string `json:"name" title:"Display name"`
|
|
Skipped string `json:"-"`
|
|
Untagged string // no json tag: the document key is the Go name
|
|
Count int `json:"count"`
|
|
Ratio float64 `json:"ratio"`
|
|
Enabled bool `json:"enabled"`
|
|
Window config.Duration `json:"window"`
|
|
Lifetime channelDuration `json:"lifetime"`
|
|
// A bare time.Duration marshals as its nanosecond count, unlike the two
|
|
// named types above, which marshal as the string time.ParseDuration reads.
|
|
// The schema describes the wire form, not the Go type's name, or a client
|
|
// renders a text box for a number.
|
|
Timeout time.Duration `json:"timeout"`
|
|
When time.Time `json:"when"`
|
|
Tags []string `json:"tags"`
|
|
Roles map[string]string `json:"roles"`
|
|
Nested schemaFixtureNested `json:"nested"`
|
|
Hinted string `json:"hinted" format:"duration" doc:"A hint."`
|
|
|
|
unexported string
|
|
}
|
|
|
|
// TestSchemaDerivesKeysTypesAndAnnotations pins the derivation itself, including
|
|
// the rules that are easy to get subtly wrong: a field with no json tag is
|
|
// described by the Go name the document actually stores, a named duration type
|
|
// is a string with a format because that is what it marshals as, and a bare
|
|
// time.Duration stays an integer for the same reason.
|
|
func TestSchemaDerivesKeysTypesAndAnnotations(t *testing.T) {
|
|
expected := map[string]any{
|
|
"type": "object",
|
|
"properties": map[string]any{
|
|
"shared": map[string]any{"type": "string"},
|
|
"name": map[string]any{"type": "string", "title": "Display name"},
|
|
"Untagged": map[string]any{"type": "string"},
|
|
"count": map[string]any{"type": "integer"},
|
|
"ratio": map[string]any{"type": "number"},
|
|
"enabled": map[string]any{"type": "boolean"},
|
|
"window": map[string]any{"type": "string", "format": "duration"},
|
|
"lifetime": map[string]any{"type": "string", "format": "duration"},
|
|
"timeout": map[string]any{"type": "integer"},
|
|
"when": map[string]any{"type": "string", "format": "date-time"},
|
|
"tags": map[string]any{"type": "array", "items": map[string]any{"type": "string"}},
|
|
"roles": map[string]any{"type": "object", "additionalProperties": map[string]any{"type": "string"}},
|
|
"nested": map[string]any{"type": "object", "properties": map[string]any{"prompt": map[string]any{"type": "string"}}},
|
|
"hinted": map[string]any{"type": "string", "format": "duration", "description": "A hint."},
|
|
},
|
|
}
|
|
var got map[string]any
|
|
// The unexported field is populated rather than left blank, so the
|
|
// assertion below proves it is omitted even when it carries a value.
|
|
if err := json.Unmarshal([]byte(schemaJSON(schemaFixture{unexported: "not in the document"})), &got); err != nil {
|
|
t.Fatalf("unmarshal derived schema: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(got, expected) {
|
|
t.Fatalf("derived schema =\n%#v\nwant\n%#v", got, expected)
|
|
}
|
|
properties, ok := got["properties"].(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("derived schema has no properties object: %#v", got)
|
|
}
|
|
if _, present := properties["Skipped"]; present {
|
|
t.Error(`json:"-" field is described, so the schema names a key the document never stores`)
|
|
}
|
|
if _, present := properties["unexported"]; present {
|
|
t.Error("unexported field is described")
|
|
}
|
|
}
|
|
|
|
// TestEveryResourceDescriptorDerivesProperties is the regression guard for the
|
|
// defect this replaced: twelve definitions each advertised a bare
|
|
// {"type":"object"} or {"type":"array"}, so no descriptor carried a single field
|
|
// for the Web UI to label, describe or format. Every kind here must describe
|
|
// something, and this walks the catalogue the constructor production uses rather
|
|
// than the definitions in isolation.
|
|
func TestEveryResourceDescriptorDerivesProperties(t *testing.T) {
|
|
server := testServer(t, nil)
|
|
catalog, err := server.Catalog(t.Context(), nil)
|
|
if err != nil {
|
|
t.Fatalf("Catalog: %v", err)
|
|
}
|
|
describing := 0
|
|
for _, descriptor := range catalog.Resources {
|
|
if descriptor.SchemaJson == "" {
|
|
// Domain-managed kinds (identities, captures, mappings, bindings)
|
|
// carry commands rather than a document this side validates.
|
|
continue
|
|
}
|
|
describing++
|
|
var schema map[string]any
|
|
if err := json.Unmarshal([]byte(descriptor.SchemaJson), &schema); err != nil {
|
|
t.Errorf("%s: schema is not JSON: %v", descriptor.Kind, err)
|
|
continue
|
|
}
|
|
switch schema["type"] {
|
|
case "object":
|
|
// A fixed document describes properties; a keyed collection
|
|
// (providers, model roles) describes additionalProperties and has
|
|
// no fixed keys by design. Either is a described document; neither
|
|
// is the bare object this guard exists to catch.
|
|
properties, hasProperties := schema["properties"].(map[string]any)
|
|
_, hasAdditional := schema["additionalProperties"].(map[string]any)
|
|
if (!hasProperties || len(properties) == 0) && !hasAdditional {
|
|
t.Errorf("%s: object schema describes no fields: %s", descriptor.Kind, descriptor.SchemaJson)
|
|
}
|
|
case "array":
|
|
if _, ok := schema["items"].(map[string]any); !ok {
|
|
t.Errorf("%s: array schema describes no items: %s", descriptor.Kind, descriptor.SchemaJson)
|
|
}
|
|
default:
|
|
t.Errorf("%s: schema type = %#v, want object or array", descriptor.Kind, schema["type"])
|
|
}
|
|
}
|
|
if describing == 0 {
|
|
t.Fatal("no descriptor advertised a schema: the guard asserted nothing")
|
|
}
|
|
}
|
|
|
|
// TestSchedulesDescriptorFormatsTheInterval is the same payoff one document over:
|
|
// the schedules interval is a Duration now, so the derivation turns it into a
|
|
// formatted string with no schema authored for it (archie-core-4w0c).
|
|
func TestSchedulesDescriptorFormatsTheInterval(t *testing.T) {
|
|
server := testServer(t, nil)
|
|
catalog, err := server.Catalog(t.Context(), nil)
|
|
if err != nil {
|
|
t.Fatalf("Catalog: %v", err)
|
|
}
|
|
var schema struct {
|
|
Items struct {
|
|
Properties struct {
|
|
Schedule struct {
|
|
Properties struct {
|
|
Interval struct {
|
|
Type string `json:"type"`
|
|
Format string `json:"format"`
|
|
} `json:"interval"`
|
|
} `json:"properties"`
|
|
} `json:"schedule"`
|
|
} `json:"properties"`
|
|
} `json:"items"`
|
|
}
|
|
found := false
|
|
for _, descriptor := range catalog.Resources {
|
|
if descriptor.Kind != SchedulesKind {
|
|
continue
|
|
}
|
|
found = true
|
|
if err := json.Unmarshal([]byte(descriptor.SchemaJson), &schema); err != nil {
|
|
t.Fatalf("unmarshal schedules schema: %v", err)
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatal("schedules is not in the catalog")
|
|
}
|
|
interval := schema.Items.Properties.Schedule.Properties.Interval
|
|
if interval.Type != "string" || interval.Format != "duration" {
|
|
t.Errorf("schedule.interval = %+v, want a duration-formatted string: the document carries 30m0s, not nanoseconds", interval)
|
|
}
|
|
}
|
|
|
|
// TestChannelSettingsDescriptorFormatsTheRateLimitWindow is the concrete payoff:
|
|
// the field that asked an operator for a nanosecond count now carries a format a
|
|
// client can render an affordance for, and it arrives by derivation rather than
|
|
// by anyone remembering to write it down.
|
|
func TestChannelSettingsDescriptorFormatsTheRateLimitWindow(t *testing.T) {
|
|
server := testServer(t, nil)
|
|
catalog, err := server.Catalog(t.Context(), nil)
|
|
if err != nil {
|
|
t.Fatalf("Catalog: %v", err)
|
|
}
|
|
var schema struct {
|
|
Properties struct {
|
|
RateLimit struct {
|
|
Properties struct {
|
|
Window struct {
|
|
Type string `json:"type"`
|
|
Format string `json:"format"`
|
|
} `json:"window"`
|
|
MaxRequests struct {
|
|
Type string `json:"type"`
|
|
} `json:"max_requests"`
|
|
} `json:"properties"`
|
|
} `json:"rate_limit"`
|
|
Email struct {
|
|
Properties map[string]struct {
|
|
Type string `json:"type"`
|
|
} `json:"properties"`
|
|
} `json:"email"`
|
|
} `json:"properties"`
|
|
}
|
|
for _, descriptor := range catalog.Resources {
|
|
if descriptor.Kind != ChannelSettingsKind {
|
|
continue
|
|
}
|
|
if err := json.Unmarshal([]byte(descriptor.SchemaJson), &schema); err != nil {
|
|
t.Fatalf("unmarshal channel-settings schema: %v", err)
|
|
}
|
|
}
|
|
if schema.Properties.RateLimit.Properties.Window.Format != "duration" {
|
|
t.Errorf("rate_limit.window format = %q, want \"duration\"", schema.Properties.RateLimit.Properties.Window.Format)
|
|
}
|
|
if schema.Properties.RateLimit.Properties.MaxRequests.Type != "integer" {
|
|
t.Errorf("rate_limit.max_requests type = %q, want \"integer\"", schema.Properties.RateLimit.Properties.MaxRequests.Type)
|
|
}
|
|
if len(schema.Properties.Email.Properties) == 0 {
|
|
t.Error("email describes no properties, want listen_addr and relay_addr")
|
|
}
|
|
}
|