[Phase 3→4] Add edge case testing across core components

[frankbria]

Overview

Current tests focus on happy paths, missing many edge cases that could cause production failures.

Missing Edge Cases

Agent Execution

• Task with empty description
• Task with malformed JSON context
• API rate limit exceeded
• API timeout or network error
• Invalid model name
• Context exceeds token limit mid-execution

Database Operations

• Concurrent writes to same task
• Database locked during write
• Invalid UTF-8 in task description
• Missing foreign key (task → issue)
• NULL values in required fields

Quality Gates

• Zero tests exist
• All tests skipped
• Coverage data unavailable
• Test output unparseable
• Test command not found

Context Management

• Flash save with no COLD items
• Restore checkpoint that doesn't exist
• Context items with duplicate IDs
• Tier assignment with missing fields

Implementation Requirements

1. Identify edge cases for each component
2. Write tests for error conditions
3. Write tests for boundary conditions
4. Write tests for concurrency issues
5. Ensure graceful degradation

Example Edge Cases

# Test: execute_task with empty description
async def test_execute_task_empty_description():
    agent = WorkerAgent(...)
    task = Task(id=1, description="", ...)
    
    result = await agent.execute_task(task)
    
    assert result["status"] == "failed"
    assert "description cannot be empty" in result["error"]

# Test: database write during lock
def test_save_task_during_lock():
    db = Database(":memory:")
    
    # Lock database
    conn = db.conn.execute("BEGIN EXCLUSIVE")
    
    # Attempt write (should retry or fail gracefully)
    with pytest.raises(DatabaseLockError):
        db.save_task(Task(...))

Acceptance Criteria

• Edge cases identified for all core components
• Tests written for each edge case
• Error handling verified
• Graceful degradation verified
• Edge case coverage >80%

Priority

P2 - Essential: Edge cases cause production failures if not tested.

References

• Issues Analysis: CODEFRAME_ISSUES_ANALYSIS.md lines 183-184

[traycerai]

Plan

Observations

The codebase has solid test coverage for happy paths (111 tests, 100% pass rate) but lacks comprehensive edge case testing across core components. Current tests focus on successful scenarios with mocked dependencies. The four core components (Agent Execution, Database Operations, Quality Gates, Context Management) have basic functionality implemented but missing critical error handling tests. The testing infrastructure uses pytest with async support, fixtures, and markers for categorization. No existing tests for quality gates edge cases were found.

Approach

The implementation will add comprehensive edge case tests for all core components as Phase 3→4 work (post-beta). Tests will be added to existing test files where appropriate, or new test files created for untested components (quality gates). Each edge case will have dedicated test methods following the existing naming conventions (test_<component>_<edge_case>). Tests will use real database connections and minimal mocking to validate actual error handling behavior. All 26 edge cases across Agent Execution, Database Operations, Quality Gates, and Context Management will be implemented together, ensuring consistent error handling patterns and comprehensive coverage across the entire codebase.

Implementation Steps

Phase 3→4: Comprehensive Edge Case Testing (Post-Beta)

1. Agent Execution Edge Cases

Add edge case tests to file:tests/agents/test_worker_agent.py:

1.1 Empty Task Description

• Create test method test_execute_task_empty_description
• Instantiate WorkerAgent with valid configuration
• Create task with description="" using database fixture
• Call agent.execute_task(task) and assert result status is "failed"
• Verify error message contains "description cannot be empty"
• Ensure no API call is made (check rate limiter not decremented)

1.2 Malformed JSON Context

• Create test method test_execute_task_malformed_json_context
• Create task with context field containing invalid JSON string
• Execute task and verify graceful failure with clear error message
• Check that task status is updated to "failed" in database
• Verify error is logged with appropriate severity

1.3 API Rate Limit Exceeded

• Create test method test_execute_task_api_rate_limit_exceeded
• Mock Anthropic API to raise RateLimitError on first 3 attempts
• Verify retry logic exhausts attempts (3 retries)
• Assert final result status is "failed" with error "RATE_LIMIT_EXCEEDED"
• Verify exponential backoff delays are applied
• Ensure task is marked as retryable for later execution

1.4 API Timeout

• Create test method test_execute_task_api_timeout
• Mock API call to raise APITimeoutError
• Verify retry logic attempts 3 times
• Assert timeout error is caught and task marked as failed
• Check error message includes timeout duration
• Verify graceful degradation without hanging

1.5 Network Error

• Create test method test_execute_task_network_error
• Mock API to raise APIConnectionError
• Verify retry mechanism handles connection failures
• Assert graceful degradation after retry exhaustion
• Verify error logged with network diagnostic info

1.6 Invalid Model Name

• Create test method test_execute_task_invalid_model_name
• Initialize WorkerAgent with model_name="invalid-model-xyz"
• Execute task and verify API rejects invalid model
• Assert error message indicates invalid model name
• Verify task marked as failed with specific error code

1.7 Context Exceeds Token Limit Mid-Execution

• Create test method test_execute_task_context_exceeds_token_limit
• Create task with description that will exceed 200k token limit
• Mock token counter to return value > 200000
• Execute task and verify it fails before API call
• Assert error message indicates token limit exceeded
• Verify cost estimation prevents expensive call

2. Database Operations Edge Cases

Add edge case tests to file:tests/persistence/test_database.py:

2.1 Concurrent Writes to Same Task

• Create test class TestDatabaseConcurrency
• Create test method test_concurrent_task_updates
• Use threading or asyncio to simulate concurrent writes
• Create 10 threads attempting to update same task simultaneously
• Verify database handles concurrent writes without corruption
• Assert final task state is consistent (last write wins or proper locking)
• Check no database errors or deadlocks occur

2.2 Database Locked During Write

• Create test method test_save_task_during_database_lock
• Acquire exclusive lock: BEGIN EXCLUSIVE transaction
• Attempt write operation from different connection
• Verify operation either waits or raises DatabaseLockError
• Assert retry mechanism handles lock timeout gracefully
• Verify data integrity maintained after lock release

2.3 Invalid UTF-8 in Task Description

• Create test method test_create_task_invalid_utf8
• Create task with description containing invalid UTF-8 bytes
• Attempt to save to database
• Verify database rejects or sanitizes invalid encoding
• Assert error message indicates encoding issue
• Check task creation fails gracefully without database corruption

2.4 Missing Foreign Key (Task → Issue)

• Create test method test_create_task_missing_foreign_key
• Enable foreign key constraints: PRAGMA foreign_keys = ON
• Attempt to create task with non-existent issue_id
• Verify foreign key constraint violation is raised
• Assert task creation fails with clear error message
• Check database remains in consistent state

2.5 NULL Values in Required Fields

• Create test method test_create_task_null_required_fields
• Attempt to create task with title=None or description=None
• Verify NOT NULL constraint is enforced
• Assert appropriate error raised (IntegrityError)
• Check error message identifies which field is NULL
• Verify no partial record created in database

2.6 Transaction Rollback on Constraint Violation

• Create test method test_transaction_rollback_on_constraint_error
• Start transaction with multiple operations
• Include operation that violates constraint (e.g., duplicate primary key)
• Verify entire transaction rolls back
• Assert no partial data committed
• Check database state unchanged after rollback

3. Quality Gates Edge Cases

