599 lines
21 KiB
Python
599 lines
21 KiB
Python
"""Step definitions for streamed change models coverage tests."""
|
|
|
|
from behave import given, then, when
|
|
|
|
from cleveragents.domain.models.streamedchange.streamed_change import (
|
|
StreamedChangeSection,
|
|
StreamedChangeWithLineNums,
|
|
)
|
|
|
|
|
|
@given("I import the StreamedChangeSection class")
|
|
def step_import_streamed_change_section(context):
|
|
"""Import StreamedChangeSection class."""
|
|
context.model_class = StreamedChangeSection
|
|
context.error = None
|
|
context.instance = None
|
|
|
|
|
|
@given("I import the StreamedChangeWithLineNums class")
|
|
def step_import_streamed_change_with_line_nums(context):
|
|
"""Import StreamedChangeWithLineNums class."""
|
|
context.model_class = StreamedChangeWithLineNums
|
|
context.error = None
|
|
context.instance = None
|
|
|
|
|
|
@when("I create a StreamedChangeSection with start_line {line:d}")
|
|
def step_create_section_with_start_line(context, line):
|
|
"""Create StreamedChangeSection with start_line."""
|
|
context.start_line = line
|
|
context.end_line = None
|
|
context.start_line_string = None
|
|
context.end_line_string = None
|
|
|
|
|
|
@when("I set end_line to {line:d}")
|
|
def step_set_end_line(context, line):
|
|
"""Set end_line field."""
|
|
context.end_line = line
|
|
|
|
|
|
@when('I set start_line_string to "{text}"')
|
|
def step_set_start_line_string(context, text):
|
|
"""Set start_line_string field."""
|
|
context.start_line_string = text
|
|
|
|
|
|
@when('I set end_line_string to "{text}"')
|
|
def step_set_end_line_string(context, text):
|
|
"""Set end_line_string field."""
|
|
context.end_line_string = text
|
|
# Create the instance now that all fields are set
|
|
if hasattr(context, "start_line"):
|
|
try:
|
|
context.instance = StreamedChangeSection(
|
|
start_line=context.start_line,
|
|
end_line=context.end_line,
|
|
start_line_string=context.start_line_string,
|
|
end_line_string=context.end_line_string,
|
|
)
|
|
except Exception as e:
|
|
context.error = e
|
|
|
|
|
|
@then("the StreamedChangeSection instance should be created successfully")
|
|
def step_section_created_successfully(context):
|
|
"""Verify StreamedChangeSection instance was created."""
|
|
assert context.instance is not None, (
|
|
"StreamedChangeSection instance was not created"
|
|
)
|
|
assert isinstance(context.instance, StreamedChangeSection), (
|
|
"Instance is not StreamedChangeSection"
|
|
)
|
|
assert context.error is None, f"Unexpected error: {context.error}"
|
|
|
|
|
|
@then("the start_line should be {line:d}")
|
|
def step_verify_start_line(context, line):
|
|
"""Verify the start_line value."""
|
|
assert context.instance.start_line == line, (
|
|
f"Expected start_line {line}, got {context.instance.start_line}"
|
|
)
|
|
|
|
|
|
@then("the end_line should be {line:d}")
|
|
def step_verify_end_line(context, line):
|
|
"""Verify the end_line value."""
|
|
assert context.instance.end_line == line, (
|
|
f"Expected end_line {line}, got {context.instance.end_line}"
|
|
)
|
|
|
|
|
|
@then('the start_line_string should be "{text}"')
|
|
def step_verify_start_line_string(context, text):
|
|
"""Verify the start_line_string value."""
|
|
assert context.instance.start_line_string == text, (
|
|
f"Expected start_line_string '{text}', got '{context.instance.start_line_string}'"
|
|
)
|
|
|
|
|
|
@then('the end_line_string should be "{text}"')
|
|
def step_verify_end_line_string(context, text):
|
|
"""Verify the end_line_string value."""
|
|
assert context.instance.end_line_string == text, (
|
|
f"Expected end_line_string '{text}', got '{context.instance.end_line_string}'"
|
|
)
|
|
|
|
|
|
@when("I create a StreamedChangeSection using aliases")
|
|
def step_create_section_using_aliases(context):
|
|
"""Create StreamedChangeSection using field aliases."""
|
|
try:
|
|
context.instance = StreamedChangeSection(
|
|
startLine=15,
|
|
endLine=25,
|
|
startLineString="function start",
|
|
endLineString="function end",
|
|
)
|
|
context.error = None
|
|
except Exception as e:
|
|
context.error = e
|
|
|
|
|
|
@then("the StreamedChangeSection should accept the aliased fields")
|
|
def step_section_accepts_aliases(context):
|
|
"""Verify StreamedChangeSection accepts aliased fields."""
|
|
assert context.instance is not None
|
|
assert context.error is None
|
|
|
|
|
|
@then("the section values should be properly mapped")
|
|
def step_section_values_mapped(context):
|
|
"""Verify section values are properly mapped."""
|
|
assert context.instance.start_line == 15
|
|
assert context.instance.end_line == 25
|
|
assert context.instance.start_line_string == "function start"
|
|
assert context.instance.end_line_string == "function end"
|
|
|
|
|
|
@when("I create a StreamedChangeSection with valid data")
|
|
def step_create_section_with_valid_data(context):
|
|
"""Create StreamedChangeSection with valid data for configuration testing."""
|
|
context.instance = StreamedChangeSection(
|
|
start_line=1, end_line=10, start_line_string="start", end_line_string="end"
|
|
)
|
|
|
|
|
|
@then("the section configuration should have str_strip_whitespace as {value}")
|
|
def step_verify_section_str_strip_whitespace(context, value):
|
|
"""Verify section str_strip_whitespace configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["str_strip_whitespace"] == expected
|
|
|
|
|
|
@then("the section configuration should have validate_assignment as {value}")
|
|
def step_verify_section_validate_assignment(context, value):
|
|
"""Verify section validate_assignment configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["validate_assignment"] == expected
|
|
|
|
|
|
@then("the section configuration should have arbitrary_types_allowed as {value}")
|
|
def step_verify_section_arbitrary_types_allowed(context, value):
|
|
"""Verify section arbitrary_types_allowed configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["arbitrary_types_allowed"] == expected
|
|
|
|
|
|
@then("the section configuration should have populate_by_name as {value}")
|
|
def step_verify_section_populate_by_name(context, value):
|
|
"""Verify section populate_by_name configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["populate_by_name"] == expected
|
|
|
|
|
|
@then("the section configuration should have use_enum_values as {value}")
|
|
def step_verify_section_use_enum_values(context, value):
|
|
"""Verify section use_enum_values configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["use_enum_values"] == expected
|
|
|
|
|
|
@given("I have a valid StreamedChangeSection for old section")
|
|
def step_create_valid_section_for_old(context):
|
|
"""Create a valid StreamedChangeSection for use as old section."""
|
|
context.old_section = StreamedChangeSection(
|
|
start_line=10,
|
|
end_line=20,
|
|
start_line_string="def old_function():",
|
|
end_line_string=" return old_value",
|
|
)
|
|
|
|
|
|
@when("I create a StreamedChangeWithLineNums with the old section")
|
|
def step_create_change_with_old_section(context):
|
|
"""Create StreamedChangeWithLineNums with old section."""
|
|
context.old = context.old_section
|
|
context.start_line_included = None
|
|
context.end_line_included = None
|
|
context.new = None
|
|
|
|
|
|
@when("I set start_line_included to {value}")
|
|
def step_set_start_line_included(context, value):
|
|
"""Set start_line_included field."""
|
|
context.start_line_included = value.lower() == "true"
|
|
|
|
|
|
@when("I set end_line_included to {value}")
|
|
def step_set_end_line_included(context, value):
|
|
"""Set end_line_included field."""
|
|
context.end_line_included = value.lower() == "true"
|
|
|
|
|
|
@when('I set new content to "{text}"')
|
|
def step_set_new_content(context, text):
|
|
"""Set new content field."""
|
|
context.new = text
|
|
# Create the instance now that all fields are set
|
|
if hasattr(context, "old"):
|
|
try:
|
|
context.instance = StreamedChangeWithLineNums(
|
|
old=context.old,
|
|
start_line_included=context.start_line_included,
|
|
end_line_included=context.end_line_included,
|
|
new=context.new,
|
|
)
|
|
except Exception as e:
|
|
context.error = e
|
|
|
|
|
|
@when('I set new content to ""')
|
|
def step_set_empty_new_content(context):
|
|
"""Set new content to empty string."""
|
|
context.new = ""
|
|
# Create the instance now that all fields are set
|
|
if hasattr(context, "old"):
|
|
try:
|
|
context.instance = StreamedChangeWithLineNums(
|
|
old=context.old,
|
|
start_line_included=context.start_line_included,
|
|
end_line_included=context.end_line_included,
|
|
new=context.new,
|
|
)
|
|
except Exception as e:
|
|
context.error = e
|
|
|
|
|
|
@then("the StreamedChangeWithLineNums instance should be created successfully")
|
|
def step_change_created_successfully(context):
|
|
"""Verify StreamedChangeWithLineNums instance was created."""
|
|
assert context.instance is not None, (
|
|
"StreamedChangeWithLineNums instance was not created"
|
|
)
|
|
assert isinstance(context.instance, StreamedChangeWithLineNums), (
|
|
"Instance is not StreamedChangeWithLineNums"
|
|
)
|
|
assert context.error is None, f"Unexpected error: {context.error}"
|
|
|
|
|
|
@then("the old section should match the provided section")
|
|
def step_verify_old_section(context):
|
|
"""Verify the old section matches."""
|
|
assert context.instance.old == context.old_section
|
|
|
|
|
|
@then("the start_line_included should be {value}")
|
|
def step_verify_start_line_included(context, value):
|
|
"""Verify start_line_included value."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.start_line_included == expected
|
|
|
|
|
|
@then("the end_line_included should be {value}")
|
|
def step_verify_end_line_included(context, value):
|
|
"""Verify end_line_included value."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.end_line_included == expected
|
|
|
|
|
|
@then('the new content should be "{text}"')
|
|
def step_verify_new_content(context, text):
|
|
"""Verify new content value."""
|
|
assert context.instance.new == text
|
|
|
|
|
|
@then('the new content should be ""')
|
|
def step_verify_empty_new_content(context):
|
|
"""Verify new content is empty."""
|
|
assert context.instance.new == ""
|
|
|
|
|
|
@when("I set new content to multiline text")
|
|
def step_set_multiline_new_content(context):
|
|
"""Set new content to multiline text."""
|
|
context.new = """def new_function():
|
|
# This is a new implementation
|
|
value = compute_value()
|
|
return value * 2"""
|
|
# Create the instance
|
|
if hasattr(context, "old"):
|
|
try:
|
|
context.instance = StreamedChangeWithLineNums(
|
|
old=context.old,
|
|
start_line_included=context.start_line_included,
|
|
end_line_included=context.end_line_included,
|
|
new=context.new,
|
|
)
|
|
except Exception as e:
|
|
context.error = e
|
|
|
|
|
|
@then("the new content should contain multiple lines")
|
|
def step_verify_multiline_content(context):
|
|
"""Verify new content contains multiple lines."""
|
|
assert "\n" in context.instance.new
|
|
assert len(context.instance.new.split("\n")) > 1
|
|
|
|
|
|
@when("I create a StreamedChangeWithLineNums using aliases")
|
|
def step_create_change_using_aliases(context):
|
|
"""Create StreamedChangeWithLineNums using field aliases."""
|
|
try:
|
|
context.instance = StreamedChangeWithLineNums(
|
|
old=context.old_section,
|
|
startLineIncluded=True,
|
|
endLineIncluded=False,
|
|
new="replacement text",
|
|
)
|
|
context.error = None
|
|
except Exception as e:
|
|
context.error = e
|
|
|
|
|
|
@then("the StreamedChangeWithLineNums should accept the aliased fields")
|
|
def step_change_accepts_aliases(context):
|
|
"""Verify StreamedChangeWithLineNums accepts aliased fields."""
|
|
assert context.instance is not None
|
|
assert context.error is None
|
|
|
|
|
|
@then("the change values should be properly mapped")
|
|
def step_change_values_mapped(context):
|
|
"""Verify change values are properly mapped."""
|
|
assert context.instance.start_line_included is True
|
|
assert context.instance.end_line_included is False
|
|
assert context.instance.new == "replacement text"
|
|
|
|
|
|
@when("I create a StreamedChangeWithLineNums with valid data")
|
|
def step_create_change_with_valid_data(context):
|
|
"""Create StreamedChangeWithLineNums with valid data for configuration testing."""
|
|
section = StreamedChangeSection(
|
|
start_line=1, end_line=5, start_line_string="start", end_line_string="end"
|
|
)
|
|
context.instance = StreamedChangeWithLineNums(
|
|
old=section, start_line_included=True, end_line_included=True, new="new content"
|
|
)
|
|
|
|
|
|
@then("the change configuration should have str_strip_whitespace as {value}")
|
|
def step_verify_change_str_strip_whitespace(context, value):
|
|
"""Verify change str_strip_whitespace configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["str_strip_whitespace"] == expected
|
|
|
|
|
|
@then("the change configuration should have validate_assignment as {value}")
|
|
def step_verify_change_validate_assignment(context, value):
|
|
"""Verify change validate_assignment configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["validate_assignment"] == expected
|
|
|
|
|
|
@then("the change configuration should have arbitrary_types_allowed as {value}")
|
|
def step_verify_change_arbitrary_types_allowed(context, value):
|
|
"""Verify change arbitrary_types_allowed configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["arbitrary_types_allowed"] == expected
|
|
|
|
|
|
@then("the change configuration should have populate_by_name as {value}")
|
|
def step_verify_change_populate_by_name(context, value):
|
|
"""Verify change populate_by_name configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["populate_by_name"] == expected
|
|
|
|
|
|
@then("the change configuration should have use_enum_values as {value}")
|
|
def step_verify_change_use_enum_values(context, value):
|
|
"""Verify change use_enum_values configuration."""
|
|
expected = value.lower() == "true"
|
|
assert context.instance.model_config["use_enum_values"] == expected
|
|
|
|
|
|
@when("I create a StreamedChangeSection with whitespace in strings")
|
|
def step_create_section_with_whitespace(context):
|
|
"""Create StreamedChangeSection with whitespace in strings."""
|
|
try:
|
|
context.instance = StreamedChangeSection(
|
|
start_line=1,
|
|
end_line=2,
|
|
start_line_string=" trimmed start ",
|
|
end_line_string=" trimmed end ",
|
|
)
|
|
context.error = None
|
|
except Exception as e:
|
|
context.error = e
|
|
|
|
|
|
@then("the whitespace should be stripped from string fields")
|
|
def step_whitespace_stripped_from_strings(context):
|
|
"""Verify whitespace is stripped from string fields."""
|
|
assert context.instance.start_line_string == "trimmed start"
|
|
assert context.instance.end_line_string == "trimmed end"
|
|
|
|
|
|
@then("the section should be created successfully")
|
|
def step_section_created_ok(context):
|
|
"""Verify section was created successfully."""
|
|
assert context.instance is not None
|
|
assert context.error is None
|
|
|
|
|
|
@when("I create a StreamedChangeWithLineNums with whitespace in new content")
|
|
def step_create_change_with_whitespace_new(context):
|
|
"""Create StreamedChangeWithLineNums with whitespace in new content."""
|
|
try:
|
|
context.instance = StreamedChangeWithLineNums(
|
|
old=context.old_section,
|
|
start_line_included=True,
|
|
end_line_included=True,
|
|
new=" trimmed new content ",
|
|
)
|
|
context.error = None
|
|
except Exception as e:
|
|
context.error = e
|
|
|
|
|
|
@then("the whitespace should be stripped from new field")
|
|
def step_whitespace_stripped_from_new(context):
|
|
"""Verify whitespace is stripped from new field."""
|
|
assert context.instance.new == "trimmed new content"
|
|
|
|
|
|
@then("the change should be created successfully")
|
|
def step_change_created_ok(context):
|
|
"""Verify change was created successfully."""
|
|
assert context.instance is not None
|
|
assert context.error is None
|
|
|
|
|
|
@when("I create a complex StreamedChangeWithLineNums")
|
|
def step_create_complex_change(context):
|
|
"""Create a complex StreamedChangeWithLineNums with nested section."""
|
|
nested_section = StreamedChangeSection(
|
|
start_line=100,
|
|
end_line=200,
|
|
start_line_string="class ComplexClass:",
|
|
end_line_string="# End of ComplexClass",
|
|
)
|
|
context.instance = StreamedChangeWithLineNums(
|
|
old=nested_section,
|
|
start_line_included=False,
|
|
end_line_included=True,
|
|
new="# Completely new implementation",
|
|
)
|
|
|
|
|
|
@then("the nested StreamedChangeSection should be accessible")
|
|
def step_verify_nested_section(context):
|
|
"""Verify nested StreamedChangeSection is accessible."""
|
|
assert context.instance.old is not None
|
|
assert isinstance(context.instance.old, StreamedChangeSection)
|
|
|
|
|
|
@then("all nested fields should be properly initialized")
|
|
def step_verify_nested_fields(context):
|
|
"""Verify all nested fields are properly initialized."""
|
|
assert context.instance.old.start_line == 100
|
|
assert context.instance.old.end_line == 200
|
|
assert context.instance.old.start_line_string == "class ComplexClass:"
|
|
assert context.instance.old.end_line_string == "# End of ComplexClass"
|
|
|
|
|
|
@when("I create a StreamedChangeSection with special characters")
|
|
def step_create_section_with_special_chars(context):
|
|
"""Create StreamedChangeSection with special characters."""
|
|
context.instance = StreamedChangeSection(
|
|
start_line=1,
|
|
end_line=2,
|
|
start_line_string="print('Hello, 世界! 🌍')",
|
|
end_line_string="# Comment with émojis 😀 and ñoñ-ASCII",
|
|
)
|
|
|
|
|
|
@then("the special characters should be preserved")
|
|
def step_verify_special_chars_preserved(context):
|
|
"""Verify special characters are preserved."""
|
|
assert "世界" in context.instance.start_line_string
|
|
assert "🌍" in context.instance.start_line_string
|
|
assert "😀" in context.instance.end_line_string
|
|
assert "ñ" in context.instance.end_line_string
|
|
|
|
|
|
@then("the section should handle unicode properly")
|
|
def step_verify_unicode_handling(context):
|
|
"""Verify section handles unicode properly."""
|
|
assert context.instance is not None
|
|
# Verify the strings are properly stored
|
|
assert len(context.instance.start_line_string) > 0
|
|
assert len(context.instance.end_line_string) > 0
|
|
|
|
|
|
@when("I create a StreamedChangeSection with different field types")
|
|
def step_create_section_with_different_types(context):
|
|
"""Create StreamedChangeSection to test field types."""
|
|
context.instance = StreamedChangeSection(
|
|
start_line=42,
|
|
end_line=100,
|
|
start_line_string="string value",
|
|
end_line_string="another string",
|
|
)
|
|
|
|
|
|
@then("the integer fields should be validated")
|
|
def step_verify_integer_fields(context):
|
|
"""Verify integer fields are validated."""
|
|
assert isinstance(context.instance.start_line, int)
|
|
assert isinstance(context.instance.end_line, int)
|
|
|
|
|
|
@then("the string fields should be validated")
|
|
def step_verify_string_fields(context):
|
|
"""Verify string fields are validated."""
|
|
assert isinstance(context.instance.start_line_string, str)
|
|
assert isinstance(context.instance.end_line_string, str)
|
|
|
|
|
|
@when("I create a StreamedChangeWithLineNums with different field types")
|
|
def step_create_change_with_different_types(context):
|
|
"""Create StreamedChangeWithLineNums to test field types."""
|
|
context.instance = StreamedChangeWithLineNums(
|
|
old=context.old_section,
|
|
start_line_included=True,
|
|
end_line_included=False,
|
|
new="test string",
|
|
)
|
|
|
|
|
|
@then("the boolean fields should be validated")
|
|
def step_verify_boolean_fields(context):
|
|
"""Verify boolean fields are validated."""
|
|
assert isinstance(context.instance.start_line_included, bool)
|
|
assert isinstance(context.instance.end_line_included, bool)
|
|
|
|
|
|
@then("the nested object should be validated")
|
|
def step_verify_nested_object(context):
|
|
"""Verify nested object is validated."""
|
|
assert isinstance(context.instance.old, StreamedChangeSection)
|
|
assert isinstance(context.instance.new, str)
|
|
|
|
|
|
@given("I have a StreamedChangeSection representing lines to delete")
|
|
def step_create_section_for_deletion(context):
|
|
"""Create a StreamedChangeSection representing lines to delete."""
|
|
context.deletion_section = StreamedChangeSection(
|
|
start_line=50,
|
|
end_line=60,
|
|
start_line_string="# Old code to remove",
|
|
end_line_string="# End of old code",
|
|
)
|
|
|
|
|
|
@when("I create a StreamedChangeWithLineNums for deletion")
|
|
def step_create_change_for_deletion(context):
|
|
"""Create StreamedChangeWithLineNums for deletion."""
|
|
context.old = context.deletion_section
|
|
context.start_line_included = None
|
|
context.end_line_included = None
|
|
context.new = None
|
|
|
|
|
|
@then("the StreamedChangeWithLineNums instance should represent a deletion")
|
|
def step_verify_deletion_representation(context):
|
|
"""Verify the instance represents a deletion."""
|
|
assert context.instance.new == ""
|
|
assert context.instance.start_line_included is True
|
|
assert context.instance.end_line_included is True
|
|
|
|
|
|
@then("the old section should contain the deleted content")
|
|
def step_verify_deleted_content(context):
|
|
"""Verify old section contains the deleted content."""
|
|
assert context.instance.old.start_line == 50
|
|
assert context.instance.old.end_line == 60
|
|
assert "Old code to remove" in context.instance.old.start_line_string
|