CoreRasurae
9753b31c7e
CI / quality (push) Successful in 36s
CI / lint (push) Successful in 38s
CI / typecheck (push) Successful in 49s
CI / security (push) Successful in 51s
CI / integration_tests (push) Successful in 55s
CI / unit_tests (push) Successful in 3m35s
CI / build (push) Successful in 33s
CI / coverage (push) Successful in 3m36s
CI / status-check (push) Successful in 3s
Add 13 BDD scenarios covering previously uncovered code paths: - SAFE_BUILTINS validation (sandbox.py: 0% → 100%) - ConfigurationError re-raise path (config.py: 99.3% → 100%) - CLI hello/main functions (cli.py: 72.7% → 90.9%) - GraphState message truncation (state.py: 98.7% → 100%) - ProgressBarManager update/context rendering (progress.py: 0% → 87.7%) - MessageRouter regex/exact/contains routing (message_router.py: 0% → 59.4%) - RoutingAdapter parse_routing_command (routing_adapter.py) - DynamicRouterNode pattern-based routing (dynamic_router.py) - EnhancedTemplateRegistry unknown template type (enhanced_registry.py: 99.2%) - CompositeAgent null-graph error path (composite.py: 97.8% → 98.6%) Cover routing_adapter.py (17% → 100%): all GOTO/ROUTE patterns, create_routing_node, create_conditional_router, dynamic config conversion. Cover dynamic_router.py (21% → 87%): execute with empty/dict/string messages, extract_message with colon parsing, config creation, graph extension with edge generation. Cover message_router.py (59% → 78%): regex, exact, contains, prefix, suffix match types, invalid regex handling, non-string message, set_state. Exercise Node._prepare_conversation_history with invalid configs, _runtime error paths, _execute_message_router with rules, _execute_agent with current_message and metadata propagation, _execute_function with dynamic_router, and _execute_conditional with content_contains/content_not_contains/content_starts_with and custom condition types. Improves nodes.py from 71.3% to 72.5%. Exercise PureGraphConfig, PureLangGraph init with dict/config, RxPyLangGraphBridge registration/connection/lookup, ReactiveStreamRouter operator creation and condition functions, ReactiveConfigParser config/route/graph parsing, ToolAgent tool execution with JSON, space-separated, single, file_read, progress_bar invocations, and ReactiveCleverAgentsApp init/dispose/visualization.
453 lines
14 KiB
Gherkin
453 lines
14 KiB
Gherkin
Feature: Application Configuration, Templating, and Lifecycle
|
|
As a developer
|
|
I want the application to initialize with templates, register agents and routes, process single-shot and interactive sessions, and dispose cleanly
|
|
So that the ReactiveCleverAgentsApp lifecycle works correctly from startup to shutdown
|
|
|
|
Background:
|
|
Given the application test environment is initialized
|
|
|
|
Scenario: Application initialization with prompt template processing
|
|
Given I have a configuration with prompt templates:
|
|
"""
|
|
cleveragents:
|
|
template_engine: JINJA2
|
|
|
|
agents:
|
|
template_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
prompts:
|
|
greeting:
|
|
content: "Hello {{name}}"
|
|
simple_prompt: "Just a string"
|
|
dict_prompt:
|
|
content: "Dict content"
|
|
metadata: "extra"
|
|
"""
|
|
When I load the configuration
|
|
Then the application should initialize successfully
|
|
And prompt templates should be registered correctly
|
|
And both string and dict prompts should be processed
|
|
|
|
Scenario: Enhanced template registry initialization
|
|
Given I have a configuration with advanced complex templates requiring preprocessing:
|
|
"""
|
|
agents:
|
|
test_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
templates:
|
|
agents:
|
|
complex_agent:
|
|
_needs_preprocessing: true
|
|
_raw_template: "{{agent_type}}"
|
|
type: "{{agent_type}}"
|
|
graphs:
|
|
simple_graph:
|
|
__jinja_template__: true
|
|
type: graph
|
|
streams:
|
|
template_stream:
|
|
__is_template__: true
|
|
type: stream
|
|
"""
|
|
When I load the configuration
|
|
Then the enhanced template registry should be used
|
|
And complex templates should be processed correctly
|
|
|
|
Scenario: Regular template registry for simple templates
|
|
Given I have a configuration with simple templates:
|
|
"""
|
|
agents:
|
|
simple_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
templates:
|
|
agents:
|
|
basic_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
"""
|
|
When I load the configuration
|
|
Then the regular template registry should be used
|
|
And simple templates should be registered
|
|
|
|
Scenario: Agent creation with template instances
|
|
Given I have a configuration with agent template instances:
|
|
"""
|
|
agents:
|
|
simple_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
template_instance_agent:
|
|
type: template_instance
|
|
config:
|
|
template: basic_agent
|
|
params:
|
|
model: gpt-4
|
|
|
|
templates:
|
|
agents:
|
|
basic_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-4
|
|
"""
|
|
When I load the configuration
|
|
Then agents should be created from templates
|
|
And template instances should be processed correctly
|
|
|
|
Scenario: Agent creation with enhanced registry template instances
|
|
Given I have a configuration requiring enhanced registry with template instances:
|
|
"""
|
|
agents:
|
|
enhanced_template_agent:
|
|
type: template_instance
|
|
config:
|
|
agent_template: complex_agent
|
|
params:
|
|
agent_type: tool
|
|
|
|
templates:
|
|
agents:
|
|
complex_agent:
|
|
_needs_preprocessing: true
|
|
_raw_template: "tool"
|
|
type: tool
|
|
config:
|
|
tools: ["echo"]
|
|
"""
|
|
When I load the configuration
|
|
Then the enhanced template registry should instantiate agents
|
|
And complex template parameters should be applied
|
|
|
|
Scenario: Bridge route configuration
|
|
Given I have a configuration with bridge routes:
|
|
"""
|
|
agents:
|
|
bridge_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
routes:
|
|
bridge_route:
|
|
type: bridge
|
|
source: input_stream
|
|
target: output_stream
|
|
"""
|
|
When I load the configuration
|
|
Then bridge routes should be registered
|
|
And the route bridge should be initialized
|
|
|
|
Scenario: Graph route with state class resolution
|
|
Given I have a configuration with graph routes and state class:
|
|
"""
|
|
agents:
|
|
graph_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
routes:
|
|
state_graph:
|
|
type: graph
|
|
state_class: "builtins.dict"
|
|
nodes:
|
|
start:
|
|
agent: graph_agent
|
|
edges:
|
|
- source: start
|
|
target: END
|
|
entry_point: start
|
|
"""
|
|
When I load the configuration
|
|
Then the state class should be resolved correctly
|
|
And the graph should be created with the state class
|
|
|
|
Scenario: Graph route with invalid state class
|
|
Given I have a configuration with invalid state class:
|
|
"""
|
|
agents:
|
|
graph_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
routes:
|
|
invalid_state_graph:
|
|
type: graph
|
|
state_class: "nonexistent.module.Class"
|
|
nodes:
|
|
start:
|
|
agent: graph_agent
|
|
edges:
|
|
- source: start
|
|
target: END
|
|
"""
|
|
When I load the configuration
|
|
Then a warning should be logged about the invalid state class
|
|
And the graph should still be created
|
|
|
|
Scenario: Route template instantiation
|
|
Given I have a configuration with route templates:
|
|
"""
|
|
agents:
|
|
template_route_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
routes:
|
|
templated_route:
|
|
template_config:
|
|
template: stream_template
|
|
params:
|
|
agent_name: template_route_agent
|
|
|
|
templates:
|
|
streams:
|
|
stream_template:
|
|
type: stream
|
|
stream_type: cold
|
|
agents:
|
|
- "{{agent_name}}"
|
|
"""
|
|
When I load the configuration
|
|
Then route templates should be instantiated
|
|
And template parameters should be applied to routes
|
|
|
|
Scenario: Stream operations setup with merges and splits
|
|
Given I have a configuration with merge and split operations:
|
|
"""
|
|
agents:
|
|
merge_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
routes:
|
|
source1:
|
|
type: stream
|
|
stream_type: cold
|
|
source2:
|
|
type: stream
|
|
stream_type: cold
|
|
target:
|
|
type: stream
|
|
stream_type: cold
|
|
operators:
|
|
- type: map
|
|
params:
|
|
agent: merge_agent
|
|
split_stream:
|
|
type: stream
|
|
stream_type: cold
|
|
|
|
merges:
|
|
- sources: [source1, source2]
|
|
target: target
|
|
|
|
splits:
|
|
- source: split_stream
|
|
targets:
|
|
positive: "content.startswith('good')"
|
|
negative: "content.startswith('bad')"
|
|
"""
|
|
When I load the configuration
|
|
Then merges should be set up correctly
|
|
And splits should be configured properly
|
|
And subscriptions should be re-setup after operations
|
|
|
|
Scenario: Hybrid pipeline setup
|
|
Given I have a configuration with hybrid pipelines:
|
|
"""
|
|
agents:
|
|
pipeline_agent:
|
|
type: llm
|
|
config:
|
|
provider: openai
|
|
model: gpt-3.5-turbo
|
|
|
|
pipelines:
|
|
hybrid_pipeline:
|
|
name: test_pipeline
|
|
stages:
|
|
- type: stream
|
|
config:
|
|
operators:
|
|
- type: map
|
|
params:
|
|
agent: pipeline_agent
|
|
- type: graph
|
|
config:
|
|
nodes:
|
|
process:
|
|
agent: pipeline_agent
|
|
metadata:
|
|
description: "Test hybrid pipeline"
|
|
"""
|
|
When I load the configuration
|
|
Then hybrid pipelines should be created
|
|
And the pipeline should be registered with the bridge
|
|
|
|
@skip
|
|
Scenario: Single-shot processing with timeout
|
|
Given I have a loaded application for single-shot testing
|
|
When I run single-shot processing with a slow operation
|
|
Then the operation should timeout after 3 seconds
|
|
And a timeout error should be raised
|
|
|
|
Scenario: Single-shot processing with None message handling
|
|
Given I have a loaded application that returns None messages
|
|
When I run single-shot processing with prompt "test"
|
|
Then the result should handle None messages gracefully
|
|
And return an empty string result
|
|
|
|
Scenario: Single-shot processing error handling
|
|
Given I have a loaded application for error testing
|
|
When I run single-shot processing that causes an error
|
|
Then the error should be wrapped in CleverAgentsException
|
|
And the original error should be preserved
|
|
|
|
Scenario: Interactive session with help command
|
|
Given I have a loaded application for interactive testing
|
|
When I start an interactive session and request help
|
|
Then help information should be displayed
|
|
And available commands should be shown
|
|
|
|
Scenario: Interactive session with stream commands
|
|
Given I have a loaded application with named streams
|
|
When I use stream commands in interactive session
|
|
Then messages should be sent to specific streams
|
|
And stream command errors should be handled
|
|
|
|
Scenario: Interactive session with graph commands
|
|
Given I have a loaded application with graph routes
|
|
When I use graph commands in interactive session
|
|
Then graphs should be executed with messages
|
|
And graph results should be displayed
|
|
|
|
Scenario: Interactive session with unknown streams and graphs
|
|
Given I have a loaded application for command testing
|
|
When I use commands with unknown streams or graphs
|
|
Then appropriate error messages should be shown
|
|
And available options should be listed
|
|
|
|
Scenario: Interactive session error handling
|
|
Given I have a loaded application for interactive error testing
|
|
When errors occur during interactive session
|
|
Then errors should be caught and displayed
|
|
And the session should continue running
|
|
|
|
Scenario: Network visualization with different formats
|
|
Given I have a complex application configuration
|
|
When I request network visualization in mermaid format
|
|
Then a mermaid network diagram should be generated
|
|
And agents, streams, and graphs should be shown
|
|
|
|
Scenario: Network visualization with unsupported format
|
|
Given I have a loaded application for visualization
|
|
When I request network visualization in unsupported format
|
|
Then an unsupported format message should be returned
|
|
|
|
Scenario: Application disposal and cleanup
|
|
Given I have a running application with active streams
|
|
When I perform application cleanup
|
|
Then all streams should be disposed
|
|
And cleanup should be logged
|
|
And resources should be freed
|
|
|
|
Scenario: Configuration without agents or routes
|
|
Given I have an empty configuration
|
|
When I try to load the configuration
|
|
Then the application should handle empty configuration
|
|
And no errors should occur for missing sections
|
|
|
|
Scenario: Agent factory error handling
|
|
Given I have a configuration that causes agent factory errors
|
|
When I try to load the configuration
|
|
Then agent creation errors should be properly handled
|
|
And meaningful error messages should be provided
|
|
|
|
Scenario: Agent type registration with built-in types
|
|
Given I have a configuration with various agent types
|
|
When I load the configuration
|
|
Then built-in agent types should be registered
|
|
And LLM and tool agents should be available
|
|
|
|
Scenario: Template renderer with different template types
|
|
Given I have a configuration with mixed template content types
|
|
When the templates are processed
|
|
Then string templates should be handled correctly
|
|
And dict templates should extract content properly
|
|
And invalid templates should be skipped
|
|
|
|
Scenario: Configuration to dict conversion
|
|
Given I have a reactive configuration
|
|
When the configuration is converted to dictionary format
|
|
Then agents should be properly mapped
|
|
And global context should be included
|
|
And prompts should be preserved
|
|
|
|
Scenario: Error stream subscription in interactive mode
|
|
Given I have an application with error handling
|
|
When I start interactive session with error streams
|
|
Then error observers should be set up
|
|
And errors should be displayed to user
|
|
|
|
Scenario: Tool command processing with valid JSON
|
|
Given I have an application with tool agents configured
|
|
And I have content with tool execution commands:
|
|
"""
|
|
Here is the result: [TOOL_EXECUTE:echo]{"text": "hello world"}[/TOOL_EXECUTE]
|
|
"""
|
|
When I process tool commands in the content
|
|
Then tool commands should be executed successfully
|
|
And the result should contain "hello world"
|
|
|
|
# Note: Tool command processing tests removed due to environment compatibility issues
|
|
# These tests require async execution context that conflicts with the test runner
|
|
|
|
Scenario: Dispose application with agent cleanup
|
|
Given an application with agents having cleanup
|
|
When disposing the application
|
|
Then all agent cleanup methods are called
|
|
|
|
Scenario: Dispose application with cleanup failure
|
|
Given an application with failing agent cleanup
|
|
When disposing the application
|
|
Then cleanup errors are logged as warnings
|
|
And disposal completes successfully
|
|
|
|
@skip
|
|
Scenario: Deferred initialization in run_single_shot
|
|
Given an app with deferred initialization
|
|
When calling run_single_shot
|
|
Then routes are initialized before execution
|
|
|
|
@skip
|
|
Scenario: Deferred initialization in interactive session
|
|
Given an app with deferred initialization
|
|
When starting interactive session
|
|
Then routes are initialized before session
|