storybook/LSP_TEST_STRATEGY.md

LSP Testing Strategy

Version: 1.0 Date: 2026-02-12 Owner: LSP Test Engineer

---

Executive Summary

This document outlines a comprehensive testing strategy for the Storybook LSP implementation, designed to achieve 85% code coverage and zero critical bugs within 4-6 weeks. The strategy is divided into 5 phases, prioritized by immediate blocking issues first, followed by coverage expansion, integration testing, automation, and finally multi-file support.

---

Strategy Goals

Primary Objectives

1. Fix Critical Bugs: Resolve 2 compilation errors blocking all tests
2. Achieve Stability: 100% of tests pass reliably
3. Expand Coverage: Reach 80%+ code coverage across all LSP features
4. Enable Automation: Set up CI/CD for continuous testing
5. Support Multi-File: Prepare infrastructure for cross-file navigation

Success Metrics

• Week 1: All tests compile and run (100% pass rate)
• Week 2: All features have dedicated unit tests (70% coverage)
• Week 3: Integration tests complete (80% coverage)
• Week 4: CI/CD operational, benchmarks established
• Weeks 5-6: Multi-file support tested (85% coverage)

---

Testing Pyramid

           /\
          /  \         E2E Tests (5%)
         /____\        - Zed extension integration
        /      \       - Real-world scenarios
       /  INTEG \
      /__________\     Integration Tests (15%)
     /            \    - Multi-file scenarios
    /  UNIT TESTS \   - Concurrent access
   /________________\  - Document lifecycle
  /                  \
 /   UNIT TESTS 80%  \ Unit Tests (80%)
/____________________\ - Feature-specific tests
                       - Edge cases
                       - Error conditions

Rationale:

• 80% Unit Tests - Fast feedback, easy to debug, high confidence in individual components
• 15% Integration Tests - Validate feature interactions, realistic scenarios
• 5% E2E Tests - Validate actual editor integration (Zed)

---

Phase 1: Stabilization (Days 1-2)

Objective

Fix blocking compilation errors and establish baseline test health.

Tasks

1.1 Fix Compilation Errors

Priority: CRITICAL Estimated Time: 30 minutes

Bug #1: Inlay Hints Import Path

• File: storybook/src/lsp/inlay_hints.rs:134
• Current: crate::project::positions::PositionTracker
• Fix: crate::position::PositionTracker
• Verification: cargo check

Bug #2: Completion Type Annotation

• File: storybook/src/lsp/completion.rs:421
• Current: let mut nesting_level = 0;
• Fix: let mut nesting_level: i32 = 0;
• Verification: cargo check

1.2 Baseline Test Run

Priority: CRITICAL Estimated Time: 1 hour

# Compile tests
cd /Users/sienna/Development/storybook/storybook
cargo test --lib lsp --no-run

# Run all LSP tests
cargo test --lib lsp

# Document results
# - Total tests run
# - Pass/fail counts
# - Any flaky tests
# - Performance outliers

Deliverable: Test baseline report

• Total test count (expect ~147)
• Pass rate (target: 100%)
• Test execution time
• Flaky test identification

1.3 Tree-sitter Verification

Priority: HIGH Estimated Time: 30 minutes

cd /Users/sienna/Development/storybook/tree-sitter-storybook
npm run test

Verification: All 27 tests pass

Phase 1 Deliverables

• ✅ All compilation errors fixed
• ✅ All tests compile successfully
• ✅ Baseline test report with 100% pass rate
• ✅ Tree-sitter tests verified
• ✅ List of any identified issues for Phase 2

---

Phase 2: Coverage Expansion (Days 3-7)

Objective

Fill test coverage gaps for under-tested features and add edge case testing.

2.1 Feature-Specific Unit Tests

2.1.1 Hover Tests

File: Create storybook/src/lsp/hover_tests.rs Estimated Time: 3 hours Target: 15 tests

Test Categories:

