Files
archie/internal/domain/mapping/mapping_test.go
T
sam aba035a396 feat(webui): payload field mapping -- bind JSON paths to named fields, preview before saving
Adds t2db.3: schema-by-example field mapping for the no-code playbook epic.
An operator picks a captured event, clicks through its payload to bind named
fields to JSON paths, and previews the resolution against a real event
before saving -- a missing, null, or type-changed path fails loudly (named
by field and event) rather than handing an agent a blank value.

- internal/domain/mapping: Mapping/Field types, path parsing/walking,
  Resolve (per-field failure reporting), Validate (incl. duplicate names)
- internal/store/mappings.go: SQLite persistence, mirrors captures.go
- internal/webui/api_mapping.go: CRUD + preview HTTP API
- ui/src/mappings/: dashboard editor (clickable payload tree, live preview)

Design decisions recorded in docs/prds/payload-field-mapping.md. t2db.4
(binding a mapping + matcher to a workflow) is out of scope here.
2026-08-22 19:18:15 +10:00

210 lines
7.1 KiB
Go

package mapping_test
import (
"testing"
"github.com/samcharles93/archie-core/internal/domain/mapping"
)
func TestResolveExtractsValuesByPath(t *testing.T) {
tests := []struct {
name string
payload string
fields []mapping.Field
want map[string]any
}{
{
name: "top level string",
payload: `{"action":"opened"}`,
fields: []mapping.Field{{Name: "action", Path: "action", Type: mapping.TypeString}},
want: map[string]any{"action": "opened"},
},
{
name: "nested object",
payload: `{"issue":{"title":"bug found"}}`,
fields: []mapping.Field{{Name: "title", Path: "issue.title", Type: mapping.TypeString}},
want: map[string]any{"title": "bug found"},
},
{
name: "array index",
payload: `{"items":[{"id":1},{"id":2}]}`,
fields: []mapping.Field{{Name: "second_id", Path: "items[1].id", Type: mapping.TypeNumber}},
want: map[string]any{"second_id": float64(2)},
},
{
name: "any type matches anything",
payload: `{"flag":true}`,
fields: []mapping.Field{{Name: "flag", Path: "flag", Type: mapping.TypeAny}},
want: map[string]any{"flag": true},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
values, failures := mapping.Resolve(tt.fields, []byte(tt.payload))
if len(failures) != 0 {
t.Fatalf("unexpected failures: %+v", failures)
}
for k, want := range tt.want {
got, ok := values[k]
if !ok {
t.Fatalf("missing resolved value for %q", k)
}
if got != want {
t.Errorf("values[%q] = %#v, want %#v", k, got, want)
}
}
})
}
}
func TestResolveReportsFailuresLoudly(t *testing.T) {
tests := []struct {
name string
payload string
fields []mapping.Field
wantReason string
}{
{
name: "missing path",
payload: `{"action":"opened"}`,
fields: []mapping.Field{{Name: "title", Path: "issue.title", Type: mapping.TypeString, Required: true}},
wantReason: mapping.ReasonMissing,
},
{
name: "null value",
payload: `{"issue":{"title":null}}`,
fields: []mapping.Field{{Name: "title", Path: "issue.title", Type: mapping.TypeString}},
wantReason: mapping.ReasonNull,
},
{
name: "type mismatch",
payload: `{"issue":{"title":42}}`,
fields: []mapping.Field{{Name: "title", Path: "issue.title", Type: mapping.TypeString}},
wantReason: mapping.ReasonTypeMismatch,
},
{
name: "index past array length",
payload: `{"items":[{"id":1}]}`,
fields: []mapping.Field{{Name: "second_id", Path: "items[1].id", Type: mapping.TypeNumber, Required: true}},
wantReason: mapping.ReasonMissing,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
values, failures := mapping.Resolve(tt.fields, []byte(tt.payload))
if len(failures) != 1 {
t.Fatalf("got %d failures, want 1: %+v", len(failures), failures)
}
f := failures[0]
if f.Reason != tt.wantReason {
t.Errorf("Reason = %q, want %q", f.Reason, tt.wantReason)
}
if f.FieldName != tt.fields[0].Name {
t.Errorf("FieldName = %q, want %q", f.FieldName, tt.fields[0].Name)
}
if f.Path != tt.fields[0].Path {
t.Errorf("Path = %q, want %q", f.Path, tt.fields[0].Path)
}
if _, ok := values[tt.fields[0].Name]; ok {
t.Errorf("a failed field must not appear in values, got %#v", values[tt.fields[0].Name])
}
})
}
}
func TestResolveOptionalMissingIsNotAFailure(t *testing.T) {
fields := []mapping.Field{{Name: "title", Path: "issue.title", Type: mapping.TypeString, Required: false}}
values, failures := mapping.Resolve(fields, []byte(`{"action":"opened"}`))
if len(failures) != 0 {
t.Fatalf("optional missing field must not fail, got %+v", failures)
}
if _, ok := values["title"]; ok {
t.Errorf("missing optional field must not appear in values")
}
}
func TestResolveOptionalButWrongTypeStillFails(t *testing.T) {
fields := []mapping.Field{{Name: "title", Path: "issue.title", Type: mapping.TypeString, Required: false}}
_, failures := mapping.Resolve(fields, []byte(`{"issue":{"title":42}}`))
if len(failures) != 1 || failures[0].Reason != mapping.ReasonTypeMismatch {
t.Fatalf("optional field with wrong type must still fail loudly, got %+v", failures)
}
}
func TestResolveKeepsGoingAfterOneFieldFails(t *testing.T) {
fields := []mapping.Field{
{Name: "missing", Path: "nope", Type: mapping.TypeString, Required: true},
{Name: "action", Path: "action", Type: mapping.TypeString},
}
values, failures := mapping.Resolve(fields, []byte(`{"action":"opened"}`))
if len(failures) != 1 {
t.Fatalf("want exactly 1 failure, got %+v", failures)
}
if values["action"] != "opened" {
t.Errorf("second field should still resolve, got values=%+v", values)
}
}
func TestValidateRejectsMalformedMappings(t *testing.T) {
tests := []struct {
name string
m mapping.Mapping
}{
{"empty name", mapping.Mapping{Name: "", Fields: []mapping.Field{{Name: "a", Path: "a", Type: mapping.TypeString}}}},
{"no fields", mapping.Mapping{Name: "m", Fields: nil}},
{"field with no name", mapping.Mapping{Name: "m", Fields: []mapping.Field{{Path: "a", Type: mapping.TypeString}}}},
{"field with no path", mapping.Mapping{Name: "m", Fields: []mapping.Field{{Name: "a", Type: mapping.TypeString}}}},
{"field with unknown type", mapping.Mapping{Name: "m", Fields: []mapping.Field{{Name: "a", Path: "a", Type: "wat"}}}},
{"duplicate field names", mapping.Mapping{Name: "m", Fields: []mapping.Field{
{Name: "a", Path: "x", Type: mapping.TypeString},
{Name: "a", Path: "y", Type: mapping.TypeString},
}}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := tt.m.Validate(); err == nil {
t.Fatalf("Validate() = nil, want an error for %+v", tt.m)
}
})
}
}
func TestValidateAcceptsWellFormedMapping(t *testing.T) {
m := mapping.Mapping{
Name: "sentry issue opened",
Fields: []mapping.Field{{Name: "title", Path: "issue.title", Type: mapping.TypeString, Required: true}},
}
if err := m.Validate(); err != nil {
t.Fatalf("Validate() = %v, want nil", err)
}
}
func TestResolveTreatsMalformedArrayIndexAsMissingNotReinterpreted(t *testing.T) {
// "items[abc].id" must never silently resolve as if it were "items.id" --
// a malformed path is a mistake the operator should see, not a different
// path succeeding by accident.
fields := []mapping.Field{{Name: "id", Path: "items[abc].id", Type: mapping.TypeNumber, Required: true}}
values, failures := mapping.Resolve(fields, []byte(`{"items":{"id":5}}`))
if len(failures) != 1 || failures[0].Reason != mapping.ReasonMissing {
t.Fatalf("failures = %+v, want exactly one ReasonMissing", failures)
}
if _, ok := values["id"]; ok {
t.Fatalf("a malformed path must never resolve a value, got %#v", values["id"])
}
}
func TestResolveNumberPreservesIntVsFloatShapeButTypeCheckIsNumeric(t *testing.T) {
fields := []mapping.Field{
{Name: "count", Path: "count", Type: mapping.TypeNumber},
}
values, failures := mapping.Resolve(fields, []byte(`{"count":42}`))
if len(failures) != 0 {
t.Fatalf("unexpected failures: %+v", failures)
}
if values["count"] != float64(42) {
t.Errorf("count = %#v, want float64(42)", values["count"])
}
}