Create new test file file:tests/lib/test_quality_gates_edge_cases.py:

3.1 Zero Tests Exist

• Create test class TestQualityGatesEdgeCases
• Create test method test_run_tests_gate_no_tests_found
• Mock project with no test files
• Execute gates.run_tests_gate(task)
• Verify gate fails with message "No tests found"
• Assert blocker created for missing tests
• Check quality gate status updated to "failed"

3.2 All Tests Skipped

• Create test method test_run_tests_gate_all_tests_skipped
• Mock pytest output showing all tests skipped
• Execute test gate
• Verify gate fails with "All tests skipped" message
• Assert skip detection gate also triggers
• Check blocker created with severity HIGH

3.3 Coverage Data Unavailable

• Create test method test_run_coverage_gate_data_unavailable
• Mock coverage tool to return no data (file not found)
• Execute gates.run_coverage_gate(task)
• Verify gate handles missing coverage data gracefully
• Assert default behavior (fail or pass based on configuration)
• Check error logged with diagnostic information

3.4 Test Output Unparseable

• Create test method test_run_tests_gate_unparseable_output
• Mock pytest to return malformed output (corrupted JSON)
• Execute test gate
• Verify parser handles unparseable output without crashing
• Assert gate fails with "Unable to parse test results"
• Check error includes sample of unparseable output

3.5 Test Command Not Found

• Create test method test_run_tests_gate_command_not_found
• Mock subprocess to raise FileNotFoundError for pytest
• Execute test gate
• Verify gate handles missing test command gracefully
• Assert gate passes with warning (tool not installed)
• Check warning logged indicating pytest not found

3.6 Test Timeout

• Create test method test_run_tests_gate_timeout
• Mock pytest to exceed 5-minute timeout
• Execute test gate
• Verify subprocess.TimeoutExpired is caught
• Assert gate fails with "Tests timed out" message
• Check timeout duration included in error

3.7 Linter Returns Non-Zero Without Errors

• Create test method test_run_linting_gate_false_positive
• Mock ruff to return exit code 1 but empty error output
• Execute linting gate
• Verify gate handles ambiguous result
• Assert gate passes or fails based on output parsing
• Check edge case logged for investigation

4. Context Management Edge Cases

Add edge case tests to file:tests/context/test_flash_save.py:

4.1 Flash Save with No COLD Items

• Create test method test_flash_save_no_cold_items_to_archive
• Create context items all in HOT or WARM tiers
• Execute context_manager.flash_save(project_id, agent_id)
• Verify checkpoint created successfully
• Assert items_archived count is 0
• Check tokens_before equals tokens_after (no reduction)
• Verify flash save completes without error

4.2 Restore Checkpoint That Doesn't Exist

• Create test method test_restore_checkpoint_not_found
• Attempt to restore checkpoint with non-existent ID
• Verify restore operation fails gracefully
• Assert error message indicates checkpoint not found
• Check no context items modified
• Verify database state unchanged

4.3 Context Items with Duplicate IDs

• Create test method test_create_context_item_duplicate_id
• Create context item with specific ID
• Attempt to create another item with same ID
• Verify primary key constraint prevents duplicate
• Assert appropriate error raised (IntegrityError)
• Check only first item exists in database

4.4 Tier Assignment with Missing Fields

• Create test method test_assign_tier_missing_importance_score
• Create context item without importance_score field
• Attempt tier assignment via update_tiers_for_agent
• Verify tier assignment handles missing score gracefully
• Assert default tier assigned (WARM) or error raised
• Check error message indicates missing field

4.5 Flash Save Threshold Edge Case

• Create test method test_flash_save_exactly_at_threshold
• Create context items totaling exactly 144k tokens (80% of 180k)
• Execute should_flash_save check
• Verify threshold comparison uses >= (not >)
• Assert flash save triggers at exact threshold
• Check boundary condition handled correctly

4.6 Checkpoint Data Corruption

• Create test method test_restore_checkpoint_corrupted_data
• Create checkpoint with invalid JSON in checkpoint_data field
• Attempt to restore checkpoint
• Verify JSON parsing error caught gracefully
• Assert restore fails with clear error message
• Check no partial restoration occurs

5. Test Organization and Fixtures

5.1 Create Shared Fixtures

• Add to file:tests/conftest.py:
  • @pytest.fixture for temp_db_with_foreign_keys (enables FK constraints)
  • @pytest.fixture for mock_anthropic_rate_limit_error
  • @pytest.fixture for mock_anthropic_timeout_error
  • @pytest.fixture for mock_anthropic_network_error
  • @pytest.fixture for task_with_empty_description
  • @pytest.fixture for task_with_malformed_json
  • @pytest.fixture for task_with_invalid_model

5.2 Add Test Markers

• Update file:pytest.ini with new markers:
  • edge_case: marks edge case tests
  • concurrency: marks tests requiring concurrent execution
  • database_constraint: marks tests for database constraint violations
  • quality_gates: marks quality gate edge case tests
  • context_management: marks context management edge case tests

5.3 Create Test Utilities

• Create file:tests/utils/edge_case_helpers.py:
  • create_oversized_context(token_count) - generates context exceeding token limit
  • simulate_concurrent_writes(db, num_threads) - helper for concurrency testing
  • create_invalid_utf8_string() - generates invalid UTF-8 bytes
  • simulate_database_lock(db, duration) - helper for lock testing
  • create_malformed_json() - generates various malformed JSON patterns

6. Documentation and Coverage

6.1 Update Test Documentation

• Update file:TESTING.md:
  • Add section "Edge Case Testing Strategy"
  • Document all 26 edge cases with examples and rationale
  • Include troubleshooting guide for edge case failures
  • Document test markers and how to run edge case tests

6.2 Coverage Verification

• Run coverage analysis: pytest -v -m edge_case
• Verify edge case coverage >80% for all core components:
  • Agent execution error paths (7 edge cases)
  • Database constraint violations and concurrency (6 edge cases)
  • Quality gates error handling (7 edge cases)
  • Context management edge cases (6 edge cases)
• Generate coverage report for all edge cases

6.3 CI/CD Integration

• Update CI configuration to run edge case tests in PR checks
• Add edge_case marker to required test suite
• Configure failure notifications for edge case regressions
• Set coverage threshold enforcement for edge case paths

7. Validation and Acceptance

7.1 Edge Case Test Validation

• Execute: pytest -v -m edge_case
• Verify all 26 edge case tests pass
• Check no regressions in existing 111 tests
• Validate test execution time <5 minutes
• Verify all edge case scenarios handled gracefully

7.2 Manual Edge Case Verification

• Test edge cases manually in development environment
• Verify error messages are clear and actionable
• Check logging provides sufficient diagnostic information
• Validate graceful degradation for all failure scenarios

7.3 Documentation Review

• Review all test docstrings for clarity
• Ensure edge cases documented in code comments
• Verify error handling patterns consistent across components
• Check all acceptance criteria met

Test Execution Flow

graph TD
    A[Start Phase 3→4 Edge Case Testing] --> B[Agent Execution Tests]
    B --> C[Database Operations Tests]
    C --> D[Quality Gates Tests]
    D --> E[Context Management Tests]
    E --> F[Run Coverage Analysis]
    F --> G{Coverage >80%?}
    G -->|Yes| H[Update Documentation]
    G -->|No| I[Add Missing Tests]
    I --> F
    H --> J[CI/CD Integration]
    J --> K[Manual Validation]
    K --> L[Phase 3→4 Complete]