1. Basic Hover (3 tests)

   • Hover on character name
   • Hover on template name
   • Hover on behavior name

2. Type Information (4 tests)

   • Hover on field shows type
   • Hover on species reference
   • Hover on template reference
   • Hover on behavior reference

3. Documentation (4 tests)

   • Hover shows field documentation
   • Hover shows prose blocks
   • Hover on state shows transitions
   • Hover on schedule shows time blocks

4. Edge Cases (4 tests)

   • Hover on whitespace (returns None)
   • Hover on comment (returns None)
   • Hover at EOF (returns None)
   • Hover on invalid position (returns None)

Coverage Target: 85%

2.1.2 Formatting Tests

File: Create storybook/src/lsp/formatting_tests.rs Estimated Time: 3 hours Target: 15 tests

Test Categories:

1. Indentation (5 tests)

   • Character block indentation
   • Template block indentation
   • Nested behavior indentation
   • Life arc state indentation
   • Consistent tab/space usage

2. Spacing (4 tests)

   • Spacing around colons
   • Spacing around braces
   • Line breaks between declarations
   • Trailing whitespace removal

3. Alignment (3 tests)

   • Field alignment in blocks
   • Comment alignment
   • Multiline value alignment

4. Edge Cases (3 tests)

   • Empty document formatting
   • Already-formatted document (no changes)
   • Document with syntax errors (graceful handling)

Coverage Target: 80%

2.1.3 Rename Tests

File: Create storybook/src/lsp/rename_tests.rs Estimated Time: 2 hours Target: 12 tests

Test Categories:

1. Basic Rename (4 tests)

   • Rename character (updates all references)
   • Rename template (updates all uses)
   • Rename behavior (updates all calls)
   • Rename field (updates all occurrences)

2. Scope Testing (3 tests)

   • Rename doesn't affect different scope
   • Rename preserves capitalization context
   • Rename updates definition + all uses

3. Validation (3 tests)

   • Reject invalid identifier names
   • Reject rename to existing symbol
   • Reject rename of built-in keywords

4. Edge Cases (2 tests)

   • Rename at EOF
   • Rename in comment (should fail gracefully)

Coverage Target: 80%

2.1.4 Semantic Tokens Tests

File: Create storybook/src/lsp/semantic_tokens_tests.rs Estimated Time: 3 hours Target: 15 tests

Test Categories:

1. Token Types (7 tests)

   • Character tokens (type.character)
   • Template tokens (type.template)
   • Behavior tokens (type.behavior)
   • Keyword tokens (keyword.declaration)
   • Field tokens (property)
   • String tokens (string)
   • Number tokens (constant.numeric)

2. Token Modifiers (3 tests)

   • Definition modifier
   • Reference modifier
   • Deprecated modifier (if applicable)

3. Complex Scenarios (3 tests)

   • Nested structures (correct scoping)
   • Multiline declarations
   • Mixed token types in single line

4. Edge Cases (2 tests)

   • Empty document (no tokens)
   • Syntax errors (partial tokenization)

Coverage Target: 80%

2.2 Edge Case Testing Suite

2.2.1 Large File Tests

File: Create storybook/src/lsp/stress_tests.rs Estimated Time: 4 hours Target: 10 tests

Test Categories:

1. Size Tests (4 tests)

   • 1,000 line document
   • 10,000 line document
   • 50,000 line document
   • Document with 1,000+ symbols

2. Depth Tests (3 tests)

   • 10-level nested behaviors
   • 20-level nested behaviors
   • Deeply nested template includes

3. Performance Tests (3 tests)

   • Parse time < 100ms for 1,000 lines
   • Symbol extraction < 50ms
   • Completion latency < 20ms

Coverage Target: N/A (performance validation)

2.2.2 Unicode and Special Characters

File: Add to storybook/src/lsp/document_edge_tests.rs Estimated Time: 2 hours Target: 8 tests

Test Categories:

