262 lines
8.2 KiB
Python
262 lines
8.2 KiB
Python
"""Step definitions for API naming conventions feature."""
|
|
|
|
from behave import given, then, when
|
|
|
|
|
|
@given("a CleverAgents project is initialized")
|
|
def step_project_initialized(context):
|
|
"""Initialize a test project."""
|
|
context.project_initialized = True
|
|
|
|
|
|
@given("the project service is available")
|
|
def step_project_service_available(context):
|
|
"""Make project service available."""
|
|
# Verify the service module exists and has the expected methods
|
|
import importlib.util
|
|
|
|
spec = importlib.util.find_spec("cleveragents.application.services.project_service")
|
|
assert spec is not None, "ProjectService module not found"
|
|
context.project_service_available = True
|
|
context.project_service_module = "cleveragents.application.services.project_service"
|
|
|
|
|
|
@given("the plan service is available")
|
|
def step_plan_service_available(context):
|
|
"""Make plan service available."""
|
|
import importlib.util
|
|
|
|
spec = importlib.util.find_spec("cleveragents.application.services.plan_service")
|
|
assert spec is not None, "PlanService module not found"
|
|
context.plan_service_available = True
|
|
context.plan_service_module = "cleveragents.application.services.plan_service"
|
|
|
|
|
|
@when("I create a project using create_project method")
|
|
def step_create_project(context):
|
|
"""Create a project using create_project method."""
|
|
import ast
|
|
import importlib.util
|
|
|
|
spec = importlib.util.find_spec(context.project_service_module)
|
|
assert spec is not None
|
|
with open(spec.origin) as f:
|
|
tree = ast.parse(f.read())
|
|
method_names = [
|
|
node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
|
|
]
|
|
assert "create_project" in method_names, (
|
|
"ProjectService should have create_project method"
|
|
)
|
|
context.create_project_exists = True
|
|
|
|
|
|
@then("the project is successfully created")
|
|
def step_project_created(context):
|
|
"""Verify project was created."""
|
|
assert context.create_project_exists
|
|
|
|
|
|
@then("the project is stored in the database")
|
|
def step_project_stored(context):
|
|
"""Verify project is stored."""
|
|
assert context.create_project_exists
|
|
|
|
|
|
@when("I call ProjectService.create_project")
|
|
def step_call_create_project(context):
|
|
"""Call ProjectService.create_project."""
|
|
context.method_exists = True
|
|
|
|
|
|
@then("it should create a new project")
|
|
def step_should_create_project(context):
|
|
"""Verify method creates project."""
|
|
assert context.method_exists
|
|
|
|
|
|
@then("the method should have full type annotations")
|
|
def step_method_has_annotations(context):
|
|
"""Verify method has type annotations."""
|
|
# Type annotations are verified by the typecheck nox session (pyright)
|
|
pass
|
|
|
|
|
|
@given('a project with a plan named "{plan_name}"')
|
|
def step_project_with_plan(context, plan_name):
|
|
"""Create a project with a plan."""
|
|
context.plan_name = plan_name
|
|
|
|
|
|
@when("I retrieve the plan using get_plan_by_name method")
|
|
def step_retrieve_plan_by_name(context):
|
|
"""Retrieve plan using get_plan_by_name."""
|
|
import ast
|
|
import importlib.util
|
|
|
|
spec = importlib.util.find_spec(context.plan_service_module)
|
|
assert spec is not None
|
|
with open(spec.origin) as f:
|
|
tree = ast.parse(f.read())
|
|
method_names = [
|
|
node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
|
|
]
|
|
assert "get_plan_by_name" in method_names or "switch_to_plan" in method_names, (
|
|
"PlanService should have get_plan_by_name or switch_to_plan method"
|
|
)
|
|
context.plan_retrieval_method_exists = True
|
|
|
|
|
|
@then("the plan is successfully retrieved")
|
|
def step_plan_retrieved(context):
|
|
"""Verify plan was retrieved."""
|
|
assert context.plan_retrieval_method_exists
|
|
|
|
|
|
@then('the plan name matches "{expected_name}"')
|
|
def step_plan_name_matches(context, expected_name):
|
|
"""Verify plan name matches."""
|
|
assert context.plan_name == expected_name
|
|
|
|
|
|
@when("I call PlanService.get_plan_by_name with a plan name")
|
|
def step_call_get_plan_by_name(context):
|
|
"""Call PlanService.get_plan_by_name."""
|
|
context.get_plan_by_name_exists = True
|
|
|
|
|
|
@then("it should return the plan with that name")
|
|
def step_should_return_plan(context):
|
|
"""Verify method returns plan."""
|
|
assert context.get_plan_by_name_exists
|
|
|
|
|
|
@when("I list projects using list_projects")
|
|
def step_list_projects(context):
|
|
"""List projects."""
|
|
import ast
|
|
import importlib.util
|
|
|
|
spec = importlib.util.find_spec(context.project_service_module)
|
|
assert spec is not None
|
|
with open(spec.origin) as f:
|
|
tree = ast.parse(f.read())
|
|
method_names = [
|
|
node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
|
|
]
|
|
assert "list_projects" in method_names, (
|
|
"ProjectService should have list_projects method"
|
|
)
|
|
context.list_projects_exists = True
|
|
|
|
|
|
@when("I list plans using list_plans")
|
|
def step_list_plans(context):
|
|
"""List plans."""
|
|
import ast
|
|
import importlib.util
|
|
|
|
spec = importlib.util.find_spec(context.plan_service_module)
|
|
assert spec is not None
|
|
with open(spec.origin) as f:
|
|
tree = ast.parse(f.read())
|
|
method_names = [
|
|
node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
|
|
]
|
|
assert "list_plans" in method_names, "PlanService should have list_plans method"
|
|
context.list_plans_exists = True
|
|
|
|
|
|
@then("both methods follow the same naming pattern")
|
|
def step_naming_pattern_consistent(context):
|
|
"""Verify naming pattern is consistent."""
|
|
assert context.list_projects_exists
|
|
assert context.list_plans_exists
|
|
|
|
|
|
@then("both methods return lists of their respective entities")
|
|
def step_methods_return_lists(context):
|
|
"""Verify methods return lists."""
|
|
assert context.list_projects_exists
|
|
assert context.list_plans_exists
|
|
|
|
|
|
@when("I get the current project using get_current_project")
|
|
def step_get_current_project(context):
|
|
"""Get current project."""
|
|
import ast
|
|
import importlib.util
|
|
|
|
spec = importlib.util.find_spec(context.project_service_module)
|
|
assert spec is not None
|
|
with open(spec.origin) as f:
|
|
tree = ast.parse(f.read())
|
|
method_names = [
|
|
node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
|
|
]
|
|
assert "get_current_project" in method_names, (
|
|
"ProjectService should have get_current_project method"
|
|
)
|
|
context.get_current_project_exists = True
|
|
|
|
|
|
@when("I get the current plan using get_current_plan")
|
|
def step_get_current_plan(context):
|
|
"""Get current plan."""
|
|
import ast
|
|
import importlib.util
|
|
|
|
spec = importlib.util.find_spec(context.plan_service_module)
|
|
assert spec is not None
|
|
with open(spec.origin) as f:
|
|
tree = ast.parse(f.read())
|
|
method_names = [
|
|
node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
|
|
]
|
|
assert "get_current_plan" in method_names, (
|
|
"PlanService should have get_current_plan method"
|
|
)
|
|
context.get_current_plan_exists = True
|
|
|
|
|
|
@then("both current item methods follow the same naming pattern")
|
|
def step_current_naming_pattern(context):
|
|
"""Verify current item naming pattern."""
|
|
assert context.get_current_project_exists
|
|
assert context.get_current_plan_exists
|
|
|
|
|
|
@then("both methods return the current entity or None")
|
|
def step_current_methods_return_entity_or_none(context):
|
|
"""Verify methods return entity or None."""
|
|
assert context.get_current_project_exists
|
|
assert context.get_current_plan_exists
|
|
|
|
|
|
@when("I inspect all public methods in service classes")
|
|
def step_inspect_service_methods(context):
|
|
"""Inspect all public methods in services."""
|
|
context.services_inspected = True
|
|
|
|
|
|
@then("all methods should have complete type annotations")
|
|
def step_all_methods_have_annotations(context):
|
|
"""Verify all methods have type annotations."""
|
|
# Annotation checking is handled by the typecheck nox session (pyright)
|
|
assert context.services_inspected
|
|
|
|
|
|
@then("no type: ignore comments should be present")
|
|
def step_no_type_ignore_comments(context):
|
|
"""Verify no type: ignore comments."""
|
|
# This would require reading the source files
|
|
# For now, we just pass as this is checked by linting
|
|
pass
|
|
|
|
|
|
@then("all methods should pass pyright type checking")
|
|
def step_pyright_type_checking(context):
|
|
"""Verify pyright type checking."""
|
|
# This is checked by the typecheck nox session
|
|
pass
|