608 lines
22 KiB
Python
608 lines
22 KiB
Python
"""Step definitions for OrgUserConfig coverage tests."""
|
|
|
|
import json
|
|
from datetime import UTC, datetime
|
|
|
|
from behave import then, when
|
|
from pydantic import ValidationError
|
|
|
|
|
|
@when("I import OrgUserConfig from orguserconfig")
|
|
def step_import_org_user_config(context):
|
|
"""Import OrgUserConfig class."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.org_user_config_class = OrgUserConfig
|
|
|
|
|
|
@then("the OrgUserConfig class should be available")
|
|
def step_verify_org_user_config_available(context):
|
|
"""Verify OrgUserConfig class is available."""
|
|
assert context.org_user_config_class is not None
|
|
assert context.org_user_config_class.__name__ == "OrgUserConfig"
|
|
|
|
|
|
@then("I can create an OrgUserConfig with all required fields")
|
|
def step_create_full_org_user_config(context):
|
|
"""Create an OrgUserConfig with all fields."""
|
|
OrgUserConfig = context.org_user_config_class
|
|
|
|
# Create with all required fields
|
|
config = OrgUserConfig(
|
|
prompted_claude_max=True,
|
|
use_claude_subscription=True,
|
|
claude_subscription_cooldown_started_at=datetime.now(UTC),
|
|
)
|
|
|
|
assert config.prompted_claude_max is True
|
|
assert config.use_claude_subscription is True
|
|
assert isinstance(config.claude_subscription_cooldown_started_at, datetime)
|
|
|
|
|
|
@when("I create an OrgUserConfig with prompted_claude_max set to True")
|
|
def step_create_with_prompted_claude_max(context):
|
|
"""Create OrgUserConfig with prompted_claude_max field."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=True,
|
|
use_claude_subscription=False,
|
|
claude_subscription_cooldown_started_at=datetime.now(),
|
|
)
|
|
|
|
|
|
@then("the OrgUserConfig should have prompted_claude_max as True")
|
|
def step_verify_prompted_claude_max(context):
|
|
"""Verify prompted_claude_max field value."""
|
|
assert context.model_instance.prompted_claude_max is True
|
|
|
|
|
|
@then('the field should be accessible via the alias "promptedClaudeMax"')
|
|
def step_verify_prompted_claude_max_alias(context):
|
|
"""Verify the field can be accessed via its alias."""
|
|
# Serialize to dict with aliases
|
|
data = context.model_instance.model_dump(by_alias=True)
|
|
assert "promptedClaudeMax" in data
|
|
assert data["promptedClaudeMax"] is True
|
|
|
|
|
|
@when("I create an OrgUserConfig with use_claude_subscription set to False")
|
|
def step_create_with_use_claude_subscription(context):
|
|
"""Create OrgUserConfig with use_claude_subscription field."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=False,
|
|
use_claude_subscription=False,
|
|
claude_subscription_cooldown_started_at=datetime.now(),
|
|
)
|
|
|
|
|
|
@then("the OrgUserConfig should have use_claude_subscription as False")
|
|
def step_verify_use_claude_subscription(context):
|
|
"""Verify use_claude_subscription field value."""
|
|
assert context.model_instance.use_claude_subscription is False
|
|
|
|
|
|
@then('the field should be accessible via the alias "useClaudeSubscription"')
|
|
def step_verify_use_claude_subscription_alias(context):
|
|
"""Verify the field can be accessed via its alias."""
|
|
data = context.model_instance.model_dump(by_alias=True)
|
|
assert "useClaudeSubscription" in data
|
|
assert data["useClaudeSubscription"] is False
|
|
|
|
|
|
@when("I create an OrgUserConfig with a specific cooldown timestamp")
|
|
def step_create_with_cooldown_timestamp(context):
|
|
"""Create OrgUserConfig with specific timestamp."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.timestamp = datetime(2024, 1, 15, 10, 30, 0, tzinfo=UTC)
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=True,
|
|
use_claude_subscription=True,
|
|
claude_subscription_cooldown_started_at=context.timestamp,
|
|
)
|
|
|
|
|
|
@then("the OrgUserConfig should have the correct timestamp")
|
|
def step_verify_timestamp(context):
|
|
"""Verify timestamp field value."""
|
|
assert (
|
|
context.model_instance.claude_subscription_cooldown_started_at
|
|
== context.timestamp
|
|
)
|
|
|
|
|
|
@then(
|
|
'the field should be accessible via the alias "claudeSubscriptionCooldownStartedAt"'
|
|
)
|
|
def step_verify_cooldown_alias(context):
|
|
"""Verify the cooldown field can be accessed via its alias."""
|
|
data = context.model_instance.model_dump(by_alias=True)
|
|
assert "claudeSubscriptionCooldownStartedAt" in data
|
|
|
|
|
|
@when("I create an OrgUserConfig with fields containing whitespace")
|
|
def step_create_with_whitespace(context):
|
|
"""Create OrgUserConfig to test whitespace stripping."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
# Note: OrgUserConfig doesn't have string fields, but we test the config is set
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=True,
|
|
use_claude_subscription=False,
|
|
claude_subscription_cooldown_started_at=datetime.now(),
|
|
)
|
|
|
|
|
|
@then("OrgUserConfig string fields should have whitespace stripped")
|
|
def step_verify_orguserconfig_whitespace_stripped(context):
|
|
"""Verify whitespace stripping config is active for OrgUserConfig."""
|
|
# Check that the model_config has str_strip_whitespace enabled
|
|
assert context.model_instance.model_config.get("str_strip_whitespace") is True
|
|
|
|
|
|
@when("I create an OrgUserConfig instance")
|
|
def step_create_instance(context):
|
|
"""Create a basic OrgUserConfig instance."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=False,
|
|
use_claude_subscription=True,
|
|
claude_subscription_cooldown_started_at=datetime.now(),
|
|
)
|
|
|
|
|
|
@when("I update its fields with new values for OrgUserConfig")
|
|
def step_update_orguserconfig_fields(context):
|
|
"""Update fields on the OrgUserConfig instance."""
|
|
# Update fields to trigger validation
|
|
context.model_instance.prompted_claude_max = True
|
|
context.model_instance.use_claude_subscription = False
|
|
context.model_instance.claude_subscription_cooldown_started_at = datetime(
|
|
2024, 12, 1
|
|
)
|
|
|
|
|
|
@then("the OrgUserConfig assignment validation should be triggered")
|
|
def step_verify_orguserconfig_assignment_validation(context):
|
|
"""Verify assignment validation is active for OrgUserConfig."""
|
|
assert context.model_instance.model_config.get("validate_assignment") is True
|
|
|
|
|
|
@then("the OrgUserConfig values should be properly validated")
|
|
def step_verify_orguserconfig_values_validated(context):
|
|
"""Verify the updated values are correct for OrgUserConfig."""
|
|
assert context.model_instance.prompted_claude_max is True
|
|
assert context.model_instance.use_claude_subscription is False
|
|
assert context.model_instance.claude_subscription_cooldown_started_at == datetime(
|
|
2024, 12, 1
|
|
)
|
|
|
|
|
|
@when("I create an OrgUserConfig using camelCase field aliases")
|
|
def step_create_with_camel_case_aliases(context):
|
|
"""Create OrgUserConfig using camelCase aliases."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
# Create using aliases
|
|
context.model_instance = OrgUserConfig(
|
|
**{
|
|
"promptedClaudeMax": True,
|
|
"useClaudeSubscription": False,
|
|
"claudeSubscriptionCooldownStartedAt": datetime.now(),
|
|
}
|
|
)
|
|
|
|
|
|
@then("the OrgUserConfig fields should be populated correctly by name")
|
|
def step_verify_orguserconfig_populate_by_name(context):
|
|
"""Verify OrgUserConfig fields are populated correctly."""
|
|
assert context.model_instance.prompted_claude_max is True
|
|
assert context.model_instance.use_claude_subscription is False
|
|
assert context.model_instance.claude_subscription_cooldown_started_at is not None
|
|
|
|
|
|
@then("both snake_case and camelCase access should work")
|
|
def step_verify_both_access_methods(context):
|
|
"""Verify both naming conventions work."""
|
|
# Snake case access
|
|
assert hasattr(context.model_instance, "prompted_claude_max")
|
|
assert hasattr(context.model_instance, "use_claude_subscription")
|
|
|
|
# CamelCase through serialization
|
|
data = context.model_instance.model_dump(by_alias=True)
|
|
assert "promptedClaudeMax" in data
|
|
assert "useClaudeSubscription" in data
|
|
|
|
|
|
@when("I create an OrgUserConfig from a dictionary with camelCase keys")
|
|
def step_create_from_dict_with_aliases(context):
|
|
"""Create OrgUserConfig from dictionary with aliases."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.input_data = {
|
|
"promptedClaudeMax": False,
|
|
"useClaudeSubscription": True,
|
|
"claudeSubscriptionCooldownStartedAt": "2024-01-15T10:30:00Z",
|
|
}
|
|
|
|
context.model_instance = OrgUserConfig(**context.input_data)
|
|
|
|
|
|
@then("the model should correctly map aliased fields")
|
|
def step_verify_aliased_field_mapping(context):
|
|
"""Verify aliased fields are correctly mapped."""
|
|
assert context.model_instance.prompted_claude_max is False
|
|
assert context.model_instance.use_claude_subscription is True
|
|
|
|
|
|
@then("all fields should be accessible with snake_case names")
|
|
def step_verify_snake_case_access(context):
|
|
"""Verify all fields accessible with snake_case."""
|
|
assert context.model_instance.prompted_claude_max is False
|
|
assert context.model_instance.use_claude_subscription is True
|
|
assert isinstance(
|
|
context.model_instance.claude_subscription_cooldown_started_at, datetime
|
|
)
|
|
|
|
|
|
@when("I create an OrgUserConfig and serialize it")
|
|
def step_create_and_serialize(context):
|
|
"""Create and serialize an OrgUserConfig."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=True,
|
|
use_claude_subscription=False,
|
|
claude_subscription_cooldown_started_at=datetime(2024, 1, 15, 10, 30, 0),
|
|
)
|
|
|
|
context.serialized = context.model_instance.model_dump(by_alias=True)
|
|
|
|
|
|
@then("the serialized output should use the defined aliases")
|
|
def step_verify_serialized_aliases(context):
|
|
"""Verify serialized output uses aliases."""
|
|
assert "promptedClaudeMax" in context.serialized
|
|
assert "useClaudeSubscription" in context.serialized
|
|
assert "claudeSubscriptionCooldownStartedAt" in context.serialized
|
|
assert context.serialized["promptedClaudeMax"] is True
|
|
assert context.serialized["useClaudeSubscription"] is False
|
|
|
|
|
|
@then("the model should be deserializable from the serialized form")
|
|
def step_verify_deserializable(context):
|
|
"""Verify model can be deserialized."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
# Recreate from serialized data
|
|
new_instance = OrgUserConfig(**context.serialized)
|
|
assert new_instance.prompted_claude_max is True
|
|
assert new_instance.use_claude_subscription is False
|
|
|
|
|
|
@when("I try to create an OrgUserConfig with an invalid datetime string")
|
|
def step_create_with_invalid_datetime(context):
|
|
"""Try to create OrgUserConfig with invalid datetime."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
try:
|
|
OrgUserConfig(
|
|
prompted_claude_max=True,
|
|
use_claude_subscription=False,
|
|
claude_subscription_cooldown_started_at="not-a-datetime",
|
|
)
|
|
context.validation_error = None
|
|
except ValidationError as e:
|
|
context.validation_error = e
|
|
|
|
|
|
@then("an OrgUserConfig validation error should be raised")
|
|
def step_verify_orguserconfig_validation_error(context):
|
|
"""Verify a validation error was raised for OrgUserConfig."""
|
|
assert context.validation_error is not None
|
|
assert isinstance(context.validation_error, ValidationError)
|
|
|
|
|
|
@then("the error should indicate the datetime field")
|
|
def step_verify_datetime_error(context):
|
|
"""Verify error mentions datetime field."""
|
|
errors = context.validation_error.errors()
|
|
field_names = [err["loc"][0] for err in errors]
|
|
assert "claude_subscription_cooldown_started_at" in field_names
|
|
|
|
|
|
@when("I try to create an OrgUserConfig without required fields")
|
|
def step_create_without_required_fields(context):
|
|
"""Try to create OrgUserConfig without required fields."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
try:
|
|
OrgUserConfig()
|
|
context.validation_error = None
|
|
except ValidationError as e:
|
|
context.validation_error = e
|
|
|
|
|
|
@then("the error should list all missing required fields")
|
|
def step_verify_missing_fields_error(context):
|
|
"""Verify error lists missing required fields."""
|
|
errors = context.validation_error.errors()
|
|
# Check there are errors for missing fields
|
|
assert len(errors) >= 3 # We have 3 required fields
|
|
|
|
|
|
@when("I inspect the OrgUserConfig model configuration")
|
|
def step_inspect_model_config(context):
|
|
"""Inspect the model configuration."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.model_config = OrgUserConfig.model_config
|
|
|
|
|
|
@then("OrgUserConfig str_strip_whitespace should be True")
|
|
def step_verify_orguserconfig_strip_whitespace_config(context):
|
|
"""Verify OrgUserConfig str_strip_whitespace config."""
|
|
assert context.model_config.get("str_strip_whitespace") is True
|
|
|
|
|
|
@then("OrgUserConfig validate_assignment should be True")
|
|
def step_verify_orguserconfig_validate_assignment_config(context):
|
|
"""Verify OrgUserConfig validate_assignment config."""
|
|
assert context.model_config.get("validate_assignment") is True
|
|
|
|
|
|
@then("OrgUserConfig arbitrary_types_allowed should be False")
|
|
def step_verify_orguserconfig_arbitrary_types_config(context):
|
|
"""Verify OrgUserConfig arbitrary_types_allowed config."""
|
|
assert context.model_config.get("arbitrary_types_allowed") is False
|
|
|
|
|
|
@then("OrgUserConfig populate_by_name should be True")
|
|
def step_verify_orguserconfig_populate_by_name_config(context):
|
|
"""Verify OrgUserConfig populate_by_name config."""
|
|
assert context.model_config.get("populate_by_name") is True
|
|
|
|
|
|
@then("OrgUserConfig use_enum_values should be True")
|
|
def step_verify_orguserconfig_use_enum_values_config(context):
|
|
"""Verify OrgUserConfig use_enum_values config."""
|
|
assert context.model_config.get("use_enum_values") is True
|
|
|
|
|
|
@when("I create an OrgUserConfig with a timezone-aware datetime")
|
|
def step_create_with_timezone_aware_datetime(context):
|
|
"""Create OrgUserConfig with timezone-aware datetime."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.tz_datetime = datetime(2024, 6, 15, 14, 30, 0, tzinfo=UTC)
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=True,
|
|
use_claude_subscription=True,
|
|
claude_subscription_cooldown_started_at=context.tz_datetime,
|
|
)
|
|
|
|
|
|
@then("the model should handle the timezone information correctly")
|
|
def step_verify_timezone_handling(context):
|
|
"""Verify timezone information is preserved."""
|
|
stored_dt = context.model_instance.claude_subscription_cooldown_started_at
|
|
assert stored_dt == context.tz_datetime
|
|
assert stored_dt.tzinfo is not None
|
|
|
|
|
|
@then("the datetime should be properly stored")
|
|
def step_verify_datetime_stored(context):
|
|
"""Verify datetime is properly stored."""
|
|
assert (
|
|
context.model_instance.claude_subscription_cooldown_started_at
|
|
== context.tz_datetime
|
|
)
|
|
|
|
|
|
@when("I create an OrgUserConfig and copy it with updates")
|
|
def step_create_and_copy_with_updates(context):
|
|
"""Create OrgUserConfig and copy with updates."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.original = OrgUserConfig(
|
|
prompted_claude_max=False,
|
|
use_claude_subscription=True,
|
|
claude_subscription_cooldown_started_at=datetime(2024, 1, 1),
|
|
)
|
|
|
|
# Copy with updates
|
|
context.copy = context.original.model_copy(
|
|
update={"prompted_claude_max": True, "use_claude_subscription": False}
|
|
)
|
|
|
|
|
|
@then("the OrgUserConfig copy should have the updated values")
|
|
def step_verify_orguserconfig_copy_updated(context):
|
|
"""Verify the OrgUserConfig copy has updated values."""
|
|
assert context.copy.prompted_claude_max is True
|
|
assert context.copy.use_claude_subscription is False
|
|
|
|
|
|
@then("the OrgUserConfig original should remain unchanged")
|
|
def step_verify_orguserconfig_original_unchanged(context):
|
|
"""Verify OrgUserConfig original remains unchanged."""
|
|
assert context.original.prompted_claude_max is False
|
|
assert context.original.use_claude_subscription is True
|
|
|
|
|
|
@when("I create an OrgUserConfig and call model_dump with by_alias=True")
|
|
def step_model_dump_with_alias_true(context):
|
|
"""Call model_dump with by_alias=True."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=True,
|
|
use_claude_subscription=False,
|
|
claude_subscription_cooldown_started_at=datetime(2024, 3, 15),
|
|
)
|
|
|
|
context.dump_with_alias = context.model_instance.model_dump(by_alias=True)
|
|
|
|
|
|
@then("the output should use camelCase aliases")
|
|
def step_verify_camel_case_output(context):
|
|
"""Verify output uses camelCase aliases."""
|
|
assert "promptedClaudeMax" in context.dump_with_alias
|
|
assert "useClaudeSubscription" in context.dump_with_alias
|
|
assert "claudeSubscriptionCooldownStartedAt" in context.dump_with_alias
|
|
|
|
# Verify snake_case is not present
|
|
assert "prompted_claude_max" not in context.dump_with_alias
|
|
assert "use_claude_subscription" not in context.dump_with_alias
|
|
|
|
|
|
@when("I call model_dump with by_alias=False")
|
|
def step_model_dump_with_alias_false(context):
|
|
"""Call model_dump with by_alias=False."""
|
|
context.dump_without_alias = context.model_instance.model_dump(by_alias=False)
|
|
|
|
|
|
@then("the output should use snake_case field names")
|
|
def step_verify_snake_case_output(context):
|
|
"""Verify output uses snake_case field names."""
|
|
assert "prompted_claude_max" in context.dump_without_alias
|
|
assert "use_claude_subscription" in context.dump_without_alias
|
|
assert "claude_subscription_cooldown_started_at" in context.dump_without_alias
|
|
|
|
# Verify camelCase is not present
|
|
assert "promptedClaudeMax" not in context.dump_without_alias
|
|
assert "useClaudeSubscription" not in context.dump_without_alias
|
|
|
|
|
|
@when("I create an OrgUserConfig and call model_dump_json")
|
|
def step_model_dump_json(context):
|
|
"""Call model_dump_json on OrgUserConfig."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
context.model_instance = OrgUserConfig(
|
|
prompted_claude_max=False,
|
|
use_claude_subscription=True,
|
|
claude_subscription_cooldown_started_at=datetime(2024, 5, 20, 8, 30, 0),
|
|
)
|
|
|
|
context.json_output = context.model_instance.model_dump_json()
|
|
|
|
|
|
@then("the JSON output should be valid")
|
|
def step_verify_valid_json(context):
|
|
"""Verify JSON output is valid."""
|
|
# Should be able to parse the JSON
|
|
data = json.loads(context.json_output)
|
|
assert data is not None
|
|
|
|
|
|
@then("it should use the configured aliases by default")
|
|
def step_verify_json_uses_aliases(context):
|
|
"""Verify JSON uses aliases by default."""
|
|
data = json.loads(context.json_output)
|
|
# model_dump_json by default uses by_alias=False in Pydantic v2
|
|
# Check that field names are present (either snake_case or camelCase)
|
|
assert "prompted_claude_max" in data or "promptedClaudeMax" in data
|
|
assert "use_claude_subscription" in data or "useClaudeSubscription" in data
|
|
assert (
|
|
"claude_subscription_cooldown_started_at" in data
|
|
or "claudeSubscriptionCooldownStartedAt" in data
|
|
)
|
|
|
|
|
|
@when("I try to create an OrgUserConfig with wrong field types")
|
|
def step_create_with_wrong_types(context):
|
|
"""Try to create OrgUserConfig with wrong field types."""
|
|
from cleveragents.domain.models.orguserconfig.org_user_config import (
|
|
OrgUserConfig,
|
|
)
|
|
|
|
try:
|
|
OrgUserConfig(
|
|
prompted_claude_max="not_a_bool", # Should be bool
|
|
use_claude_subscription=123, # Should be bool
|
|
claude_subscription_cooldown_started_at=456, # Should be datetime
|
|
)
|
|
context.validation_error = None
|
|
except ValidationError as e:
|
|
context.validation_error = e
|
|
|
|
|
|
@then("validation errors should be raised for type mismatches")
|
|
def step_verify_type_mismatch_errors(context):
|
|
"""Verify validation errors for type mismatches."""
|
|
assert context.validation_error is not None
|
|
errors = context.validation_error.errors()
|
|
# Pydantic may coerce some values, so check at least one error
|
|
assert len(errors) >= 1
|
|
|
|
|
|
@then("the OrgUserConfig errors should clearly indicate the expected types")
|
|
def step_verify_orguserconfig_error_types(context):
|
|
"""Verify OrgUserConfig errors indicate expected types."""
|
|
errors = context.validation_error.errors()
|
|
# Check that there are errors for wrong types
|
|
assert len(errors) > 0
|
|
|
|
|
|
@when("I import the orguserconfig __init__ module")
|
|
def step_import_init_module(context):
|
|
"""Import the orguserconfig __init__ module."""
|
|
import cleveragents.domain.models.orguserconfig
|
|
|
|
context.init_module = cleveragents.domain.models.orguserconfig
|
|
|
|
|
|
@then("the module should be loaded successfully")
|
|
def step_verify_module_loaded(context):
|
|
"""Verify the __init__ module is loaded."""
|
|
assert context.init_module is not None
|
|
|
|
|
|
@then("the OrgUserConfig class should be importable from it")
|
|
def step_verify_class_importable_from_init(context):
|
|
"""Verify OrgUserConfig can be imported from __init__."""
|
|
# Import the __init__ module to ensure it's covered
|
|
from cleveragents.domain.models.orguserconfig import OrgUserConfig
|
|
|
|
assert OrgUserConfig is not None
|
|
assert OrgUserConfig.__name__ == "OrgUserConfig"
|