1. Unicode Identifiers (3 tests)

   • Chinese character names: character 爱丽丝 {}
   • Emoji in prose: ---backstory\n😊\n---
   • Mixed scripts: character Αλίκη {}

2. Special Characters (3 tests)

   • Underscores in identifiers
   • Hyphens in strings
   • Escape sequences in strings

3. Boundary Conditions (2 tests)

   • Zero-width characters
   • RTL text in prose blocks

Coverage Target: 85%

2.2.3 Malformed Input Tests

File: Create storybook/src/lsp/error_recovery_tests.rs Estimated Time: 3 hours Target: 12 tests

Test Categories:

1. Truncated Files (4 tests)

   • Incomplete character block
   • Unclosed prose block
   • Missing closing brace
   • Truncated at field value

2. Invalid UTF-8 (2 tests)

   • Invalid byte sequences
   • Null bytes in content

3. Syntax Errors (4 tests)

   • Missing colons in fields
   • Invalid identifiers (starting with numbers)
   • Unmatched braces
   • Invalid keywords

4. Graceful Degradation (2 tests)

   • Partial symbol extraction on errors
   • Diagnostics still generated
   • Server doesn't crash

Coverage Target: 90%

Phase 2 Deliverables

• ✅ 4 new test modules created (~57 new tests)
• ✅ Coverage increased from ~60% to 80%
• ✅ All features have dedicated unit tests
• ✅ Edge cases comprehensively tested

---

Phase 3: Integration Testing (Days 8-12)

Objective

Validate feature interactions and real-world scenarios.

3.1 Multi-File Scenarios

3.1.1 Multi-File Test Suite

File: Create storybook/src/lsp/integration_tests.rs Estimated Time: 6 hours Target: 15 tests

Test Categories:

1. Use Declarations (3 tests)

   • Import character from another file
   • Import template from another file
   • Wildcard imports (use characters::*)

2. Cross-File References (4 tests)

   • Template include from another file
   • Species reference from another file
   • Behavior subtree reference (@module::tree)
   • Relationship participants from other files

3. Workspace State (3 tests)

   • Workspace rebuild on file add
   • Workspace rebuild on file remove
   • Workspace rebuild on file modify

4. Symbol Resolution (3 tests)

   • Go-to-definition across files (even if not fully supported)
   • Find references across files (even if not fully supported)
   • Completion shows cross-file symbols (even if not fully supported)

5. Edge Cases (2 tests)

   • Circular dependencies
   • Missing import targets

Note: These tests document expected behavior even if cross-file support isn't fully implemented. They serve as regression tests for when Phase 5 is implemented.

Coverage Target: Establish baseline for multi-file features

3.1.2 Concurrent Access Tests

File: Create storybook/src/lsp/concurrency_tests.rs Estimated Time: 4 hours Target: 8 tests

Test Categories:

1. Multiple Clients (3 tests)

   • Two clients open same document
   • Simultaneous edits from different clients
   • One client closes while other edits

2. Rapid Operations (3 tests)

   • Rapid did_change events
   • Open/close/reopen sequences
   • Completion requests during editing

3. Locking (2 tests)

   • No deadlocks on concurrent reads
   • Write lock releases properly

Coverage Target: Validate concurrency safety

3.2 Document Lifecycle Tests

3.2.1 Lifecycle Integration

File: Add to storybook/src/lsp/integration_tests.rs Estimated Time: 3 hours Target: 10 tests

Test Categories:

1. Open/Edit/Close (4 tests)

   • Normal lifecycle (open → edit → close)
   • Multiple edits before close
   • Close without edit
   • Reopen after close

2. State Consistency (3 tests)

   • Symbols update on edit
   • Diagnostics update on edit
   • Workspace rebuilds on change

3. Error Recovery (3 tests)

   • Server survives parse errors
   • Server survives malformed edits
   • Server recovers from invalid positions

Coverage Target: 90% of document.rs

Phase 3 Deliverables

