forked from HAL9000/cleveragents-core
khyari hamza
cc45b5ff2c
Implement GitWorktreeSandbox (worktree creation, commit+merge, rollback, cleanup, branch sanitization, git timeouts) and CopyOnWriteSandbox (directory copy, diff-based commit, rollback, cleanup). Update SandboxFactory to wire new strategies, remove stale overlay/ versioning constants, add snapshot placeholder, align resource type mapping to spec types (git-checkout, fs-mount, fs-directory, fs-file). Add 40 Behave scenarios (19 git_worktree + 21 copy_on_write) with gwt/cow prefixed steps. Update existing sandbox_factory_coverage feature (21 scenarios) to reflect new factory behavior. All quality gates pass: ruff, pyright, 2325 scenarios, 97% coverage. TASK-006 / Stage B4
379 lines
14 KiB
Python
379 lines
14 KiB
Python
"""Step definitions for sandbox factory strategy routing coverage.
|
|
|
|
Covers lines in ``factory.py``:
|
|
- Empty resource_id / original_path validation
|
|
- none strategy -> NoSandbox
|
|
- git_worktree strategy -> GitWorktreeSandbox
|
|
- copy_on_write strategy -> CopyOnWriteSandbox
|
|
- transaction_rollback / snapshot -> NotImplementedError
|
|
- overlay / versioning (removed) -> ValueError (unknown)
|
|
- Unknown strategy -> ValueError
|
|
- is_supported() for all strategies
|
|
- get_supported_strategies() for spec-aligned resource types
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from behave import given, then, when
|
|
|
|
from cleveragents.infrastructure.sandbox.copy_on_write import CopyOnWriteSandbox
|
|
from cleveragents.infrastructure.sandbox.factory import SandboxFactory
|
|
from cleveragents.infrastructure.sandbox.git_worktree import GitWorktreeSandbox
|
|
from cleveragents.infrastructure.sandbox.no_sandbox import NoSandbox
|
|
from cleveragents.infrastructure.sandbox.protocol import SandboxStatus
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Givens
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("the sandbox factory is available")
|
|
def given_sandbox_factory_available(context):
|
|
"""Instantiate a SandboxFactory for the scenario."""
|
|
context.sandbox_factory = SandboxFactory()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Whens - create_sandbox
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@when("a sandbox is requested with an empty resource identifier")
|
|
def when_factory_empty_resource_id(context):
|
|
"""Attempt to create a sandbox with an empty resource_id."""
|
|
context.factory_error = None
|
|
try:
|
|
context.sandbox_factory.create_sandbox(
|
|
resource_id="",
|
|
original_path="/some/path",
|
|
sandbox_strategy="none",
|
|
)
|
|
except ValueError as exc:
|
|
context.factory_error = exc
|
|
|
|
|
|
@when("a sandbox is requested with an empty resource path")
|
|
def when_factory_empty_path(context):
|
|
"""Attempt to create a sandbox with an empty original_path."""
|
|
context.factory_error = None
|
|
try:
|
|
context.sandbox_factory.create_sandbox(
|
|
resource_id="res-1",
|
|
original_path="",
|
|
sandbox_strategy="none",
|
|
)
|
|
except ValueError as exc:
|
|
context.factory_error = exc
|
|
|
|
|
|
@when(
|
|
'a sandbox is requested for resource "{res_id}" at "{path}" using the none strategy'
|
|
)
|
|
def when_factory_none_strategy(context, res_id: str, path: str):
|
|
"""Request a sandbox with the 'none' (passthrough) strategy."""
|
|
context.factory_error = None
|
|
context.factory_sandbox = context.sandbox_factory.create_sandbox(
|
|
resource_id=res_id,
|
|
original_path=path,
|
|
sandbox_strategy="none",
|
|
)
|
|
|
|
|
|
@when(
|
|
'a sandbox is requested for resource "{res_id}" at "{path}" '
|
|
"using the git worktree strategy"
|
|
)
|
|
def when_factory_git_worktree(context, res_id: str, path: str):
|
|
"""Request a sandbox with the 'git_worktree' strategy."""
|
|
context.factory_error = None
|
|
context.factory_sandbox = context.sandbox_factory.create_sandbox(
|
|
resource_id=res_id,
|
|
original_path=path,
|
|
sandbox_strategy="git_worktree",
|
|
)
|
|
|
|
|
|
@when(
|
|
'a sandbox is requested for resource "{res_id}" at "{path}" '
|
|
"using the copy-on-write strategy"
|
|
)
|
|
def when_factory_copy_on_write(context, res_id: str, path: str):
|
|
"""Request a sandbox with the 'copy_on_write' strategy."""
|
|
context.factory_error = None
|
|
context.factory_sandbox = context.sandbox_factory.create_sandbox(
|
|
resource_id=res_id,
|
|
original_path=path,
|
|
sandbox_strategy="copy_on_write",
|
|
)
|
|
|
|
|
|
@when(
|
|
'a sandbox is requested for resource "{res_id}" at "{path}" '
|
|
"using the overlay strategy"
|
|
)
|
|
def when_factory_overlay(context, res_id: str, path: str):
|
|
"""Request a sandbox with the removed 'overlay' strategy (now unknown)."""
|
|
context.factory_error = None
|
|
try:
|
|
context.sandbox_factory.create_sandbox(
|
|
resource_id=res_id,
|
|
original_path=path,
|
|
sandbox_strategy="overlay", # type: ignore[arg-type]
|
|
)
|
|
except ValueError as exc:
|
|
context.factory_error = exc
|
|
|
|
|
|
@when(
|
|
'a sandbox is requested for resource "{res_id}" at "{path}" '
|
|
"using the transaction rollback strategy"
|
|
)
|
|
def when_factory_transaction_rollback(context, res_id: str, path: str):
|
|
"""Request a sandbox with the 'transaction_rollback' strategy."""
|
|
context.factory_error = None
|
|
try:
|
|
context.sandbox_factory.create_sandbox(
|
|
resource_id=res_id,
|
|
original_path=path,
|
|
sandbox_strategy="transaction_rollback",
|
|
)
|
|
except NotImplementedError as exc:
|
|
context.factory_error = exc
|
|
|
|
|
|
@when(
|
|
'a sandbox is requested for resource "{res_id}" at "{path}" '
|
|
"using the versioning strategy"
|
|
)
|
|
def when_factory_versioning(context, res_id: str, path: str):
|
|
"""Request a sandbox with the removed 'versioning' strategy (now unknown)."""
|
|
context.factory_error = None
|
|
try:
|
|
context.sandbox_factory.create_sandbox(
|
|
resource_id=res_id,
|
|
original_path=path,
|
|
sandbox_strategy="versioning", # type: ignore[arg-type]
|
|
)
|
|
except ValueError as exc:
|
|
context.factory_error = exc
|
|
|
|
|
|
@when(
|
|
'a sandbox is requested for resource "{res_id}" at "{path}" '
|
|
"using the snapshot strategy"
|
|
)
|
|
def when_factory_snapshot(context, res_id: str, path: str):
|
|
"""Request a sandbox with the 'snapshot' strategy (not yet implemented)."""
|
|
context.factory_error = None
|
|
try:
|
|
context.sandbox_factory.create_sandbox(
|
|
resource_id=res_id,
|
|
original_path=path,
|
|
sandbox_strategy="snapshot",
|
|
)
|
|
except NotImplementedError as exc:
|
|
context.factory_error = exc
|
|
|
|
|
|
@when(
|
|
'a sandbox is requested for resource "{res_id}" at "{path}" '
|
|
"using an unrecognised strategy"
|
|
)
|
|
def when_factory_unknown_strategy(context, res_id: str, path: str):
|
|
"""Request a sandbox with a completely bogus strategy name."""
|
|
context.factory_error = None
|
|
try:
|
|
context.sandbox_factory.create_sandbox(
|
|
resource_id=res_id,
|
|
original_path=path,
|
|
sandbox_strategy="quantum_entanglement", # type: ignore[arg-type]
|
|
)
|
|
except ValueError as exc:
|
|
context.factory_error = exc
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Whens - is_supported
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@when("the factory is asked whether the none strategy is supported")
|
|
def when_factory_is_supported_none(context):
|
|
"""Check support for the 'none' strategy."""
|
|
context.factory_supported = SandboxFactory.is_supported("none")
|
|
|
|
|
|
@when("the factory is asked whether the git worktree strategy is supported")
|
|
def when_factory_is_supported_git(context):
|
|
"""Check support for the 'git_worktree' strategy."""
|
|
context.factory_supported = SandboxFactory.is_supported("git_worktree")
|
|
|
|
|
|
@when("the factory is asked whether the copy-on-write strategy is supported")
|
|
def when_factory_is_supported_cow(context):
|
|
"""Check support for the 'copy_on_write' strategy."""
|
|
context.factory_supported = SandboxFactory.is_supported("copy_on_write")
|
|
|
|
|
|
@when("the factory is asked whether an unrecognised strategy is supported")
|
|
def when_factory_is_supported_unknown(context):
|
|
"""Check support for a made-up strategy."""
|
|
context.factory_supported = SandboxFactory.is_supported("quantum_entanglement")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Whens - get_supported_strategies
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@when('the compatible strategies for a "{resource_type}" resource are queried')
|
|
def when_factory_get_strategies(context, resource_type: str):
|
|
"""Query the compatible strategies for a known resource type."""
|
|
context.factory_strategies = SandboxFactory.get_supported_strategies(resource_type)
|
|
|
|
|
|
@when('the compatible strategies for an "{resource_type}" resource are queried')
|
|
def when_factory_get_strategies_an(context, resource_type: str):
|
|
"""Query the compatible strategies for a known resource type (article 'an')."""
|
|
context.factory_strategies = SandboxFactory.get_supported_strategies(resource_type)
|
|
|
|
|
|
@when("the compatible strategies for an unknown resource type are queried")
|
|
def when_factory_get_strategies_unknown(context):
|
|
"""Query the compatible strategies for a resource type not in the map."""
|
|
context.factory_strategies = SandboxFactory.get_supported_strategies(
|
|
"quantum_computer"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Thens - validation errors
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then("the factory should reject the request due to a missing resource identifier")
|
|
def then_factory_missing_resource_id(context):
|
|
"""Assert a ValueError about resource_id was raised."""
|
|
assert context.factory_error is not None, "Expected a ValueError"
|
|
assert isinstance(context.factory_error, ValueError)
|
|
assert "resource_id" in str(context.factory_error)
|
|
|
|
|
|
@then("the factory should reject the request due to a missing resource path")
|
|
def then_factory_missing_path(context):
|
|
"""Assert a ValueError about original_path was raised."""
|
|
assert context.factory_error is not None, "Expected a ValueError"
|
|
assert isinstance(context.factory_error, ValueError)
|
|
assert "original_path" in str(context.factory_error)
|
|
|
|
|
|
@then("the factory should reject the request due to an unknown strategy")
|
|
def then_factory_unknown_strategy(context):
|
|
"""Assert a ValueError about an unknown strategy was raised."""
|
|
assert context.factory_error is not None, "Expected a ValueError"
|
|
assert isinstance(context.factory_error, ValueError)
|
|
assert "unknown" in str(context.factory_error).lower()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Thens - none strategy produces passthrough sandbox
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then("the factory should produce a passthrough sandbox")
|
|
def then_factory_produces_nosandbox(context):
|
|
"""Assert the returned sandbox is a NoSandbox instance."""
|
|
assert isinstance(context.factory_sandbox, NoSandbox)
|
|
|
|
|
|
@then("the produced sandbox should be in the pending state")
|
|
def then_factory_sandbox_pending(context):
|
|
"""Assert the sandbox is in PENDING status."""
|
|
assert context.factory_sandbox.status == SandboxStatus.PENDING
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Thens - git worktree strategy produces sandbox
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then("the factory should produce a git worktree sandbox")
|
|
def then_factory_produces_git_worktree(context):
|
|
"""Assert the returned sandbox is a GitWorktreeSandbox instance."""
|
|
assert isinstance(context.factory_sandbox, GitWorktreeSandbox)
|
|
|
|
|
|
@then("the produced git worktree sandbox should be in the pending state")
|
|
def then_factory_git_worktree_pending(context):
|
|
"""Assert the git worktree sandbox is in PENDING status."""
|
|
assert context.factory_sandbox.status == SandboxStatus.PENDING
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Thens - copy-on-write strategy produces sandbox
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then("the factory should produce a copy-on-write sandbox")
|
|
def then_factory_produces_cow(context):
|
|
"""Assert the returned sandbox is a CopyOnWriteSandbox instance."""
|
|
assert isinstance(context.factory_sandbox, CopyOnWriteSandbox)
|
|
|
|
|
|
@then("the produced copy-on-write sandbox should be in the pending state")
|
|
def then_factory_cow_pending(context):
|
|
"""Assert the copy-on-write sandbox is in PENDING status."""
|
|
assert context.factory_sandbox.status == SandboxStatus.PENDING
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Thens - not yet implemented
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then("the factory should indicate the strategy is not yet implemented")
|
|
def then_factory_not_implemented(context):
|
|
"""Assert a NotImplementedError was raised."""
|
|
assert context.factory_error is not None, "Expected a NotImplementedError"
|
|
assert isinstance(context.factory_error, NotImplementedError)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Thens - is_supported
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then("the factory should confirm the strategy is supported")
|
|
def then_factory_supported_true(context):
|
|
"""Assert the strategy is reported as supported."""
|
|
assert context.factory_supported is True
|
|
|
|
|
|
@then("the factory should indicate the strategy is not supported")
|
|
def then_factory_supported_false(context):
|
|
"""Assert the strategy is reported as not supported."""
|
|
assert context.factory_supported is False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Thens - get_supported_strategies
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then("the factory should return git worktree, copy-on-write, and none as compatible")
|
|
def then_factory_git_checkout_strategies(context):
|
|
"""Assert the git-checkout strategies are correct."""
|
|
assert context.factory_strategies == ["git_worktree", "copy_on_write", "none"]
|
|
|
|
|
|
@then("the factory should return copy-on-write and none as compatible")
|
|
def then_factory_cow_none_strategies(context):
|
|
"""Assert the resource type supports copy_on_write and none."""
|
|
assert context.factory_strategies == ["copy_on_write", "none"]
|
|
|
|
|
|
@then("the factory should return only the none strategy as compatible")
|
|
def then_factory_none_only_strategies(context):
|
|
"""Assert only the 'none' strategy is returned."""
|
|
assert context.factory_strategies == ["none"]
|