Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Mother-AI-OS_mother /tests /test_editions.py
| """Tests for edition-based feature configuration.""" | |
| import pytest | |
| from mother.config.editions import ( | |
| EDITION_FEATURES, | |
| Edition, | |
| EditionFeatures, | |
| EditionManager, | |
| get_edition, | |
| get_edition_manager, | |
| set_edition, | |
| ) | |
| class TestEdition: | |
| """Tests for Edition enum.""" | |
| def test_editions_exist(self) -> None: | |
| """Test all editions are defined.""" | |
| assert Edition.COMMUNITY == "community" | |
| assert Edition.PROFESSIONAL == "professional" | |
| assert Edition.ENTERPRISE == "enterprise" | |
| def test_edition_from_string(self) -> None: | |
| """Test creating edition from string.""" | |
| assert Edition("community") == Edition.COMMUNITY | |
| assert Edition("professional") == Edition.PROFESSIONAL | |
| assert Edition("enterprise") == Edition.ENTERPRISE | |
| class TestEditionFeatures: | |
| """Tests for EditionFeatures dataclass.""" | |
| def test_default_features(self) -> None: | |
| """Test default feature values.""" | |
| features = EditionFeatures() | |
| assert features.core_plugin_system is True | |
| assert features.multi_llm_support is True | |
| assert features.safe_mode is True | |
| assert features.schema_validation is True | |
| assert features.policy_engine == "basic" | |
| assert features.audit_retention_days == 7 | |
| def test_custom_features(self) -> None: | |
| """Test custom feature values.""" | |
| features = EditionFeatures( | |
| policy_engine="advanced", | |
| audit_retention_days=30, | |
| ldap_sso_integration=True, | |
| ) | |
| assert features.policy_engine == "advanced" | |
| assert features.audit_retention_days == 30 | |
| assert features.ldap_sso_integration is True | |
| class TestEditionFeaturesMapping: | |
| """Tests for EDITION_FEATURES mapping.""" | |
| def test_community_features(self) -> None: | |
| """Test Community edition features.""" | |
| features = EDITION_FEATURES[Edition.COMMUNITY] | |
| assert features.policy_engine == "basic" | |
| assert features.custom_policy_rules is False | |
| assert features.audit_retention_days == 7 | |
| assert features.pii_redaction == "basic" | |
| assert features.sandbox_isolation == "basic" | |
| assert features.ldap_sso_integration is False | |
| assert features.dedicated_support is False | |
| assert features.sla_percentage is None | |
| def test_professional_features(self) -> None: | |
| """Test Professional edition features.""" | |
| features = EDITION_FEATURES[Edition.PROFESSIONAL] | |
| assert features.policy_engine == "advanced" | |
| assert features.custom_policy_rules is True | |
| assert features.audit_retention_days == 30 | |
| assert features.pii_redaction == "extended" | |
| assert features.sandbox_isolation == "advanced" | |
| assert features.ldap_sso_integration is True | |
| assert features.dedicated_support is False | |
| assert features.sla_percentage == 99.5 | |
| def test_enterprise_features(self) -> None: | |
| """Test Enterprise edition features.""" | |
| features = EDITION_FEATURES[Edition.ENTERPRISE] | |
| assert features.policy_engine == "advanced" | |
| assert features.custom_policy_rules is True | |
| assert features.audit_retention_days == -1 # Unlimited | |
| assert features.pii_redaction == "custom" | |
| assert features.sandbox_isolation == "advanced" | |
| assert features.ldap_sso_integration is True | |
| assert features.dedicated_support is True | |
| assert features.sla_percentage == 99.9 | |
| class TestEditionManager: | |
| """Tests for EditionManager class.""" | |
| def test_default_edition(self) -> None: | |
| """Test default edition is Community.""" | |
| manager = EditionManager() | |
| assert manager.edition == Edition.COMMUNITY | |
| def test_specific_edition(self) -> None: | |
| """Test creating manager with specific edition.""" | |
| manager = EditionManager(Edition.ENTERPRISE) | |
| assert manager.edition == Edition.ENTERPRISE | |
| def test_features_property(self) -> None: | |
| """Test features property returns correct features.""" | |
| manager = EditionManager(Edition.PROFESSIONAL) | |
| assert manager.features.policy_engine == "advanced" | |
| assert manager.features.audit_retention_days == 30 | |
| def test_is_feature_available_bool(self) -> None: | |
| """Test checking boolean features.""" | |
| community = EditionManager(Edition.COMMUNITY) | |
| enterprise = EditionManager(Edition.ENTERPRISE) | |
| assert community.is_feature_available("core_plugin_system") is True | |
| assert community.is_feature_available("ldap_sso_integration") is False | |
| assert enterprise.is_feature_available("ldap_sso_integration") is True | |
| def test_is_feature_available_nonexistent(self) -> None: | |
| """Test checking non-existent features.""" | |
| manager = EditionManager() | |
| assert manager.is_feature_available("nonexistent_feature") is False | |
| def test_get_audit_retention_days(self) -> None: | |
| """Test getting audit retention days.""" | |
| community = EditionManager(Edition.COMMUNITY) | |
| professional = EditionManager(Edition.PROFESSIONAL) | |
| enterprise = EditionManager(Edition.ENTERPRISE) | |
| assert community.get_audit_retention_days() == 7 | |
| assert professional.get_audit_retention_days() == 30 | |
| assert enterprise.get_audit_retention_days() == -1 | |
| def test_get_pii_redaction_level(self) -> None: | |
| """Test getting PII redaction level.""" | |
| community = EditionManager(Edition.COMMUNITY) | |
| professional = EditionManager(Edition.PROFESSIONAL) | |
| enterprise = EditionManager(Edition.ENTERPRISE) | |
| assert community.get_pii_redaction_level() == "basic" | |
| assert professional.get_pii_redaction_level() == "extended" | |
| assert enterprise.get_pii_redaction_level() == "custom" | |
| def test_has_advanced_policy_engine(self) -> None: | |
| """Test checking for advanced policy engine.""" | |
| community = EditionManager(Edition.COMMUNITY) | |
| professional = EditionManager(Edition.PROFESSIONAL) | |
| assert community.has_advanced_policy_engine() is False | |
| assert professional.has_advanced_policy_engine() is True | |
| def test_has_ldap_sso(self) -> None: | |
| """Test checking for LDAP/SSO.""" | |
| community = EditionManager(Edition.COMMUNITY) | |
| professional = EditionManager(Edition.PROFESSIONAL) | |
| assert community.has_ldap_sso() is False | |
| assert professional.has_ldap_sso() is True | |
| def test_has_custom_policy_rules(self) -> None: | |
| """Test checking for custom policy rules.""" | |
| community = EditionManager(Edition.COMMUNITY) | |
| enterprise = EditionManager(Edition.ENTERPRISE) | |
| assert community.has_custom_policy_rules() is False | |
| assert enterprise.has_custom_policy_rules() is True | |
| def test_has_advanced_sandbox(self) -> None: | |
| """Test checking for advanced sandbox.""" | |
| community = EditionManager(Edition.COMMUNITY) | |
| enterprise = EditionManager(Edition.ENTERPRISE) | |
| assert community.has_advanced_sandbox() is False | |
| assert enterprise.has_advanced_sandbox() is True | |
| def test_set_custom_pii_patterns_enterprise(self) -> None: | |
| """Test setting custom PII patterns in Enterprise edition.""" | |
| manager = EditionManager(Edition.ENTERPRISE) | |
| patterns = [r"\bCUSTOM-\d{8}\b", r"\bINTERNAL-[A-Z]{4}\b"] | |
| manager.set_custom_pii_patterns(patterns) | |
| assert manager.get_custom_pii_patterns() == patterns | |
| def test_set_custom_pii_patterns_non_enterprise(self) -> None: | |
| """Test setting custom PII patterns fails in non-Enterprise editions.""" | |
| manager = EditionManager(Edition.COMMUNITY) | |
| with pytest.raises(PermissionError): | |
| manager.set_custom_pii_patterns([r"\bCUSTOM-\d+\b"]) | |
| def test_to_dict(self) -> None: | |
| """Test converting to dictionary.""" | |
| manager = EditionManager(Edition.PROFESSIONAL) | |
| result = manager.to_dict() | |
| assert result["edition"] == "professional" | |
| assert result["features"]["policy_engine"] == "advanced" | |
| assert result["features"]["audit_retention_days"] == 30 | |
| assert result["features"]["sla_percentage"] == 99.5 | |
| class TestGlobalEditionFunctions: | |
| """Tests for global edition functions.""" | |
| def test_get_edition_manager(self) -> None: | |
| """Test getting global edition manager.""" | |
| manager = get_edition_manager() | |
| assert isinstance(manager, EditionManager) | |
| def test_set_edition_with_enum(self) -> None: | |
| """Test setting edition with enum.""" | |
| set_edition(Edition.ENTERPRISE) | |
| assert get_edition() == Edition.ENTERPRISE | |
| # Reset to default | |
| set_edition(Edition.COMMUNITY) | |
| def test_set_edition_with_string(self) -> None: | |
| """Test setting edition with string.""" | |
| set_edition("professional") | |
| assert get_edition() == Edition.PROFESSIONAL | |
| # Reset to default | |
| set_edition(Edition.COMMUNITY) | |
| def test_get_edition(self) -> None: | |
| """Test getting current edition.""" | |
| set_edition(Edition.COMMUNITY) | |
| assert get_edition() == Edition.COMMUNITY | |
| class TestEditionUpgradeScenarios: | |
| """Tests for edition upgrade scenarios.""" | |
| def test_community_to_professional_upgrade(self) -> None: | |
| """Test features gained when upgrading from Community to Professional.""" | |
| community = EditionManager(Edition.COMMUNITY) | |
| professional = EditionManager(Edition.PROFESSIONAL) | |
| # Features gained | |
| assert not community.has_advanced_policy_engine() | |
| assert professional.has_advanced_policy_engine() | |
| assert not community.has_custom_policy_rules() | |
| assert professional.has_custom_policy_rules() | |
| assert community.get_audit_retention_days() == 7 | |
| assert professional.get_audit_retention_days() == 30 | |
| assert not community.has_ldap_sso() | |
| assert professional.has_ldap_sso() | |
| def test_professional_to_enterprise_upgrade(self) -> None: | |
| """Test features gained when upgrading from Professional to Enterprise.""" | |
| professional = EditionManager(Edition.PROFESSIONAL) | |
| enterprise = EditionManager(Edition.ENTERPRISE) | |
| # Both have these | |
| assert professional.has_advanced_policy_engine() | |
| assert enterprise.has_advanced_policy_engine() | |
| # Enterprise-only features | |
| assert professional.get_audit_retention_days() == 30 | |
| assert enterprise.get_audit_retention_days() == -1 # Unlimited | |
| assert professional.get_pii_redaction_level() == "extended" | |
| assert enterprise.get_pii_redaction_level() == "custom" | |
| assert not professional.is_feature_available("dedicated_support") | |
| assert enterprise.is_feature_available("dedicated_support") | |
Xet Storage Details
- Size:
- 10.8 kB
- Xet hash:
- 3642c6fec628a78b0fba34bf12aa9d87e2d9b702f07aa72518f4269109e0b6d6
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.