• ✅ Integration test suite (33 tests)
• ✅ Multi-file behavior documented
• ✅ Concurrency safety validated
• ✅ Document lifecycle coverage > 90%

---

Phase 4: Automation & Performance (Days 13-15)

Objective

Enable automated testing and establish performance baselines.

4.1 CI/CD Setup

4.1.1 GitHub Actions Workflow

File: Create .github/workflows/lsp-tests.yml Estimated Time: 4 hours

Workflow Components:

1. Test Jobs

   • Rust version: stable, nightly
   • OS: ubuntu-latest, macos-latest
   • Run: cargo test --lib lsp

2. Coverage Job

   • Tool: cargo-tarpaulin or cargo-llvm-cov
   • Upload to: codecov.io or coveralls.io
   • Fail if coverage < 75%

3. Tree-sitter Job

   • Setup: Node.js 18+
   • Run: cd tree-sitter-storybook && npm test

4. Benchmark Job

   • Run: cargo bench --bench lsp_benchmarks
   • Upload results for regression tracking

Triggers:

• On push to main
• On pull requests
• Nightly (for performance tracking)

4.1.2 Pre-commit Hooks

File: Update .github/workflows/pre-commit.yml or lefthook.yml Estimated Time: 1 hour

Hooks:

• cargo test --lib lsp (fast tests only)
• cargo clippy (linting)
• cargo fmt --check (formatting)

4.2 Performance Benchmarking

4.2.1 Benchmark Suite

File: Create storybook/benches/lsp_benchmarks.rs Estimated Time: 6 hours

Benchmarks:

1. Parse Benchmarks (4 benchmarks)

   • Small file (100 lines)
   • Medium file (1,000 lines)
   • Large file (10,000 lines)
   • Very large file (50,000 lines)

2. Symbol Extraction (3 benchmarks)

   • 10 symbols
   • 100 symbols
   • 1,000 symbols

3. Completion (3 benchmarks)

   • Field completion (10 options)
   • Template completion (100 options)
   • Completion in large file

4. Navigation (3 benchmarks)

   • Go-to-definition in small file
   • Go-to-definition in large file
   • Find references (100 occurrences)

5. Workspace (2 benchmarks)

   • Workspace rebuild (10 files)
   • Workspace rebuild (100 files)

Tool: Use criterion.rs for statistical analysis

Baselines:

• Parse: < 10ms per 1,000 lines
• Symbol extraction: < 5ms per 100 symbols
• Completion: < 20ms latency
• Navigation: < 10ms per operation
• Workspace rebuild: < 100ms per 10 files

4.2.2 Memory Profiling

Estimated Time: 3 hours

Profiling Scenarios:

1. Memory usage with 100 open documents
2. Memory usage with 1,000+ symbols
3. Memory leak detection (long-running session)

Tools:

• valgrind (Linux)
• instruments (macOS)
• heaptrack (cross-platform)

Phase 4 Deliverables

• ✅ CI/CD pipeline operational
• ✅ Code coverage reporting automated
• ✅ Benchmark suite established
• ✅ Performance baselines documented
• ✅ Memory profiling completed

---

Phase 5: Multi-File Support (Days 16-30)

Objective

Implement and test cross-file navigation and workspace features.

5.1 Architecture Implementation

5.1.1 Workspace NameTable Integration

File: storybook/src/lsp/server.rs Estimated Time: 8 hours

Changes:

1. Populate WorkspaceState.name_table in rebuild()
2. Use file indices from NameTable
3. Store symbol locations with file indices
4. Expose workspace-level symbol lookup

Testing:

• Unit tests for NameTable population
• Verify symbol file indices correct
• Test incremental updates

5.1.2 Cross-File Go-to-Definition

File: storybook/src/lsp/definition.rs Estimated Time: 6 hours

Changes:

1. Check local document symbols first (fast path)
2. Fall back to workspace NameTable
3. Resolve file URL from file index
4. Return Location with correct file URL

