analyze_test.go

package strut

// Everything from a command struct to the payload Discord receives. A bug
// here produces a command that is silently wrong, or one Discord rejects.

import (
	"encoding/json"
	"reflect"
	"strings"
	"testing"

	"github.com/disgoorg/disgo/discord"
)

// Severity has a static choice list.
type Severity string

func (Severity) Choices() []Choice[Severity] {
	return []Choice[Severity]{{Name: "Low", Value: "low"}}
}

// TagName is autocompleted. The first parameter stands in for *Event[D],
// which analyze does not need to know about.
type TagName string

func (TagName) Autocomplete(_ *Event[testData], _ Partial) []Choice[TagName] { return nil }

// Both declares a choice list and an autocomplete method, which Discord
// forbids on the same option.
type Both string

func (Both) Choices() []Choice[Both]                                   { return nil }
func (Both) Autocomplete(_ *Event[testData], _ Partial) []Choice[Both] { return nil }

func analyzeErr(t *testing.T, v any, m mode) string {
	t.Helper()
	_, err := analyze(reflect.TypeOf(v), m)
	if err == nil {
		return ""
	}
	return err.Error()
}

func mustAnalyze(t *testing.T, v any, m mode) *structSpec {
	t.Helper()
	spec, err := analyze(reflect.TypeOf(v), m)
	if err != nil {
		t.Fatalf("analyze: %v", err)
	}
	return spec
}

func TestAnalyzeValidCommand(t *testing.T) {
	type ban struct {
		db  int `strut:"-"` //nolint:unused // exercises the skip tag
		log int

		User   discord.ResolvedMember `strut:"user" desc:"Member to ban"`
		Sev    Severity               `strut:"severity"`
		Tag    Option[TagName]        `strut:"tag,autocomplete"`
		Reason Option[string]         `strut:"reason,max=512"`
		Days   Option[int]            `strut:"days,min=0,max=7"`
	}

	spec := mustAnalyze(t, ban{}, modeCommand)

	if len(spec.Fields) != 5 {
		t.Fatalf("got %d options; want 5 (unexported and - fields skipped)", len(spec.Fields))
	}
	if spec.Fields[0].Kind != kindMember {
		t.Errorf("User kind = %s; want member", spec.Fields[0].Kind)
	}
	if spec.Fields[1].ChoiceElem != reflect.TypeFor[Severity]() {
		t.Errorf("Severity choices not detected")
	}
	if !spec.Fields[2].Optional || !spec.Fields[2].Autocomplete {
		t.Errorf("Tag should be optional and autocompleted")
	}
	// An absent desc falls back to the option name.
	if got := spec.Fields[4].Tag.Desc; got != "days" {
		t.Errorf("default Desc = %q; want days", got)
	}
}

func TestAnalyzeSubcommands(t *testing.T) {
	type leaf struct {
		V Option[string] `strut:"v"`
	}
	type root struct {
		Prefix *leaf `strut:"prefix"`
		Log    *leaf `strut:"log"`
	}

	spec := mustAnalyze(t, root{}, modeCommand)
	if len(spec.Subs) != 2 || len(spec.Fields) != 0 {
		t.Fatalf("got %d subs and %d options; want 2 and 0", len(spec.Subs), len(spec.Fields))
	}
}

