From 2c36522dfb3bbc54ea8dff3d5e33670bdd81583a Mon Sep 17 00:00:00 2001 From: CI Bot Date: Sun, 26 Jul 2026 17:37:21 +0800 Subject: [PATCH] test(wave97): 53 unit tests for quota domain system - QuotaDimension enum: 3 tests - QuotaTier: 6 tests (get_limit / is_unlimited) - QUOTA_TIERS: 4 tests (free/basic/premium + monotonic) - QuotaWarningLevel: 1 test - QuotaCheckResult.usage_percent: 6 tests - QuotaRegistry: 9 tests (init / register / idempotent / tiers) - QuotaChecker: 18 tests (check / multiple / warning levels / edge cases) - get_warning_level + global singletons: 6 tests Total: 53 unit tests for quota.py (270 lines) --- tests/unit/test_quota_domain.py | 508 ++++++++++++++------------------ 1 file changed, 223 insertions(+), 285 deletions(-) diff --git a/tests/unit/test_quota_domain.py b/tests/unit/test_quota_domain.py index c00023f17..3d11e1ec7 100755 --- a/tests/unit/test_quota_domain.py +++ b/tests/unit/test_quota_domain.py @@ -1,13 +1,11 @@ -"""Quota 领域层单元测试 - quota.py""" - -import math +"""Quota 配额系统单元测试。""" import pytest from packages.domain.quota import ( QUOTA_TIERS, - QuotaChecker, QuotaCheckResult, + QuotaChecker, QuotaDimension, QuotaRegistry, QuotaTier, @@ -19,103 +17,114 @@ from packages.domain.quota import ( class TestQuotaDimension: - """QuotaDimension 枚举测试""" + def test_core_dimensions_exist(self): + assert QuotaDimension.STORAGE_GB.value == "storage_gb" + assert QuotaDimension.VIDEOS_PER_MONTH.value == "videos_per_month" + assert QuotaDimension.MAX_CONCURRENT.value == "max_concurrent" + assert QuotaDimension.MAX_TEMPLATES.value == "max_templates" + assert QuotaDimension.MAX_TITLES.value == "max_titles" + assert QuotaDimension.MAX_VOICEOVERS.value == "max_voiceovers" + assert QuotaDimension.AI_VOICE_ENABLED.value == "ai_voice_enabled" - def test_all_dimensions_have_values(self): - """所有枚举成员都有字符串值""" + def test_extended_dimensions_exist(self): + assert QuotaDimension.AI_VOICE_CREDITS.value == "ai_voice_credits" + assert QuotaDimension.BATCH_EXPORT_ENABLED.value == "batch_export_enabled" + assert QuotaDimension.MULTI_PLATFORM_ENABLED.value == "multi_platform_enabled" + assert QuotaDimension.DEDUP_REPORT_ENABLED.value == "dedup_report_enabled" + + def test_all_dimensions_are_strings(self): for dim in QuotaDimension: assert isinstance(dim.value, str) - assert dim.value - - def test_dimension_count(self): - """配额维度数量 >= 内置维度""" - # 至少有 storage_gb, videos_per_month, max_concurrent, max_templates 等 - assert len(QuotaDimension) >= 7 - - def test_str_enum_behavior(self): - """是 str 枚举，可直接当字符串用""" - assert QuotaDimension.STORAGE_GB == "storage_gb" - assert isinstance(QuotaDimension.STORAGE_GB, str) class TestQuotaTier: - """QuotaTier 测试""" - def test_get_limit_defined(self): - """已定义的维度返回正确值""" - tier = QuotaTier(name="test", limits={"storage": 10, "videos": 5}) - assert tier.get_limit("storage") == 10 + tier = QuotaTier(name="test", limits={"storage_gb": 10, "videos": 5}) + assert tier.get_limit("storage_gb") == 10 assert tier.get_limit("videos") == 5 def test_get_limit_undefined_returns_zero(self): - """未定义的维度返回 0""" - tier = QuotaTier(name="test", limits={"storage": 10}) - assert tier.get_limit("unknown") == 0 + tier = QuotaTier(name="test", limits={"storage_gb": 10}) + assert tier.get_limit("unknown_dim") == 0 - def test_is_unlimited_true(self): - """不限量判断 - inf""" + def test_is_unlimited_false_for_finite(self): + tier = QuotaTier(name="test", limits={"storage_gb": 10}) + assert tier.is_unlimited("storage_gb") is False + + def test_is_unlimited_true_for_inf(self): tier = QuotaTier(name="test", limits={"templates": float("inf")}) assert tier.is_unlimited("templates") is True - def test_is_unlimited_false(self): - """限量判断""" - tier = QuotaTier(name="test", limits={"storage": 10}) - assert tier.is_unlimited("storage") is False - - def test_is_unlimited_undefined_returns_true(self): - """未定义的维度默认 inf，is_unlimited 返回 True""" + def test_is_unlimited_undefined(self): tier = QuotaTier(name="test", limits={}) - # get_limit 用 dict.get 默认 0，但 is_unlimited 用 dict.get 默认 inf + # 未定义的维度，limits.get 返回默认 inf，所以 is_unlimited 返回 True assert tier.is_unlimited("unknown") is True + def test_empty_limits(self): + tier = QuotaTier(name="empty") + assert tier.limits == {} + assert tier.name == "empty" + class TestQuotaTiers: - """内置套餐配额测试""" - def test_three_tiers_exist(self): - """三个套餐等级都存在""" assert "free" in QUOTA_TIERS assert "basic" in QUOTA_TIERS assert "premium" in QUOTA_TIERS - def test_free_tier_storage(self): - """free 套餐 2GB 存储""" - assert QUOTA_TIERS["free"].get_limit(QuotaDimension.STORAGE_GB) == 2 + def test_free_tier_limits(self): + free = QUOTA_TIERS["free"] + assert free.get_limit("storage_gb") == 2 + assert free.get_limit("videos_per_month") == 5 + assert free.get_limit("max_concurrent") == 3 + assert free.get_limit("max_templates") == 3 + assert free.get_limit("max_titles") == 50 + assert free.get_limit("max_voiceovers") == 10 + assert free.get_limit("ai_voice_enabled") == 0 - def test_basic_tier_storage(self): - """basic 套餐 20GB 存储""" - assert QUOTA_TIERS["basic"].get_limit(QuotaDimension.STORAGE_GB) == 20 + def test_basic_tier_limits(self): + basic = QUOTA_TIERS["basic"] + assert basic.get_limit("storage_gb") == 20 + assert basic.get_limit("videos_per_month") == 30 + assert basic.get_limit("max_concurrent") == 10 + assert basic.get_limit("max_templates") == 15 + assert basic.get_limit("max_titles") == 500 + assert basic.get_limit("max_voiceovers") == 100 + assert basic.get_limit("ai_voice_enabled") == 1 + assert basic.get_limit("ai_voice_credits") == 100 + assert basic.get_limit("batch_export_enabled") == 1 - def test_premium_tier_storage(self): - """premium 套餐 100GB 存储""" - assert QUOTA_TIERS["premium"].get_limit(QuotaDimension.STORAGE_GB) == 100 + def test_premium_tier_limits(self): + premium = QUOTA_TIERS["premium"] + assert premium.get_limit("storage_gb") == 100 + assert premium.get_limit("videos_per_month") == 100 + assert premium.get_limit("max_concurrent") == 20 + assert premium.is_unlimited("max_templates") is True + assert premium.get_limit("ai_voice_enabled") == 1 + assert premium.get_limit("ai_voice_credits") == 500 + assert premium.get_limit("batch_export_enabled") == 1 + assert premium.get_limit("multi_platform_enabled") == 1 + assert premium.get_limit("dedup_report_enabled") == 1 - def test_free_no_ai_voice(self): - """free 套餐没有 AI 配音""" - assert QUOTA_TIERS["free"].get_limit(QuotaDimension.AI_VOICE_ENABLED) == 0 - - def test_basic_has_ai_voice(self): - """basic 套餐有 AI 配音""" - assert QUOTA_TIERS["basic"].get_limit(QuotaDimension.AI_VOICE_ENABLED) == 1 - - def test_premium_templates_unlimited(self): - """premium 套餐模板不限量""" - assert QUOTA_TIERS["premium"].is_unlimited(QuotaDimension.MAX_TEMPLATES) is True - - def test_free_videos_per_month(self): - """free 每月 5 个视频""" - assert QUOTA_TIERS["free"].get_limit(QuotaDimension.VIDEOS_PER_MONTH) == 5 - - def test_premium_multi_platform_enabled(self): - """premium 支持多平台发布""" - assert QUOTA_TIERS["premium"].get_limit(QuotaDimension.MULTI_PLATFORM_ENABLED) == 1 + def test_tier_increase_monotonic(self): + free = QUOTA_TIERS["free"] + basic = QUOTA_TIERS["basic"] + premium = QUOTA_TIERS["premium"] + # 高级套餐应该 >= 低级套餐的所有限制 + for dim in [ + "storage_gb", + "videos_per_month", + "max_concurrent", + "max_titles", + "max_voiceovers", + "ai_voice_credits", + ]: + assert basic.get_limit(dim) >= free.get_limit(dim) + assert premium.get_limit(dim) >= basic.get_limit(dim) class TestQuotaWarningLevel: - """告警级别常量测试""" - - def test_level_values(self): - """四个告警级别都有定义""" + def test_levels_exist(self): assert QuotaWarningLevel.NORMAL == "normal" assert QuotaWarningLevel.WARNING == "warning" assert QuotaWarningLevel.CRITICAL == "critical" @@ -123,302 +132,231 @@ class TestQuotaWarningLevel: class TestQuotaCheckResult: - """QuotaCheckResult 测试""" - def test_usage_percent_normal(self): - """正常使用百分比计算""" result = QuotaCheckResult( allowed=True, - dimension="storage", + dimension="storage_gb", limit=100, - used=30, - remaining=70, - warning_level=QuotaWarningLevel.NORMAL, + used=50, + remaining=50, + warning_level="normal", ) - assert result.usage_percent == 30.0 + assert result.usage_percent == 50.0 - def test_usage_percent_capped_at_100(self): - """超过 100% 时截断为 100%""" + def test_usage_percent_exceeded(self): result = QuotaCheckResult( - allowed=False, - dimension="storage", - limit=100, - used=150, - remaining=0, - warning_level=QuotaWarningLevel.EXCEEDED, + allowed=False, dimension="d", limit=100, used=150, remaining=0, warning_level="exceeded" ) - assert result.usage_percent == 100.0 + assert result.usage_percent == 100.0 # min(100, 150%) + + def test_usage_percent_zero_used(self): + result = QuotaCheckResult(allowed=True, dimension="d", limit=100, used=0, remaining=100, warning_level="normal") + assert result.usage_percent == 0.0 def test_usage_percent_zero_limit_with_usage(self): - """limit=0 但有使用量，返回 100%""" - result = QuotaCheckResult( - allowed=False, - dimension="storage", - limit=0, - used=5, - remaining=0, - warning_level=QuotaWarningLevel.EXCEEDED, - ) + result = QuotaCheckResult(allowed=False, dimension="d", limit=0, used=10, remaining=0, warning_level="exceeded") assert result.usage_percent == 100.0 def test_usage_percent_zero_limit_no_usage(self): - """limit=0 且无使用量，返回 0%""" - result = QuotaCheckResult( - allowed=True, - dimension="storage", - limit=0, - used=0, - remaining=0, - warning_level=QuotaWarningLevel.NORMAL, - ) + result = QuotaCheckResult(allowed=True, dimension="d", limit=0, used=0, remaining=0, warning_level="normal") assert result.usage_percent == 0.0 def test_usage_percent_unlimited(self): - """不限量时使用百分比为 0""" result = QuotaCheckResult( allowed=True, - dimension="templates", + dimension="d", limit=float("inf"), - used=50, + used=1000, remaining=float("inf"), - warning_level=QuotaWarningLevel.NORMAL, + warning_level="normal", ) assert result.usage_percent == 0.0 class TestQuotaRegistry: - """QuotaRegistry 测试""" - def test_initial_dimensions(self): - """初始化时内置维度已注册""" - registry = QuotaRegistry() - dims = registry.list_dimensions() - assert QuotaDimension.STORAGE_GB in dims - assert QuotaDimension.VIDEOS_PER_MONTH in dims + reg = QuotaRegistry() + dims = reg.list_dimensions() + assert "storage_gb" in dims + assert "videos_per_month" in dims + assert len(dims) == len(QuotaDimension) - def test_initial_tiers(self): - """初始化时三个套餐已注册""" - registry = QuotaRegistry() - tiers = registry.list_tiers() + def test_list_tiers(self): + reg = QuotaRegistry() + tiers = reg.list_tiers() assert "free" in tiers assert "basic" in tiers assert "premium" in tiers - - def test_register_new_dimension(self): - """注册新的配额维度""" - registry = QuotaRegistry() - registry.register_dimension("custom_dim", "自定义维度") - dims = registry.list_dimensions() - assert "custom_dim" in dims - assert dims["custom_dim"] == "自定义维度" - - def test_register_dimension_idempotent(self): - """重复注册是幂等的""" - registry = QuotaRegistry() - registry.register_dimension("custom", "描述1") - registry.register_dimension("custom", "描述2") - # 保留第一次注册的描述 - assert registry.list_dimensions()["custom"] == "描述1" - - def test_register_with_default_limits(self): - """注册时指定各套餐的默认限制""" - registry = QuotaRegistry() - registry.register_dimension( - "custom", - "自定义", - default_limits={"free": 1, "basic": 10, "premium": 100}, - ) - assert registry.get_limit("free", "custom") == 1 - assert registry.get_limit("basic", "custom") == 10 - assert registry.get_limit("premium", "custom") == 100 - - def test_register_without_default_limits_defaults_to_zero(self): - """不指定默认限制时各套餐该维度为 0""" - registry = QuotaRegistry() - registry.register_dimension("custom_no_limit", "自定义") - assert registry.get_limit("free", "custom_no_limit") == 0 - assert registry.get_limit("basic", "custom_no_limit") == 0 - - def test_register_default_limits_ignores_unknown_plan(self): - """默认限制中未知的套餐名被忽略""" - registry = QuotaRegistry() - registry.register_dimension( - "custom", - "自定义", - default_limits={"nonexistent": 999}, - ) - # 不报错，但也不会创建新套餐 - assert registry.get_tier("nonexistent") is None + assert len(tiers) == 3 def test_get_tier_existing(self): - """获取存在的套餐""" - registry = QuotaRegistry() - tier = registry.get_tier("free") + reg = QuotaRegistry() + tier = reg.get_tier("free") assert tier is not None assert tier.name == "free" - def test_get_tier_nonexistent(self): - """获取不存在的套餐返回 None""" - registry = QuotaRegistry() - assert registry.get_tier("enterprise") is None + def test_get_tier_unknown(self): + reg = QuotaRegistry() + assert reg.get_tier("unknown_plan") is None - def test_get_limit_existing(self): - """获取存在的套餐和维度的限制""" - registry = QuotaRegistry() - assert registry.get_limit("free", QuotaDimension.STORAGE_GB) == 2 + def test_get_limit_known(self): + reg = QuotaRegistry() + assert reg.get_limit("free", "storage_gb") == 2 + assert reg.get_limit("premium", "storage_gb") == 100 - def test_get_limit_nonexistent_plan(self): - """不存在的套餐返回 0""" - registry = QuotaRegistry() - assert registry.get_limit("unknown", QuotaDimension.STORAGE_GB) == 0 + def test_get_limit_unknown_plan(self): + reg = QuotaRegistry() + assert reg.get_limit("unknown", "storage_gb") == 0 - def test_list_dimensions_returns_copy(self): - """list_dimensions 返回副本，修改不影响内部""" - registry = QuotaRegistry() - dims = registry.list_dimensions() - dims["fake"] = "fake" - assert "fake" not in registry.list_dimensions() + def test_register_new_dimension(self): + reg = QuotaRegistry() + reg.register_dimension("new_feature", "新功能", default_limits={"free": 0, "basic": 1, "premium": 5}) + dims = reg.list_dimensions() + assert "new_feature" in dims + assert dims["new_feature"] == "新功能" + assert reg.get_limit("free", "new_feature") == 0 + assert reg.get_limit("basic", "new_feature") == 1 + assert reg.get_limit("premium", "new_feature") == 5 - def test_list_tiers_returns_all_three(self): - """列出所有套餐""" - registry = QuotaRegistry() - tiers = registry.list_tiers() - assert len(tiers) == 3 - assert set(tiers) == {"free", "basic", "premium"} + def test_register_dimension_idempotent(self): + reg = QuotaRegistry() + reg.register_dimension("storage_gb", "should not change", default_limits={"free": 999}) + # 已经存在的不覆盖 + assert reg.get_limit("free", "storage_gb") == 2 + + def test_register_without_defaults(self): + reg = QuotaRegistry() + reg.register_dimension("new_dim", "描述") + assert reg.get_limit("free", "new_dim") == 0 + assert reg.get_limit("basic", "new_dim") == 0 + assert reg.get_limit("premium", "new_dim") == 0 + + def test_register_partial_limits(self): + reg = QuotaRegistry() + reg.register_dimension("partial", "partial", default_limits={"premium": 42}) + assert reg.get_limit("free", "partial") == 0 # 未设置的保持 0 + assert reg.get_limit("premium", "partial") == 42 class TestQuotaChecker: - """QuotaChecker 测试""" - - def test_check_under_limit_allowed(self): - """使用量低于限制，允许""" + def test_check_within_limit(self): checker = QuotaChecker() - result = checker.check("free", QuotaDimension.STORAGE_GB, 1.0) + result = checker.check("free", "storage_gb", 1) assert result.allowed is True - assert result.remaining == 1.0 - assert result.warning_level == QuotaWarningLevel.NORMAL + assert result.limit == 2 + assert result.used == 1 + assert result.remaining == 1 + assert result.dimension == "storage_gb" - def test_check_at_limit_not_allowed(self): - """使用量等于限制，不允许（used < limit 判定）""" + def test_check_exceeded(self): checker = QuotaChecker() - result = checker.check("free", QuotaDimension.STORAGE_GB, 2.0) + result = checker.check("free", "storage_gb", 3) assert result.allowed is False assert result.remaining == 0 - assert result.warning_level == QuotaWarningLevel.EXCEEDED + assert result.warning_level == "exceeded" - def test_check_over_limit(self): - """使用量超过限制""" + def test_check_exact_limit_not_allowed(self): + # used < limit 才 allowed，等于不算 checker = QuotaChecker() - result = checker.check("free", QuotaDimension.STORAGE_GB, 3.0) + result = checker.check("free", "storage_gb", 2) assert result.allowed is False assert result.remaining == 0 - assert result.warning_level == QuotaWarningLevel.EXCEEDED - def test_check_warning_level_80_percent(self): - """80% 触发 WARNING""" + def test_check_unlimited(self): checker = QuotaChecker() - # 100GB 的 80% = 80GB - result = checker.check("premium", QuotaDimension.STORAGE_GB, 80.0) - assert result.warning_level == QuotaWarningLevel.WARNING + result = checker.check("premium", "max_templates", 999999) + assert result.allowed is True + assert result.remaining == float("inf") + assert result.warning_level == "normal" - def test_check_warning_level_95_percent(self): - """95% 触发 CRITICAL""" + def test_check_warning_level_normal(self): checker = QuotaChecker() - result = checker.check("premium", QuotaDimension.STORAGE_GB, 95.0) - assert result.warning_level == QuotaWarningLevel.CRITICAL + result = checker.check("free", "storage_gb", 1) # 50% + assert result.warning_level == "normal" + + def test_check_warning_level_warning(self): + checker = QuotaChecker() + # 80% <= used < 95% + result = checker.check("free", "max_templates", 2.5) # 2.5/3 = 83% + assert result.warning_level == "warning" + + def test_check_warning_level_critical(self): + checker = QuotaChecker() + # 95% <= used < 100% + result = checker.check("free", "max_templates", 2.9) # 2.9/3 = 97% + assert result.warning_level == "critical" def test_check_warning_level_exceeded(self): - """100% 及以上触发 EXCEEDED""" checker = QuotaChecker() - result = checker.check("premium", QuotaDimension.STORAGE_GB, 100.0) - assert result.warning_level == QuotaWarningLevel.EXCEEDED - - def test_check_unlimited_always_allowed(self): - """不限量的维度始终允许""" - checker = QuotaChecker() - result = checker.check("premium", QuotaDimension.MAX_TEMPLATES, 9999) - assert result.allowed is True - assert math.isinf(result.remaining) - assert result.warning_level == QuotaWarningLevel.NORMAL - - def test_check_unknown_plan_zero_limit(self): - """未知套餐限制为 0，used=0 时不允许（0 < 0 为 False）""" - checker = QuotaChecker() - result = checker.check("unknown", QuotaDimension.STORAGE_GB, 0) - assert result.limit == 0 - assert result.allowed is False + result = checker.check("free", "storage_gb", 5) # 250% + assert result.warning_level == "exceeded" def test_check_multiple(self): - """批量检查多个维度""" checker = QuotaChecker() results = checker.check_multiple( "free", - { - QuotaDimension.STORAGE_GB: 1.0, - QuotaDimension.VIDEOS_PER_MONTH: 3, - }, + {"storage_gb": 1, "max_templates": 2, "max_titles": 10}, ) - assert len(results) == 2 + assert len(results) == 3 + assert results[0].dimension == "storage_gb" + assert results[1].dimension == "max_templates" + assert results[2].dimension == "max_titles" assert all(r.allowed for r in results) - dims = {r.dimension for r in results} - assert QuotaDimension.STORAGE_GB in dims - assert QuotaDimension.VIDEOS_PER_MONTH in dims - def test_check_with_custom_registry(self): - """使用自定义注册表""" - registry = QuotaRegistry() - registry.register_dimension("custom", "自定义", default_limits={"free": 5}) - checker = QuotaChecker(registry) - result = checker.check("free", "custom", 3) - assert result.allowed is True - assert result.limit == 5 + def test_check_zero_limit(self): + checker = QuotaChecker() + result = checker.check("free", "ai_voice_enabled", 0) + # limit=0, used=0: used < limit 为 False → allowed=False + assert result.allowed is False + assert result.remaining == 0 + assert result.warning_level == "normal" - def test_compute_warning_level_zero_limit_no_usage(self): - """limit=0, used=0 → NORMAL""" - level = QuotaChecker._compute_warning_level(0, 0) - assert level == QuotaWarningLevel.NORMAL + def test_compute_warning_level_normal(self): + assert QuotaChecker._compute_warning_level(50, 100) == "normal" + assert QuotaChecker._compute_warning_level(79, 100) == "normal" + + def test_compute_warning_level_warning_boundary(self): + assert QuotaChecker._compute_warning_level(80, 100) == "warning" + assert QuotaChecker._compute_warning_level(94, 100) == "warning" + + def test_compute_warning_level_critical_boundary(self): + assert QuotaChecker._compute_warning_level(95, 100) == "critical" + assert QuotaChecker._compute_warning_level(99, 100) == "critical" + + def test_compute_warning_level_exceeded(self): + assert QuotaChecker._compute_warning_level(100, 100) == "exceeded" + assert QuotaChecker._compute_warning_level(150, 100) == "exceeded" + + def test_compute_warning_level_unlimited(self): + assert QuotaChecker._compute_warning_level(9999, float("inf")) == "normal" def test_compute_warning_level_zero_limit_with_usage(self): - """limit=0, used>0 → EXCEEDED""" - level = QuotaChecker._compute_warning_level(1, 0) - assert level == QuotaWarningLevel.EXCEEDED + assert QuotaChecker._compute_warning_level(1, 0) == "exceeded" + + def test_compute_warning_level_zero_limit_no_usage(self): + assert QuotaChecker._compute_warning_level(0, 0) == "normal" def test_compute_warning_level_negative_limit(self): - """limit<0 视同 0 处理""" - level = QuotaChecker._compute_warning_level(1, -1) - assert level == QuotaWarningLevel.EXCEEDED + # limit <= 0 且 used=0 → NORMAL + assert QuotaChecker._compute_warning_level(0, -1) == "normal" class TestGetWarningLevel: - """get_warning_level 便捷函数测试""" - - def test_normal(self): - assert get_warning_level(50, 100) == QuotaWarningLevel.NORMAL - - def test_warning(self): - assert get_warning_level(85, 100) == QuotaWarningLevel.WARNING - - def test_critical(self): - assert get_warning_level(97, 100) == QuotaWarningLevel.CRITICAL - - def test_exceeded(self): - assert get_warning_level(100, 100) == QuotaWarningLevel.EXCEEDED - - def test_unlimited(self): - assert get_warning_level(9999, float("inf")) == QuotaWarningLevel.NORMAL + def test_convenience_function(self): + assert get_warning_level(50, 100) == "normal" + assert get_warning_level(99, 100) == "critical" + assert get_warning_level(100, 100) == "exceeded" + assert get_warning_level(0, 0) == "normal" + assert get_warning_level(1, 0) == "exceeded" class TestGlobalSingletons: - """全局单例测试""" - def test_quota_registry_is_instance(self): assert isinstance(quota_registry, QuotaRegistry) def test_quota_checker_is_instance(self): assert isinstance(quota_checker, QuotaChecker) - def test_global_checker_uses_global_registry(self): - """全局 checker 使用全局 registry""" - # 验证能正常工作 - result = quota_checker.check("free", QuotaDimension.STORAGE_GB, 1.0) + def test_global_checker_works(self): + result = quota_checker.check("free", "storage_gb", 1) assert result.allowed is True