Loading

Edge Case Coverage Matrix

Component	Edge Cases	Test File	Count
Agent Execution	Empty description, malformed JSON, rate limit, timeout, network error, invalid model, token limit	test_worker_agent.py	7
Database Operations	Concurrent writes, database lock, invalid UTF-8, missing foreign key, NULL values, transaction rollback	test_database.py	6
Quality Gates	No tests, all skipped, coverage unavailable, unparseable output, command not found, timeout, false positive	test_quality_gates_edge_cases.py (new)	7
Context Management	No COLD items, missing checkpoint, duplicate IDs, missing fields, threshold boundary, corrupted data	test_flash_save.py	6
Total	-	3 test files	26

Success Criteria

• ✅ All 26 edge case tests implemented and passing
• ✅ Edge case coverage >80% for all core components
• ✅ No regressions in existing 111 tests
• ✅ Error messages clear and actionable for all edge cases
• ✅ Graceful degradation verified for all failure scenarios
• ✅ Documentation updated with comprehensive edge case testing strategy
• ✅ CI/CD pipeline includes full edge case test suite
• ✅ Manual validation confirms edge case handling in development environment

Import In IDE

🤖 Prompt for AI Agents

## Observations

The codebase has solid test coverage for happy paths (111 tests, 100% pass rate) but lacks comprehensive edge case testing across core components. Current tests focus on successful scenarios with mocked dependencies. The four core components (Agent Execution, Database Operations, Quality Gates, Context Management) have basic functionality implemented but missing critical error handling tests. The testing infrastructure uses pytest with async support, fixtures, and markers for categorization. No existing tests for quality gates edge cases were found.

## Approach

The implementation will add comprehensive edge case tests for all core components as Phase 3→4 work (post-beta). Tests will be added to existing test files where appropriate, or new test files created for untested components (quality gates). Each edge case will have dedicated test methods following the existing naming conventions (`test_<component>_<edge_case>`). Tests will use real database connections and minimal mocking to validate actual error handling behavior. All 26 edge cases across Agent Execution, Database Operations, Quality Gates, and Context Management will be implemented together, ensuring consistent error handling patterns and comprehensive coverage across the entire codebase.

## Implementation Steps

### Phase 3→4: Comprehensive Edge Case Testing (Post-Beta)

#### 1. Agent Execution Edge Cases

Add edge case tests to `file:tests/agents/test_worker_agent.py`:

**1.1 Empty Task Description**
- Create test method `test_execute_task_empty_description`
- Instantiate `WorkerAgent` with valid configuration
- Create task with `description=""` using database fixture
- Call `agent.execute_task(task)` and assert result status is "failed"
- Verify error message contains "description cannot be empty"
- Ensure no API call is made (check rate limiter not decremented)

**1.2 Malformed JSON Context**
- Create test method `test_execute_task_malformed_json_context`
- Create task with context field containing invalid JSON string
- Execute task and verify graceful failure with clear error message
- Check that task status is updated to "failed" in database
- Verify error is logged with appropriate severity

**1.3 API Rate Limit Exceeded**
- Create test method `test_execute_task_api_rate_limit_exceeded`
- Mock Anthropic API to raise `RateLimitError` on first 3 attempts
- Verify retry logic exhausts attempts (3 retries)
- Assert final result status is "failed" with error "RATE_LIMIT_EXCEEDED"
- Verify exponential backoff delays are applied
- Ensure task is marked as retryable for later execution

**1.4 API Timeout**
- Create test method `test_execute_task_api_timeout`
- Mock API call to raise `APITimeoutError`
- Verify retry logic attempts 3 times
- Assert timeout error is caught and task marked as failed
- Check error message includes timeout duration
- Verify graceful degradation without hanging

**1.5 Network Error**
- Create test method `test_execute_task_network_error`
- Mock API to raise `APIConnectionError`
- Verify retry mechanism handles connection failures
- Assert graceful degradation after retry exhaustion
- Verify error logged with network diagnostic info

**1.6 Invalid Model Name**
- Create test method `test_execute_task_invalid_model_name`
- Initialize `WorkerAgent` with `model_name="invalid-model-xyz"`
- Execute task and verify API rejects invalid model
- Assert error message indicates invalid model name
- Verify task marked as failed with specific error code

**1.7 Context Exceeds Token Limit Mid-Execution**
- Create test method `test_execute_task_context_exceeds_token_limit`
- Create task with description that will exceed 200k token limit
- Mock token counter to return value > 200000
- Execute task and verify it fails before API call
- Assert error message indicates token limit exceeded
- Verify cost estimation prevents expensive call

#### 2. Database Operations Edge Cases

Add edge case tests to `file:tests/persistence/test_database.py`:

**2.1 Concurrent Writes to Same Task**
- Create test class `TestDatabaseConcurrency`
- Create test method `test_concurrent_task_updates`
- Use `threading` or `asyncio` to simulate concurrent writes
- Create 10 threads attempting to update same task simultaneously
- Verify database handles concurrent writes without corruption
- Assert final task state is consistent (last write wins or proper locking)
- Check no database errors or deadlocks occur

**2.2 Database Locked During Write**
- Create test method `test_save_task_during_database_lock`
- Acquire exclusive lock: `BEGIN EXCLUSIVE` transaction
- Attempt write operation from different connection
- Verify operation either waits or raises `DatabaseLockError`
- Assert retry mechanism handles lock timeout gracefully
- Verify data integrity maintained after lock release

**2.3 Invalid UTF-8 in Task Description**
- Create test method `test_create_task_invalid_utf8`
- Create task with description containing invalid UTF-8 bytes
- Attempt to save to database
- Verify database rejects or sanitizes invalid encoding
- Assert error message indicates encoding issue
- Check task creation fails gracefully without database corruption

**2.4 Missing Foreign Key (Task → Issue)**
- Create test method `test_create_task_missing_foreign_key`
- Enable foreign key constraints: `PRAGMA foreign_keys = ON`
- Attempt to create task with non-existent `issue_id`
- Verify foreign key constraint violation is raised
- Assert task creation fails with clear error message
- Check database remains in consistent state

**2.5 NULL Values in Required Fields**
- Create test method `test_create_task_null_required_fields`
- Attempt to create task with `title=None` or `description=None`
- Verify NOT NULL constraint is enforced
- Assert appropriate error raised (IntegrityError)
- Check error message identifies which field is NULL
- Verify no partial record created in database

**2.6 Transaction Rollback on Constraint Violation**
- Create test method `test_transaction_rollback_on_constraint_error`
- Start transaction with multiple operations
- Include operation that violates constraint (e.g., duplicate primary key)
- Verify entire transaction rolls back
- Assert no partial data committed
- Check database state unchanged after rollback

#### 3. Quality Gates Edge Cases

Create new test file `file:tests/lib/test_quality_gates_edge_cases.py`:

**3.1 Zero Tests Exist**
- Create test class `TestQualityGatesEdgeCases`
- Create test method `test_run_tests_gate_no_tests_found`
- Mock project with no test files
- Execute `gates.run_tests_gate(task)`
- Verify gate fails with message "No tests found"
- Assert blocker created for missing tests
- Check quality gate status updated to "failed"

