Files
summercms/modules/cabana/form_extensions_smoke_test.go
Jakub Zych e7423bd21f feat(32-01): form extension placement rules, boot errors and owner-aware branches
- placement: tabs before/after tab anchors, anchor cursor for plugin
  order, own-field anchors sorted with cycle detection, Requires() rule,
  anchor tab inheritance, Hide with reference checks, zone refusal (D-101)
- boot errors name plugin, controller and offending name; fileupload is
  refused (D-100); localized tab label collisions checked in Activate
- extension widgets dispatch to AdminFormExtension.Actions, partials
  render from the contributor's Dir through PartialData, plugin field
  types decode for Save and load after Load, translatable values reach
  Save as locale maps and never the owner's translations
- Permissions and Visible apply to schema, show, save, widgets and
  partials; AdminFormErrors answer 422, Save notices join meta.notices
2026-10-26 22:00:51 +01:00

544 lines
28 KiB
Go

package cabana
import (
"bytes"
"context"
"encoding/json"
"io/fs"
"net/http"
"net/http/httptest"
"strings"
"testing"
"testing/fstest"
"git.golem15.com/golem15/summercms/modules/backpack"
"git.golem15.com/golem15/summercms/modules/bouncer"
"git.golem15.com/golem15/summercms/modules/pact"
"git.golem15.com/golem15/summercms/modules/party"
"git.golem15.com/golem15/summercms/modules/phrasebook"
)
// Pure compile smoke tests of D-91 form extensions (no database): placement,
// boot errors, plugin order and the unextended-form invariant. The
// exhaustive unit matrix is plan 32-06.
// feWide is the smoke owners' model: a column for every owner field name
// the smoke tests use.
type feWide struct {
ID uint `gorm:"column:id;primaryKey"`
A string `gorm:"column:a"`
B string `gorm:"column:b"`
X string `gorm:"column:x"`
X2 string `gorm:"column:x2"`
Y string `gorm:"column:y"`
Z string `gorm:"column:z"`
On bool `gorm:"column:on"`
Title string `gorm:"column:title"`
Slug string `gorm:"column:slug"`
}
// feCtl is a configurable owner controller over the feWide model.
type feCtl struct {
id string
actions []pact.AdminAction
}
func (c feCtl) ID() string { return c.id }
func (feCtl) ModelName() string { return "Post" }
func (feCtl) ConfigDir() string { return "controllers/posts" }
func (feCtl) NewRecord() any { return &feWide{} }
func (feCtl) RequiredPermissions() []string { return nil }
func (c feCtl) AdminActions() []pact.AdminAction { return c.actions }
func (feCtl) AdminJS() []string { return []string{"assets/js/owner.js"} }
func (feCtl) AdminCSS() []string { return nil }
func (feCtl) PartialData(context.Context, string, any) (any, error) {
return map[string]any{"title": "owner"}, nil
}
// feOwnerPlugin owns one controller (id.posts unless ctl is set) whose
// fields.yaml is fields.
type feOwnerPlugin struct {
id, ctl, fields string
actions []pact.AdminAction
}
func (p feOwnerPlugin) ID() string { return p.id }
func (feOwnerPlugin) Requires() []string { return nil }
func (feOwnerPlugin) Register(*backpack.App) error { return nil }
func (feOwnerPlugin) Boot(*backpack.App) error { return nil }
func (p feOwnerPlugin) AdminFS() fs.FS {
dir := strings.ReplaceAll(p.id, ".", "/")
return fstest.MapFS{
"controllers/posts/config_form.yaml": &fstest.MapFile{Data: []byte("name: Post\nform: ~/plugins/" + dir + "/models/post/fields.yaml\nmodelClass: Post\n")},
"controllers/posts/config_list.yaml": &fstest.MapFile{Data: []byte("list: ~/plugins/" + dir + "/models/post/columns.yaml\nmodelClass: Post\nrecordsPerPage: 20\n")},
"controllers/posts/_summary.htm": &fstest.MapFile{Data: []byte("<p>{{ .Data.title }}</p>\n")},
"models/post/columns.yaml": &fstest.MapFile{Data: []byte("columns:\n a:\n label: A\n")},
"models/post/fields.yaml": &fstest.MapFile{Data: []byte(p.fields)},
"assets/js/owner.js": &fstest.MapFile{Data: []byte("// owner\n")},
}
}
func (p feOwnerPlugin) AdminControllers() []pact.AdminController {
ctl := p.ctl
if ctl == "" {
ctl = p.id + ".posts"
}
return []pact.AdminController{feCtl{id: ctl, actions: p.actions}}
}
// feFields builds a fields.yaml from name/tab pairs of text fields
// ("a", "b:T1" for field b in tab T1).
func feFields(specs ...string) string {
var out strings.Builder
out.WriteString("fields:\n")
for _, spec := range specs {
name, tab, _ := strings.Cut(spec, ":")
out.WriteString(" " + name + ":\n type: text\n label: " + strings.ToUpper(name) + "\n")
if tab != "" {
out.WriteString(" tab: " + tab + "\n")
}
}
return out.String()
}
// feExt is a contributor with one extension of controller ctl built from
// the fields document doc; mods adjust the extension.
func feExt(id string, requires []string, ctl, doc string, mods ...func(*pact.AdminFormExtension)) feContributor {
ext := &pact.AdminFormExtension{FieldsYAML: []byte(doc), Save: feNoopSave}
for _, mod := range mods {
mod(ext)
}
return feContributor{id: id, requires: requires, fsys: fstest.MapFS{}, extensions: []pact.AdminActionExtension{{Controller: ctl, Form: ext}}}
}
func feNoopSave(context.Context, pact.AdminFormSave) (pact.AdminFormSaveResult, error) {
return pact.AdminFormSaveResult{}, nil
}
// feBlog is the default owner: acme.blog.posts with fields a and b.
func feBlog(specs ...string) feOwnerPlugin {
if len(specs) == 0 {
specs = []string{"a", "b"}
}
return feOwnerPlugin{id: "acme.blog", fields: feFields(specs...)}
}
// feLayout compiles plugins and returns the field names and the tab keys
// (first appearance, "" for the default tab) of controller ctl.
func feLayout(t *testing.T, ctl string, plugins ...party.Plugin) ([]string, []string) {
t.Helper()
reg, err := feCompile(plugins...)
if err != nil {
t.Fatalf("compile: %v", err)
}
return feLayoutOf(t, reg, ctl)
}
func feLayoutOf(t *testing.T, reg *Registry, ctl string) ([]string, []string) {
t.Helper()
cc, ok := reg.Get(ctl)
if !ok || cc.Form == nil {
t.Fatalf("controller %s has no form", ctl)
}
var names, tabs []string
seen := map[string]bool{}
for _, field := range cc.Form.Fields {
names = append(names, field.Name)
if !seen[field.Tab] {
seen[field.Tab] = true
tabs = append(tabs, field.Tab)
}
}
return names, tabs
}
func feJoin(items []string) string {
out := make([]string, len(items))
for i, item := range items {
if item == "" {
item = "default"
}
out[i] = item
}
return strings.Join(out, " ")
}
func TestFormExtensionPlacement(t *testing.T) {
cases := []struct {
name string
owner feOwnerPlugin
doc string
hide []string
wantNames string
wantTabs string
}{
{"C after A gives A C B", feBlog(), "fields:\n c:\n type: text\n after: a\n", nil, "a c b", "default"},
{"C before the first field", feBlog(), "fields:\n c:\n type: text\n before: a\n", nil, "c a b", "default"},
{"no anchor goes to the end of its tab", feBlog(), "fields:\n c:\n type: text\n", nil, "a b c", "default"},
{"no anchor in a tab goes to the end of that tab", feBlog("a", "x:T1", "y:T1", "z:T2"), "fields:\n c:\n type: text\n tab: T1\n", nil, "a x y c z", "default T1 T2"},
{"an anchor without tab: takes the anchor's tab", feBlog("a", "x:T1", "y:T1"), "fields:\n c:\n type: text\n after: x\n", nil, "a x c y", "default T1"},
{"a field anchored on its own extension's field", feBlog(), "fields:\n d:\n type: text\n after: c\n c:\n type: text\n after: a\n", nil, "a c d b", "default"},
{"two fields after one anchor keep document order", feBlog(), "fields:\n c:\n type: text\n after: a\n d:\n type: text\n after: a\n", nil, "a c d b", "default"},
{"a new tab between two tabs", feBlog("a", "x:T1", "z:T3"), "tabs:\n - name: T2\n after: T1\n before: T3\nfields:\n d:\n type: text\n tab: T2\n", nil, "a x d z", "default T1 T2 T3"},
{"a new tab before a tab", feBlog("a", "x:T1", "z:T3"), "tabs:\n - name: T2\n before: T3\nfields:\n d:\n type: text\n tab: T2\n", nil, "a x d z", "default T1 T2 T3"},
{"a new tab without anchor goes last", feBlog("a", "x:T1"), "tabs:\n - name: T9\nfields:\n d:\n type: text\n tab: T9\n", nil, "a x d", "default T1 T9"},
{"a tab-less form gains the default tab then the new tab", feBlog(), "tabs:\n - name: N\n after: default\nfields:\n n:\n type: text\n tab: N\n", nil, "a b n", "default N"},
{"interleaved owner tabs are grouped by first appearance", feBlog("x:T1", "y:T2", "x2:T1", "a"), "fields:\n c:\n type: text\n tab: T2\n", nil, "a x x2 y c", "default T1 T2"},
{"hide removes an owner field", feBlog(), "fields:\n c:\n type: text\n after: a\n", []string{"b"}, "a c", "default"},
{"a tab that loses all its fields disappears", feBlog("a", "x:T1", "z:T3"), "", []string{"z"}, "a x", "default T1"},
{"zone tabs is the default zone", feBlog(), "fields:\n c:\n type: text\n after: a\n zone: tabs\n", nil, "a c b", "default"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
ext := feExt("acme.extra", nil, "acme.blog.posts", tc.doc, func(e *pact.AdminFormExtension) { e.Hide = tc.hide })
names, tabs := feLayout(t, "acme.blog.posts", tc.owner, ext)
if feJoin(names) != tc.wantNames || feJoin(tabs) != tc.wantTabs {
t.Fatalf("fields = %s, tabs = %s; want fields %s, tabs %s", feJoin(names), feJoin(tabs), tc.wantNames, tc.wantTabs)
}
})
}
t.Run("span keeps its value next to inserted fields", func(t *testing.T) {
ext := feExt("acme.extra", nil, "acme.blog.posts", "fields:\n c:\n type: text\n span: left\n after: a\n")
reg, err := feCompile(feBlog(), ext)
if err != nil {
t.Fatal(err)
}
cc, _ := reg.Get("acme.blog.posts")
if cc.Form.Fields[1].Name != "c" || cc.Form.Fields[1].Span != "left" {
t.Fatalf("fields = %+v", cc.Form.Fields)
}
})
t.Run("a hidden field leaves the owner's bindings", func(t *testing.T) {
ext := feExt("acme.extra", nil, "acme.blog.posts", "", func(e *pact.AdminFormExtension) { e.Hide = []string{"b"} })
reg, err := feCompile(feBlog(), ext)
if err != nil {
t.Fatal(err)
}
cc, _ := reg.Get("acme.blog.posts")
for _, field := range cc.Writable {
if field.Name == "b" {
t.Fatalf("hidden b is still writable: %+v", cc.Writable)
}
}
})
t.Run("a Save-only extension is valid and leaves the layout alone", func(t *testing.T) {
owner := feBlog("x:T1", "a")
ext := feExt("acme.extra", nil, "acme.blog.posts", "")
names, _ := feLayout(t, "acme.blog.posts", owner, ext)
if feJoin(names) != "x a" {
t.Fatalf("fields = %s, want the owner's order x a", feJoin(names))
}
})
}
func TestFormExtensionTwoPluginsSameAnchor(t *testing.T) {
one := feExt("acme.one", nil, "acme.blog.posts", "fields:\n c1:\n type: text\n after: a\n")
two := feExt("acme.two", []string{"acme.one"}, "acme.blog.posts", "fields:\n c2:\n type: text\n after: a\n")
for range 3 {
names, _ := feLayout(t, "acme.blog.posts", feBlog(), one, two)
if feJoin(names) != "a c1 c2 b" {
t.Fatalf("fields = %s, want a c1 c2 b (plugin order kept)", feJoin(names))
}
}
before1 := feExt("acme.one", nil, "acme.blog.posts", "fields:\n c1:\n type: text\n before: b\n")
before2 := feExt("acme.two", []string{"acme.one"}, "acme.blog.posts", "fields:\n c2:\n type: text\n before: b\n")
if names, _ := feLayout(t, "acme.blog.posts", feBlog(), before1, before2); feJoin(names) != "a c1 c2 b" {
t.Fatalf("before: fields = %s, want a c1 c2 b", feJoin(names))
}
onOther := feExt("acme.two", []string{"acme.one"}, "acme.blog.posts", "fields:\n c2:\n type: text\n after: c1\n")
if names, _ := feLayout(t, "acme.blog.posts", feBlog(), one, onOther); feJoin(names) != "a c1 c2 b" {
t.Fatalf("anchored on a required plugin's field: fields = %s", feJoin(names))
}
notRequired := feExt("acme.two", nil, "acme.blog.posts", "fields:\n c2:\n type: text\n after: c1\n")
_, err := feCompile(feBlog(), one, notRequired)
if err == nil || !strings.Contains(err.Error(), "acme.two") || !strings.Contains(err.Error(), "acme.one") || !strings.Contains(err.Error(), "Requires") {
t.Fatalf("err = %v, want the Requires() rule naming acme.two and acme.one", err)
}
}
func TestFormExtensionOnePluginTwoControllers(t *testing.T) {
news := feOwnerPlugin{id: "acme.news", fields: feFields("x:T1", "y")}
both := feContributor{id: "acme.extra", fsys: fstest.MapFS{}, extensions: []pact.AdminActionExtension{
{Controller: "acme.blog.posts", Form: &pact.AdminFormExtension{FieldsYAML: []byte("fields:\n c:\n type: text\n after: a\n"), Save: feNoopSave}},
{Controller: "acme.news.posts", Form: &pact.AdminFormExtension{FieldsYAML: []byte("fields:\n c:\n type: text\n before: x\n"), Save: feNoopSave}},
}}
other := feExt("acme.more", nil, "acme.blog.posts", "fields:\n m:\n type: text\n before: b\n")
for range 3 {
reg, err := feCompile(feBlog(), news, both, other)
if err != nil {
t.Fatal(err)
}
blog, _ := feLayoutOf(t, reg, "acme.blog.posts")
newsNames, newsTabs := feLayoutOf(t, reg, "acme.news.posts")
if feJoin(blog) != "a c m b" || feJoin(newsNames) != "y c x" || feJoin(newsTabs) != "default T1" {
t.Fatalf("blog = %s, news = %s (%s)", feJoin(blog), feJoin(newsNames), feJoin(newsTabs))
}
}
}
func TestFormExtensionUnextendedSchemaUnchanged(t *testing.T) {
// Interleaved tabs: the form would change if it were regrouped.
news := feOwnerPlugin{id: "acme.news", fields: feFields("x:T1", "y:T2", "x2:T1", "a")}
blog := feBlog("x:T1", "a", "y:T1")
canonical := func(plugins ...party.Plugin) (string, string) {
t.Helper()
reg, err := feCompile(plugins...)
if err != nil {
t.Fatal(err)
}
out := make([]string, 0, 2)
for _, id := range []string{"acme.news.posts", "acme.blog.posts"} {
cc, _ := reg.Get(id)
raw, err := cc.Form.CanonicalJSON()
if err != nil {
t.Fatal(err)
}
out = append(out, string(raw))
}
return out[0], out[1]
}
newsBefore, blogBefore := canonical(news, blog)
extended := feExt("acme.extra", nil, "acme.blog.posts", "fields:\n c:\n type: text\n after: a\n")
newsAfter, _ := canonical(news, blog, extended)
if newsBefore != newsAfter {
t.Fatalf("a form no extension targets changed:\n%s\n%s", newsBefore, newsAfter)
}
saveOnly := feExt("acme.extra", nil, "acme.blog.posts", "")
_, blogSaveOnly := canonical(news, blog, saveOnly)
if blogBefore != blogSaveOnly {
t.Fatalf("a Save-only extension changed the form:\n%s\n%s", blogBefore, blogSaveOnly)
}
}
// feTabTranslator has two tab keys that read the same in pl only.
func feTabTranslator(t *testing.T) *phrasebook.Translator {
t.Helper()
cat := phrasebook.NewCatalog()
if err := cat.Load("acme.extra", fstest.MapFS{
"lang/en/lang.yaml": {Data: []byte("tabs:\n meta: Meta\n details: Details\n")},
"lang/pl/lang.yaml": {Data: []byte("tabs:\n meta: Szczegóły\n details: Szczegóły\n")},
}); err != nil {
t.Fatal(err)
}
return phrasebook.NewTranslator(cat, phrasebook.Options{Locale: "en", Fallback: "en"})
}
func TestFormExtensionBootErrors(t *testing.T) {
widgetDoc := "fields:\n w:\n type: widget\n widget: acme-extra-preview\n action: preview\n"
partialDoc := "fields:\n p:\n type: partial\n path: summary\n"
ownerWithPartial := feOwnerPlugin{id: "acme.blog", fields: feFields("a", "b") + " s:\n type: partial\n path: summary\n"}
ownerWithAction := feOwnerPlugin{id: "acme.blog", fields: feFields("a", "b"), actions: []pact.AdminAction{{Name: "preview", Label: "Preview", Run: feActionRun}}}
cases := []struct {
name string
plugins []party.Plugin
want []string
}{
{"unknown controller", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.nope", "")}, []string{"acme.extra", "acme.blog.nope"}},
{"unknown field anchor", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "fields:\n c:\n type: text\n after: zz\n")}, []string{"acme.extra", "acme.blog.posts", "zz", "unknown anchor"}},
{"unknown tab anchor", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "tabs:\n - name: T2\n after: T7\n")}, []string{"acme.extra", "acme.blog.posts", "T7", "unknown"}},
{"unknown tab of a field", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "fields:\n c:\n type: text\n tab: T7\n")}, []string{"acme.extra", "acme.blog.posts", "T7"}},
{"duplicate field name against the owner", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "fields:\n b:\n type: text\n")}, []string{"acme.extra", "acme.blog.posts", "field b", "duplicate"}},
{"duplicate field name against an earlier extension", []party.Plugin{feBlog(), feExt("acme.one", nil, "acme.blog.posts", "fields:\n c:\n type: text\n"), feExt("acme.two", nil, "acme.blog.posts", "fields:\n c:\n type: text\n")}, []string{"acme.two", "acme.one", "acme.blog.posts", "field c", "duplicate"}},
{"duplicate tab key against the owner", []party.Plugin{feBlog("a", "x:T1"), feExt("acme.extra", nil, "acme.blog.posts", "tabs:\n - name: T1\n")}, []string{"acme.extra", "acme.blog.posts", "T1", "duplicate"}},
{"duplicate tab key against an earlier extension", []party.Plugin{feBlog(), feExt("acme.one", nil, "acme.blog.posts", "tabs:\n - name: N\n"), feExt("acme.two", nil, "acme.blog.posts", "tabs:\n - name: N\n")}, []string{"acme.two", "acme.blog.posts", "N", "duplicate"}},
{"an anchor cycle", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "fields:\n c:\n type: text\n after: d\n d:\n type: text\n after: c\n")}, []string{"acme.extra", "acme.blog.posts", "cycle", "c", "d"}},
{"an anchor outside Requires()", []party.Plugin{feBlog(), feExt("acme.one", nil, "acme.blog.posts", "fields:\n c1:\n type: text\n"), feExt("acme.two", nil, "acme.blog.posts", "fields:\n c2:\n type: text\n before: c1\n")}, []string{"acme.two", "acme.blog.posts", "c1", "Requires"}},
{"before the default tab", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "tabs:\n - name: N\n before: default\n")}, []string{"acme.extra", "acme.blog.posts", "N", "default"}},
{"zone outside", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "fields:\n c:\n type: text\n zone: outside\n")}, []string{"acme.extra", "acme.blog.posts", "field c", `zone "outside" is not supported yet`}},
{"zone secondary on a tab", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "tabs:\n - name: N\n zone: secondary\n")}, []string{"acme.extra", "acme.blog.posts", "N", `zone "secondary" is not supported yet`}},
{"hide of an unknown field", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "", func(e *pact.AdminFormExtension) { e.Hide = []string{"zz"} })}, []string{"acme.extra", "acme.blog.posts", "zz", "Hide"}},
{"hide of a field a trigger references", []party.Plugin{feOwnerPlugin{id: "acme.blog", fields: "fields:\n on:\n type: switch\n a:\n type: text\n trigger:\n action: hide\n field: on\n condition: checked\n"}, feExt("acme.extra", nil, "acme.blog.posts", "", func(e *pact.AdminFormExtension) { e.Hide = []string{"on"} })}, []string{"acme.extra", "acme.blog.posts", "on", "field a"}},
{"hide of a field a preset references", []party.Plugin{feOwnerPlugin{id: "acme.blog", fields: "fields:\n title:\n type: text\n slug:\n type: text\n preset:\n field: title\n type: slug\n"}, feExt("acme.extra", nil, "acme.blog.posts", "", func(e *pact.AdminFormExtension) { e.Hide = []string{"title"} })}, []string{"acme.extra", "acme.blog.posts", "title", "field slug"}},
{"a fileupload field", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "fields:\n img:\n type: fileupload\n mode: image\n")}, []string{"acme.extra", "acme.blog.posts", "field img", "fileupload", "Upload"}},
{"a widget action the owner registers", []party.Plugin{ownerWithAction, feExtWidgetPlugin(widgetDoc)}, []string{"acme.extra", "acme.blog.posts", "preview", "owner"}},
{"a partial name the owner uses", []party.Plugin{ownerWithPartial, feExtPartialPlugin(partialDoc)}, []string{"acme.extra", "acme.blog.posts", "summary", "owner"}},
{"fields with values and no Save", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "fields:\n c:\n type: text\n", func(e *pact.AdminFormExtension) { e.Save = nil })}, []string{"acme.extra", "acme.blog.posts", "Save"}},
{"both Fields and FieldsYAML", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "fields: {}\n", func(e *pact.AdminFormExtension) { e.Fields = "x.yaml" })}, []string{"acme.extra", "acme.blog.posts", "FieldsYAML"}},
{"an unknown document key", []party.Plugin{feBlog(), feExt("acme.extra", nil, "acme.blog.posts", "secondaryTabs: {}\n")}, []string{"acme.extra", "acme.blog.posts", "secondaryTabs"}},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
_, err := feCompile(tc.plugins...)
if err == nil {
t.Fatalf("boot succeeded, want an error naming %v", tc.want)
}
for _, want := range tc.want {
if !strings.Contains(err.Error(), want) {
t.Fatalf("err = %v, want it to name %q", err, want)
}
}
})
}
t.Run("two tab keys whose labels translate to the same text", func(t *testing.T) {
ext := feExt("acme.extra", nil, "acme.blog.posts", "tabs:\n - name: acme.extra::lang.tabs.meta\n - name: acme.extra::lang.tabs.details\nfields:\n m:\n type: text\n tab: acme.extra::lang.tabs.meta\n d:\n type: text\n tab: acme.extra::lang.tabs.details\n")
reg, err := feCompile(feBlog(), ext)
if err != nil {
t.Fatal(err)
}
err = checkFormExtensionTabLabels(reg, feTabTranslator(t))
for _, want := range []string{"acme.extra", "acme.blog.posts", "acme.extra::lang.tabs.details", "pl"} {
if err == nil || !strings.Contains(err.Error(), want) {
t.Fatalf("err = %v, want it to name %q", err, want)
}
}
})
}
func feActionRun(context.Context, pact.AdminActionInput) (pact.AdminActionResult, error) {
return pact.AdminActionResult{Message: "ran"}, nil
}
// feWidgetType is a field type of acme.extra whose script defines the
// extension's widget element.
func feWidgetType() pact.FormFieldType {
return pact.FormFieldType{
Name: "extranote", Element: "acme-extra-note", Scripts: []string{"assets/js/extra.js"},
Decode: func(_ context.Context, in pact.FormFieldValue) (pact.FormFieldDecoded, error) {
return pact.FormFieldDecoded{Value: in.Value}, nil
},
}
}
func feExtWidgetPlugin(doc string) feContributor {
ext := feExt("acme.extra", nil, "acme.blog.posts", doc, func(e *pact.AdminFormExtension) {
e.Actions = []pact.AdminAction{{Name: "preview", Label: "acme.extra::lang.preview", Run: func(_ context.Context, in pact.AdminActionInput) (pact.AdminActionResult, error) {
return pact.AdminActionResult{Message: "previewed", Fill: map[string]any{"title": in.Values["title"]}}, nil
}}}
})
ext.fsys = fstest.MapFS{"assets/js/extra.js": &fstest.MapFile{Data: []byte("// extra\n")}}
ext.types = []pact.FormFieldType{feWidgetType()}
return ext
}
// feGORMView is a GORM model the partial guard must refuse.
type feGORMView struct {
ID uint `gorm:"primaryKey"`
}
func feExtPartialPlugin(doc string) feContributor {
ext := feExt("acme.extra", nil, "acme.blog.posts", doc, func(e *pact.AdminFormExtension) {
e.Dir = "partials"
e.PartialData = func(_ context.Context, name string, _ any) (any, error) {
if name == "leak" {
return &feGORMView{ID: 1}, nil
}
return map[string]any{"title": "from " + name}, nil
}
})
ext.fsys = fstest.MapFS{
"partials/_summary.htm": &fstest.MapFile{Data: []byte("<p>{{ .Data.title }}</p>\n")},
"partials/_status.htm": &fstest.MapFile{Data: []byte("<p>{{ .Data.title }}</p>\n")},
"partials/_leak.htm": &fstest.MapFile{Data: []byte("<p>leak</p>\n")},
}
return ext
}
// feRequest is an admin request to controller acme.blog.posts.
func feRequest(principal *bouncer.Principal, method, target string, body any, values map[string]string) *http.Request {
var raw []byte
if body != nil {
raw, _ = json.Marshal(body)
}
req := httptest.NewRequest(method, target, bytes.NewReader(raw))
req.Header.Set("Content-Type", "application/json")
for name, value := range map[string]string{"vendor": "acme", "plugin": "blog", "controller": "posts"} {
req.SetPathValue(name, value)
}
for name, value := range values {
req.SetPathValue(name, value)
}
return req.WithContext(bouncer.WithUser(req.Context(), principal))
}
func TestFormExtensionWidgetsAndPartials(t *testing.T) {
doc := "fields:\n title:\n type: text\n after: a\n preview:\n type: widget\n widget: acme-extra-preview\n action: preview\n fill: [title]\n after: title\n status:\n type: partial\n path: status\n leak:\n type: partial\n path: leak\n"
widget := feExtWidgetPlugin(doc)
partials := feExtPartialPlugin("")
ext := widget
ext.fsys = fstest.MapFS{}
for name, file := range widget.fsys {
ext.fsys[name] = file
}
for name, file := range partials.fsys {
ext.fsys[name] = file
}
ext.extensions[0].Form.Dir = "partials"
ext.extensions[0].Form.PartialData = partials.extensions[0].Form.PartialData
reg, err := feCompile(feBlog(), ext)
if err != nil {
t.Fatalf("compile: %v", err)
}
svc := &service{reg: reg}
rec := httptest.NewRecorder()
svc.formSchema(rec, feRequest(superUser(), http.MethodGet, "/", nil, nil))
if names := feSchemaNames(t, rec); feJoin(names) != "a title preview b status leak" {
t.Fatalf("schema = %v", names)
}
if !strings.Contains(rec.Body.String(), `"actionLabel":"acme.extra::lang.preview"`) {
t.Fatalf("the widget carries no action label: %s", rec.Body.String())
}
rec = httptest.NewRecorder()
svc.widgetAction(rec, feRequest(superUser(), http.MethodPost, "/", map[string]any{"values": map[string]any{"title": "T", "a": "x"}}, map[string]string{"field": "preview"}))
if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"previewed"`) || !strings.Contains(rec.Body.String(), `"title":"T"`) {
t.Fatalf("widget action status=%d body=%s", rec.Code, rec.Body.String())
}
rec = httptest.NewRecorder()
svc.partial(rec, feRequest(superUser(), http.MethodGet, "/", nil, map[string]string{"name": "status"}))
if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), "from status") {
t.Fatalf("partial status=%d body=%s", rec.Code, rec.Body.String())
}
rec = httptest.NewRecorder()
svc.partial(rec, feRequest(superUser(), http.MethodGet, "/", nil, map[string]string{"name": "leak"}))
if rec.Code != http.StatusInternalServerError {
t.Fatalf("a GORM view model rendered: status=%d body=%s", rec.Code, rec.Body.String())
}
t.Run("an invisible extension offers no field, widget or partial", func(t *testing.T) {
hidden := ext
form := *ext.extensions[0].Form
form.Permissions = []string{"acme.extra.manage"}
hidden.extensions = []pact.AdminActionExtension{{Controller: "acme.blog.posts", Form: &form}}
reg, err := feCompile(feBlog(), hidden)
if err != nil {
t.Fatal(err)
}
svc := &service{reg: reg}
editor := &bouncer.Principal{ID: 2, Backend: true, PermissionGrants: map[string]bool{"acme.blog.access": true}}
rec := httptest.NewRecorder()
svc.formSchema(rec, feRequest(editor, http.MethodGet, "/", nil, nil))
if names := feSchemaNames(t, rec); feJoin(names) != "a b" {
t.Fatalf("schema without the permission = %v", names)
}
rec = httptest.NewRecorder()
svc.widgetAction(rec, feRequest(editor, http.MethodPost, "/", map[string]any{}, map[string]string{"field": "preview"}))
if rec.Code != http.StatusNotFound && rec.Code != http.StatusForbidden {
t.Fatalf("widget without the permission status=%d", rec.Code)
}
rec = httptest.NewRecorder()
svc.partial(rec, feRequest(editor, http.MethodGet, "/", nil, map[string]string{"name": "status"}))
if rec.Code != http.StatusNotFound && rec.Code != http.StatusForbidden {
t.Fatalf("partial without the permission status=%d", rec.Code)
}
})
t.Run("a widget tag outside the contributor's prefix fails boot", func(t *testing.T) {
bad := feExtWidgetPlugin("fields:\n w:\n type: widget\n widget: acme-blog-preview\n action: preview\n")
if _, err := feCompile(feBlog(), bad); err == nil || !strings.Contains(err.Error(), "acme-extra-") {
t.Fatalf("err = %v, want the contributor's prefix", err)
}
})
t.Run("a widget filling an owner field fails boot", func(t *testing.T) {
bad := feExtWidgetPlugin("fields:\n w:\n type: widget\n widget: acme-extra-preview\n action: preview\n fill: [a]\n")
if _, err := feCompile(feBlog(), bad); err == nil || !strings.Contains(err.Error(), "fill a") {
t.Fatalf("err = %v, want the fill refusal", err)
}
})
}