Your Name
209 lines
7.0 KiB
Gherkin
209 lines
7.0 KiB
Gherkin
Feature: MCP (Model Context Protocol) Integration
|
|
As a CleverClaude user
|
|
I want to use MCP tools and services
|
|
So that I can extend CleverClaude capabilities with external tools
|
|
|
|
Background:
|
|
Given CleverClaude is running
|
|
And the MCP client is initialized
|
|
|
|
@smoke
|
|
Scenario: Initialize MCP client
|
|
When I initialize the MCP client
|
|
Then the MCP client should be ready
|
|
And available tools should be loaded
|
|
And the client should be connected to MCP servers
|
|
|
|
Scenario: List available MCP tools
|
|
When I request the list of available MCP tools
|
|
Then I should receive a list of tools
|
|
And the list should contain more than 80 tools
|
|
And each tool should have proper metadata
|
|
|
|
Scenario Outline: Execute basic MCP tools
|
|
When I execute the MCP tool "<tool_name>" with parameters:
|
|
"""
|
|
<parameters>
|
|
"""
|
|
Then the tool should execute successfully
|
|
And I should receive valid results
|
|
And the response should match the expected format
|
|
|
|
Examples:
|
|
| tool_name | parameters |
|
|
| swarm_init | {"topology": "mesh", "maxAgents": 5} |
|
|
| agent_spawn | {"type": "researcher", "name": "test_agent"} |
|
|
| task_orchestrate | {"task": "Simple test task"} |
|
|
| swarm_status | {} |
|
|
| memory_usage | {"action": "list"} |
|
|
|
|
Scenario: Execute swarm management via MCP
|
|
When I execute MCP tool "swarm_init" with parameters:
|
|
"""
|
|
{
|
|
"topology": "hierarchical",
|
|
"maxAgents": 10,
|
|
"strategy": "balanced"
|
|
}
|
|
"""
|
|
Then a new swarm should be created
|
|
And the swarm should have hierarchical topology
|
|
When I execute MCP tool "agent_spawn" with parameters:
|
|
"""
|
|
{
|
|
"type": "researcher",
|
|
"name": "mcp_researcher",
|
|
"capabilities": ["research", "analysis"]
|
|
}
|
|
"""
|
|
Then a new agent should be spawned
|
|
And the agent should be added to the swarm
|
|
|
|
Scenario: Neural network operations via MCP
|
|
When I execute MCP tool "neural_train" with parameters:
|
|
"""
|
|
{
|
|
"pattern_type": "coordination",
|
|
"training_data": "sample training data",
|
|
"epochs": 10
|
|
}
|
|
"""
|
|
Then neural training should begin
|
|
And training progress should be reported
|
|
When I execute MCP tool "neural_predict" with parameters:
|
|
"""
|
|
{
|
|
"modelId": "coordination_model",
|
|
"input": "test prediction input"
|
|
}
|
|
"""
|
|
Then prediction results should be returned
|
|
|
|
Scenario: Memory management via MCP
|
|
When I execute MCP tool "memory_usage" with parameters:
|
|
"""
|
|
{
|
|
"action": "store",
|
|
"key": "test_key",
|
|
"value": "test_value",
|
|
"namespace": "test_namespace"
|
|
}
|
|
"""
|
|
Then the data should be stored successfully
|
|
When I execute MCP tool "memory_usage" with parameters:
|
|
"""
|
|
{
|
|
"action": "retrieve",
|
|
"key": "test_key",
|
|
"namespace": "test_namespace"
|
|
}
|
|
"""
|
|
Then the stored data should be retrieved
|
|
And the retrieved value should match "test_value"
|
|
|
|
Scenario: Performance monitoring via MCP
|
|
Given I have an active swarm with agents
|
|
When I execute MCP tool "performance_report" with parameters:
|
|
"""
|
|
{
|
|
"format": "detailed",
|
|
"timeframe": "24h"
|
|
}
|
|
"""
|
|
Then I should receive detailed performance metrics
|
|
And metrics should include swarm statistics
|
|
And metrics should include agent performance data
|
|
|
|
Scenario: Workflow automation via MCP
|
|
When I execute MCP tool "workflow_create" with parameters:
|
|
"""
|
|
{
|
|
"name": "test_workflow",
|
|
"steps": [
|
|
{"action": "create_agent", "type": "researcher"},
|
|
{"action": "assign_task", "task_type": "analysis"},
|
|
{"action": "collect_results"}
|
|
]
|
|
}
|
|
"""
|
|
Then a new workflow should be created
|
|
When I execute MCP tool "workflow_execute" with parameters:
|
|
"""
|
|
{
|
|
"workflowId": "test_workflow"
|
|
}
|
|
"""
|
|
Then the workflow should execute successfully
|
|
And all workflow steps should complete
|
|
|
|
Scenario: Error handling in MCP operations
|
|
When I execute MCP tool "swarm_init" with invalid parameters:
|
|
"""
|
|
{
|
|
"topology": "invalid_topology",
|
|
"maxAgents": -1
|
|
}
|
|
"""
|
|
Then the operation should fail gracefully
|
|
And I should receive a meaningful error message
|
|
And the system should remain stable
|
|
|
|
Scenario: MCP tool discovery and metadata
|
|
When I request tool metadata for "agent_spawn"
|
|
Then I should receive complete tool information
|
|
And the metadata should include parameter schemas
|
|
And the metadata should include usage examples
|
|
And the metadata should specify return types
|
|
|
|
@wip
|
|
Scenario: Custom MCP server integration
|
|
Given I have a custom MCP server running
|
|
When I register the custom server with CleverClaude
|
|
Then the server should be added to available servers
|
|
And custom tools should be discoverable
|
|
And I should be able to execute custom tools
|
|
|
|
Scenario: Concurrent MCP operations
|
|
When I execute multiple MCP tools simultaneously:
|
|
| tool_name | parameters |
|
|
| swarm_status | {} |
|
|
| agent_metrics | {"agentId": "test_agent"} |
|
|
| memory_usage | {"action": "list"} |
|
|
| performance_report | {"format": "summary"} |
|
|
Then all operations should complete successfully
|
|
And no operation should block others
|
|
And results should be returned in reasonable time
|
|
|
|
Scenario: MCP session management
|
|
When I start a new MCP session
|
|
Then session state should be initialized
|
|
When I execute multiple related operations in the session
|
|
Then session context should be maintained
|
|
And operations should share session state
|
|
When I close the MCP session
|
|
Then all session resources should be cleaned up
|
|
|
|
@hypothesis
|
|
Scenario: Stress test MCP operations
|
|
When I execute many MCP operations rapidly
|
|
Then all operations should complete or fail gracefully
|
|
And the MCP client should remain responsive
|
|
And no memory leaks should occur
|
|
And connection pools should be managed properly
|
|
|
|
Scenario: MCP connection resilience
|
|
Given I have an active MCP connection
|
|
When the MCP server becomes temporarily unavailable
|
|
Then the client should detect the connection loss
|
|
And automatic reconnection should be attempted
|
|
When the server becomes available again
|
|
Then the connection should be restored
|
|
And pending operations should resume
|
|
|
|
Scenario: MCP tool versioning and compatibility
|
|
When I request tool version information
|
|
Then I should receive version details for each tool
|
|
And compatibility information should be provided
|
|
When I execute a tool with version-specific parameters
|
|
Then the correct tool version should be used
|
|
And deprecated features should show warnings |