harness.go

package strut

import (
	"fmt"
	"reflect"

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

// Simulation drives a registered handler with caller-supplied seams, so a
// command can be exercised without a gateway or a REST client. The struttest
// package builds on these; a bot never calls them.
//
// Each returns the failure the framework reported, which is nil on success
// and has already been routed through the error handlers.

// SimulateCommand runs the command at route against the given interaction
// data.
func (f *Framework[D]) SimulateCommand(route string, data discord.SlashCommandInteractionData, e *Event[D]) (*Error[D], error) {
	inv, ok := f.invs[route]
	if !ok {
		return nil, fmt.Errorf("strut: no command registered at %q", route)
	}
	e.meta = inv.meta

	if err := f.run(inv, e, data, func(*Event[D], reflect.Value) error { return nil }); err != nil {
		f.report(inv, err)
		return err, nil
	}
	return nil, nil
}

// SimulateText runs a prefix invocation. content is the whole message,
// including the prefix.
func (f *Framework[D]) SimulateText(content string, e *Event[D]) (*Error[D], error) {
	if f.opts.Prefix == nil {
		return nil, fmt.Errorf("strut: prefix commands are not enabled")
	}

	node, lex, ok := f.resolveText(content)
	if !ok {
		return nil, fmt.Errorf("strut: %q names no command", content)
	}
	return f.finishPrefix(node, e, lex), nil
}

// SimulateComponent runs the handler registered for the given state value.
func (f *Framework[D]) SimulateComponent(state any, e *Event[D]) (*Error[D], error) {
	c, err := codecFor(reflect.TypeOf(state))
	if err != nil {
		return nil, err
	}
	h, ok := f.components[c.route]
	if !ok {
		return nil, fmt.Errorf("strut: no component handler for %s", c.route)
	}
	return h(e, reflect.ValueOf(state)), nil
}

// SimulateModal runs the handler registered for modals of the given type.
func (f *Framework[D]) SimulateModal(modal reflect.Type, data discord.ModalSubmitInteractionData, e *Event[D]) (*Error[D], error) {
	h, ok := f.modals[modalRoute(modal)]
	if !ok {
		return nil, fmt.Errorf("strut: no modal handler for %s", modal)
	}

	c, err := modalCodecFor(modal)
	if err != nil {
		return nil, err
	}
	v, err := c.decode(data)
	if err != nil {
		return nil, err
	}
	return h(e, v), nil
}

// SimulateAutocomplete asks a command's autocomplete method for suggestions.
func (f *Framework[D]) SimulateAutocomplete(route, option string, p Partial, e *Event[D]) ([]discord.AutocompleteChoice, error) {
	inv, ok := f.invs[route]
	if !ok {
		return nil, fmt.Errorf("strut: no command registered at %q", route)
	}
	c, ok := inv.completers[option]
	if !ok {
		return nil, fmt.Errorf("strut: option %q on %q is not autocompleted", option, route)
	}
	e.meta = inv.meta

	// Same chain the live path runs, so a harness sees what production does.
	var out []discord.AutocompleteChoice
	err := f.chain(func(ev *Event[D]) error {
		var err error
		out, err = c.call(reflect.ValueOf(ev), p)
		return err
	})(e)
	return out, err
}

// OptionTypes reports the wire type of each option of a command, so a harness
// can build interaction data without restating them.
func (f *Framework[D]) OptionTypes(route string) (map[string]discord.ApplicationCommandOptionType, bool) {
	inv, ok := f.invs[route]
	if !ok {
		return nil, false
	}
	return inv.dec.types, true
}