func TestAnalyzeCommandErrors(t *testing.T) {
	type leaf struct {
		V Option[string] `strut:"v"`
	}

	tests := []struct {
		name string
		val  any
		want string
	}{
		{
			"required after optional",
			struct {
				A Option[string] `strut:"a"`
				B string         `strut:"b"`
			}{},
			"required option after optional",
		},
		{
			"unsupported type",
			struct {
				A chan int `strut:"a"`
			}{},
			"unsupported option type",
		},
		{
			"duplicate name",
			struct {
				A string `strut:"x"`
				B string `strut:"x"`
			}{},
			`already used`,
		},
		{
			"uppercase name",
			struct {
				A string `strut:"Bad"`
			}{},
			"must be lowercase",
		},
		{
			"channels on non-channel",
			struct {
				A string `strut:"a,channels=text"`
			}{},
			"channels applies to channel options only",
		},
		{
			"min on user",
			struct {
				A discord.User `strut:"a,min=1"`
			}{},
			"min and max do not apply",
		},
		{
			"min above max",
			struct {
				A int `strut:"a,min=9,max=2"`
			}{},
			"greater than max",
		},
		{
			"autocomplete without method",
			struct {
				A string `strut:"a,autocomplete"`
			}{},
			"has no Autocomplete",
		},
		{
			"autocomplete method without tag",
			struct {
				A TagName `strut:"a"`
			}{},
			"not tagged autocomplete",
		},
		{
			"autocomplete tag on a choices-only type",
			struct {
				A Severity `strut:"a,autocomplete"`
			}{},
			"has no Autocomplete",
		},
		{
			"autocomplete together with choices",
			struct {
				A Both `strut:"a,autocomplete"`
			}{},
			"cannot use autocomplete together with a Choices method",
		},
		{
			"flag on non-bool",
			struct {
				A string `strut:"a,flag"`
			}{},
			"flag applies to boolean options only",
		},
		{
			"rest on non-string",
			struct {
				A int `strut:"a,rest"`
			}{},
			"rest applies to string options only",
		},
		{
			"lazy on required",
			struct {
				A string `strut:"a,lazy"`
			}{},
			"lazy applies to optional options only",
		},
		{
			"modal settings on command",
			struct {
				A string `strut:"a" label:"nope"`
			}{},
			"modal fields only",
		},
		{
			"mixing options and subcommands",
			struct {
				A   string `strut:"a"`
				Sub *leaf  `strut:"sub"`
			}{},
			"cannot mix options and subcommands",
		},
		{
			"optional subcommand",
			struct {
				Sub Option[*leaf] `strut:"sub"`
			}{},
			"subcommands cannot be optional",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := analyzeErr(t, tt.val, modeCommand)
			if !strings.Contains(got, tt.want) {
				t.Errorf("error = %q; want it to contain %q", got, tt.want)
			}
		})
	}
}

func TestAnalyzeReportsEveryError(t *testing.T) {
	got := analyzeErr(t, struct {
		A string `strut:"Bad"`
		B int    `strut:"b,channels=text"`
	}{}, modeCommand)

	for _, want := range []string{"must be lowercase", "channels applies to channel options only"} {
		if !strings.Contains(got, want) {
			t.Errorf("error = %q; want it to contain %q", got, want)
		}
	}
}

func TestAnalyzeTooManyOptions(t *testing.T) {
	f := make([]reflect.StructField, 0, maxOptions+1)
	for i := range maxOptions + 1 {
		f = append(f, reflect.StructField{
			Name: "F" + string(rune('a'+i)),
			Type: reflect.TypeFor[Option[string]](),
			Tag:  reflect.StructTag(`strut:"o` + string(rune('a'+i)) + `"`),
		})
	}
	_, err := analyze(reflect.StructOf(f), modeCommand)
	if err == nil || !strings.Contains(err.Error(), "max 25") {
		t.Errorf("error = %v; want a max 25 options error", err)
	}
}

func TestAnalyzeModal(t *testing.T) {
	type appeal struct {
		Reason  string         `strut:"reason,paragraph,max=1000" label:"Why should we unban you?"`
		Contact Option[string] `strut:"contact" label:"Contact" placeholder:"email"`
	}

	spec := mustAnalyze(t, appeal{}, modeModal)
	if len(spec.Fields) != 2 {
		t.Fatalf("got %d fields; want 2", len(spec.Fields))
	}
	if !spec.Fields[0].Tag.Paragraph {
		t.Error("Reason should be a paragraph input")
	}
	if spec.Fields[1].Tag.Placeholder != "email" {
		t.Error("placeholder not parsed")
	}
}

