@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/core/eventbus/eventbus_test.go

@@ -0,0 +1,792 @@
+package eventbus
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+)
+
+// newTestBus 创建用于测试的 EventBus，使用 nop logger 避免日志噪音
+func newTestBus(t *testing.T) *EventBus {
+	t.Helper()
+	logger := zap.NewNop()
+	bus := New(logger)
+	t.Cleanup(func() { bus.Close() })
+	return bus
+}
+
+// makeEvent 创建带有给定名称的 DomainEvent
+func makeEvent(eventName string) DomainEvent {
+	return NewDomainEvent(eventName, "agg-1", nil)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 1. New() 创建有效的 EventBus
+// ═══════════════════════════════════════════════════════════════
+
+func TestNew_CreatesValidEventBus(t *testing.T) {
+	logger := zap.NewNop()
+	bus := New(logger)
+	defer bus.Close()
+
+	require.NotNil(t, bus)
+	assert.NotNil(t, bus.subscriptions)
+	assert.NotNil(t, bus.handlers)
+	assert.False(t, bus.closed.Load(), "新建的 EventBus 不应处于关闭状态")
+	assert.Equal(t, 0, bus.SubscriptionCount())
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 2. Subscribe + Publish — 处理器接收到字段正确的事件
+// ═══════════════════════════════════════════════════════════════
+
+func TestSubscribePublish_HandlerReceivesCorrectEvent(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	received := make(chan DomainEvent, 1)
+	bus.Subscribe("user.created", func(_ context.Context, event DomainEvent) error {
+		received <- event
+		return nil
+	})
+
+	evt := NewDomainEvent("user.created", "user-123", &EventMetadata{
+		UserID:  42,
+		TraceID: "trace-abc",
+	})
+	err := bus.Publish(ctx, evt)
+	require.NoError(t, err)
+
+	select {
+	case got := <-received:
+		assert.Equal(t, "user.created", got.EventName)
+		assert.Equal(t, "user-123", got.AggregateID)
+		assert.Equal(t, 1, got.Version)
+		assert.NotEmpty(t, got.EventID, "EventID 应自动生成")
+		assert.False(t, got.OccurredAt.IsZero(), "OccurredAt 应自动填充")
+		require.NotNil(t, got.Metadata)
+		assert.Equal(t, int64(42), got.Metadata.UserID)
+		assert.Equal(t, "trace-abc", got.Metadata.TraceID)
+	case <-time.After(time.Second):
+		t.Fatal("超时：未收到事件")
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 3. Subscribe 优先级排序 — 高优先级处理器先执行
+// ═══════════════════════════════════════════════════════════════
+
+func TestSubscribe_PriorityOrdering(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	var order []int
+	var mu sync.Mutex
+
+	appendOrder := func(n int) Handler {
+		return func(_ context.Context, _ DomainEvent) error {
+			mu.Lock()
+			order = append(order, n)
+			mu.Unlock()
+			return nil
+		}
+	}
+
+	// 以随机顺序注册，期望按优先级执行
+	bus.Subscribe("order.placed", appendOrder(10), SubscribeOptions{Priority: 10})
+	bus.Subscribe("order.placed", appendOrder(5), SubscribeOptions{Priority: 5})
+	bus.Subscribe("order.placed", appendOrder(20), SubscribeOptions{Priority: 20})
+	bus.Subscribe("order.placed", appendOrder(1), SubscribeOptions{Priority: 1})
+
+	err := bus.Publish(ctx, makeEvent("order.placed"))
+	require.NoError(t, err)
+
+	mu.Lock()
+	got := make([]int, len(order))
+	copy(got, order)
+	mu.Unlock()
+
+	assert.Equal(t, []int{20, 10, 5, 1}, got, "处理器应按优先级降序执行")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 4. 通配符 user.* — 匹配 user.created，不匹配 user.profile.updated
+// ═══════════════════════════════════════════════════════════════
+
+func TestWildcard_SingleStar_MatchesSingleSegment(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	var count int32
+	bus.Subscribe("user.*", func(_ context.Context, _ DomainEvent) error {
+		atomic.AddInt32(&count, 1)
+		return nil
+	})
+
+	// 应匹配
+	err := bus.Publish(ctx, makeEvent("user.created"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(1), atomic.LoadInt32(&count), "user.* 应匹配 user.created")
+
+	// 不应匹配（段数不同）
+	err = bus.Publish(ctx, makeEvent("user.profile.updated"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(1), atomic.LoadInt32(&count), "user.* 不应匹配 user.profile.updated")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 5. 通配符 user.** — 匹配比模式段数更多的事件（如 user.profile.updated）
+//
+// 实现说明：matchPattern 中 ** 仅在段数不等时触发尾部匹配逻辑。
+// 当段数相等时（如 user.** vs user.created 均为 2 段），进入逐段比较，
+// ** 不被视为通配符，因此 user.** 不匹配 user.created。
+// 要同时匹配 user.created，应使用 user.* 或精确订阅 user.created。
+// ═══════════════════════════════════════════════════════════════
+
+func TestWildcard_DoubleStar_MatchesDeepSegments(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	var count int32
+	bus.Subscribe("user.**", func(_ context.Context, _ DomainEvent) error {
+		atomic.AddInt32(&count, 1)
+		return nil
+	})
+
+	// user.** 段数(2)与 user.created 段数(2)相同，走逐段比较，** 不匹配 "created"
+	err := bus.Publish(ctx, makeEvent("user.created"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(0), atomic.LoadInt32(&count), "user.** 不匹配与模式等长的 user.created")
+
+	// user.** 去掉 ** 后为 [user]，user.profile.updated 段数(3) > 1，且首段匹配
+	err = bus.Publish(ctx, makeEvent("user.profile.updated"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(1), atomic.LoadInt32(&count), "user.** 应匹配段数更多的 user.profile.updated")
+
+	// 任意深度均可匹配，只要 user 前缀一致
+	err = bus.Publish(ctx, makeEvent("user.profile.avatar.changed"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(2), atomic.LoadInt32(&count), "user.** 应匹配任意深度子路径")
+
+	// 不应匹配 order 域
+	err = bus.Publish(ctx, makeEvent("order.item.added"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(2), atomic.LoadInt32(&count), "user.** 不应匹配 order 域")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 6. 通配符 ** — 匹配所有事件
+// ═══════════════════════════════════════════════════════════════
+
+func TestWildcard_DoubleStarAlone_MatchesEverything(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	var count int32
+	bus.Subscribe("**", func(_ context.Context, _ DomainEvent) error {
+		atomic.AddInt32(&count, 1)
+		return nil
+	})
+
+	events := []string{"user.created", "order.placed", "user.profile.updated", "payment.refunded"}
+	for _, name := range events {
+		err := bus.Publish(ctx, makeEvent(name))
+		require.NoError(t, err)
+	}
+
+	assert.Equal(t, int32(len(events)), atomic.LoadInt32(&count), "** 应匹配所有事件")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 7. SubscribeOnce — 处理器只执行一次后自动取消订阅
+// ═══════════════════════════════════════════════════════════════
+
+func TestSubscribeOnce_FiresOnlyOnce(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	var count int32
+	sub := bus.SubscribeOnce("payment.processed", func(_ context.Context, _ DomainEvent) error {
+		atomic.AddInt32(&count, 1)
+		return nil
+	})
+
+	// 发布三次
+	for i := 0; i < 3; i++ {
+		err := bus.Publish(ctx, makeEvent("payment.processed"))
+		require.NoError(t, err)
+	}
+
+	assert.Equal(t, int32(1), atomic.LoadInt32(&count), "SubscribeOnce 处理器只应执行一次")
+	assert.False(t, sub.IsActive(), "首次执行后订阅应自动失活")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 8. Unsubscribe — 取消后不再接收事件
+// ═══════════════════════════════════════════════════════════════
+
+func TestUnsubscribe_StopsReceivingEvents(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	var count int32
+	sub := bus.Subscribe("inventory.updated", func(_ context.Context, _ DomainEvent) error {
+		atomic.AddInt32(&count, 1)
+		return nil
+	})
+
+	// 取消前发布一次
+	err := bus.Publish(ctx, makeEvent("inventory.updated"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(1), atomic.LoadInt32(&count))
+
+	// 取消订阅
+	ok := sub.Unsubscribe()
+	assert.True(t, ok, "首次取消应返回 true")
+	assert.False(t, sub.IsActive(), "取消后订阅应失活")
+
+	// 重复取消应返回 false
+	ok = sub.Unsubscribe()
+	assert.False(t, ok, "重复取消应返回 false")
+
+	// 取消后再发布，不应再触发
+	err = bus.Publish(ctx, makeEvent("inventory.updated"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(1), atomic.LoadInt32(&count), "取消后不应再接收事件")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 9. PublishAsync — 异步执行，Close() 确保 drain 完成
+// ═══════════════════════════════════════════════════════════════
+
+func TestPublishAsync_HandlersExecuteAsynchronously(t *testing.T) {
+	logger := zap.NewNop()
+	bus := New(logger)
+
+	ctx := context.Background()
+
+	const numHandlers = 5
+	var wg sync.WaitGroup
+	wg.Add(numHandlers)
+
+	var count int32
+	for i := 0; i < numHandlers; i++ {
+		bus.Subscribe("notification.sent", func(_ context.Context, _ DomainEvent) error {
+			atomic.AddInt32(&count, 1)
+			wg.Done()
+			return nil
+		})
+	}
+
+	bus.PublishAsync(ctx, makeEvent("notification.sent"))
+
+	// 等待所有处理器完成
+	done := make(chan struct{})
+	go func() {
+		wg.Wait()
+		close(done)
+	}()
+
+	select {
+	case <-done:
+		// 成功
+	case <-time.After(5 * time.Second):
+		t.Fatal("超时：异步处理器未全部完成")
+	}
+
+	// Close() 应 drain 所有 goroutine
+	bus.Close()
+	assert.Equal(t, int32(numHandlers), atomic.LoadInt32(&count))
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 10. Publish 在 CatchErrors=false 时传播处理器错误
+// ═══════════════════════════════════════════════════════════════
+
+func TestPublish_ReturnsHandlerError_WhenCatchErrorsDisabled(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	catchErrors := false
+	expectedErr := errors.New("handler failure")
+
+	bus.Subscribe("email.sent", func(_ context.Context, _ DomainEvent) error {
+		return expectedErr
+	}, SubscribeOptions{CatchErrors: &catchErrors})
+
+	err := bus.Publish(ctx, makeEvent("email.sent"))
+	require.Error(t, err)
+	assert.Equal(t, expectedErr, err, "CatchErrors=false 时应返回处理器错误")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 10b. Publish 在 CatchErrors=true（默认）时吞掉处理器错误
+// ═══════════════════════════════════════════════════════════════
+
+func TestPublish_SwallowsHandlerError_WhenCatchErrorsEnabled(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	// 默认 catchErrors = true
+	bus.Subscribe("sms.sent", func(_ context.Context, _ DomainEvent) error {
+		return errors.New("handler blew up")
+	})
+
+	err := bus.Publish(ctx, makeEvent("sms.sent"))
+	assert.NoError(t, err, "CatchErrors=true（默认）时应吞掉错误")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 11. WaitFor — 阻塞直到匹配事件到达，context 取消时超时
+// ═══════════════════════════════════════════════════════════════
+
+func TestWaitFor_ReceivesMatchingEvent(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	publishDelay := 50 * time.Millisecond
+	go func() {
+		time.Sleep(publishDelay)
+		_ = bus.Publish(ctx, NewDomainEvent("session.started", "sess-99", nil))
+	}()
+
+	evt, err := bus.WaitFor(ctx, "session.started", 2*time.Second)
+	require.NoError(t, err)
+	assert.Equal(t, "session.started", evt.EventName)
+	assert.Equal(t, "sess-99", evt.AggregateID)
+}
+
+func TestWaitFor_TimesOut_WhenContextCancelled(t *testing.T) {
+	bus := newTestBus(t)
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// 立即取消 context
+	go func() {
+		time.Sleep(20 * time.Millisecond)
+		cancel()
+	}()
+
+	_, err := bus.WaitFor(ctx, "ghost.event", 5*time.Second)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, context.Canceled, "context 取消后应返回 context.Canceled")
+}
+
+func TestWaitFor_TimesOut_WhenTimeoutExpires(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	_, err := bus.WaitFor(ctx, "never.fires", 50*time.Millisecond)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "timeout", "超时后应返回包含 'timeout' 的错误")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 12. 多订阅者同一事件 — 全部接收
+// ═══════════════════════════════════════════════════════════════
+
+func TestMultipleSubscribers_AllReceiveEvent(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	const numSubscribers = 5
+	received := make([]chan struct{}, numSubscribers)
+	for i := range received {
+		received[i] = make(chan struct{}, 1)
+		idx := i
+		bus.Subscribe("product.created", func(_ context.Context, _ DomainEvent) error {
+			received[idx] <- struct{}{}
+			return nil
+		})
+	}
+
+	err := bus.Publish(ctx, makeEvent("product.created"))
+	require.NoError(t, err)
+
+	for i, ch := range received {
+		select {
+		case <-ch:
+			// 成功接收
+		case <-time.After(time.Second):
+			t.Fatalf("订阅者 %d 未收到事件", i)
+		}
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 13. Filter 谓词 — 只有匹配的事件到达处理器
+// ═══════════════════════════════════════════════════════════════
+
+func TestFilter_OnlyMatchingEventsReachHandler(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	var count int32
+	bus.Subscribe("order.*", func(_ context.Context, event DomainEvent) error {
+		atomic.AddInt32(&count, 1)
+		return nil
+	}, SubscribeOptions{
+		Filter: func(event DomainEvent) bool {
+			// 只处理 aggregateID 以 "vip-" 开头的事件
+			return len(event.AggregateID) >= 4 && event.AggregateID[:4] == "vip-"
+		},
+	})
+
+	// 不匹配 filter
+	err := bus.Publish(ctx, NewDomainEvent("order.placed", "normal-100", nil))
+	require.NoError(t, err)
+	assert.Equal(t, int32(0), atomic.LoadInt32(&count), "普通订单不应触发 VIP 过滤器")
+
+	// 匹配 filter
+	err = bus.Publish(ctx, NewDomainEvent("order.placed", "vip-200", nil))
+	require.NoError(t, err)
+	assert.Equal(t, int32(1), atomic.LoadInt32(&count), "VIP 订单应通过过滤器")
+
+	// 再次不匹配
+	err = bus.Publish(ctx, NewDomainEvent("order.cancelled", "normal-300", nil))
+	require.NoError(t, err)
+	assert.Equal(t, int32(1), atomic.LoadInt32(&count))
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 14. 事件元数据 — EventID 和 OccurredAt 自动填充
+// ═══════════════════════════════════════════════════════════════
+
+func TestEventMetadata_AutoPopulated(t *testing.T) {
+	before := time.Now()
+	evt := NewDomainEvent("catalog.updated", "prod-42", nil)
+	after := time.Now()
+
+	assert.NotEmpty(t, evt.EventID, "EventID 应自动生成")
+	assert.False(t, evt.OccurredAt.IsZero(), "OccurredAt 不应为零值")
+	assert.True(t, !evt.OccurredAt.Before(before) && !evt.OccurredAt.After(after),
+		"OccurredAt 应在创建时刻范围内")
+}
+
+func TestEventMetadata_EventIDsAreUnique(t *testing.T) {
+	ids := make(map[string]struct{}, 100)
+	for i := 0; i < 100; i++ {
+		evt := NewDomainEvent(fmt.Sprintf("event.%d", i), "agg", nil)
+		_, duplicate := ids[evt.EventID]
+		assert.False(t, duplicate, "EventID 应唯一，发现重复: %s", evt.EventID)
+		ids[evt.EventID] = struct{}{}
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 15. Close — drain 异步 goroutine
+// ═══════════════════════════════════════════════════════════════
+
+func TestClose_DrainsAsyncGoroutines(t *testing.T) {
+	logger := zap.NewNop()
+	bus := New(logger)
+
+	ctx := context.Background()
+
+	started := make(chan struct{})
+	finished := make(chan struct{})
+
+	bus.Subscribe("job.queued", func(_ context.Context, _ DomainEvent) error {
+		close(started)
+		// 模拟耗时处理
+		time.Sleep(100 * time.Millisecond)
+		close(finished)
+		return nil
+	})
+
+	bus.PublishAsync(ctx, makeEvent("job.queued"))
+
+	// 等待处理器启动
+	select {
+	case <-started:
+	case <-time.After(time.Second):
+		t.Fatal("处理器未启动")
+	}
+
+	// Close 应阻塞直到 goroutine 完成
+	closeDone := make(chan struct{})
+	go func() {
+		bus.Close()
+		close(closeDone)
+	}()
+
+	select {
+	case <-finished:
+		// goroutine 正常完成
+	case <-time.After(2 * time.Second):
+		t.Fatal("Close 未等待 goroutine 完成")
+	}
+
+	select {
+	case <-closeDone:
+		// Close 正常返回
+	case <-time.After(2 * time.Second):
+		t.Fatal("Close 未能正常返回")
+	}
+}
+
+func TestClose_RejectsNewPublish(t *testing.T) {
+	logger := zap.NewNop()
+	bus := New(logger)
+
+	bus.Close()
+
+	err := bus.Publish(context.Background(), makeEvent("any.event"))
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "closed", "关闭后 Publish 应返回错误")
+}
+
+func TestClose_RejectsNewPublishAsync(t *testing.T) {
+	logger := zap.NewNop()
+	bus := New(logger)
+
+	var count int32
+	bus.Subscribe("any.event", func(_ context.Context, _ DomainEvent) error {
+		atomic.AddInt32(&count, 1)
+		return nil
+	})
+
+	bus.Close()
+
+	// PublishAsync 在关闭后不应执行处理器（不 panic，静默丢弃）
+	bus.PublishAsync(context.Background(), makeEvent("any.event"))
+	assert.Equal(t, int32(0), atomic.LoadInt32(&count), "关闭后 PublishAsync 不应触发处理器")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 额外测试：Subscription.IsActive 正确反映状态
+// ═══════════════════════════════════════════════════════════════
+
+func TestSubscription_IsActive(t *testing.T) {
+	bus := newTestBus(t)
+
+	sub := bus.Subscribe("test.event", func(_ context.Context, _ DomainEvent) error {
+		return nil
+	})
+
+	assert.True(t, sub.IsActive(), "订阅刚创建时应为活跃状态")
+	sub.Unsubscribe()
+	assert.False(t, sub.IsActive(), "取消后应为非活跃状态")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 额外测试：SubscriptionCount 计数正确
+// ═══════════════════════════════════════════════════════════════
+
+func TestSubscriptionCount(t *testing.T) {
+	bus := newTestBus(t)
+
+	assert.Equal(t, 0, bus.SubscriptionCount())
+
+	sub1 := bus.Subscribe("a.b", func(_ context.Context, _ DomainEvent) error { return nil })
+	assert.Equal(t, 1, bus.SubscriptionCount())
+
+	sub2 := bus.Subscribe("c.d", func(_ context.Context, _ DomainEvent) error { return nil })
+	assert.Equal(t, 2, bus.SubscriptionCount())
+
+	sub1.Unsubscribe()
+	assert.Equal(t, 1, bus.SubscriptionCount())
+
+	sub2.Unsubscribe()
+	assert.Equal(t, 0, bus.SubscriptionCount())
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 额外测试：UnsubscribeAll 批量取消
+// ═══════════════════════════════════════════════════════════════
+
+func TestUnsubscribeAll_RemovesAllSubscribersForEvent(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	var count int32
+	handler := func(_ context.Context, _ DomainEvent) error {
+		atomic.AddInt32(&count, 1)
+		return nil
+	}
+
+	bus.Subscribe("log.written", handler)
+	bus.Subscribe("log.written", handler)
+	bus.Subscribe("log.written", handler)
+
+	removed := bus.UnsubscribeAll("log.written")
+	assert.Equal(t, 3, removed)
+	assert.Equal(t, 0, bus.SubscriptionCount())
+
+	err := bus.Publish(ctx, makeEvent("log.written"))
+	require.NoError(t, err)
+	assert.Equal(t, int32(0), atomic.LoadInt32(&count), "批量取消后不应再触发任何处理器")
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 额外测试：HasSubscribers 反映正确状态
+// ═══════════════════════════════════════════════════════════════
+
+func TestHasSubscribers(t *testing.T) {
+	bus := newTestBus(t)
+
+	assert.False(t, bus.HasSubscribers("test.event"))
+
+	sub := bus.Subscribe("test.event", func(_ context.Context, _ DomainEvent) error { return nil })
+	assert.True(t, bus.HasSubscribers("test.event"))
+
+	sub.Unsubscribe()
+	assert.False(t, bus.HasSubscribers("test.event"))
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 额外测试：处理器 panic 不应崩溃整个进程
+// ═══════════════════════════════════════════════════════════════
+
+func TestPublish_HandlerPanic_IsRecovered(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	catchErrors := false
+	bus.Subscribe("panic.event", func(_ context.Context, _ DomainEvent) error {
+		panic("intentional panic")
+	}, SubscribeOptions{CatchErrors: &catchErrors})
+
+	// 不应 panic 到测试运行时
+	require.NotPanics(t, func() {
+		err := bus.Publish(ctx, makeEvent("panic.event"))
+		// panic 被转换为 error
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "handler panic")
+	})
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 额外测试：OnError 回调在处理器出错时被调用
+// ═══════════════════════════════════════════════════════════════
+
+func TestSubscribe_OnError_CalledWhenHandlerFails(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	handlerErr := errors.New("something went wrong")
+	onErrorCalled := make(chan error, 1)
+
+	bus.Subscribe("report.failed", func(_ context.Context, _ DomainEvent) error {
+		return handlerErr
+	}, SubscribeOptions{
+		OnError: func(err error, _ DomainEvent) {
+			onErrorCalled <- err
+		},
+		// 默认 CatchErrors=true，错误会被吞掉但 OnError 仍被调用
+	})
+
+	err := bus.Publish(ctx, makeEvent("report.failed"))
+	require.NoError(t, err, "CatchErrors=true 时 Publish 不应返回错误")
+
+	select {
+	case gotErr := <-onErrorCalled:
+		assert.Equal(t, handlerErr, gotErr, "OnError 应接收到处理器返回的错误")
+	case <-time.After(time.Second):
+		t.Fatal("超时：OnError 未被调用")
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 内部函数测试：matchPattern
+// ═══════════════════════════════════════════════════════════════
+
+func TestMatchPattern(t *testing.T) {
+	cases := []struct {
+		pattern   string
+		eventName string
+		expect    bool
+		desc      string
+	}{
+		// 精确匹配
+		{"user.created", "user.created", true, "精确匹配"},
+		{"user.created", "user.deleted", false, "精确匹配不同事件"},
+		// 全局通配符
+		{"**", "user.created", true, "** 匹配单段"},
+		{"**", "user.profile.updated", true, "** 匹配多段"},
+		{"*", "user.created", true, "单独 * 匹配所有"},
+		// 单段通配符
+		{"user.*", "user.created", true, "user.* 匹配 user.created"},
+		{"user.*", "user.deleted", true, "user.* 匹配 user.deleted"},
+		{"user.*", "user.profile.updated", false, "user.* 不匹配多段"},
+		{"user.*", "order.created", false, "user.* 不匹配其他域"},
+		// 多段双星通配符
+		// user.** 的 ** 仅在段数不等时触发尾部展开；与模式等长时走逐段比较，** 不匹配字面值
+		{"user.**", "user.created", false, "user.** 不匹配与模式等长的 user.created"},
+		{"user.**", "user.profile.updated", true, "user.** 匹配段数更多的 user.profile.updated"},
+		{"user.**", "user.a.b.c", true, "user.** 匹配任意深度子路径"},
+		{"user.**", "order.created", false, "user.** 不匹配 order 域"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.desc, func(t *testing.T) {
+			got := matchPattern(tc.pattern, tc.eventName)
+			assert.Equal(t, tc.expect, got, "pattern=%q, event=%q", tc.pattern, tc.eventName)
+		})
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 并发安全测试
+// ═══════════════════════════════════════════════════════════════
+
+func TestConcurrency_SubscribePublishUnsubscribe(t *testing.T) {
+	bus := newTestBus(t)
+	ctx := context.Background()
+
+	const (
+		numPublishers   = 10
+		numSubscribers  = 10
+		eventsPerWorker = 20
+	)
+
+	var wg sync.WaitGroup
+	var publishCount, receiveCount int64
+
+	// 并发订阅
+	subs := make([]*Subscription, numSubscribers)
+	for i := 0; i < numSubscribers; i++ {
+		subs[i] = bus.Subscribe("concurrent.event", func(_ context.Context, _ DomainEvent) error {
+			atomic.AddInt64(&receiveCount, 1)
+			return nil
+		})
+	}
+
+	// 并发发布
+	for i := 0; i < numPublishers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < eventsPerWorker; j++ {
+				if err := bus.Publish(ctx, makeEvent("concurrent.event")); err == nil {
+					atomic.AddInt64(&publishCount, 1)
+				}
+			}
+		}()
+	}
+
+	// 并发取消订阅
+	for i := 0; i < numSubscribers/2; i++ {
+		idx := i
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			time.Sleep(10 * time.Millisecond)
+			subs[idx].Unsubscribe()
+		}()
+	}
+
+	wg.Wait()
+
+	// 核心断言：不应 panic，数据竞争检测（race detector）应通过
+	assert.True(t, atomic.LoadInt64(&publishCount) > 0, "应有事件被成功发布")
+	t.Logf("发布次数: %d, 处理次数: %d", publishCount, receiveCount)
+}