**3.2 All Tests Skipped**
- Create test method `test_run_tests_gate_all_tests_skipped`
- Mock pytest output showing all tests skipped
- Execute test gate
- Verify gate fails with "All tests skipped" message
- Assert skip detection gate also triggers
- Check blocker created with severity HIGH

**3.3 Coverage Data Unavailable**
- Create test method `test_run_coverage_gate_data_unavailable`
- Mock coverage tool to return no data (file not found)
- Execute `gates.run_coverage_gate(task)`
- Verify gate handles missing coverage data gracefully
- Assert default behavior (fail or pass based on configuration)
- Check error logged with diagnostic information

**3.4 Test Output Unparseable**
- Create test method `test_run_tests_gate_unparseable_output`
- Mock pytest to return malformed output (corrupted JSON)
- Execute test gate
- Verify parser handles unparseable output without crashing
- Assert gate fails with "Unable to parse test results"
- Check error includes sample of unparseable output

**3.5 Test Command Not Found**
- Create test method `test_run_tests_gate_command_not_found`
- Mock subprocess to raise `FileNotFoundError` for pytest
- Execute test gate
- Verify gate handles missing test command gracefully
- Assert gate passes with warning (tool not installed)
- Check warning logged indicating pytest not found

**3.6 Test Timeout**
- Create test method `test_run_tests_gate_timeout`
- Mock pytest to exceed 5-minute timeout
- Execute test gate
- Verify `subprocess.TimeoutExpired` is caught
- Assert gate fails with "Tests timed out" message
- Check timeout duration included in error

**3.7 Linter Returns Non-Zero Without Errors**
- Create test method `test_run_linting_gate_false_positive`
- Mock ruff to return exit code 1 but empty error output
- Execute linting gate
- Verify gate handles ambiguous result
- Assert gate passes or fails based on output parsing
- Check edge case logged for investigation

#### 4. Context Management Edge Cases

Add edge case tests to `file:tests/context/test_flash_save.py`:

**4.1 Flash Save with No COLD Items**
- Create test method `test_flash_save_no_cold_items_to_archive`
- Create context items all in HOT or WARM tiers
- Execute `context_manager.flash_save(project_id, agent_id)`
- Verify checkpoint created successfully
- Assert `items_archived` count is 0
- Check `tokens_before` equals `tokens_after` (no reduction)
- Verify flash save completes without error

**4.2 Restore Checkpoint That Doesn't Exist**
- Create test method `test_restore_checkpoint_not_found`
- Attempt to restore checkpoint with non-existent ID
- Verify restore operation fails gracefully
- Assert error message indicates checkpoint not found
- Check no context items modified
- Verify database state unchanged

**4.3 Context Items with Duplicate IDs**
- Create test method `test_create_context_item_duplicate_id`
- Create context item with specific ID
- Attempt to create another item with same ID
- Verify primary key constraint prevents duplicate
- Assert appropriate error raised (IntegrityError)
- Check only first item exists in database

**4.4 Tier Assignment with Missing Fields**
- Create test method `test_assign_tier_missing_importance_score`
- Create context item without `importance_score` field
- Attempt tier assignment via `update_tiers_for_agent`
- Verify tier assignment handles missing score gracefully
- Assert default tier assigned (WARM) or error raised
- Check error message indicates missing field

**4.5 Flash Save Threshold Edge Case**
- Create test method `test_flash_save_exactly_at_threshold`
- Create context items totaling exactly 144k tokens (80% of 180k)
- Execute `should_flash_save` check
- Verify threshold comparison uses >= (not >)
- Assert flash save triggers at exact threshold
- Check boundary condition handled correctly

**4.6 Checkpoint Data Corruption**
- Create test method `test_restore_checkpoint_corrupted_data`
- Create checkpoint with invalid JSON in `checkpoint_data` field
- Attempt to restore checkpoint
- Verify JSON parsing error caught gracefully
- Assert restore fails with clear error message
- Check no partial restoration occurs

### 5. Test Organization and Fixtures

**5.1 Create Shared Fixtures**
- Add to `file:tests/conftest.py`:
  - `@pytest.fixture` for `temp_db_with_foreign_keys` (enables FK constraints)
  - `@pytest.fixture` for `mock_anthropic_rate_limit_error`
  - `@pytest.fixture` for `mock_anthropic_timeout_error`
  - `@pytest.fixture` for `mock_anthropic_network_error`
  - `@pytest.fixture` for `task_with_empty_description`
  - `@pytest.fixture` for `task_with_malformed_json`
  - `@pytest.fixture` for `task_with_invalid_model`

**5.2 Add Test Markers**
- Update `file:pytest.ini` with new markers:
  - `edge_case: marks edge case tests`
  - `concurrency: marks tests requiring concurrent execution`
  - `database_constraint: marks tests for database constraint violations`
  - `quality_gates: marks quality gate edge case tests`
  - `context_management: marks context management edge case tests`

**5.3 Create Test Utilities**
- Create `file:tests/utils/edge_case_helpers.py`:
  - `create_oversized_context(token_count)` - generates context exceeding token limit
  - `simulate_concurrent_writes(db, num_threads)` - helper for concurrency testing
  - `create_invalid_utf8_string()` - generates invalid UTF-8 bytes
  - `simulate_database_lock(db, duration)` - helper for lock testing
  - `create_malformed_json()` - generates various malformed JSON patterns

### 6. Documentation and Coverage

**6.1 Update Test Documentation**
- Update `file:TESTING.md`:
  - Add section "Edge Case Testing Strategy"
  - Document all 26 edge cases with examples and rationale
  - Include troubleshooting guide for edge case failures
  - Document test markers and how to run edge case tests

**6.2 Coverage Verification**
- Run coverage analysis: `pytest -v -m edge_case`
- Verify edge case coverage >80% for all core components:
  - Agent execution error paths (7 edge cases)
  - Database constraint violations and concurrency (6 edge cases)
  - Quality gates error handling (7 edge cases)
  - Context management edge cases (6 edge cases)
- Generate coverage report for all edge cases

**6.3 CI/CD Integration**
- Update CI configuration to run edge case tests in PR checks
- Add `edge_case` marker to required test suite
- Configure failure notifications for edge case regressions
- Set coverage threshold enforcement for edge case paths

### 7. Validation and Acceptance

**7.1 Edge Case Test Validation**
- Execute: `pytest -v -m edge_case`
- Verify all 26 edge case tests pass
- Check no regressions in existing 111 tests
- Validate test execution time <5 minutes
- Verify all edge case scenarios handled gracefully

**7.2 Manual Edge Case Verification**
- Test edge cases manually in development environment
- Verify error messages are clear and actionable
- Check logging provides sufficient diagnostic information
- Validate graceful degradation for all failure scenarios

**7.3 Documentation Review**
- Review all test docstrings for clarity
- Ensure edge cases documented in code comments
- Verify error handling patterns consistent across components
- Check all acceptance criteria met

## Test Execution Flow