Testing:

• Go to character in another file
• Go to template in another file
• Go to behavior in another file
• Handle missing symbols gracefully

5.1.3 Cross-File Find References

File: storybook/src/lsp/references.rs Estimated Time: 6 hours

Changes:

1. Search all open documents (not just current)
2. Use workspace NameTable for symbol lookup
3. Aggregate results from multiple files
4. Return Locations with file URLs

Testing:

• Find character references across files
• Find template uses across files
• Find behavior calls across files
• Performance with 100+ open files

5.1.4 Use Declaration Resolution

File: Create storybook/src/lsp/imports.rs Estimated Time: 8 hours

Changes:

1. Parse use declarations
2. Resolve module paths to file URLs
3. Populate symbol table from imports
4. Handle grouped imports (use foo::{bar, baz})
5. Handle wildcard imports (use foo::*)

Testing:

• Simple use declaration
• Grouped imports
• Wildcard imports
• Nested module paths
• Missing import targets

5.2 Multi-File Test Suite

5.2.1 Cross-File Navigation Tests

File: Create storybook/src/lsp/cross_file_tests.rs Estimated Time: 6 hours Target: 20 tests

Test Categories:

1. Go-to-Definition (5 tests)

   • Navigate to character in other file
   • Navigate to template in other file
   • Navigate to behavior in other file
   • Navigate with nested modules
   • Navigate with use declarations

2. Find References (5 tests)

   • Find character uses across files
   • Find template includes across files
   • Find behavior calls across files
   • Find species references across files
   • Performance with 50+ files

3. Completion (5 tests)

   • Complete imported symbols
   • Complete from wildcard imports
   • Complete nested module paths
   • Complete with use declarations
   • Don't show non-imported symbols

4. Workspace Management (5 tests)

   • Add file updates workspace
   • Remove file updates workspace
   • Modify file updates workspace
   • Rename file updates workspace
   • Large workspace (100+ files)

Coverage Target: 85% of cross-file features

5.2.2 Import Resolution Tests

File: Create storybook/src/lsp/import_tests.rs Estimated Time: 4 hours Target: 15 tests

Test Categories:

1. Simple Imports (3 tests)

   • use characters::Alice;
   • use templates::Child;
   • use behaviors::Walk;

2. Grouped Imports (3 tests)

   • use characters::{Alice, Bob};
   • use templates::{Child, Adult};
   • Mixed types in group

3. Wildcard Imports (3 tests)

   • use characters::*;
   • Multiple wildcards from different modules
   • Wildcard precedence

4. Nested Modules (3 tests)

   • use world::characters::Alice;
   • use world::locations::wonderland::Garden;
   • Deep nesting (5+ levels)

5. Edge Cases (3 tests)

   • Import non-existent symbol
   • Circular imports
   • Import from self

Coverage Target: 90% of import resolution

Phase 5 Deliverables

• ✅ Cross-file navigation implemented
• ✅ Use declaration resolution working
• ✅ Workspace NameTable populated
• ✅ 35 new multi-file tests
• ✅ Overall coverage > 85%

---

Test Execution Strategy

Daily Test Runs

# Quick sanity check (< 5 seconds)
cargo test --lib lsp -- --test-threads=1 --nocapture

# Full test suite (< 2 minutes)
cargo test --lib lsp

# With coverage (< 5 minutes)
cargo tarpaulin --lib --out Html --output-dir coverage

# Tree-sitter tests (< 10 seconds)
cd tree-sitter-storybook && npm test

Weekly Test Runs

# Performance benchmarks (~ 10 minutes)
cargo bench --bench lsp_benchmarks

# Memory profiling (~ 15 minutes)
./scripts/memory_profile.sh

# Stress tests (~ 20 minutes)
cargo test --lib lsp --release -- stress_tests

Pre-Release Test Runs

# Full suite with coverage
cargo tarpaulin --lib --out Html --output-dir coverage

