ForcePilot/backend/test/unit/channels/test_channels_accounts.py

from __future__ import annotations

from yuxi.channels.accounts.base import (
    BaseChannelAccount,
    BaseAccountManager,
    resolve_account_from_config_section,
    resolve_account_ids,
    resolve_default_account_id,
    resolve_effective_dm_scope,
)


class TestBaseChannelAccount:
    def test_default_values(self):
        account = BaseChannelAccount()
        assert account.account_id == "default"
        assert account.enabled is True
        assert account.dm_policy == "allowlist"
        assert account.group_policy == "allowlist"
        assert account.name == ""
        assert account.upgrade_url == ""
        assert account.upgrade_mode == ""

    def test_custom_values(self):
        account = BaseChannelAccount(
            account_id="custom-1",
            enabled=False,
            dm_policy="pairing",
            group_policy="blacklist",
            name="测试",
            upgrade_url="https://upgrade.example.com",
            upgrade_mode="hot-reload",
        )
        assert account.account_id == "custom-1"
        assert account.enabled is False
        assert account.dm_policy == "pairing"
        assert account.group_policy == "blacklist"
        assert account.name == "测试"
        assert account.upgrade_url == "https://upgrade.example.com"
        assert account.upgrade_mode == "hot-reload"


class TestResolveAccountFromConfigSection:
    def test_multi_account_structure(self):
        config = {
            "accounts": {
                "default": {"app_id": "app-default", "secret": "s1"},
                "second": {"app_id": "app-second", "secret": "s2"},
            },
            "defaultAccount": "default",
        }
        result = resolve_account_from_config_section(config, "default")
        assert result == {"app_id": "app-default", "secret": "s1"}

    def test_specific_account(self):
        config = {
            "accounts": {
                "default": {"app_id": "app-default"},
                "second": {"app_id": "app-second"},
            },
        }
        result = resolve_account_from_config_section(config, "second")
        assert result == {"app_id": "app-second"}

    def test_flat_config_no_accounts_section(self):
        config = {"app_id": "flat-app", "client_secret": "flat-secret"}
        result = resolve_account_from_config_section(config, "default")
        assert result == config

    def test_default_fallback_to_first_account(self):
        config = {
            "accounts": {
                "first": {"app_id": "app-first"},
                "second": {"app_id": "app-second"},
            },
        }
        result = resolve_account_from_config_section(config, "default")
        assert result == {"app_id": "app-first"}

    def test_empty_accounts_returns_env_config(self):
        config = {"accounts": {}}
        result = resolve_account_from_config_section(config, "default")
        assert result == config

    def test_custom_section_key(self):
        config = {
            "configs": {
                "default": {"key": "val-default"},
                "other": {"key": "val-other"},
            },
        }
        result = resolve_account_from_config_section(config, "default", section_key="configs")
        assert result == {"key": "val-default"}


class TestResolveAccountIds:
    def test_multi_account_ids(self):
        config = {
            "accounts": {
                "default": {},
                "second": {},
                "third": {},
            },
        }
        ids = resolve_account_ids(config)
        assert sorted(ids) == sorted(["default", "second", "third"])

    def test_no_accounts_returns_default(self):
        config = {}
        ids = resolve_account_ids(config)
        assert ids == ["default"]

    def test_empty_accounts_returns_default(self):
        config = {"accounts": {}}
        ids = resolve_account_ids(config)
        assert ids == ["default"]

    def test_custom_section_key(self):
        config = {"configs": {"a": {}, "b": {}}}
        ids = resolve_account_ids(config, section_key="configs")
        assert sorted(ids) == sorted(["a", "b"])


class TestResolveDefaultAccountId:
    def test_explicit_default_account(self):
        config = {
            "accounts": {"first": {}, "second": {}},
            "defaultAccount": "second",
        }
        result = resolve_default_account_id(config)
        assert result == "second"

    def test_explicit_default_account_alt_key(self):
        config = {
            "accounts": {"first": {}},
            "default_account": "first",
        }
        result = resolve_default_account_id(config)
        assert result == "first"

    def test_default_in_accounts(self):
        config = {"accounts": {"default": {}, "other": {}}}
        result = resolve_default_account_id(config)
        assert result == "default"

    def test_fallback_to_first_account(self):
        config = {"accounts": {"first": {}, "second": {}}}
        result = resolve_default_account_id(config)
        assert result == "first"

    def test_no_accounts_returns_default_literal(self):
        config = {}
        result = resolve_default_account_id(config)
        assert result == "default"


class TestResolveEffectiveDmScope:
    def test_default_value(self):
        config = {}
        result = resolve_effective_dm_scope(config)
        assert result == "per-account-channel-peer"

    def test_explicit_dm_scope(self):
        config = {"dmScope": "merged"}
        result = resolve_effective_dm_scope(config)
        assert result == "merged"

    def test_alt_key_dm_scope(self):
        config = {"dm_scope": "per-account-channel-peer"}
        result = resolve_effective_dm_scope(config)
        assert result == "per-account-channel-peer"

    def test_priority_of_primary_key(self):
        config = {"dmScope": "merged", "dm_scope": "per-account-channel-peer"}
        result = resolve_effective_dm_scope(config)
        assert result == "merged"