yumi-golang/internal/config/config_test.go

package config

import (
	"os"
	"testing"
)

func TestNormalizeLuckyGiftConfigsKeepsDedicatedAccountWhenSharedPresent(t *testing.T) {
	configs := normalizeLuckyGiftConfigs([]LuckyGiftProviderConfig{
		{
			StandardID: 18816,
			URL:        "https://provider.example.com",
			AppID:      "lucky-app-id",
			AppChannel: "lucky-app-channel",
			AppKey:     "legacy-lucky-key",
		},
	}, "shared-baishun-app-id", "shared-baishun-app-channel", "shared-baishun-key")
	if len(configs) != 1 {
		t.Fatalf("expected 1 config, got %d", len(configs))
	}
	if got := configs[0].AppID; got != "lucky-app-id" {
		t.Fatalf("expected dedicated lucky gift app id, got %q", got)
	}
	if got := configs[0].AppChannel; got != "lucky-app-channel" {
		t.Fatalf("expected dedicated lucky gift app channel, got %q", got)
	}
	if got := configs[0].AppKey; got != "legacy-lucky-key" {
		t.Fatalf("expected dedicated lucky gift key, got %q", got)
	}
}

func TestNormalizeLuckyGiftConfigsFallsBackToSharedAccountWhenDedicatedBlank(t *testing.T) {
	configs := normalizeLuckyGiftConfigs([]LuckyGiftProviderConfig{
		{
			StandardID: 18816,
			URL:        "https://provider.example.com",
		},
	}, "shared-baishun-app-id", "shared-baishun-app-channel", "shared-baishun-key")
	if len(configs) != 1 {
		t.Fatalf("expected 1 config, got %d", len(configs))
	}
	if got := configs[0].AppID; got != "shared-baishun-app-id" {
		t.Fatalf("expected shared baishun app id fallback, got %q", got)
	}
	if got := configs[0].AppChannel; got != "shared-baishun-app-channel" {
		t.Fatalf("expected shared baishun app channel fallback, got %q", got)
	}
	if got := configs[0].AppKey; got != "shared-baishun-key" {
		t.Fatalf("expected shared baishun key fallback, got %q", got)
	}
}

func TestGetEnvBoolAliasSupportsLegacyLuckyGiftKey(t *testing.T) {
	t.Setenv("LUCKY_GIFT_GO_ENABLED", "true")
	if got := getEnvBoolAny([]string{"LUCKY_GIFT_ENABLED", "LUCKY_GIFT_GO_ENABLED"}, false); !got {
		t.Fatalf("expected legacy lucky gift bool alias to be true")
	}
}

func TestLoadWeekStarRocketMQAutoEnablesWhenCredentialsPresent(t *testing.T) {
	unsetEnvForTest(t, "CHATAPP_WEEK_STAR_ROCKETMQ_ENABLED", "WEEK_STAR_ROCKETMQ_ENABLED")
	t.Setenv("CHATAPP_WEEK_STAR_ROCKETMQ_ENDPOINT", "rmq.example.com:8081")
	t.Setenv("CHATAPP_WEEK_STAR_ROCKETMQ_ACCESS_KEY", "access-key")
	t.Setenv("CHATAPP_WEEK_STAR_ROCKETMQ_ACCESS_SECRET", "access-secret")

	cfg := Load()
	if !cfg.WeekStar.RocketMQ.Enabled {
		t.Fatalf("expected week star rocketmq to auto-enable when endpoint and credentials are present")
	}
}

func TestLoadWeekStarRocketMQExplicitDisableOverridesCredentials(t *testing.T) {
	t.Setenv("CHATAPP_WEEK_STAR_ROCKETMQ_ENABLED", "false")
	t.Setenv("CHATAPP_WEEK_STAR_ROCKETMQ_ENDPOINT", "rmq.example.com:8081")
	t.Setenv("CHATAPP_WEEK_STAR_ROCKETMQ_ACCESS_KEY", "access-key")
	t.Setenv("CHATAPP_WEEK_STAR_ROCKETMQ_ACCESS_SECRET", "access-secret")

	cfg := Load()
	if cfg.WeekStar.RocketMQ.Enabled {
		t.Fatalf("expected explicit week star rocketmq disable to override credentials")
	}
}

func TestLoadTaskCenterMQUsesSharedRocketMQCredentials(t *testing.T) {
	t.Setenv("CHATAPP_TASK_CENTER_MQ_ENABLED", "true")
	t.Setenv("LIKEI_ROCKETMQ_ENDPOINT", "rmq.example.com:8081")
	t.Setenv("LIKEI_ROCKETMQ_ACCESS_KEY", "access-key")
	t.Setenv("LIKEI_ROCKETMQ_SECRET_KEY", "access-secret")

	cfg := Load()
	if !cfg.TaskCenter.MQ.Enabled {
		t.Fatalf("expected task center mq enabled")
	}
	if got := cfg.TaskCenter.MQ.Endpoint; got != "rmq.example.com:8081" {
		t.Fatalf("task center mq endpoint = %q", got)
	}
	if got := cfg.TaskCenter.MQ.Topic; got != "RC_DEFAULT_APP_ORDINARY" {
		t.Fatalf("task center mq topic = %q", got)
	}
	if got := cfg.TaskCenter.MQ.Tag; got != "task_center_event" {
		t.Fatalf("task center mq tag = %q", got)
	}
}