# Performance regression check
cargo bench --bench lsp_benchmarks -- --save-baseline main

# Integration tests
cargo test --test '*'

# E2E tests (manual)
# 1. Build Zed extension
# 2. Test in Zed editor
# 3. Validate all LSP features work

---

Coverage Measurement

Tools

1. cargo-tarpaulin - Code coverage for Rust

   cargo install cargo-tarpaulin
   cargo tarpaulin --lib --out Html --output-dir coverage
   

2. cargo-llvm-cov - Alternative coverage tool

   cargo install cargo-llvm-cov
   cargo llvm-cov --html --lib
   

Coverage Targets by Phase

Phase	Target	Focus
Phase 1	60%	Existing tests
Phase 2	80%	Feature coverage
Phase 3	82%	Integration
Phase 4	83%	Automation
Phase 5	85%	Multi-file

Coverage Exemptions

• Generated code (tree-sitter bindings)
• Test utilities and fixtures
• Deprecated code paths
• Unreachable error handling (panic paths)

---

Risk Management

High-Risk Areas

1. Concurrency Bugs

   • Risk: Deadlocks, race conditions in RwLock usage
   • Mitigation: Dedicated concurrency test suite, stress testing
   • Detection: Thread sanitizer, long-running tests

2. Performance Regressions

   • Risk: Features slow down with large files/workspaces
   • Mitigation: Benchmark suite, performance tracking in CI
   • Detection: Criterion benchmarks, regression alerts

3. Memory Leaks

   • Risk: Documents not cleaned up, symbol table grows unbounded
   • Mitigation: Memory profiling, leak detection tools
   • Detection: Valgrind, long-running session tests

4. Cross-File State Corruption

   • Risk: NameTable inconsistencies, stale file references
   • Mitigation: Workspace state validation tests
   • Detection: Integration tests, state invariant checks

Medium-Risk Areas

1. Unicode Handling

   • Risk: Position calculations off by one with multi-byte chars
   • Mitigation: Comprehensive unicode test suite
   • Detection: Unicode-heavy test files

2. Error Recovery

   • Risk: Server crashes on malformed input
   • Mitigation: Fuzz testing, malformed input tests
   • Detection: Error recovery test suite

3. Zed Integration

   • Risk: LSP features not working in actual editor
   • Mitigation: E2E testing in Zed
   • Detection: Manual testing, user feedback

---

Test Maintenance

Test Naming Convention

// Pattern: test_<feature>_<scenario>_<expected_result>
#[test]
fn test_goto_definition_character_in_same_file() { ... }

#[test]
fn test_completion_field_after_colon() { ... }

#[test]
fn test_diagnostics_parse_error_missing_brace() { ... }

Test Organization

src/lsp/
├── *_tests.rs           # Feature-specific unit tests
├── integration_tests.rs # Multi-feature integration
├── stress_tests.rs      # Performance and scale
└── cross_file_tests.rs  # Multi-file scenarios

Test Documentation

• Each test file has module-level doc comment explaining scope
• Each test has doc comment explaining scenario
• Complex tests have inline comments for key assertions

Test Refactoring Guidelines

• Extract common test fixtures to test_utils.rs
• Use builder pattern for complex test data
• Keep tests independent (no shared mutable state)
• Aim for tests < 50 lines each

---

Appendix A: Test Counting Summary

Current Tests (Phase 1)

• behavior_tests.rs: 7
• code_actions_tests.rs: 27
• completion_tests.rs: 10
• diagnostics_tests.rs: 20
• document_edge_tests.rs: 17
• navigation_tests.rs: 11
• validation_tests.rs: 10
• Integration tests: ~45
• Total: ~147 tests

New Tests by Phase

Phase 2 (+57 tests):

• hover_tests.rs: 15
• formatting_tests.rs: 15
• rename_tests.rs: 12
• semantic_tokens_tests.rs: 15

