forked from cleveragents/cleveragents-core
363 lines
12 KiB
Gherkin
363 lines
12 KiB
Gherkin
Feature: Smart YAML Loader Coverage
|
|
As a developer
|
|
I want comprehensive test coverage for SmartYAMLLoader
|
|
So that all functionality is properly tested and validated
|
|
|
|
Background:
|
|
Given the SmartYAMLLoader is available
|
|
|
|
Scenario: Load simple YAML without templates
|
|
Given I have a simple YAML string without templates
|
|
"""
|
|
name: simple_config
|
|
version: 1.0
|
|
settings:
|
|
debug: true
|
|
max_items: 100
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then the parsed YAML should be correct
|
|
And the template sections should be empty
|
|
|
|
Scenario: Load YAML file without templates
|
|
Given I have a YAML file "simple.yaml" without templates
|
|
"""
|
|
database:
|
|
host: localhost
|
|
port: 5432
|
|
name: testdb
|
|
features:
|
|
- authentication
|
|
- logging
|
|
- caching
|
|
"""
|
|
When I load the YAML file using SmartYAMLLoader
|
|
Then the parsed YAML should match the file content
|
|
And no template sections should be extracted
|
|
|
|
Scenario: Load YAML with inline Jinja2 template in value
|
|
Given I have a YAML string with inline template
|
|
"""
|
|
app:
|
|
name: myapp
|
|
debug: true
|
|
welcome_message: "Hello {{ user.name }}, welcome to {{ app.title }}!"
|
|
port: 8080
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then the template should be extracted from welcome_message
|
|
And the parsed YAML should have template placeholder
|
|
And the template sections should contain the original template
|
|
|
|
Scenario: Load YAML with multiple inline templates
|
|
Given I have a YAML string with multiple inline templates
|
|
"""
|
|
config:
|
|
title: "{{ site.title | default('My Site') }}"
|
|
description: "{{ site.description }}"
|
|
footer: "Copyright {{ current_year }}"
|
|
normal_field: "no template here"
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then multiple template sections should be extracted
|
|
And each template should have unique identifiers
|
|
And the parsed YAML should have multiple template placeholders
|
|
|
|
Scenario: Load YAML with Jinja2 for loop block
|
|
Given I have a YAML string with for loop template
|
|
"""
|
|
navigation:
|
|
items:
|
|
{% for item in menu_items %}
|
|
- name: "{{ item.name }}"
|
|
url: "{{ item.url }}"
|
|
active: {{ item.active }}
|
|
{% endfor %}
|
|
content:
|
|
static: "This is static content"
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then the for loop template should be extracted
|
|
And the template should preserve proper indentation
|
|
And the key should be correctly identified
|
|
|
|
Scenario: Load YAML with Jinja2 if-else block
|
|
Given I have a YAML string with if block template
|
|
"""
|
|
config:
|
|
auth_section:
|
|
{% if enable_auth %}
|
|
authentication:
|
|
type: oauth2
|
|
provider: google
|
|
{% endif %}
|
|
other_config:
|
|
logging:
|
|
level: info
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then the if block template should be extracted
|
|
And the template block should include endif
|
|
And the template key should be identified correctly
|
|
|
|
Scenario: Load YAML with Jinja2 macro block
|
|
Given I have a YAML string with macro template
|
|
"""
|
|
helpers:
|
|
{% macro render_button(text, class) %}
|
|
button:
|
|
text: "{{ text }}"
|
|
class: "{{ class }}"
|
|
type: submit
|
|
{% endmacro %}
|
|
forms:
|
|
login: "Standard form"
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then the macro template should be extracted
|
|
And the macro definition should be preserved
|
|
And the endmacro should be included
|
|
|
|
Scenario: Load YAML with nested template blocks
|
|
Given I have a YAML string with nested templates
|
|
"""
|
|
pages:
|
|
{% for page in site.pages %}
|
|
- title: "{{ page.title }}"
|
|
content:
|
|
{% if page.has_sidebar %}
|
|
sidebar:
|
|
widgets:
|
|
{% for widget in page.widgets %}
|
|
- type: "{{ widget.type }}"
|
|
config: {{ widget.config | tojson }}
|
|
{% endfor %}
|
|
{% endif %}
|
|
footer: "{{ page.footer }}"
|
|
{% endfor %}
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then nested templates should be handled correctly
|
|
And proper indentation should be maintained
|
|
And all template blocks should be extracted
|
|
|
|
Scenario: Load YAML with mixed templates and regular content
|
|
Given I have a YAML string with mixed content
|
|
"""
|
|
app:
|
|
name: "{{ app.name }}"
|
|
version: "1.0.0"
|
|
features:
|
|
{% for feature in app.features %}
|
|
- name: "{{ feature.name }}"
|
|
enabled: {{ feature.enabled }}
|
|
{% endfor %}
|
|
database:
|
|
host: localhost
|
|
port: 5432
|
|
api:
|
|
base_url: "{{ api.base_url }}"
|
|
timeout: 30
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then both inline and block templates should be extracted
|
|
And regular YAML content should remain unchanged
|
|
And template placeholders should be properly inserted
|
|
|
|
Scenario: Handle YAML parsing errors gracefully
|
|
Given I have invalid YAML with templates
|
|
"""
|
|
app:
|
|
name: "{{ app.name }}"
|
|
invalid_yaml: [unclosed list
|
|
port: 8080
|
|
"""
|
|
When I load the invalid YAML string
|
|
Then a YAML parsing error should be raised
|
|
And the error should include debug information
|
|
And the error should be logged
|
|
|
|
Scenario: TemplateDefinitionStore initialization
|
|
Given I need to test TemplateDefinitionStore
|
|
When I create a new TemplateDefinitionStore instance
|
|
Then it should have a SmartYAMLLoader instance
|
|
And it should have empty definitions and template sections
|
|
|
|
Scenario: TemplateDefinitionStore load_config without templates
|
|
Given I have a TemplateDefinitionStore instance
|
|
And I have a config without templates section
|
|
"""
|
|
app:
|
|
name: myapp
|
|
version: 1.0
|
|
database:
|
|
host: localhost
|
|
"""
|
|
When I load the config using TemplateDefinitionStore
|
|
Then the config should be returned unchanged
|
|
And no template definitions should be stored
|
|
|
|
Scenario: TemplateDefinitionStore load_config with templates
|
|
Given I have a TemplateDefinitionStore instance
|
|
And I have a config with templates section
|
|
"""
|
|
templates:
|
|
agents:
|
|
chat_agent:
|
|
type: llm
|
|
config:
|
|
model: "{{ model_name }}"
|
|
temperature: __TEMPLATE:_template_0__
|
|
routes:
|
|
main_route:
|
|
type: stream
|
|
operators: __TEMPLATE:_template_1__
|
|
other:
|
|
data: value
|
|
"""
|
|
When I load the config using TemplateDefinitionStore
|
|
Then templates should be processed correctly
|
|
And template definitions should be marked for deferred processing
|
|
And definition IDs should be generated
|
|
|
|
Scenario: TemplateDefinitionStore contains_template_markers detection
|
|
Given I have a TemplateDefinitionStore instance
|
|
When I check various data types for template markers
|
|
| data_type | value | has_markers |
|
|
| string | __TEMPLATE:_template_0__ | true |
|
|
| string | normal string | false |
|
|
| dict | {"key": "__TEMPLATE:_template_0__"} | true |
|
|
| dict | {"key": "normal"} | false |
|
|
| list | ["__TEMPLATE:_template_0__"] | true |
|
|
| list | ["normal", "values"] | false |
|
|
| int | 123 | false |
|
|
Then template marker detection should work correctly
|
|
|
|
Scenario: TemplateDefinitionStore get_definition
|
|
Given I have a TemplateDefinitionStore instance
|
|
And I have stored a template definition with ID "agents:test"
|
|
When I get the definition for ID "agents:test"
|
|
Then the stored definition should be returned
|
|
When I get a definition for non-existent ID "missing:id"
|
|
Then None should be returned
|
|
|
|
Scenario: TemplateDefinitionStore render_definition
|
|
Given I have a TemplateDefinitionStore instance
|
|
And I have a stored template definition with templates
|
|
And I have template sections with original content
|
|
And I have a template rendering context
|
|
When I render the definition with context
|
|
Then the template should be properly rendered
|
|
And Jinja2 expressions should be evaluated
|
|
|
|
Scenario: TemplateDefinitionStore render_definition with missing ID
|
|
Given I have a TemplateDefinitionStore instance
|
|
When I try to render a definition with non-existent ID
|
|
Then a ValueError should be raised
|
|
And the error message should mention the missing definition
|
|
|
|
Scenario: TemplateDefinitionStore reconstruct_yaml with string templates
|
|
Given I have a TemplateDefinitionStore instance
|
|
And I have data with string template markers
|
|
And I have corresponding template sections
|
|
When I reconstruct the YAML
|
|
Then the original template syntax should be restored
|
|
And inline templates should be properly formatted
|
|
|
|
Scenario: TemplateDefinitionStore reconstruct_yaml with block templates
|
|
Given I have a TemplateDefinitionStore instance
|
|
And I have data with block template markers
|
|
And I have multi-line template sections
|
|
When I reconstruct the YAML
|
|
Then block templates should be properly indented
|
|
And template keys should be correctly formatted
|
|
|
|
Scenario: TemplateDefinitionStore reconstruct_yaml with complex structures
|
|
Given I have a TemplateDefinitionStore instance
|
|
And I have nested data structures with templates
|
|
"""
|
|
{
|
|
"level1": {
|
|
"level2": {
|
|
"template_field": "__TEMPLATE:_template_0__",
|
|
"normal_field": "value"
|
|
},
|
|
"list_field": [
|
|
"__TEMPLATE:_template_1__",
|
|
"normal_item"
|
|
]
|
|
},
|
|
"empty_field": null
|
|
}
|
|
"""
|
|
When I reconstruct the YAML with proper template sections
|
|
Then nested structures should be handled correctly
|
|
And lists should be properly formatted
|
|
And null values should be handled
|
|
|
|
Scenario: SmartYAMLLoader regex pattern matching
|
|
Given I have a SmartYAMLLoader instance
|
|
When I test the template pattern regex
|
|
| text | should_match |
|
|
| "{{ variable }}" | true |
|
|
| "{% for item %}" | true |
|
|
| "{# comment #}" | false |
|
|
| "{{ nested.value }}" | true |
|
|
| "{% if condition %}" | true |
|
|
| "normal text" | false |
|
|
| "{{ complex\|filter }}" | true |
|
|
Then the regex should match Jinja2 templates correctly
|
|
|
|
Scenario: SmartYAMLLoader template block detection edge cases
|
|
Given I have a YAML string with edge case templates
|
|
"""
|
|
config:
|
|
# This should not be detected as template
|
|
comment: "# Not a template"
|
|
# This should be detected
|
|
template_value: "{{ value }}"
|
|
nested:
|
|
{% if condition %}
|
|
inner:
|
|
value: "{{ inner.value }}"
|
|
{% endif %}
|
|
after: "normal value"
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then only actual templates should be extracted
|
|
And comments should be ignored
|
|
And nested templates should be properly handled
|
|
|
|
Scenario: SmartYAMLLoader with deeply nested template blocks
|
|
Given I have a YAML string with deeply nested templates
|
|
"""
|
|
levels:
|
|
level1:
|
|
level2:
|
|
level3:
|
|
{% for item in deep.items %}
|
|
- name: "{{ item.name }}"
|
|
details:
|
|
{% if item.has_details %}
|
|
description: "{{ item.description }}"
|
|
{% endif %}
|
|
{% endfor %}
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then deep nesting should be handled correctly
|
|
And indentation should be preserved accurately
|
|
And template structure should be maintained
|
|
|
|
Scenario: SmartYAMLLoader template block without proper key association
|
|
Given I have a YAML string with orphaned template block
|
|
"""
|
|
{% for item in orphaned %}
|
|
- value: "{{ item }}"
|
|
{% endfor %}
|
|
normal:
|
|
key: value
|
|
"""
|
|
When I load the YAML string using SmartYAMLLoader
|
|
Then orphaned templates should be handled gracefully
|
|
And processing should not fail
|
|
And valid YAML parts should still be parsed |