1
0
Fork 0
mirror of https://github.com/diamondburned/arikawa.git synced 2024-12-14 01:15:00 +00:00
arikawa/utils/bot/ctx_test.go
2021-09-18 00:39:34 -07:00

455 lines
10 KiB
Go

package bot
import (
"errors"
"fmt"
"reflect"
"strconv"
"strings"
"testing"
"time"
"github.com/diamondburned/arikawa/v3/discord"
"github.com/diamondburned/arikawa/v3/gateway"
"github.com/diamondburned/arikawa/v3/state"
"github.com/diamondburned/arikawa/v3/state/store"
"github.com/diamondburned/arikawa/v3/utils/handler"
)
type testUnexportedCtx struct {
ctx *Context
}
func TestUnexportedCtx(t *testing.T) {
s := &state.State{
Cabinet: store.NoopCabinet,
}
_, err := New(s, &testUnexportedCtx{})
if err == nil {
t.Fatal("New returned unexpected nil error")
}
if !strings.Contains(err.Error(), "no exported field with *bot.Context found") {
t.Fatal("unexpected New error:", err)
}
}
type testc struct {
Ctx *Context
Return chan interface{}
Counter uint64
Typed int8
}
func (t *testc) Setup(sub *Subcommand) {
sub.AddMiddleware([]string{"*", "GetCounter"}, func(v interface{}) {
t.Counter++
})
sub.AddMiddleware("*", func(*gateway.MessageCreateEvent) {
t.Counter++
})
// stub middleware for testing
sub.AddMiddleware(t.OnTyping, func(*gateway.TypingStartEvent) {
t.Typed = 2
})
sub.Hide(t.Hidden)
}
func (t *testc) Hidden(*gateway.MessageCreateEvent) {}
func (t *testc) Noop(*gateway.MessageCreateEvent) {}
func (t *testc) GetCounter(*gateway.MessageCreateEvent) {
t.Return <- strconv.FormatUint(t.Counter, 10)
}
func (t *testc) Send(_ *gateway.MessageCreateEvent, args ...string) error {
t.Return <- args
return errors.New("oh no")
}
func (t *testc) Custom(_ *gateway.MessageCreateEvent, c *ArgumentParts) {
t.Return <- []string(*c)
}
func (t *testc) Variadic(_ *gateway.MessageCreateEvent, c ...*customParsed) {
t.Return <- c[len(c)-1]
}
func (t *testc) TrailCustom(_ *gateway.MessageCreateEvent, _ string, c ArgumentParts) {
t.Return <- c
}
func (t *testc) Content(_ *gateway.MessageCreateEvent, c RawArguments) {
t.Return <- c
}
func (t *testc) NoArgs(*gateway.MessageCreateEvent) error {
return errors.New("passed")
}
func (t *testc) OnTyping(*gateway.TypingStartEvent) {
t.Typed--
}
func TestNewContext(t *testing.T) {
var s = &state.State{
Cabinet: store.NoopCabinet,
}
c, err := New(s, &testc{})
if err != nil {
t.Fatal("Failed to create new context:", err)
}
if !reflect.DeepEqual(c.Subcommands(), c.subcommands) {
t.Fatal("Subcommands mismatch.")
}
}
func TestContext(t *testing.T) {
var given = &testc{}
var s = &state.State{
Cabinet: store.NoopCabinet,
Handler: handler.New(),
}
sub, err := NewSubcommand(given)
if err != nil {
t.Fatal("Failed to create subcommand:", err)
}
var ctx = &Context{
Name: "arikawa/bot test",
Description: "Just a test.",
Subcommand: sub,
State: s,
ParseArgs: DefaultArgsParser,
}
t.Run("init commands", func(t *testing.T) {
if err := ctx.Subcommand.InitCommands(ctx); err != nil {
t.Fatal("Failed to init commands:", err)
}
if given.Ctx != ctx {
t.Fatal("given Context field has invalid pointer")
}
})
t.Run("find commands", func(t *testing.T) {
cmd := ctx.FindCommand("", "NoArgs")
if cmd == nil {
t.Fatal("Failed to find NoArgs")
}
})
t.Run("middleware", func(t *testing.T) {
ctx.HasPrefix = NewPrefix("pls do ")
// This should trigger the middleware first.
if err := expect(ctx, given, "3", "pls do getCounter"); err != nil {
t.Fatal("Unexpected error:", err)
}
})
t.Run("derive intents", func(t *testing.T) {
intents := ctx.DeriveIntents()
assertIntents := func(target gateway.Intents, name string) {
if !intents.Has(target) {
t.Error("Derived intents do not have", name)
}
}
assertIntents(gateway.IntentGuildMessages, "guild messages")
assertIntents(gateway.IntentDirectMessages, "direct messages")
assertIntents(gateway.IntentGuildMessageTyping, "guild typing")
assertIntents(gateway.IntentDirectMessageTyping, "direct message typing")
})
t.Run("typing event", func(t *testing.T) {
typing := &gateway.TypingStartEvent{}
if err := ctx.callCmd(typing); err != nil {
t.Fatal("Failed to call with TypingStart:", err)
}
// -1 none ran
if given.Typed != 1 {
t.Fatal("Typed bool is false")
}
})
t.Run("call command", func(t *testing.T) {
// Set a custom prefix
ctx.HasPrefix = NewPrefix("~")
var (
send = "hacka doll no. 3"
expects = []string{"hacka", "doll", "no.", "3"}
)
if err := expect(ctx, given, expects, "~send "+send); err.Error() != "oh no" {
t.Fatal("Unexpected error:", err)
}
})
t.Run("call command rawarguments", func(t *testing.T) {
ctx.HasPrefix = NewPrefix("!")
expects := RawArguments("just things")
if err := expect(ctx, given, expects, "!content just things"); err != nil {
t.Fatal("Unexpected call error:", err)
}
})
t.Run("call command custom manual parser", func(t *testing.T) {
ctx.HasPrefix = NewPrefix("!")
expects := []string{"arg1", ":)"}
if err := expect(ctx, given, expects, "!custom arg1 :)"); err != nil {
t.Fatal("Unexpected call error:", err)
}
})
t.Run("call command custom variadic parser", func(t *testing.T) {
ctx.HasPrefix = NewPrefix("!")
expects := &customParsed{true}
if err := expect(ctx, given, expects, "!variadic bruh moment"); err != nil {
t.Fatal("Unexpected call error:", err)
}
})
t.Run("call command custom trailing manual parser", func(t *testing.T) {
ctx.HasPrefix = NewPrefix("!")
expects := ArgumentParts{"arikawa"}
if err := sendMsg(ctx, given, &expects, "!trailCustom hime arikawa"); err != nil {
t.Fatal("Unexpected call error:", err)
}
if expects.Length() != 1 {
t.Fatal("Unexpected ArgumentParts length.")
}
if expects.After(1)+expects.After(2)+expects.After(-1) != "" {
t.Fatal("Unexpected ArgumentsParts after.")
}
if expects.String() != "arikawa" {
t.Fatal("Unexpected ArgumentsParts string.")
}
if expects.Arg(0) != "arikawa" {
t.Fatal("Unexpected ArgumentParts arg 0")
}
if expects.Arg(1) != "" {
t.Fatal("Unexpected ArgumentParts arg 1")
}
})
testMessage := func(content string) error {
// Mock a messageCreate event
m := &gateway.MessageCreateEvent{
Message: discord.Message{
Content: content,
},
}
return ctx.callCmd(m)
}
t.Run("call command without args", func(t *testing.T) {
ctx.HasPrefix = NewPrefix("")
if err := testMessage("noArgs"); err.Error() != "passed" {
t.Fatal("unexpected error:", err)
}
})
// Test error cases
t.Run("call unknown command", func(t *testing.T) {
ctx.HasPrefix = NewPrefix("joe pls ")
err := testMessage("joe pls no")
if err == nil || !strings.HasPrefix(err.Error(), "unknown command:") {
t.Fatal("unexpected error:", err)
}
})
// Test subcommands
t.Run("register subcommand", func(t *testing.T) {
ctx.HasPrefix = NewPrefix("run ")
sub := &testc{}
ctx.MustRegisterSubcommand(sub)
if err := testMessage("run testc noop"); err != nil {
t.Fatal("Unexpected error:", err)
}
expects := RawArguments("hackadoll no. 3")
if err := expect(ctx, sub, expects, "run testc content hackadoll no. 3"); err != nil {
t.Fatal("Unexpected call error:", err)
}
if cmd := ctx.FindCommand("testc", "Noop"); cmd == nil {
t.Fatal("Failed to find subcommand Noop")
}
})
t.Run("register subcommand custom", func(t *testing.T) {
ctx.MustRegisterSubcommand(&testc{}, "arikawa", "a")
})
t.Run("duplicate subcommand", func(t *testing.T) {
_, err := ctx.RegisterSubcommand(&testc{}, "arikawa")
if err := err.Error(); !strings.Contains(err, "duplicate") {
t.Fatal("Unexpected error:", err)
}
_, err = ctx.RegisterSubcommand(&testc{}, "a")
if err := err.Error(); !strings.Contains(err, "duplicate") {
t.Fatal("Unexpected error:", err)
}
})
t.Run("help", func(t *testing.T) {
ctx.MustRegisterSubcommand(&testc{}, "helper")
h := ctx.Help()
if h == "" {
t.Fatal("Empty help?")
}
if strings.Contains(h, "hidden") {
t.Fatal("Hidden command shown in help.")
}
if !strings.Contains(h, "arikawa/bot test") {
t.Fatal("Name not found.")
}
if !strings.Contains(h, "Just a test.") {
t.Fatal("Description not found.")
}
if !strings.Contains(h, "**a**") {
t.Fatal("arikawa alias `a' not found.")
}
})
t.Run("start", func(t *testing.T) {
cancel := ctx.Start()
defer cancel()
ctx.HasPrefix = NewPrefix("!")
given.Return = make(chan interface{})
ctx.Handler.Call(&gateway.MessageCreateEvent{
Message: discord.Message{
Content: "!content hime arikawa best trap",
},
})
if c := (<-given.Return).(RawArguments); c != "hime arikawa best trap" {
t.Fatal("Unexpected content:", c)
}
})
}
func expect(ctx *Context, given *testc, expects interface{}, content string) (call error) {
var v interface{}
if call = sendMsg(ctx, given, &v, content); call != nil {
return
}
if !reflect.DeepEqual(v, expects) {
return fmt.Errorf("returned argument is invalid: %v", v)
}
return nil
}
func sendMsg(ctx *Context, given *testc, into interface{}, content string) (call error) {
// Return channel for testing
ret := make(chan interface{})
given.Return = ret
// Mock a messageCreate event
m := &gateway.MessageCreateEvent{
Message: discord.Message{
Content: content,
},
}
var callCh = make(chan error)
go func() {
callCh <- ctx.Call(m)
}()
select {
case arg := <-ret:
call = <-callCh
reflect.ValueOf(into).Elem().Set(reflect.ValueOf(arg))
return
case call = <-callCh:
return fmt.Errorf("expected return before error: %w", call)
case <-time.After(time.Second):
return errors.New("timed out while waiting")
}
}
func BenchmarkConstructor(b *testing.B) {
var s = &state.State{
Cabinet: store.NoopCabinet,
}
for i := 0; i < b.N; i++ {
_, _ = New(s, &testc{})
}
}
func BenchmarkCall(b *testing.B) {
var given = &testc{}
var s = &state.State{
Cabinet: store.NoopCabinet,
}
sub, _ := NewSubcommand(given)
var ctx = &Context{
Subcommand: sub,
State: s,
HasPrefix: NewPrefix("~"),
ParseArgs: DefaultArgsParser,
}
m := &gateway.MessageCreateEvent{
Message: discord.Message{
Content: "~noop",
},
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
ctx.callCmd(m)
}
}
func BenchmarkHelp(b *testing.B) {
var given = &testc{}
var s = &state.State{
Cabinet: store.NoopCabinet,
}
sub, _ := NewSubcommand(given)
var ctx = &Context{
Subcommand: sub,
State: s,
HasPrefix: NewPrefix("~"),
ParseArgs: DefaultArgsParser,
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = ctx.Help()
}
}