```mermaid
graph TD
    A[Start Phase 3→4 Edge Case Testing] --> B[Agent Execution Tests]
    B --> C[Database Operations Tests]
    C --> D[Quality Gates Tests]
    D --> E[Context Management Tests]
    E --> F[Run Coverage Analysis]
    F --> G{Coverage >80%?}
    G -->|Yes| H[Update Documentation]
    G -->|No| I[Add Missing Tests]
    I --> F
    H --> J[CI/CD Integration]
    J --> K[Manual Validation]
    K --> L[Phase 3→4 Complete]
```

## Edge Case Coverage Matrix

| Component | Edge Cases | Test File | Count |
|-----------|-----------|-----------|-------|
| Agent Execution | Empty description, malformed JSON, rate limit, timeout, network error, invalid model, token limit | `test_worker_agent.py` | 7 |
| Database Operations | Concurrent writes, database lock, invalid UTF-8, missing foreign key, NULL values, transaction rollback | `test_database.py` | 6 |
| Quality Gates | No tests, all skipped, coverage unavailable, unparseable output, command not found, timeout, false positive | `test_quality_gates_edge_cases.py` (new) | 7 |
| Context Management | No COLD items, missing checkpoint, duplicate IDs, missing fields, threshold boundary, corrupted data | `test_flash_save.py` | 6 |
| **Total** | - | **3 test files** | **26** |

## Success Criteria

- ✅ All 26 edge case tests implemented and passing
- ✅ Edge case coverage >80% for all core components
- ✅ No regressions in existing 111 tests
- ✅ Error messages clear and actionable for all edge cases
- ✅ Graceful degradation verified for all failure scenarios
- ✅ Documentation updated with comprehensive edge case testing strategy
- ✅ CI/CD pipeline includes full edge case test suite
- ✅ Manual validation confirms edge case handling in development environment

---

Execution Information

Branch: main
Commit: 4d894a6

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[coderabbitai]

📝 CodeRabbit Plan Mode

Generate an implementation plan and prompts that you can use with your favorite coding agent.

• Create Plan

Examples

• Example 1
• Example 2

---

🔗 Related PRs

#125 - Implement WorkerAgent execute_task method [merged]
#151 - Integrate QualityTracker with workflow system [merged]
#191 - feat(e2e): Enable conditional tests and fix discovery startup [merged]
#246 - feat(agents): trigger multi-agent execution after task approval [merged]
#267 - fix: standardize worker agent task dict interface [merged]

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!

[traycerai]

I have updated the Implementation Plan to reflect the recent changes in the ticket.

New Plan

Observations

The codebase has solid test coverage for happy paths (111 tests, 100% pass rate) but lacks comprehensive edge case testing across core components. Current tests focus on successful scenarios with mocked dependencies. The four core components (Agent Execution, Database Operations, Quality Gates, Context Management) have basic functionality implemented but missing critical error handling tests. The testing infrastructure uses pytest with async support, fixtures, and markers for categorization. No existing tests for quality gates edge cases were found.

Approach

The implementation will follow a systematic approach to add edge case tests for each core component, organized by priority and component. Tests will be added to existing test files where appropriate, or new test files created for untested components (quality gates). Each edge case will have dedicated test methods following the existing naming conventions (test_<component>_<edge_case>). Tests will use real database connections and minimal mocking to validate actual error handling behavior. The plan prioritizes edge cases that could cause production failures, starting with Agent Execution and Database Operations.

Implementation Steps

1. Agent Execution Edge Cases

Add edge case tests to file:tests/agents/test_worker_agent.py:

1.1 Empty Task Description

• Create test method test_execute_task_empty_description
• Instantiate WorkerAgent with valid configuration
• Create task with description="" using database fixture
• Call agent.execute_task(task) and assert result status is "failed"
• Verify error message contains "description cannot be empty"
• Ensure no API call is made (check rate limiter not decremented)

1.2 Malformed JSON Context

• Create test method test_execute_task_malformed_json_context
• Create task with context field containing invalid JSON string
• Execute task and verify graceful failure with clear error message
• Check that task status is updated to "failed" in database
• Verify error is logged with appropriate severity

1.3 Invalid Model Name

• Create test method test_execute_task_invalid_model_name
• Initialize WorkerAgent with model_name="invalid-model-xyz"
• Execute task and verify API rejects invalid model
• Assert error message indicates invalid model name
• Verify task marked as failed with specific error code

1.4 API Rate Limit Exceeded

• Create test method test_execute_task_api_rate_limit_exceeded
• Mock Anthropic API to raise RateLimitError on first 3 attempts
• Verify retry logic exhausts attempts (3 retries)
• Assert final result status is "failed" with error "RATE_LIMIT_EXCEEDED"
• Verify exponential backoff delays are applied

1.5 API Timeout

• Create test method test_execute_task_api_timeout
• Mock API call to raise APITimeoutError
• Verify retry logic attempts 3 times
• Assert timeout error is caught and task marked as failed
• Check error message includes timeout duration

1.6 Network Error

• Create test method test_execute_task_network_error
• Mock API to raise APIConnectionError
• Verify retry mechanism handles connection failures
• Assert graceful degradation after retry exhaustion
• Verify error logged with network diagnostic info

1.7 Context Exceeds Token Limit Mid-Execution

• Create test method test_execute_task_context_exceeds_token_limit
• Create task with description that will exceed 200k token limit
• Mock token counter to return value > 200000
• Execute task and verify it fails before API call
• Assert error message indicates token limit exceeded
• Verify cost estimation prevents expensive call

2. Database Operations Edge Cases

Add edge case tests to file:tests/persistence/test_database.py:

2.1 Concurrent Writes to Same Task

• Create test class TestDatabaseConcurrency
• Create test method test_concurrent_task_updates
• Use threading or asyncio to simulate concurrent writes
• Create 10 threads attempting to update same task simultaneously
• Verify database handles concurrent writes without corruption
• Assert final task state is consistent (last write wins or proper locking)
• Check no database errors or deadlocks occur

2.2 Database Locked During Write

• Create test method test_save_task_during_database_lock
• Acquire exclusive lock: BEGIN EXCLUSIVE transaction
• Attempt write operation from different connection
• Verify operation either waits or raises DatabaseLockError
• Assert retry mechanism handles lock timeout gracefully
• Verify data integrity maintained after lock release

2.3 Invalid UTF-8 in Task Description

• Create test method test_create_task_invalid_utf8
• Create task with description containing invalid UTF-8 bytes
• Attempt to save to database
• Verify database rejects or sanitizes invalid encoding
• Assert error message indicates encoding issue
• Check task creation fails gracefully without database corruption

2.4 Missing Foreign Key (Task → Issue)

• Create test method test_create_task_missing_foreign_key
• Enable foreign key constraints: PRAGMA foreign_keys = ON
• Attempt to create task with non-existent issue_id
• Verify foreign key constraint violation is raised
• Assert task creation fails with clear error message
• Check database remains in consistent state

2.5 NULL Values in Required Fields

• Create test method test_create_task_null_required_fields
• Attempt to create task with title=None or description=None
• Verify NOT NULL constraint is enforced
• Assert appropriate error raised (IntegrityError)
• Check error message identifies which field is NULL
• Verify no partial record created in database

2.6 Transaction Rollback on Constraint Violation

• Create test method test_transaction_rollback_on_constraint_error
• Start transaction with multiple operations
• Include operation that violates constraint (e.g., duplicate primary key)
• Verify entire transaction rolls back
• Assert no partial data committed
• Check database state unchanged after rollback