func TestAnalyzeModalErrors(t *testing.T) {
	tests := []struct {
		name string
		val  any
		want string
	}{
		{
			"non-string field",
			struct {
				A int `strut:"a"`
			}{},
			"modal fields must be string",
		},
		{
			"desc instead of label",
			struct {
				A string `strut:"a" desc:"nope"`
			}{},
			"use label, not desc",
		},
		{
			"paragraph with choices",
			struct {
				A Severity `strut:"a,paragraph"`
			}{},
			"select menu, so paragraph does not apply",
		},
		{
			"no fields",
			struct{}{},
			"modal has no fields",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := analyzeErr(t, tt.val, modeModal)
			if !strings.Contains(got, tt.want) {
				t.Errorf("error = %q; want it to contain %q", got, tt.want)
			}
		})
	}
}

func TestAnalyzeModalTooManyFields(t *testing.T) {
	f := make([]reflect.StructField, 0, maxModalFields+1)
	for i := range maxModalFields + 1 {
		f = append(f, reflect.StructField{
			Name: "F" + string(rune('a'+i)),
			Type: reflect.TypeFor[string](),
			Tag:  reflect.StructTag(`strut:"o` + string(rune('a'+i)) + `"`),
		})
	}
	_, err := analyze(reflect.StructOf(f), modeModal)
	if err == nil || !strings.Contains(err.Error(), "max 5") {
		t.Errorf("error = %v; want a max 5 fields error", err)
	}
}

func TestAnalyzeRejectsNonStruct(t *testing.T) {
	if _, err := analyze(reflect.TypeFor[string](), modeCommand); err == nil {
		t.Error("analyze on a non-struct should fail")
	}
}

func TestAnalyzeAcceptsPointer(t *testing.T) {
	type ping struct {
		A Option[string] `strut:"a"`
	}
	mustAnalyze(t, &ping{}, modeCommand)
}

// Pagination is an option group shared between commands.
type Pagination struct {
	Page  Option[int] `strut:"page,min=1" desc:"Page number"`
	Limit Option[int] `strut:"limit,min=1,max=100" desc:"Per page"`
}

type listUsers struct {
	Query string `strut:"query" desc:"Search"`
	Pagination
}

func TestAnalyzeFlattensEmbeddedGroup(t *testing.T) {
	spec := mustAnalyze(t, listUsers{}, modeCommand)

	if len(spec.Fields) != 3 {
		t.Fatalf("got %d options; want 3, the group should flatten", len(spec.Fields))
	}
	var names []string
	for _, f := range spec.Fields {
		names = append(names, f.Tag.Name)
	}
	if got := strings.Join(names, ","); got != "query,page,limit" {
		t.Errorf("options = %s; want query,page,limit in declaration order", got)
	}
	// A promoted field is reached through a two step index path.
	if len(spec.Fields[1].Index) != 2 {
		t.Errorf("Index = %v; want a path into the embedded struct", spec.Fields[1].Index)
	}
}

type dupGroup struct {
	Page Option[int] `strut:"page"`
	Pagination
}

func TestAnalyzeRejectsGroupNameCollision(t *testing.T) {
	got := analyzeErr(t, dupGroup{}, modeCommand)
	if !strings.Contains(got, `"page" already used`) {
		t.Errorf("error = %q; want a collision with the embedded group", got)
	}
}

// deps is embedded purely to share dependencies, and contributes no options.
type depsGroup struct {
	db string
}

type withDeps struct {
	depsGroup
	Name string `strut:"name" desc:"d"`
}

func TestAnalyzeEmbeddedDepsAddNoOptions(t *testing.T) {
	spec := mustAnalyze(t, withDeps{}, modeCommand)
	if len(spec.Fields) != 1 {
		t.Errorf("got %d options; want only name", len(spec.Fields))
	}
}

func TestAnalyzeModalAllowsChoices(t *testing.T) {
	// A modal field with a choice list is a select menu, not free text.
	spec := mustAnalyze(t, struct {
		A Severity `strut:"a" label:"Severity"`
	}{}, modeModal)

	if len(spec.Fields) != 1 || spec.Fields[0].ChoiceElem == nil {
		t.Errorf("choices not carried through to the modal field: %+v", spec.Fields)
	}
}

