优化结构

2026-08-24 13:25:16 +08:00
parent 7a9a738c6a
commit 0b6b8ddf1a
72 changed files with 2475 additions and 1443 deletions
@@ -0,0 +1,153 @@
+package global
+
+import (
+	"context"
+	"io"
+	"log/slog"
+	"sync"
+	"testing"
+
+	"github.com/redis/go-redis/v9"
+	"go.mongodb.org/mongo-driver/mongo"
+	"gorm.io/gorm"
+	platformmq "kra/pkg/mq"
+	platformws "kra/pkg/websocket"
+)
+
+type storageStub struct{}
+
+func (*storageStub) Open(context.Context, string) (io.ReadCloser, error) { return nil, nil }
+func (*storageStub) Delete(context.Context, string) error                { return nil }
+func (*storageStub) DeletePrefix(context.Context, string) error          { return nil }
+
+type schedulerStub struct{}
+
+func (*schedulerStub) Start(context.Context) error { return nil }
+func (*schedulerStub) Stop(context.Context) error  { return nil }
+
+type mqStub struct{}
+
+func (*mqStub) Register(platformmq.SubscriptionSet) error { return nil }
+func (*mqStub) Unregister(string) error                   { return nil }
+func (*mqStub) Client(string) platformmq.Client           { return nil }
+func (*mqStub) PublishTo(context.Context, string, string, []byte, byte, bool) error {
+	return nil
+}
+func (*mqStub) SubscribeTo(context.Context, string, string, byte, platformmq.Handler) error {
+	return nil
+}
+func (*mqStub) UnsubscribeFrom(context.Context, string, ...string) error { return nil }
+func (*mqStub) ConnectedTo(string) bool                                  { return true }
+
+type webSocketStub struct{}
+
+func (*webSocketStub) Enabled() bool                                     { return true }
+func (*webSocketStub) Broadcast([]byte) error                            { return nil }
+func (*webSocketStub) BroadcastBinary([]byte) error                      { return nil }
+func (*webSocketStub) Sessions() ([]*platformws.Session, error)          { return nil, nil }
+func (*webSocketStub) Len() int                                          { return 0 }
+func (*webSocketStub) Send(*platformws.Session, []byte) error            { return nil }
+func (*webSocketStub) SendBinary(*platformws.Session, []byte) error      { return nil }
+func (*webSocketStub) OnMessage(func(*platformws.Session, []byte))       {}
+func (*webSocketStub) OnBinaryMessage(func(*platformws.Session, []byte)) {}
+func (*webSocketStub) OnConnect(func(*platformws.Session))               {}
+func (*webSocketStub) OnDisconnect(func(*platformws.Session))            {}
+
+func TestResourceRegistryDefaults(t *testing.T) {
+	registry := NewResourceRegistry()
+	if registry.Logger() == nil {
+		t.Fatal("default logger is nil")
+	}
+	resources := registry.Snapshot()
+	if resources.DB != nil || len(resources.NamedDBs) != 0 || resources.Redis != nil || len(resources.NamedRedis) != 0 || resources.Mongo != nil || resources.Storage != nil || resources.MQ != nil || resources.WebSocket != nil || resources.Scheduler != nil {
+		t.Fatalf("unexpected initialized resource: %#v", resources)
+	}
+}
+
+func TestResourceRegistryReplaceAndSetters(t *testing.T) {
+	logger := slog.Default().With("test", true)
+	db := &gorm.DB{}
+	redisClient := redis.NewClient(&redis.Options{Addr: "127.0.0.1:6379"})
+	t.Cleanup(func() { _ = redisClient.Close() })
+	mongoClient := &mongo.Client{}
+	storage := &storageStub{}
+	mq := &mqStub{}
+	webSocket := &webSocketStub{}
+	scheduler := &schedulerStub{}
+
+	registry := NewResourceRegistry()
+	registry.Replace(Resources{
+		Logger: logger, DB: db, NamedDBs: map[string]*gorm.DB{"reporting": db},
+		Redis: redisClient, NamedRedis: map[string]redis.UniversalClient{"cache": redisClient}, Mongo: mongoClient,
+		Storage: storage, MQ: mq, WebSocket: webSocket, Scheduler: scheduler,
+	})
+	resources := registry.Snapshot()
+	if resources.Logger != logger || resources.DB != db || resources.Redis != redisClient || resources.Mongo != mongoClient || resources.Storage != storage || resources.MQ != mq || resources.WebSocket != webSocket || resources.Scheduler != scheduler {
+		t.Fatalf("replacement snapshot does not match: %#v", resources)
+	}
+
+	nextDB := &gorm.DB{}
+	registry.SetDB(nextDB)
+	if registry.DB() != nextDB {
+		t.Fatal("database setter did not publish the new database")
+	}
+	if registry.Redis() != redisClient || registry.Storage() != storage {
+		t.Fatal("database setter changed unrelated resources")
+	}
+	if registry.NamedDB("reporting") != db || registry.NamedDB("") != nextDB {
+		t.Fatal("named database lookup returned the wrong resource")
+	}
+	if registry.NamedRedis("cache") != redisClient || registry.NamedRedis("") != redisClient {
+		t.Fatal("named redis lookup returned the wrong resource")
+	}
+	inputDBs := map[string]*gorm.DB{"analytics": db}
+	registry.SetNamedDBs(inputDBs)
+	inputDBs["mutated"] = nextDB
+	if registry.NamedDB("mutated") != nil || registry.NamedDB("analytics") != db {
+		t.Fatal("named database map was not copied")
+	}
+	inputRedis := map[string]redis.UniversalClient{"sessions": redisClient}
+	registry.SetNamedRedis(inputRedis)
+	inputRedis["mutated"] = redisClient
+	if registry.NamedRedis("mutated") != nil || registry.NamedRedis("sessions") != redisClient {
+		t.Fatal("named redis map was not copied")
+	}
+}
+
+func TestResourceRegistryNormalizesTypedNilInterfaces(t *testing.T) {
+	registry := NewResourceRegistry()
+	var redisClient *redis.Client
+	var storage *storageStub
+	var mq *mqStub
+	var webSocket *webSocketStub
+	var scheduler *schedulerStub
+	registry.Replace(Resources{Redis: redisClient, Storage: storage, MQ: mq, WebSocket: webSocket, Scheduler: scheduler})
+	resources := registry.Snapshot()
+	if resources.Redis != nil || resources.Storage != nil || resources.MQ != nil || resources.WebSocket != nil || resources.Scheduler != nil {
+		t.Fatalf("typed nil resource was retained: %#v", resources)
+	}
+	if resources.Logger == nil {
+		t.Fatal("nil logger was not replaced with the default logger")
+	}
+}
+
+func TestResourceRegistryConcurrentAccess(t *testing.T) {
+	registry := NewResourceRegistry()
+	const iterations = 1000
+	var wait sync.WaitGroup
+	for index := 0; index < 8; index++ {
+		wait.Add(1)
+		go func() {
+			defer wait.Done()
+			for step := 0; step < iterations; step++ {
+				registry.SetDB(&gorm.DB{})
+				_ = registry.Snapshot()
+				_ = registry.Logger()
+			}
+		}()
+	}
+	wait.Wait()
+	if registry.DB() == nil {
+		t.Fatal("concurrent setters lost the database")
+	}
+}