3. Quality Gates Edge Cases

Create new test file file:tests/lib/test_quality_gates_edge_cases.py:

3.1 Zero Tests Exist

• Create test class TestQualityGatesEdgeCases
• Create test method test_run_tests_gate_no_tests_found
• Mock project with no test files
• Execute gates.run_tests_gate(task)
• Verify gate fails with message "No tests found"
• Assert blocker created for missing tests
• Check quality gate status updated to "failed"

3.2 All Tests Skipped

• Create test method test_run_tests_gate_all_tests_skipped
• Mock pytest output showing all tests skipped
• Execute test gate
• Verify gate fails with "All tests skipped" message
• Assert skip detection gate also triggers
• Check blocker created with severity HIGH

3.3 Coverage Data Unavailable

• Create test method test_run_coverage_gate_data_unavailable
• Mock coverage tool to return no data (file not found)
• Execute gates.run_coverage_gate(task)
• Verify gate handles missing coverage data gracefully
• Assert default behavior (fail or pass based on configuration)
• Check error logged with diagnostic information

3.4 Test Output Unparseable

• Create test method test_run_tests_gate_unparseable_output
• Mock pytest to return malformed output (corrupted JSON)
• Execute test gate
• Verify parser handles unparseable output without crashing
• Assert gate fails with "Unable to parse test results"
• Check error includes sample of unparseable output

3.5 Test Command Not Found

• Create test method test_run_tests_gate_command_not_found
• Mock subprocess to raise FileNotFoundError for pytest
• Execute test gate
• Verify gate handles missing test command gracefully
• Assert gate passes with warning (tool not installed)
• Check warning logged indicating pytest not found

3.6 Test Timeout

• Create test method test_run_tests_gate_timeout
• Mock pytest to exceed 5-minute timeout
• Execute test gate
• Verify subprocess.TimeoutExpired is caught
• Assert gate fails with "Tests timed out" message
• Check timeout duration included in error

3.7 Linter Returns Non-Zero Without Errors

• Create test method test_run_linting_gate_false_positive
• Mock ruff to return exit code 1 but empty error output
• Execute linting gate
• Verify gate handles ambiguous result
• Assert gate passes or fails based on output parsing
• Check edge case logged for investigation

4. Context Management Edge Cases

Add edge case tests to file:tests/context/test_flash_save.py:

4.1 Flash Save with No COLD Items

• Create test method test_flash_save_no_cold_items_to_archive
• Create context items all in HOT or WARM tiers
• Execute context_manager.flash_save(project_id, agent_id)
• Verify checkpoint created successfully
• Assert items_archived count is 0
• Check tokens_before equals tokens_after (no reduction)
• Verify flash save completes without error

4.2 Restore Checkpoint That Doesn't Exist

• Create test method test_restore_checkpoint_not_found
• Attempt to restore checkpoint with non-existent ID
• Verify restore operation fails gracefully
• Assert error message indicates checkpoint not found
• Check no context items modified
• Verify database state unchanged

4.3 Context Items with Duplicate IDs

• Create test method test_create_context_item_duplicate_id
• Create context item with specific ID
• Attempt to create another item with same ID
• Verify primary key constraint prevents duplicate
• Assert appropriate error raised (IntegrityError)
• Check only first item exists in database

4.4 Tier Assignment with Missing Fields

• Create test method test_assign_tier_missing_importance_score
• Create context item without importance_score field
• Attempt tier assignment via update_tiers_for_agent
• Verify tier assignment handles missing score gracefully
• Assert default tier assigned (WARM) or error raised
• Check error message indicates missing field

4.5 Flash Save Threshold Edge Case

• Create test method test_flash_save_exactly_at_threshold
• Create context items totaling exactly 144k tokens (80% of 180k)
• Execute should_flash_save check
• Verify threshold comparison uses >= (not >)
• Assert flash save triggers at exact threshold
• Check boundary condition handled correctly

4.6 Checkpoint Data Corruption

• Create test method test_restore_checkpoint_corrupted_data
• Create checkpoint with invalid JSON in checkpoint_data field
• Attempt to restore checkpoint
• Verify JSON parsing error caught gracefully
• Assert restore fails with clear error message
• Check no partial restoration occurs

5. Test Organization and Fixtures

5.1 Create Shared Fixtures

• Add to file:tests/conftest.py:
  • @pytest.fixture for temp_db_with_foreign_keys (enables FK constraints)
  • @pytest.fixture for mock_anthropic_rate_limit_error
  • @pytest.fixture for mock_anthropic_timeout_error
  • @pytest.fixture for task_with_empty_description
  • @pytest.fixture for task_with_malformed_json

5.2 Add Test Markers

• Update file:pytest.ini with new markers:
  • edge_case: marks tests as edge case tests
  • concurrency: marks tests requiring concurrent execution
  • error_handling: marks tests for error handling validation

5.3 Create Test Utilities

• Create file:tests/utils/edge_case_helpers.py:
  • create_invalid_utf8_string() - generates invalid UTF-8 bytes
  • create_oversized_context(token_count) - generates context exceeding token limit
  • simulate_database_lock(db, duration) - helper for lock testing
  • create_malformed_json() - generates various malformed JSON patterns

6. Documentation and Coverage

6.1 Update Test Documentation

• Update file:TESTING.md:
  • Add section "Edge Case Testing Strategy"
  • Document each edge case category with examples
  • Include troubleshooting guide for edge case failures
  • Add coverage targets for edge cases (>80%)

6.2 Coverage Verification

• Run coverage analysis: pytest --cov=codeframe --cov-report=html
• Verify edge case coverage >80% for each component:
  • Agent execution error paths
  • Database constraint violations
  • Quality gate failure scenarios
  • Context management boundary conditions
• Generate coverage report highlighting edge case coverage

6.3 CI/CD Integration

• Update CI configuration to run edge case tests separately
• Add edge case test suite to PR checks
• Configure failure notifications for edge case regressions
• Set coverage threshold enforcement for edge cases

7. Validation and Acceptance

7.1 Run Complete Test Suite

• Execute: pytest -v -m edge_case
• Verify all edge case tests pass
• Check no regressions in existing tests
• Validate test execution time <5 minutes

7.2 Manual Edge Case Verification

• Test each edge case manually in development environment
• Verify error messages are clear and actionable
• Check logging provides sufficient diagnostic information
• Validate graceful degradation behavior

7.3 Documentation Review

• Review all test docstrings for clarity
• Ensure edge cases documented in code comments
• Verify error handling patterns consistent across components
• Check acceptance criteria met for each edge case

Test Execution Flow

graph TD
    A[Start Edge Case Testing] --> B[Agent Execution Tests]
    B --> C[Database Operations Tests]
    C --> D[Quality Gates Tests]
    D --> E[Context Management Tests]
    E --> F[Run Coverage Analysis]
    F --> G{Coverage >80%?}
    G -->|Yes| H[Update Documentation]
    G -->|No| I[Add Missing Tests]
    I --> F
    H --> J[CI/CD Integration]
    J --> K[Manual Validation]
    K --> L[Complete]

Loading

Edge Case Coverage Matrix

