mirror of
https://github.com/gookit/event
synced 2025-09-26 19:11:14 +08:00
138 lines
2.5 KiB
Go
138 lines
2.5 KiB
Go
package event_test
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/gookit/event"
|
|
"github.com/gookit/goutil/testutil/assert"
|
|
)
|
|
|
|
// Thread-safe buffer for testing
|
|
type safeBuffer struct {
|
|
bytes.Buffer
|
|
mu sync.Mutex
|
|
}
|
|
|
|
func (sb *safeBuffer) Write(p []byte) (n int, err error) {
|
|
sb.mu.Lock()
|
|
defer sb.mu.Unlock()
|
|
return sb.Buffer.Write(p)
|
|
}
|
|
|
|
type testListener struct {
|
|
userData string
|
|
}
|
|
|
|
func (l *testListener) Handle(e event.Event) error {
|
|
if ret := e.Get("result"); ret != nil {
|
|
str := ret.(string) + fmt.Sprintf(" -> %s(%s)", e.Name(), l.userData)
|
|
e.Set("result", str)
|
|
} else {
|
|
e.Set("result", fmt.Sprintf("handled: %s(%s)", e.Name(), l.userData))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type testSubscriber struct {
|
|
// ooo
|
|
}
|
|
|
|
func (s *testSubscriber) SubscribedEvents() map[string]any {
|
|
return map[string]any{
|
|
"e1": event.ListenerFunc(s.e1Handler),
|
|
"e2": event.ListenerItem{
|
|
Priority: event.AboveNormal,
|
|
Listener: event.ListenerFunc(func(e event.Event) error {
|
|
return fmt.Errorf("an error")
|
|
}),
|
|
},
|
|
"e3": &testListener{},
|
|
}
|
|
}
|
|
|
|
func (s *testSubscriber) e1Handler(e event.Event) error {
|
|
e.Set("e1-key", "val1")
|
|
return nil
|
|
}
|
|
|
|
type testSubscriber2 struct{}
|
|
|
|
func (s testSubscriber2) SubscribedEvents() map[string]any {
|
|
return map[string]any{
|
|
"e1": "invalid",
|
|
}
|
|
}
|
|
|
|
type testEvent struct {
|
|
event.ContextTrait
|
|
name string
|
|
data map[string]any
|
|
abort bool
|
|
}
|
|
|
|
func (t *testEvent) Name() string {
|
|
return t.name
|
|
}
|
|
|
|
func (t *testEvent) Get(key string) any {
|
|
return t.data[key]
|
|
}
|
|
|
|
func (t *testEvent) Set(key string, val any) {
|
|
t.data[key] = val
|
|
}
|
|
|
|
func (t *testEvent) Add(key string, val any) {
|
|
t.data[key] = val
|
|
}
|
|
|
|
func (t *testEvent) Data() map[string]any {
|
|
return t.data
|
|
}
|
|
|
|
func (t *testEvent) SetData(m event.M) event.Event {
|
|
t.data = m
|
|
return t
|
|
}
|
|
|
|
func (t *testEvent) Abort(b bool) {
|
|
t.abort = b
|
|
}
|
|
|
|
func (t *testEvent) IsAborted() bool {
|
|
return t.abort
|
|
}
|
|
|
|
func TestEvent(t *testing.T) {
|
|
e := &event.BasicEvent{}
|
|
e.SetName("n1")
|
|
e.SetData(event.M{
|
|
"arg0": "val0",
|
|
})
|
|
e.SetTarget("tgt")
|
|
|
|
e.Add("arg1", "val1")
|
|
|
|
assert.False(t, e.IsAborted())
|
|
e.Abort(true)
|
|
assert.True(t, e.IsAborted())
|
|
|
|
assert.Equal(t, "n1", e.Name())
|
|
assert.Equal(t, "tgt", e.Target())
|
|
assert.Contains(t, e.Data(), "arg1")
|
|
assert.Equal(t, "val0", e.Get("arg0"))
|
|
assert.Equal(t, nil, e.Get("not-exist"))
|
|
|
|
e.Set("arg1", "new val")
|
|
assert.Equal(t, "new val", e.Get("arg1"))
|
|
|
|
e1 := &event.BasicEvent{}
|
|
e1.Set("k", "v")
|
|
assert.Equal(t, "v", e1.Get("k"))
|
|
// assert.NotEmpty(t, e1.Clone())
|
|
// assert.NotNil(t, e1.Context())
|
|
}
|