func TestParseTagDefaults(t *testing.T) {
	tg, err := parseTag(``, "MaxAge")
	if err != nil {
		t.Fatal(err)
	}
	if tg.Name != "maxage" {
		t.Errorf("Name = %q; want %q", tg.Name, "maxage")
	}
	if tg.Skip {
		t.Error("empty tag should not skip")
	}
}

func TestParseTagSkip(t *testing.T) {
	tg, err := parseTag(`strut:"-"`, "DB")
	if err != nil {
		t.Fatal(err)
	}
	if !tg.Skip {
		t.Error(`strut:"-" should skip the field`)
	}
}

func TestParseTagSettings(t *testing.T) {
	raw := `strut:"days,min=0,max=7,autocomplete,rest,lazy,flag,paragraph" desc:"Days, including today"`

	tg, err := parseTag(raw, "Days")
	if err != nil {
		t.Fatal(err)
	}

	if tg.Name != "days" {
		t.Errorf("Name = %q; want days", tg.Name)
	}
	// The description holds a comma, which is why desc is its own tag key.
	if want := "Days, including today"; tg.Desc != want {
		t.Errorf("Desc = %q; want %q", tg.Desc, want)
	}
	if v, ok := tg.Min.Load(); !ok || v != 0 {
		t.Errorf("Min = %v, %v; want 0, true", v, ok)
	}
	if v, ok := tg.Max.Load(); !ok || v != 7 {
		t.Errorf("Max = %v, %v; want 7, true", v, ok)
	}
	for name, got := range map[string]bool{
		"autocomplete": tg.Autocomplete,
		"rest":         tg.Rest,
		"lazy":         tg.Lazy,
		"flag":         tg.Flag,
		"paragraph":    tg.Paragraph,
	} {
		if !got {
			t.Errorf("%s not set", name)
		}
	}
}

func TestParseTagChannels(t *testing.T) {
	tg, err := parseTag(`strut:"c,channels=text|announcement|forum"`, "C")
	if err != nil {
		t.Fatal(err)
	}
	want := []discord.ChannelType{
		discord.ChannelTypeGuildText,
		discord.ChannelTypeGuildNews,
		discord.ChannelTypeGuildForum,
	}
	if !reflect.DeepEqual(tg.Channels, want) {
		t.Errorf("Channels = %v; want %v", tg.Channels, want)
	}
}

func TestParseTagLocalization(t *testing.T) {
	raw := `strut:"user" desc:"Member" desc.de:"Mitglied" name.de:"nutzer" desc.en-US:"Member"`

	tg, err := parseTag(raw, "User")
	if err != nil {
		t.Fatal(err)
	}
	if got := tg.DescL10n[discord.Locale("de")]; got != "Mitglied" {
		t.Errorf("DescL10n[de] = %q; want Mitglied", got)
	}
	if got := tg.DescL10n[discord.Locale("en-US")]; got != "Member" {
		t.Errorf("DescL10n[en-US] = %q; want Member", got)
	}
	if got := tg.NameL10n[discord.Locale("de")]; got != "nutzer" {
		t.Errorf("NameL10n[de] = %q; want nutzer", got)
	}
}

func TestParseTagErrors(t *testing.T) {
	tests := []struct{ name, raw string }{
		{"unknown setting", `strut:"x,bogus"`},
		{"min without value", `strut:"x,min"`},
		{"min not a number", `strut:"x,min=abc"`},
		{"channels without value", `strut:"x,channels"`},
		{"unknown channel type", `strut:"x,channels=text|nope"`},
		{"unterminated value", `strut:"x`},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if _, err := parseTag(tt.raw, "X"); err == nil {
				t.Errorf("parseTag(%q) = nil error; want error", tt.raw)
			}
		})
	}
}

func TestScanTagIgnoresUnknownKeys(t *testing.T) {
	pairs, err := scanTag(`json:"a,omitempty" strut:"a" xml:"a"`)
	if err != nil {
		t.Fatal(err)
	}
	if len(pairs) != 3 {
		t.Fatalf("scanTag returned %d pairs; want 3", len(pairs))
	}

	tg, err := parseTag(`json:"days,omitzero" strut:"d"`, "Days")
	if err != nil {
		t.Fatal(err)
	}
	// A json tag must not leak into the option name.
	if tg.Name != "d" {
		t.Errorf("Name = %q; want d", tg.Name)
	}
}