Component	Edge Cases	Test Files	Priority
Agent Execution	7 cases	test_worker_agent.py	P0 - Critical
Database Operations	6 cases	test_database.py	P0 - Critical
Quality Gates	7 cases	test_quality_gates_edge_cases.py (new)	P1 - High
Context Management	6 cases	test_flash_save.py	P2 - Medium
Total	26 edge cases	3 test files	-

Success Criteria

• ✅ All 26 edge case tests implemented and passing
• ✅ Edge case coverage >80% for each core component
• ✅ No regressions in existing 111 tests
• ✅ Error messages clear and actionable for all edge cases
• ✅ Graceful degradation verified for all failure scenarios
• ✅ Documentation updated with edge case testing strategy
• ✅ CI/CD pipeline includes edge case test suite

Import In IDE

🤖 Prompt for AI Agents

## Observations

The codebase has solid test coverage for happy paths (111 tests, 100% pass rate) but lacks comprehensive edge case testing across core components. Current tests focus on successful scenarios with mocked dependencies. The four core components (Agent Execution, Database Operations, Quality Gates, Context Management) have basic functionality implemented but missing critical error handling tests. The testing infrastructure uses pytest with async support, fixtures, and markers for categorization. No existing tests for quality gates edge cases were found.

## Approach

The implementation will follow a systematic approach to add edge case tests for each core component, organized by priority and component. Tests will be added to existing test files where appropriate, or new test files created for untested components (quality gates). Each edge case will have dedicated test methods following the existing naming conventions (`test_<component>_<edge_case>`). Tests will use real database connections and minimal mocking to validate actual error handling behavior. The plan prioritizes edge cases that could cause production failures, starting with Agent Execution and Database Operations.

## Implementation Steps

### 1. Agent Execution Edge Cases

Add edge case tests to `file:tests/agents/test_worker_agent.py`:

**1.1 Empty Task Description**
- Create test method `test_execute_task_empty_description`
- Instantiate `WorkerAgent` with valid configuration
- Create task with `description=""` using database fixture
- Call `agent.execute_task(task)` and assert result status is "failed"
- Verify error message contains "description cannot be empty"
- Ensure no API call is made (check rate limiter not decremented)

**1.2 Malformed JSON Context**
- Create test method `test_execute_task_malformed_json_context`
- Create task with context field containing invalid JSON string
- Execute task and verify graceful failure with clear error message
- Check that task status is updated to "failed" in database
- Verify error is logged with appropriate severity

**1.3 Invalid Model Name**
- Create test method `test_execute_task_invalid_model_name`
- Initialize `WorkerAgent` with `model_name="invalid-model-xyz"`
- Execute task and verify API rejects invalid model
- Assert error message indicates invalid model name
- Verify task marked as failed with specific error code

**1.4 API Rate Limit Exceeded**
- Create test method `test_execute_task_api_rate_limit_exceeded`
- Mock Anthropic API to raise `RateLimitError` on first 3 attempts
- Verify retry logic exhausts attempts (3 retries)
- Assert final result status is "failed" with error "RATE_LIMIT_EXCEEDED"
- Verify exponential backoff delays are applied

**1.5 API Timeout**
- Create test method `test_execute_task_api_timeout`
- Mock API call to raise `APITimeoutError`
- Verify retry logic attempts 3 times
- Assert timeout error is caught and task marked as failed
- Check error message includes timeout duration

**1.6 Network Error**
- Create test method `test_execute_task_network_error`
- Mock API to raise `APIConnectionError`
- Verify retry mechanism handles connection failures
- Assert graceful degradation after retry exhaustion
- Verify error logged with network diagnostic info

**1.7 Context Exceeds Token Limit Mid-Execution**
- Create test method `test_execute_task_context_exceeds_token_limit`
- Create task with description that will exceed 200k token limit
- Mock token counter to return value > 200000
- Execute task and verify it fails before API call
- Assert error message indicates token limit exceeded
- Verify cost estimation prevents expensive call

### 2. Database Operations Edge Cases

Add edge case tests to `file:tests/persistence/test_database.py`:

**2.1 Concurrent Writes to Same Task**
- Create test class `TestDatabaseConcurrency`
- Create test method `test_concurrent_task_updates`
- Use `threading` or `asyncio` to simulate concurrent writes
- Create 10 threads attempting to update same task simultaneously
- Verify database handles concurrent writes without corruption
- Assert final task state is consistent (last write wins or proper locking)
- Check no database errors or deadlocks occur

**2.2 Database Locked During Write**
- Create test method `test_save_task_during_database_lock`
- Acquire exclusive lock: `BEGIN EXCLUSIVE` transaction
- Attempt write operation from different connection
- Verify operation either waits or raises `DatabaseLockError`
- Assert retry mechanism handles lock timeout gracefully
- Verify data integrity maintained after lock release

**2.3 Invalid UTF-8 in Task Description**
- Create test method `test_create_task_invalid_utf8`
- Create task with description containing invalid UTF-8 bytes
- Attempt to save to database
- Verify database rejects or sanitizes invalid encoding
- Assert error message indicates encoding issue
- Check task creation fails gracefully without database corruption

**2.4 Missing Foreign Key (Task → Issue)**
- Create test method `test_create_task_missing_foreign_key`
- Enable foreign key constraints: `PRAGMA foreign_keys = ON`
- Attempt to create task with non-existent `issue_id`
- Verify foreign key constraint violation is raised
- Assert task creation fails with clear error message
- Check database remains in consistent state

**2.5 NULL Values in Required Fields**
- Create test method `test_create_task_null_required_fields`
- Attempt to create task with `title=None` or `description=None`
- Verify NOT NULL constraint is enforced
- Assert appropriate error raised (IntegrityError)
- Check error message identifies which field is NULL
- Verify no partial record created in database

**2.6 Transaction Rollback on Constraint Violation**
- Create test method `test_transaction_rollback_on_constraint_error`
- Start transaction with multiple operations
- Include operation that violates constraint (e.g., duplicate primary key)
- Verify entire transaction rolls back
- Assert no partial data committed
- Check database state unchanged after rollback

### 3. Quality Gates Edge Cases

Create new test file `file:tests/lib/test_quality_gates_edge_cases.py`:

**3.1 Zero Tests Exist**
- Create test class `TestQualityGatesEdgeCases`
- Create test method `test_run_tests_gate_no_tests_found`
- Mock project with no test files
- Execute `gates.run_tests_gate(task)`
- Verify gate fails with message "No tests found"
- Assert blocker created for missing tests
- Check quality gate status updated to "failed"

**3.2 All Tests Skipped**
- Create test method `test_run_tests_gate_all_tests_skipped`
- Mock pytest output showing all tests skipped
- Execute test gate
- Verify gate fails with "All tests skipped" message
- Assert skip detection gate also triggers
- Check blocker created with severity HIGH

**3.3 Coverage Data Unavailable**
- Create test method `test_run_coverage_gate_data_unavailable`
- Mock coverage tool to return no data (file not found)
- Execute `gates.run_coverage_gate(task)`
- Verify gate handles missing coverage data gracefully
- Assert default behavior (fail or pass based on configuration)
- Check error logged with diagnostic information

