704 lines
24 KiB
Python
704 lines
24 KiB
Python
"""Step definitions for AI models providers unit tests."""
|
|
|
|
import json
|
|
|
|
from behave import given, then, when
|
|
from pydantic import ValidationError
|
|
|
|
from cleveragents.domain.models.aimodelsproviders.ai_models_providers import (
|
|
ModelProviderConfigSchema,
|
|
ModelProviderExtraAuthVars,
|
|
)
|
|
from cleveragents.domain.models.core.enums import ModelProvider
|
|
|
|
|
|
@given("I import the ModelProviderExtraAuthVars class")
|
|
def step_import_extra_auth_vars(context):
|
|
"""Import ModelProviderExtraAuthVars class."""
|
|
context.model_class = ModelProviderExtraAuthVars
|
|
|
|
|
|
@given("I import the ModelProviderConfigSchema class")
|
|
def step_import_config_schema(context):
|
|
"""Import ModelProviderConfigSchema class."""
|
|
context.model_class = ModelProviderConfigSchema
|
|
|
|
|
|
@given("I import the ModelProvider enum for provider config")
|
|
def step_import_model_provider_enum_for_config(context):
|
|
"""Import ModelProvider enum for provider config."""
|
|
context.enum_class = ModelProvider
|
|
|
|
|
|
@when('I create a ModelProviderExtraAuthVars with var "{var}"')
|
|
def step_create_extra_auth_vars_with_var(context, var):
|
|
"""Create ModelProviderExtraAuthVars with var field."""
|
|
context.instance = ModelProviderExtraAuthVars(var=var)
|
|
|
|
|
|
@when("I set maybeJSONFilePath to {value}")
|
|
def step_set_maybe_json_file_path(context, value):
|
|
"""Set maybeJSONFilePath field."""
|
|
value_bool = value.lower() == "true"
|
|
context.instance = ModelProviderExtraAuthVars(
|
|
var=context.instance.var, maybe_j_s_o_n_file_path=value_bool
|
|
)
|
|
|
|
|
|
@when("I set required to {value}")
|
|
def step_set_required(context, value):
|
|
"""Set required field."""
|
|
value_bool = value.lower() == "true"
|
|
context.instance = ModelProviderExtraAuthVars(
|
|
var=context.instance.var,
|
|
maybe_j_s_o_n_file_path=context.instance.maybe_j_s_o_n_file_path,
|
|
required=value_bool,
|
|
)
|
|
|
|
|
|
@when('I set default to "{value}"')
|
|
def step_set_default(context, value):
|
|
"""Set default field."""
|
|
context.instance = ModelProviderExtraAuthVars(
|
|
var=context.instance.var,
|
|
maybe_j_s_o_n_file_path=context.instance.maybe_j_s_o_n_file_path,
|
|
required=context.instance.required,
|
|
default=value,
|
|
)
|
|
|
|
|
|
@when('I create a ModelProviderExtraAuthVars with only var "{var}"')
|
|
def step_create_minimal_extra_auth_vars(context, var):
|
|
"""Create ModelProviderExtraAuthVars with only required field."""
|
|
context.instance = ModelProviderExtraAuthVars(var=var)
|
|
|
|
|
|
@when('I create a ModelProviderExtraAuthVars using alias "{alias}"')
|
|
def step_create_with_alias(context, alias):
|
|
"""Create ModelProviderExtraAuthVars using field alias."""
|
|
context.instance = ModelProviderExtraAuthVars(
|
|
var="TEST_VAR",
|
|
maybeJSONFilePath=True, # Using alias
|
|
)
|
|
|
|
|
|
@when('I create a ModelProviderConfigSchema with provider "{provider}"')
|
|
def step_create_config_schema_with_provider(context, provider):
|
|
"""Create ModelProviderConfigSchema with provider."""
|
|
context.instance = ModelProviderConfigSchema(
|
|
provider=provider, base_url="https://api.example.com"
|
|
)
|
|
|
|
|
|
@when('I set base_url to "{url}"')
|
|
def step_set_base_url(context, url):
|
|
"""Set base_url field."""
|
|
context.instance.base_url = url
|
|
|
|
|
|
@when('I set custom_provider to "{value}"')
|
|
def step_set_custom_provider(context, value):
|
|
"""Set custom_provider field."""
|
|
context.instance.custom_provider = value
|
|
|
|
|
|
@when("I set has_a_w_s_auth to {value}")
|
|
def step_set_has_aws_auth(context, value):
|
|
"""Set has_a_w_s_auth field."""
|
|
context.instance.has_a_w_s_auth = value.lower() == "true"
|
|
|
|
|
|
@when("I set has_claude_max_auth to {value}")
|
|
def step_set_has_claude_max_auth(context, value):
|
|
"""Set has_claude_max_auth field."""
|
|
context.instance.has_claude_max_auth = value.lower() == "true"
|
|
|
|
|
|
@when("I set skip_auth to {value}")
|
|
def step_set_skip_auth(context, value):
|
|
"""Set skip_auth field."""
|
|
context.instance.skip_auth = value.lower() == "true"
|
|
|
|
|
|
@when("I set local_only to {value}")
|
|
def step_set_local_only(context, value):
|
|
"""Set local_only field."""
|
|
context.instance.local_only = value.lower() == "true"
|
|
|
|
|
|
@when('I set api_key_env_var to "{value}"')
|
|
def step_set_api_key_env_var(context, value):
|
|
"""Set api_key_env_var field."""
|
|
context.instance.api_key_env_var = value
|
|
|
|
|
|
@when("I add extra_auth_vars list")
|
|
def step_add_extra_auth_vars_list(context):
|
|
"""Add extra_auth_vars list."""
|
|
extra_var = ModelProviderExtraAuthVars(var="EXTRA_KEY", required=True)
|
|
context.instance.extra_auth_vars = [extra_var]
|
|
|
|
|
|
@when("I create a ModelProviderConfigSchema with only required fields")
|
|
def step_create_minimal_config_schema(context):
|
|
"""Create ModelProviderConfigSchema with only required fields."""
|
|
context.instance = ModelProviderConfigSchema(
|
|
provider=ModelProvider.OPENAI, base_url="https://api.openai.com"
|
|
)
|
|
|
|
|
|
@when("I create a ModelProviderConfigSchema with ModelProvider.ANTHROPIC")
|
|
def step_create_config_with_enum(context):
|
|
"""Create ModelProviderConfigSchema with enum value."""
|
|
context.instance = ModelProviderConfigSchema(
|
|
provider=ModelProvider.ANTHROPIC, base_url="https://api.anthropic.com"
|
|
)
|
|
|
|
|
|
@when("I create a ModelProviderConfigSchema with whitespace in fields")
|
|
def step_create_config_with_whitespace(context):
|
|
"""Create ModelProviderConfigSchema with whitespace in fields."""
|
|
context.instance = ModelProviderConfigSchema(
|
|
provider=ModelProvider.OPENAI,
|
|
base_url=" https://api.openai.com ",
|
|
custom_provider=" custom ",
|
|
api_key_env_var=" API_KEY ",
|
|
)
|
|
|
|
|
|
@when("I create a ModelProviderConfigSchema using aliases")
|
|
def step_create_config_using_aliases(context):
|
|
"""Create ModelProviderConfigSchema using field aliases."""
|
|
context.instance = ModelProviderConfigSchema(
|
|
provider=ModelProvider.OPENAI,
|
|
baseUrl="https://api.openai.com", # alias
|
|
customProvider="custom", # alias
|
|
hasAWSAuth=True, # alias
|
|
hasClaudeMaxAuth=False, # alias
|
|
skipAuth=False, # alias
|
|
localOnly=False, # alias
|
|
apiKeyEnvVar="API_KEY", # alias
|
|
extraAuthVars=[], # alias
|
|
)
|
|
|
|
|
|
@when("I create a ModelProviderConfigSchema with empty extra_auth_vars list")
|
|
def step_create_config_with_empty_list(context):
|
|
"""Create ModelProviderConfigSchema with empty extra_auth_vars."""
|
|
context.instance = ModelProviderConfigSchema(
|
|
provider=ModelProvider.OPENAI,
|
|
base_url="https://api.openai.com",
|
|
extra_auth_vars=[],
|
|
)
|
|
|
|
|
|
@when("I create a ModelProviderConfigSchema with multiple extra_auth_vars")
|
|
def step_create_config_with_multiple_auth_vars(context):
|
|
"""Create ModelProviderConfigSchema with multiple extra_auth_vars."""
|
|
vars_list = [
|
|
ModelProviderExtraAuthVars(var="VAR1", required=True),
|
|
ModelProviderExtraAuthVars(var="VAR2", required=False),
|
|
ModelProviderExtraAuthVars(var="VAR3", default="default_val"),
|
|
]
|
|
context.instance = ModelProviderConfigSchema(
|
|
provider=ModelProvider.OPENAI,
|
|
base_url="https://api.openai.com",
|
|
extra_auth_vars=vars_list,
|
|
)
|
|
|
|
|
|
@when("I export it to dict with aliases")
|
|
def step_export_to_dict_with_aliases(context):
|
|
"""Export model to dictionary with aliases."""
|
|
context.dict_output = context.instance.model_dump(by_alias=True)
|
|
|
|
|
|
@when("I serialize it to JSON")
|
|
def step_serialize_to_json(context):
|
|
"""Serialize model to JSON."""
|
|
context.json_output = context.instance.model_dump_json(by_alias=True)
|
|
|
|
|
|
@when("I deserialize it to ModelProviderConfigSchema")
|
|
def step_deserialize_from_json(context):
|
|
"""Deserialize JSON to ModelProviderConfigSchema."""
|
|
json_data = {
|
|
"provider": "ModelProviderOpenAI",
|
|
"baseUrl": "https://api.openai.com",
|
|
"customProvider": "custom",
|
|
"hasAWSAuth": True,
|
|
"extraAuthVars": [{"var": "KEY1", "required": True}],
|
|
}
|
|
context.json_string = json.dumps(json_data)
|
|
context.instance = ModelProviderConfigSchema.model_validate_json(
|
|
context.json_string
|
|
)
|
|
|
|
|
|
@when("I check the model configuration")
|
|
def step_check_model_config(context):
|
|
"""Check model configuration."""
|
|
context.model_config = context.model_class.model_config
|
|
|
|
|
|
@when('I update the var field to "{value}"')
|
|
def step_update_var_field(context, value):
|
|
"""Update var field."""
|
|
context.instance.var = value
|
|
|
|
|
|
@when('I update the base_url field to "{value}"')
|
|
def step_update_base_url_field(context, value):
|
|
"""Update base_url field."""
|
|
context.instance.base_url = value
|
|
|
|
|
|
@when("I create a copy with updated fields")
|
|
def step_create_copy_with_updates(context):
|
|
"""Create a copy with updated fields."""
|
|
context.original = context.instance
|
|
if hasattr(context.instance, "var"):
|
|
context.copy = context.instance.model_copy(update={"var": "NEW_VAR"})
|
|
else:
|
|
context.copy = context.instance.model_copy(
|
|
update={"base_url": "https://new.com"}
|
|
)
|
|
|
|
|
|
@when("I compare them for equality")
|
|
def step_compare_equality(context):
|
|
"""Compare instances for equality."""
|
|
if (
|
|
hasattr(context, "model_class")
|
|
and context.model_class == ModelProviderExtraAuthVars
|
|
):
|
|
context.instance1 = ModelProviderExtraAuthVars(var="VAR1")
|
|
context.instance2 = ModelProviderExtraAuthVars(var="VAR1")
|
|
context.instance3 = ModelProviderExtraAuthVars(var="VAR2")
|
|
else:
|
|
context.instance1 = ModelProviderConfigSchema(
|
|
provider=ModelProvider.OPENAI, base_url="https://api.openai.com"
|
|
)
|
|
context.instance2 = ModelProviderConfigSchema(
|
|
provider=ModelProvider.OPENAI, base_url="https://api.openai.com"
|
|
)
|
|
context.instance3 = ModelProviderConfigSchema(
|
|
provider=ModelProvider.ANTHROPIC, base_url="https://api.anthropic.com"
|
|
)
|
|
|
|
|
|
@when("I try to use them as dictionary keys")
|
|
def step_try_use_as_dict_keys(context):
|
|
"""Try to use instances as dictionary keys."""
|
|
context.instance1 = ModelProviderExtraAuthVars(var="KEY1")
|
|
context.instance2 = ModelProviderExtraAuthVars(var="KEY2")
|
|
context.test_dict = {}
|
|
try:
|
|
context.test_dict[context.instance1] = "value1"
|
|
context.test_dict[context.instance2] = "value2"
|
|
context.can_be_key = True
|
|
context.hash_error = None
|
|
except TypeError as e:
|
|
context.can_be_key = False
|
|
context.hash_error = e
|
|
|
|
|
|
@when("I try to create an instance with missing required fields")
|
|
def step_create_with_missing_fields(context):
|
|
"""Try to create instance with missing required fields."""
|
|
try:
|
|
context.instance = ModelProviderConfigSchema()
|
|
context.error_raised = False
|
|
except ValidationError as e:
|
|
context.error = e
|
|
context.error_raised = True
|
|
|
|
|
|
@then('the var field should equal "{expected}"')
|
|
def step_verify_var_field(context, expected):
|
|
"""Verify var field value."""
|
|
assert context.instance.var == expected
|
|
|
|
|
|
@then("the maybe_j_s_o_n_file_path field should be {expected}")
|
|
def step_verify_maybe_json_field(context, expected):
|
|
"""Verify maybe_j_s_o_n_file_path field."""
|
|
if expected == "None":
|
|
assert context.instance.maybe_j_s_o_n_file_path is None
|
|
else:
|
|
assert context.instance.maybe_j_s_o_n_file_path == (expected.lower() == "true")
|
|
|
|
|
|
@then("the required field should be {expected}")
|
|
def step_verify_required_field(context, expected):
|
|
"""Verify required field."""
|
|
if expected == "None":
|
|
assert context.instance.required is None
|
|
else:
|
|
assert context.instance.required == (expected.lower() == "true")
|
|
|
|
|
|
@then('the default field should equal "{expected}"')
|
|
def step_verify_default_field_string(context, expected):
|
|
"""Verify default field with string value."""
|
|
assert context.instance.default == expected
|
|
|
|
|
|
@then("the default field should be {expected}")
|
|
def step_verify_default_field(context, expected):
|
|
"""Verify default field."""
|
|
if expected == "None":
|
|
assert context.instance.default is None
|
|
else:
|
|
assert context.instance.default == expected
|
|
|
|
|
|
@then("the model should strip whitespace from string fields")
|
|
def step_verify_whitespace_stripping(context):
|
|
"""Verify whitespace stripping."""
|
|
assert context.instance.var == "TRIMMED_VAR"
|
|
|
|
|
|
@then("the field should be accessible as maybe_j_s_o_n_file_path")
|
|
def step_verify_field_accessible(context):
|
|
"""Verify field is accessible with snake_case name."""
|
|
assert context.instance.maybe_j_s_o_n_file_path is True
|
|
|
|
|
|
@then("the model should populate by name")
|
|
def step_verify_populate_by_name(context):
|
|
"""Verify model populates by name."""
|
|
assert context.instance.maybe_j_s_o_n_file_path is True
|
|
|
|
|
|
@then('the dict should contain "{key}" key')
|
|
def step_verify_dict_contains_key(context, key):
|
|
"""Verify dictionary contains specific key."""
|
|
assert key in context.dict_output
|
|
|
|
|
|
@then('the dict should not contain "{key}" key')
|
|
def step_verify_dict_not_contains_key(context, key):
|
|
"""Verify dictionary does not contain specific key."""
|
|
assert key not in context.dict_output
|
|
|
|
|
|
@then('the provider field should equal "{expected}"')
|
|
def step_verify_provider_field(context, expected):
|
|
"""Verify provider field value."""
|
|
assert context.instance.provider == expected
|
|
|
|
|
|
@then('the base_url field should equal "{expected}"')
|
|
def step_verify_base_url_field(context, expected):
|
|
"""Verify base_url field value."""
|
|
assert context.instance.base_url == expected
|
|
|
|
|
|
@then('the custom_provider field should equal "{expected}"')
|
|
def step_verify_custom_provider_field(context, expected):
|
|
"""Verify custom_provider field value."""
|
|
assert context.instance.custom_provider == expected
|
|
|
|
|
|
@then("the has_a_w_s_auth field should be {expected}")
|
|
def step_verify_has_aws_auth_field(context, expected):
|
|
"""Verify has_a_w_s_auth field."""
|
|
assert context.instance.has_a_w_s_auth == (expected.lower() == "true")
|
|
|
|
|
|
@then("the has_claude_max_auth field should be {expected}")
|
|
def step_verify_has_claude_max_auth_field(context, expected):
|
|
"""Verify has_claude_max_auth field."""
|
|
assert context.instance.has_claude_max_auth == (expected.lower() == "true")
|
|
|
|
|
|
@then("the skip_auth field should be {expected}")
|
|
def step_verify_skip_auth_field(context, expected):
|
|
"""Verify skip_auth field."""
|
|
assert context.instance.skip_auth == (expected.lower() == "true")
|
|
|
|
|
|
@then("the local_only field should be {expected}")
|
|
def step_verify_local_only_field(context, expected):
|
|
"""Verify local_only field."""
|
|
assert context.instance.local_only == (expected.lower() == "true")
|
|
|
|
|
|
@then('the api_key_env_var field should equal "{expected}"')
|
|
def step_verify_api_key_env_var_field(context, expected):
|
|
"""Verify api_key_env_var field value."""
|
|
assert context.instance.api_key_env_var == expected
|
|
|
|
|
|
@then("the extra_auth_vars should be a list")
|
|
def step_verify_extra_auth_vars_is_list(context):
|
|
"""Verify extra_auth_vars is a list."""
|
|
assert isinstance(context.instance.extra_auth_vars, list)
|
|
|
|
|
|
@then("the provider field should be set")
|
|
def step_verify_provider_set(context):
|
|
"""Verify provider field is set."""
|
|
assert context.instance.provider is not None
|
|
|
|
|
|
@then("the base_url field should be set")
|
|
def step_verify_base_url_set(context):
|
|
"""Verify base_url field is set."""
|
|
assert context.instance.base_url is not None
|
|
|
|
|
|
@then("all optional fields should be None")
|
|
def step_verify_optional_fields_none(context):
|
|
"""Verify all optional fields are None."""
|
|
assert context.instance.custom_provider is None
|
|
assert context.instance.has_a_w_s_auth is None
|
|
assert context.instance.has_claude_max_auth is None
|
|
assert context.instance.skip_auth is None
|
|
assert context.instance.local_only is None
|
|
assert context.instance.api_key_env_var is None
|
|
assert context.instance.extra_auth_vars is None
|
|
|
|
|
|
@then("the model should use enum values")
|
|
def step_verify_enum_values(context):
|
|
"""Verify model uses enum values."""
|
|
assert context.instance.provider == "ModelProviderAnthropic"
|
|
|
|
|
|
@then("all string fields should have whitespace stripped")
|
|
def step_verify_all_whitespace_stripped(context):
|
|
"""Verify all string fields have whitespace stripped."""
|
|
assert context.instance.base_url == "https://api.openai.com"
|
|
assert context.instance.custom_provider == "custom"
|
|
assert context.instance.api_key_env_var == "API_KEY"
|
|
|
|
|
|
@then("the model should validate assignment")
|
|
def step_verify_validate_assignment(context):
|
|
"""Verify model validates assignment."""
|
|
# Assignment validation happens automatically in Pydantic
|
|
assert True
|
|
|
|
|
|
@then('"{alias}" should map to {field}')
|
|
def step_verify_alias_mapping(context, alias, field):
|
|
"""Verify alias maps to field."""
|
|
assert hasattr(context.instance, field.replace('"', ""))
|
|
|
|
|
|
@then("the dict should use camelCase keys")
|
|
def step_verify_camelcase_keys(context):
|
|
"""Verify dictionary uses camelCase keys."""
|
|
assert "baseUrl" in context.dict_output
|
|
|
|
|
|
@then('"{key}" should be in the dict')
|
|
def step_verify_key_in_dict(context, key):
|
|
"""Verify key is in dictionary."""
|
|
assert key in context.dict_output
|
|
|
|
|
|
@then("the extra_auth_vars should be an empty list")
|
|
def step_verify_empty_list(context):
|
|
"""Verify extra_auth_vars is empty list."""
|
|
assert context.instance.extra_auth_vars == []
|
|
|
|
|
|
@then("the model should accept empty lists")
|
|
def step_verify_accepts_empty_lists(context):
|
|
"""Verify model accepts empty lists."""
|
|
assert context.instance.extra_auth_vars == []
|
|
|
|
|
|
@then("each extra_auth_var should be a ModelProviderExtraAuthVars instance")
|
|
def step_verify_auth_vars_instances(context):
|
|
"""Verify each item is ModelProviderExtraAuthVars instance."""
|
|
for item in context.instance.extra_auth_vars:
|
|
assert isinstance(item, ModelProviderExtraAuthVars)
|
|
|
|
|
|
@then("the list should maintain order")
|
|
def step_verify_list_order(context):
|
|
"""Verify list maintains order."""
|
|
assert context.instance.extra_auth_vars[0].var == "VAR1"
|
|
assert context.instance.extra_auth_vars[1].var == "VAR2"
|
|
assert context.instance.extra_auth_vars[2].var == "VAR3"
|
|
|
|
|
|
@then("the JSON should be valid")
|
|
def step_verify_valid_json(context):
|
|
"""Verify JSON is valid."""
|
|
parsed = json.loads(context.json_output)
|
|
assert parsed is not None
|
|
|
|
|
|
@then("it should contain all set fields")
|
|
def step_verify_json_contains_fields(context):
|
|
"""Verify JSON contains all set fields."""
|
|
parsed = json.loads(context.json_output)
|
|
assert "provider" in parsed
|
|
assert "baseUrl" in parsed
|
|
|
|
|
|
@then("it should use aliases in the output")
|
|
def step_verify_json_uses_aliases(context):
|
|
"""Verify JSON uses aliases."""
|
|
parsed = json.loads(context.json_output)
|
|
assert "baseUrl" in parsed
|
|
assert "base_url" not in parsed
|
|
|
|
|
|
@given("I have a JSON string with provider config")
|
|
def step_have_json_string(context):
|
|
"""Have a JSON string with provider config."""
|
|
# JSON string is created in the when step
|
|
pass
|
|
|
|
|
|
@then("the object should be correctly populated")
|
|
def step_verify_object_populated(context):
|
|
"""Verify object is correctly populated."""
|
|
assert context.instance.provider == "ModelProviderOpenAI"
|
|
assert context.instance.base_url == "https://api.openai.com"
|
|
assert context.instance.custom_provider == "custom"
|
|
assert context.instance.has_a_w_s_auth is True
|
|
|
|
|
|
@then("aliases should be resolved to field names")
|
|
def step_verify_aliases_resolved(context):
|
|
"""Verify aliases are resolved to field names."""
|
|
assert hasattr(context.instance, "base_url")
|
|
assert hasattr(context.instance, "has_a_w_s_auth")
|
|
assert not hasattr(context.instance, "baseUrl")
|
|
assert not hasattr(context.instance, "hasAWSAuth")
|
|
|
|
|
|
@then("str_strip_whitespace should be True")
|
|
def step_verify_strip_whitespace_config(context):
|
|
"""Verify str_strip_whitespace configuration."""
|
|
assert context.model_config.get("str_strip_whitespace") is True
|
|
|
|
|
|
@then("validate_assignment should be True")
|
|
def step_verify_validate_assignment_config(context):
|
|
"""Verify validate_assignment configuration."""
|
|
assert context.model_config.get("validate_assignment") is True
|
|
|
|
|
|
@then("arbitrary_types_allowed should be False")
|
|
def step_verify_arbitrary_types_config(context):
|
|
"""Verify arbitrary_types_allowed configuration."""
|
|
assert context.model_config.get("arbitrary_types_allowed") is False
|
|
|
|
|
|
@then("populate_by_name should be True")
|
|
def step_verify_populate_by_name_config(context):
|
|
"""Verify populate_by_name configuration."""
|
|
assert context.model_config.get("populate_by_name") is True
|
|
|
|
|
|
@then("use_enum_values should be True")
|
|
def step_verify_use_enum_values_config(context):
|
|
"""Verify use_enum_values configuration."""
|
|
assert context.model_config.get("use_enum_values") is True
|
|
|
|
|
|
@then("the update should be validated")
|
|
def step_verify_update_validated(context):
|
|
"""Verify update is validated."""
|
|
# Validation happens automatically in Pydantic
|
|
assert True
|
|
|
|
|
|
@given("I have a ModelProviderExtraAuthVars instance")
|
|
def step_have_extra_auth_vars_instance(context):
|
|
"""Have a ModelProviderExtraAuthVars instance."""
|
|
context.instance = ModelProviderExtraAuthVars(var="TEST_VAR", required=True)
|
|
|
|
|
|
@given("I have a ModelProviderConfigSchema instance")
|
|
def step_have_config_schema_instance(context):
|
|
"""Have a ModelProviderConfigSchema instance."""
|
|
context.instance = ModelProviderConfigSchema(
|
|
provider=ModelProvider.OPENAI,
|
|
base_url="https://api.openai.com",
|
|
custom_provider="custom",
|
|
)
|
|
|
|
|
|
@then("the copy should have new values")
|
|
def step_verify_copy_new_values(context):
|
|
"""Verify copy has new values."""
|
|
if hasattr(context.copy, "var"):
|
|
assert context.copy.var == "NEW_VAR"
|
|
else:
|
|
assert context.copy.base_url == "https://new.com"
|
|
|
|
|
|
@then("the original should remain unchanged")
|
|
def step_verify_original_unchanged(context):
|
|
"""Verify original remains unchanged."""
|
|
if hasattr(context.original, "var"):
|
|
assert context.original.var != "NEW_VAR"
|
|
else:
|
|
assert context.original.base_url != "https://new.com"
|
|
|
|
|
|
@given("I have two ModelProviderExtraAuthVars instances")
|
|
def step_have_two_extra_auth_vars(context):
|
|
"""Have two ModelProviderExtraAuthVars instances."""
|
|
context.model_class = ModelProviderExtraAuthVars
|
|
|
|
|
|
@given("I have two ModelProviderConfigSchema instances")
|
|
def step_have_two_config_schemas(context):
|
|
"""Have two ModelProviderConfigSchema instances."""
|
|
context.model_class = ModelProviderConfigSchema
|
|
|
|
|
|
@then("identical instances should be equal")
|
|
def step_verify_identical_equal(context):
|
|
"""Verify identical instances are equal."""
|
|
assert context.instance1 == context.instance2
|
|
|
|
|
|
@then("different instances should not be equal")
|
|
def step_verify_different_not_equal(context):
|
|
"""Verify different instances are not equal."""
|
|
assert context.instance1 != context.instance3
|
|
|
|
|
|
@given("I have ModelProviderExtraAuthVars instances")
|
|
def step_have_extra_auth_vars_instances(context):
|
|
"""Have ModelProviderExtraAuthVars instances."""
|
|
pass # Instances created in when step
|
|
|
|
|
|
@then("the instances should not work as dictionary keys")
|
|
def step_verify_dict_keys_dont_work(context):
|
|
"""Verify instances don't work as dictionary keys."""
|
|
assert context.can_be_key is False
|
|
assert context.hash_error is not None
|
|
|
|
|
|
@then("a TypeError should be raised when hashing")
|
|
def step_verify_type_error_hashing(context):
|
|
"""Verify TypeError is raised when hashing."""
|
|
assert isinstance(context.hash_error, TypeError)
|
|
assert "unhashable" in str(context.hash_error)
|
|
|
|
|
|
@then("a validation error should be raised for missing fields")
|
|
def step_verify_validation_error_raised_missing(context):
|
|
"""Verify validation error is raised for missing fields."""
|
|
assert context.error_raised is True
|
|
|
|
|
|
@then("the error should indicate missing fields")
|
|
def step_verify_error_indicates_missing(context):
|
|
"""Verify error indicates missing fields."""
|
|
error_str = str(context.error)
|
|
assert "provider" in error_str.lower() or "base_url" in error_str.lower()
|