type testData struct{}

// ping is the smallest possible command.
type ping struct{}

func (*ping) Meta() Meta                 { return Meta{Name: "ping", Description: "Pong"} }
func (*ping) Run(*Event[testData]) error { return nil }

// ban exercises every option feature that affects the payload.
type ban struct {
	db int `strut:"-"` //nolint:unused // exercises the skip tag

	User    discord.ResolvedMember     `strut:"user" desc:"Member to ban"`
	Sev     Severity                   `strut:"severity" desc:"How bad"`
	Where   discord.ResolvedChannel    `strut:"where,channels=text|forum" desc:"Log channel"`
	Tag     Option[TagName]            `strut:"tag,autocomplete" desc:"Tag"`
	Reason  Option[string]             `strut:"reason,min=1,max=512" desc:"Why"`
	Days    Option[int]                `strut:"days,min=0,max=7" desc:"Message days"`
	Ratio   Option[float64]            `strut:"ratio,min=0.5,max=1.5" desc:"Ratio"`
	Silent  Option[bool]               `strut:"silent" desc:"Quietly"`
	Proof   Option[discord.Attachment] `strut:"proof" desc:"Evidence"`
	Culprit Option[discord.Role]       `strut:"role" desc:"Role"`
}

func (*ban) Meta() Meta {
	return Meta{Name: "ban", Description: "Ban a member", GuildOnly: true}
}
func (*ban) Run(*Event[testData]) error { return nil }

func mustSchema(t *testing.T, cmd Command[testData]) []discord.ApplicationCommandCreate {
	t.Helper()
	got, err := schemaFor(cmd)
	if err != nil {
		t.Fatalf("schemaFor: %v", err)
	}
	return got
}

func schemaJSON(t *testing.T, cmd Command[testData]) string {
	t.Helper()
	got := mustSchema(t, cmd)
	if len(got) != 1 {
		t.Fatalf("got %d payloads; want 1", len(got))
	}
	b, err := json.Marshal(got[0])
	if err != nil {
		t.Fatalf("marshal: %v", err)
	}
	return string(b)
}

func TestSchemaMinimalCommand(t *testing.T) {
	want := `{"type":1,"name":"ping","description":"Pong"}`
	if got := schemaJSON(t, &ping{}); got != want {
		t.Errorf("payload =\n%s\nwant\n%s", got, want)
	}
}

func TestSchemaOptions(t *testing.T) {
	got := schemaJSON(t, &ban{})

	// Discord requires optional options after required ones; the payload must
	// preserve declaration order.
	want := `{"type":1,"name":"ban","description":"Ban a member","options":[` +
		`{"type":6,"name":"user","description":"Member to ban","required":true},` +
		`{"type":3,"name":"severity","description":"How bad","required":true,"choices":[{"name":"Low","value":"low"}]},` +
		`{"type":7,"name":"where","description":"Log channel","required":true,"channel_types":[0,15]},` +
		`{"type":3,"name":"tag","description":"Tag","autocomplete":true},` +
		`{"type":3,"name":"reason","description":"Why","min_length":1,"max_length":512},` +
		`{"type":4,"name":"days","description":"Message days","min_value":0,"max_value":7},` +
		`{"type":10,"name":"ratio","description":"Ratio","min_value":0.5,"max_value":1.5},` +
		`{"type":5,"name":"silent","description":"Quietly"},` +
		`{"type":11,"name":"proof","description":"Evidence"},` +
		`{"type":8,"name":"role","description":"Role"}` +
		`]}`

	if got != want {
		t.Errorf("payload =\n%s\nwant\n%s", got, want)
	}
}

// Priority is an int-valued enum with a localized choice name.
type Priority int