**3.4 Test Output Unparseable**
- Create test method `test_run_tests_gate_unparseable_output`
- Mock pytest to return malformed output (corrupted JSON)
- Execute test gate
- Verify parser handles unparseable output without crashing
- Assert gate fails with "Unable to parse test results"
- Check error includes sample of unparseable output

**3.5 Test Command Not Found**
- Create test method `test_run_tests_gate_command_not_found`
- Mock subprocess to raise `FileNotFoundError` for pytest
- Execute test gate
- Verify gate handles missing test command gracefully
- Assert gate passes with warning (tool not installed)
- Check warning logged indicating pytest not found

**3.6 Test Timeout**
- Create test method `test_run_tests_gate_timeout`
- Mock pytest to exceed 5-minute timeout
- Execute test gate
- Verify `subprocess.TimeoutExpired` is caught
- Assert gate fails with "Tests timed out" message
- Check timeout duration included in error

**3.7 Linter Returns Non-Zero Without Errors**
- Create test method `test_run_linting_gate_false_positive`
- Mock ruff to return exit code 1 but empty error output
- Execute linting gate
- Verify gate handles ambiguous result
- Assert gate passes or fails based on output parsing
- Check edge case logged for investigation

### 4. Context Management Edge Cases

Add edge case tests to `file:tests/context/test_flash_save.py`:

**4.1 Flash Save with No COLD Items**
- Create test method `test_flash_save_no_cold_items_to_archive`
- Create context items all in HOT or WARM tiers
- Execute `context_manager.flash_save(project_id, agent_id)`
- Verify checkpoint created successfully
- Assert `items_archived` count is 0
- Check `tokens_before` equals `tokens_after` (no reduction)
- Verify flash save completes without error

**4.2 Restore Checkpoint That Doesn't Exist**
- Create test method `test_restore_checkpoint_not_found`
- Attempt to restore checkpoint with non-existent ID
- Verify restore operation fails gracefully
- Assert error message indicates checkpoint not found
- Check no context items modified
- Verify database state unchanged

**4.3 Context Items with Duplicate IDs**
- Create test method `test_create_context_item_duplicate_id`
- Create context item with specific ID
- Attempt to create another item with same ID
- Verify primary key constraint prevents duplicate
- Assert appropriate error raised (IntegrityError)
- Check only first item exists in database

**4.4 Tier Assignment with Missing Fields**
- Create test method `test_assign_tier_missing_importance_score`
- Create context item without `importance_score` field
- Attempt tier assignment via `update_tiers_for_agent`
- Verify tier assignment handles missing score gracefully
- Assert default tier assigned (WARM) or error raised
- Check error message indicates missing field

**4.5 Flash Save Threshold Edge Case**
- Create test method `test_flash_save_exactly_at_threshold`
- Create context items totaling exactly 144k tokens (80% of 180k)
- Execute `should_flash_save` check
- Verify threshold comparison uses >= (not >)
- Assert flash save triggers at exact threshold
- Check boundary condition handled correctly

**4.6 Checkpoint Data Corruption**
- Create test method `test_restore_checkpoint_corrupted_data`
- Create checkpoint with invalid JSON in `checkpoint_data` field
- Attempt to restore checkpoint
- Verify JSON parsing error caught gracefully
- Assert restore fails with clear error message
- Check no partial restoration occurs

### 5. Test Organization and Fixtures

**5.1 Create Shared Fixtures**
- Add to `file:tests/conftest.py`:
  - `@pytest.fixture` for `temp_db_with_foreign_keys` (enables FK constraints)
  - `@pytest.fixture` for `mock_anthropic_rate_limit_error`
  - `@pytest.fixture` for `mock_anthropic_timeout_error`
  - `@pytest.fixture` for `task_with_empty_description`
  - `@pytest.fixture` for `task_with_malformed_json`

**5.2 Add Test Markers**
- Update `file:pytest.ini` with new markers:
  - `edge_case: marks tests as edge case tests`
  - `concurrency: marks tests requiring concurrent execution`
  - `error_handling: marks tests for error handling validation`

**5.3 Create Test Utilities**
- Create `file:tests/utils/edge_case_helpers.py`:
  - `create_invalid_utf8_string()` - generates invalid UTF-8 bytes
  - `create_oversized_context(token_count)` - generates context exceeding token limit
  - `simulate_database_lock(db, duration)` - helper for lock testing
  - `create_malformed_json()` - generates various malformed JSON patterns

### 6. Documentation and Coverage

**6.1 Update Test Documentation**
- Update `file:TESTING.md`:
  - Add section "Edge Case Testing Strategy"
  - Document each edge case category with examples
  - Include troubleshooting guide for edge case failures
  - Add coverage targets for edge cases (>80%)

**6.2 Coverage Verification**
- Run coverage analysis: `pytest --cov=codeframe --cov-report=html`
- Verify edge case coverage >80% for each component:
  - Agent execution error paths
  - Database constraint violations
  - Quality gate failure scenarios
  - Context management boundary conditions
- Generate coverage report highlighting edge case coverage

**6.3 CI/CD Integration**
- Update CI configuration to run edge case tests separately
- Add edge case test suite to PR checks
- Configure failure notifications for edge case regressions
- Set coverage threshold enforcement for edge cases

### 7. Validation and Acceptance

**7.1 Run Complete Test Suite**
- Execute: `pytest -v -m edge_case`
- Verify all edge case tests pass
- Check no regressions in existing tests
- Validate test execution time <5 minutes

**7.2 Manual Edge Case Verification**
- Test each edge case manually in development environment
- Verify error messages are clear and actionable
- Check logging provides sufficient diagnostic information
- Validate graceful degradation behavior

**7.3 Documentation Review**
- Review all test docstrings for clarity
- Ensure edge cases documented in code comments
- Verify error handling patterns consistent across components
- Check acceptance criteria met for each edge case

## Test Execution Flow

```mermaid
graph TD
    A[Start Edge Case Testing] --> B[Agent Execution Tests]
    B --> C[Database Operations Tests]
    C --> D[Quality Gates Tests]
    D --> E[Context Management Tests]
    E --> F[Run Coverage Analysis]
    F --> G{Coverage >80%?}
    G -->|Yes| H[Update Documentation]
    G -->|No| I[Add Missing Tests]
    I --> F
    H --> J[CI/CD Integration]
    J --> K[Manual Validation]
    K --> L[Complete]
```

## Edge Case Coverage Matrix

| Component | Edge Cases | Test Files | Priority |
|-----------|-----------|------------|----------|
| Agent Execution | 7 cases | `test_worker_agent.py` | P0 - Critical |
| Database Operations | 6 cases | `test_database.py` | P0 - Critical |
| Quality Gates | 7 cases | `test_quality_gates_edge_cases.py` (new) | P1 - High |
| Context Management | 6 cases | `test_flash_save.py` | P2 - Medium |
| **Total** | **26 edge cases** | **3 test files** | - |

## Success Criteria

- ✅ All 26 edge case tests implemented and passing
- ✅ Edge case coverage >80% for each core component
- ✅ No regressions in existing 111 tests
- ✅ Error messages clear and actionable for all edge cases
- ✅ Graceful degradation verified for all failure scenarios
- ✅ Documentation updated with edge case testing strategy
- ✅ CI/CD pipeline includes edge case test suite

---

Execution Information

Branch: main
Commit: 1169cb6