Phase 3 (+33 tests):

• integration_tests.rs: 25
• concurrency_tests.rs: 8

Phase 4 (+15 benchmarks):

• lsp_benchmarks.rs: 15 benchmarks

Phase 5 (+35 tests):

• cross_file_tests.rs: 20
• import_tests.rs: 15

Grand Total: ~287 tests + 15 benchmarks

---

Appendix B: Test Commands Reference

# === LSP Tests ===

# Run all LSP tests
cargo test --lib lsp

# Run specific test file
cargo test --lib lsp::hover_tests

# Run single test
cargo test --lib lsp::hover_tests::test_hover_on_character

# Run tests with output
cargo test --lib lsp -- --nocapture

# Run tests in single thread (for debugging)
cargo test --lib lsp -- --test-threads=1

# === Tree-sitter Tests ===

# Run all tree-sitter tests
cd tree-sitter-storybook && npm test

# Run with verbose output
cd tree-sitter-storybook && npm test -- --debug

# === Coverage ===

# Generate HTML coverage report
cargo tarpaulin --lib --out Html --output-dir coverage

# Coverage with specific minimum threshold
cargo tarpaulin --lib --fail-under 80

# === Benchmarks ===

# Run all benchmarks
cargo bench --bench lsp_benchmarks

# Run specific benchmark
cargo bench --bench lsp_benchmarks -- parse

# Save baseline
cargo bench --bench lsp_benchmarks -- --save-baseline main

# Compare to baseline
cargo bench --bench lsp_benchmarks -- --baseline main

# === Memory Profiling ===

# Linux (valgrind)
valgrind --leak-check=full --show-leak-kinds=all \
  cargo test --lib lsp

# macOS (instruments)
instruments -t Leaks cargo test --lib lsp

# === Linting ===

# Run clippy
cargo clippy --lib

# Run clippy with strict rules
cargo clippy --lib -- -D warnings

# Format check
cargo fmt --check

# Auto-format
cargo fmt

---

Appendix C: Coverage Report Template

# LSP Test Coverage Report
**Date:** YYYY-MM-DD
**Commit:** <git sha>

## Summary
- **Overall Coverage:** XX%
- **Tests Run:** XXX
- **Tests Passed:** XXX
- **Tests Failed:** X
- **Duration:** XX seconds

## Coverage by Module
| Module | Coverage | Lines Covered | Total Lines |
|--------|----------|---------------|-------------|
| server.rs | XX% | XXX / XXX | XXX |
| hover.rs | XX% | XXX / XXX | XXX |
| completion.rs | XX% | XXX / XXX | XXX |
| definition.rs | XX% | XXX / XXX | XXX |
| references.rs | XX% | XXX / XXX | XXX |
| symbols.rs | XX% | XXX / XXX | XXX |
| diagnostics.rs | XX% | XXX / XXX | XXX |
| formatting.rs | XX% | XXX / XXX | XXX |
| rename.rs | XX% | XXX / XXX | XXX |
| code_actions.rs | XX% | XXX / XXX | XXX |
| semantic_tokens.rs | XX% | XXX / XXX | XXX |
| inlay_hints.rs | XX% | XXX / XXX | XXX |

## Uncovered Lines
- server.rs: lines XXX-XXX (error handling)
- completion.rs: line XXX (unreachable branch)

## Recommendations
- [ ] Add tests for uncovered error paths
- [ ] Increase coverage in completion.rs
- [ ] ...

---

Conclusion

This testing strategy provides a clear roadmap from the current broken state (compilation errors) to a fully tested, production-ready LSP implementation with 85% coverage. The phased approach allows for incremental progress while maintaining immediate value at each phase:

• Phase 1 - Unblocks development
• Phase 2 - Achieves stability
• Phase 3 - Validates integration
• Phase 4 - Enables automation
• Phase 5 - Adds advanced features

By following this strategy, the Storybook LSP will become robust, maintainable, and reliable for end users.