func (Priority) Choices() []Choice[Priority] {
	return []Choice[Priority]{
		{Name: "Low", Value: 1},
		{Name: "High", Value: 9, NameLocalized: map[discord.Locale]string{"de": "Hoch"}},
	}
}

// Ratio is a float-valued enum.
type Ratio float64

func (Ratio) Choices() []Choice[Ratio] {
	return []Choice[Ratio]{{Name: "Half", Value: 0.5}}
}

type enums struct {
	P Priority `strut:"p" desc:"Priority"`
	R Ratio    `strut:"r" desc:"Ratio"`
}

func (*enums) Meta() Meta                 { return Meta{Name: "enums", Description: "Enums"} }
func (*enums) Run(*Event[testData]) error { return nil }

func TestSchemaEnumChoices(t *testing.T) {
	got := schemaJSON(t, &enums{})

	want := `{"type":1,"name":"enums","description":"Enums","options":[` +
		`{"type":4,"name":"p","description":"Priority","required":true,"choices":[` +
		`{"name":"Low","value":1},{"name":"High","name_localizations":{"de":"Hoch"},"value":9}]},` +
		`{"type":10,"name":"r","description":"Ratio","required":true,"choices":[{"name":"Half","value":0.5}]}` +
		`]}`

	if got != want {
		t.Errorf("payload =\n%s\nwant\n%s", got, want)
	}
}

// Nested subcommands. Leaves carry Run; groups do not.
type cfgSet struct {
	Value string `strut:"value" desc:"New value"`
}

func (*cfgSet) Run(*Event[testData]) error { return nil }

type cfgGet struct{}

func (*cfgGet) Run(*Event[testData]) error { return nil }

type cfgPrefix struct {
	Set *cfgSet `strut:"set" desc:"Set the prefix"`
	Get *cfgGet `strut:"get" desc:"Show the prefix"`
}

type config struct {
	Prefix *cfgPrefix `strut:"prefix" desc:"Prefix settings"`
	Reset  *cfgGet    `strut:"reset" desc:"Reset everything"`
}

func (*config) Meta() Meta {
	return Meta{Name: "config", Description: "Server config"}
}
func (*config) Run(*Event[testData]) error { return nil }

func TestSchemaSubcommands(t *testing.T) {
	got := schemaJSON(t, &config{})

	want := `{"type":1,"name":"config","description":"Server config","options":[` +
		`{"type":2,"name":"prefix","description":"Prefix settings","options":[` +
		`{"type":1,"name":"set","description":"Set the prefix","options":[` +
		`{"type":3,"name":"value","description":"New value","required":true}]},` +
		`{"type":1,"name":"get","description":"Show the prefix"}]},` +
		`{"type":1,"name":"reset","description":"Reset everything"}` +
		`]}`

	if got != want {
		t.Errorf("payload =\n%s\nwant\n%s", got, want)
	}
}

// Three levels of nesting, which Discord does not allow.
type deepC struct{}

func (*deepC) Run(*Event[testData]) error { return nil }

type deepB struct {
	C *deepC `strut:"c" desc:"c"`
}
type deepA struct {
	B *deepB `strut:"b" desc:"b"`
}
type deep struct {
	A *deepA `strut:"a" desc:"a"`
}

func (*deep) Meta() Meta                 { return Meta{Name: "deep", Description: "Too deep"} }
func (*deep) Run(*Event[testData]) error { return nil }

// A subcommand leaf that never implements Run.
type noRun struct {
	V Option[string] `strut:"v"`
}
type hasNoRun struct {
	Sub *noRun `strut:"sub" desc:"sub"`
}

func (*hasNoRun) Meta() Meta                 { return Meta{Name: "norun", Description: "Broken"} }
func (*hasNoRun) Run(*Event[testData]) error { return nil }

// More choices than Discord accepts.
type manyChoice string

func (manyChoice) Choices() []Choice[manyChoice] {
	out := make([]Choice[manyChoice], maxChoices+1)
	for i := range out {
		out[i] = Choice[manyChoice]{Name: string(rune('a' + i)), Value: manyChoice("v")}
	}
	return out
}