func TestLoadCPRelationBroadcastMQUsesSharedRocketMQCredentials(t *testing.T) {
	t.Setenv("LIKEI_ROCKETMQ_ENDPOINT", "rmq.example.com:8081")
	t.Setenv("LIKEI_ROCKETMQ_ACCESS_KEY", "access-key")
	t.Setenv("LIKEI_ROCKETMQ_SECRET_KEY", "access-secret")
	t.Setenv("CHATAPP_CP_RELATION_BROADCAST_MQ_ENDPOINT", "should-not-use:8081")
	t.Setenv("CHATAPP_CP_RELATION_BROADCAST_MQ_TOPIC", "should-not-use")
	t.Setenv("CHATAPP_CP_RELATION_BROADCAST_MQ_TAG", "should-not-use")

	cfg := Load()
	if !cfg.CPRelationBroadcast.MQ.Enabled {
		t.Fatalf("expected cp relation broadcast mq enabled")
	}
	if got := cfg.CPRelationBroadcast.MQ.Endpoint; got != "rmq.example.com:8081" {
		t.Fatalf("cp relation broadcast mq endpoint = %q", got)
	}
	if got := cfg.CPRelationBroadcast.MQ.Topic; got != "RC_DEFAULT_APP_ORDINARY" {
		t.Fatalf("cp relation broadcast mq topic = %q", got)
	}
	if got := cfg.CPRelationBroadcast.MQ.Tag; got != "cp_relation_broadcast" {
		t.Fatalf("cp relation broadcast mq tag = %q", got)
	}
}

func TestLoadTaskCenterArchiveUsesSharedCOSCredentials(t *testing.T) {
	t.Setenv("CHATAPP_TASK_CENTER_ARCHIVE_ENABLED", "true")
	t.Setenv("LIKEI_TENCENT_COS_BUCKET", "bucket-123")
	t.Setenv("LIKEI_TENCENT_COS_REGION", "ap-test")
	t.Setenv("LIKEI_TENCENT_COS_SECRET_ID", "secret-id")
	t.Setenv("LIKEI_TENCENT_COS_SECRET_KEY", "secret-key")

	cfg := Load()
	if !cfg.TaskCenter.Archive.Enabled {
		t.Fatalf("expected task center archive enabled")
	}
	if got := cfg.TaskCenter.Archive.Bucket; got != "bucket-123" {
		t.Fatalf("task center archive bucket = %q", got)
	}
	if got := cfg.TaskCenter.Archive.Prefix; got != "task-center-events/v1" {
		t.Fatalf("task center archive prefix = %q", got)
	}
}

func TestLoadLingxianConfigSupportsLikeiHkysSignKey(t *testing.T) {
	t.Setenv("LIKEI_GAME_HKYS_SIGN_KEY", "likei-hkys-key")

	cfg := Load()
	if got := cfg.Lingxian.AppKey; got != "likei-hkys-key" {
		t.Fatalf("expected legacy likei hkys sign key, got %q", got)
	}
}

func unsetEnvForTest(t *testing.T, keys ...string) {
	t.Helper()
	values := make(map[string]string, len(keys))
	present := make(map[string]bool, len(keys))
	for _, key := range keys {
		value, ok := os.LookupEnv(key)
		values[key] = value
		present[key] = ok
		if err := os.Unsetenv(key); err != nil {
			t.Fatalf("unset %s: %v", key, err)
		}
	}
	t.Cleanup(func() {
		for _, key := range keys {
			if present[key] {
				_ = os.Setenv(key, values[key])
			} else {
				_ = os.Unsetenv(key)
			}
		}
	})
}

func TestLoadLuckyGiftConfigsSupportsLegacyDefaultEnv(t *testing.T) {
	oldJSON, hadJSON := os.LookupEnv("LUCKY_GIFT_CONFIGS_JSON")
	oldList, hadList := os.LookupEnv("LUCKY_GIFT_CONFIGS")
	t.Cleanup(func() {
		if hadJSON {
			_ = os.Setenv("LUCKY_GIFT_CONFIGS_JSON", oldJSON)
		} else {
			_ = os.Unsetenv("LUCKY_GIFT_CONFIGS_JSON")
		}
		if hadList {
			_ = os.Setenv("LUCKY_GIFT_CONFIGS", oldList)
		} else {
			_ = os.Unsetenv("LUCKY_GIFT_CONFIGS")
		}
	})
	_ = os.Unsetenv("LUCKY_GIFT_CONFIGS_JSON")
	_ = os.Unsetenv("LUCKY_GIFT_CONFIGS")
	t.Setenv("LUCKY_GIFT_API_DEFAULT_URL", "https://provider.example.com/lucky_gift/start_game")
	t.Setenv("LUCKY_GIFT_API_DEFAULT_APP_ID", "legacy-app-id")
	t.Setenv("LUCKY_GIFT_API_DEFAULT_APP_CHANNEL", "legacy-app-channel")
	t.Setenv("LUCKY_GIFT_API_DEFAULT_APP_KEY", "legacy-app-key")

	configs := loadLuckyGiftConfigs()
	if len(configs) != 1 {
		t.Fatalf("expected 1 config, got %d", len(configs))
	}
	if got := configs[0].URL; got != "https://provider.example.com/lucky_gift/start_game" {
		t.Fatalf("expected legacy lucky gift default url, got %q", got)
	}
	if got := configs[0].AppID; got != "legacy-app-id" {
		t.Fatalf("expected legacy lucky gift default app id, got %q", got)
	}
	if got := configs[0].AppChannel; got != "legacy-app-channel" {
		t.Fatalf("expected legacy lucky gift default app channel, got %q", got)
	}
	if got := configs[0].AppKey; got != "legacy-app-key" {
		t.Fatalf("expected legacy lucky gift default app key, got %q", got)
	}
}