type tooManyChoices struct {
	A manyChoice `strut:"a" desc:"a"`
}

func (*tooManyChoices) Meta() Meta                 { return Meta{Name: "choices", Description: "Too many"} }
func (*tooManyChoices) Run(*Event[testData]) error { return nil }

type noDesc struct{}

func (*noDesc) Meta() Meta                 { return Meta{Name: "nodesc"} }
func (*noDesc) Run(*Event[testData]) error { return nil }

type badName struct{}

func (*badName) Meta() Meta                 { return Meta{Name: "Bad Name", Description: "x"} }
func (*badName) Run(*Event[testData]) error { return nil }

func TestSchemaErrors(t *testing.T) {
	tests := []struct {
		name string
		cmd  Command[testData]
		want string
	}{
		{"nested too deep", &deep{}, "nested more than 2 levels"},
		{"leaf without Run", &hasNoRun{}, "must implement Run"},
		{"too many choices", &tooManyChoices{}, "max 25"},
		{"missing description", &noDesc{}, "description is required"},
		{"invalid name", &badName{}, "command name"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			_, err := schemaFor(tt.cmd)
			if err == nil {
				t.Fatalf("schemaFor = nil error; want one containing %q", tt.want)
			}
			if !strings.Contains(err.Error(), tt.want) {
				t.Errorf("error = %q; want it to contain %q", err, tt.want)
			}
		})
	}
}

// report serves a slash command and both context menu surfaces. Targets are
// filled from the interaction, so they are absent from the slash payload.
type report struct {
	Reason Option[string] `strut:"reason" desc:"Why"`

	User    UserTarget
	Message MessageTarget
}

func (*report) Meta() Meta {
	return Meta{
		Name:            "report",
		Description:     "Report something",
		Kinds:           Slash | UserMenu | MessageMenu,
		ContextMenuName: "Report",
	}
}
func (*report) Run(*Event[testData]) error { return nil }

type menuOnly struct {
	Message MessageTarget
}

func (*menuOnly) Meta() Meta {
	return Meta{Name: "pin", Kinds: MessageMenu, ContextMenuName: "Pin It"}
}
func (*menuOnly) Run(*Event[testData]) error { return nil }

type menuNoTarget struct{}

func (*menuNoTarget) Meta() Meta                 { return Meta{Name: "pin", Kinds: MessageMenu} }
func (*menuNoTarget) Run(*Event[testData]) error { return nil }

// Target declared on a command that is never invoked from a menu.
type targetNoMenu struct {
	User UserTarget
}

func (*targetNoMenu) Meta() Meta                 { return Meta{Name: "x", Description: "x"} }
func (*targetNoMenu) Run(*Event[testData]) error { return nil }

type twoTargets struct {
	A UserTarget
	B UserTarget
}

func (*twoTargets) Meta() Meta                 { return Meta{Name: "x", Kinds: UserMenu} }
func (*twoTargets) Run(*Event[testData]) error { return nil }

type optionalTarget struct {
	User Option[UserTarget]
}

func (*optionalTarget) Meta() Meta                 { return Meta{Name: "x", Kinds: UserMenu} }
func (*optionalTarget) Run(*Event[testData]) error { return nil }

type prefixOnly struct{}

func (*prefixOnly) Meta() Meta                 { return Meta{Name: "shrug", Kinds: Prefix} }
func (*prefixOnly) Run(*Event[testData]) error { return nil }

type perms struct{}

func (*perms) Meta() Meta {
	zero := discord.Permissions(0)
	return Meta{Name: "locked", Description: "Locked", DefaultMemberPermissions: &zero}
}
func (*perms) Run(*Event[testData]) error { return nil }

type localizedCmd struct{}

func (*localizedCmd) Meta() Meta { return Meta{Name: "ban", Description: "Ban a member"} }
func (*localizedCmd) Localize() L10n {
	return L10n{
		"de": {Name: "bannen", Description: "Mitglied bannen"},
		"fr": {Description: "Bannir un membre"},
	}
}
func (*localizedCmd) Run(*Event[testData]) error { return nil }