┌─────────────────────────────────────────────────────────────┐
│                    API Layer (Fiber)                         │
│  Health Checks │ Project Management │ Build Triggers         │
└────────────────────┬────────────────────────────────────────┘
                     │
┌────────────────────┴────────────────────────────────────────┐
│              Service Layer (Business Logic)                  │
│  ProjectService │ BuildService │ DetectionService │ etc.    │
└────────────────────┬────────────────────────────────────────┘
                     │
         ┌───────────┼───────────┬────────────────┐
         │           │           │                │
    ┌────▼────┐ ┌───▼────┐ ┌───▼──────┐ ┌──────▼──┐
    │Detection │ │Pipeline│ │Executor  │ │Repository
    │Subsystem │ │Generator│ │(Docker)  │ │(Database)
    └──────────┘ └────────┘ └──────────┘ └─────────┘
         │           │           │           │
    ┌────▼────────────┴───────────┴───────────▼───────────┐
    │         Loco Deployment Orchestration               │
    │  (Railway/Multi-cloud Deployment Management)        │
    └────────────────────────────────────────────────────┘
         │
    ┌────▼────────────────────────────────────────────┐
    │      Infrastructure Layer                       │
    │  PostgreSQL │ Redis │ Docker │ Prometheus       │
    └─────────────────────────────────────────────────┘

Level 1: Unit Tests (Deterministic, No External Dependencies)
├── Core Types & Structures
├── Business Logic
├── Error Handling
└── Concurrent Operations (50-100 goroutines)

Level 2: Integration Tests (With Infrastructure)
├── Database Operations
├── Cache Operations
├── API Endpoints
└── Cross-service Communication

Level 3: System Tests (Full Workflow)
├── End-to-end Project Creation
├── Detection → Pipeline → Build
├── Multi-project Concurrent Handling
└── Failure Recovery

type TestContext struct {
    Context   context.Context
    Cancel    context.CancelFunc
    Logger    *zap.Logger
    Registry  *prometheus.Registry  // Isolated for each test
    Timeout   time.Duration
    Cleanup   []func()              // LIFO cleanup
}

// Builders for consistent test data
- DetectionResultBuilder
- PipelineBuilder
- TestArtifactBuilder
- TestConfigBuilder

// Pre-configured test data sets
TestDataSets.GoLanguageFrameworks
TestDataSets.PythonLanguageFrameworks
TestDataSets.RustLanguageFrameworks
TestDataSets.NodeLanguageFrameworks
TestDataSets.JavaLanguageFrameworks

✅ PipelineSteps validation
✅ BuildJob configuration
✅ PipelineConfig handling
✅ Deterministic execution (3 runs validated)
✅ Concurrent build creation (50 goroutines)
✅ Step validation with edge cases
✅ Sequential step execution
✅ Timeout handling
✅ Environment variable management

🔬 Benchmarks
  - BuildJob creation
  - PipelineStep creation
  - PipelineConfig creation

✅ Go language pipeline generation
✅ Rust language pipeline generation
✅ Python language pipeline generation
✅ Empty frameworks handling
✅ Concurrent generation (5 concurrent)

🔬 Benchmarks
  - Pipeline generation performance

✅ Go language detection
✅ Python language detection
✅ Multi-framework detection
✅ All supported languages (5 languages)
✅ Framework version detection
✅ Deterministic results (5 runs)
✅ Empty result handling
✅ Concurrent detection (10 goroutines)

🔬 Benchmarks
  - Language detection performance

✅ Subsystem creation
✅ Configuration initialization
✅ Default values verification
✅ Start/stop lifecycle

🔬 Key Implementation
  - NewTestMetricsCollector() with isolated registry
  - TestLocoSubsystemHelper for proper setup/teardown
  - Prevents duplicate metric registration

// Every deterministic test follows this pattern:
func TestDeterministic_Example(t *testing.T) {
    // Multiple identical runs
    for run := 0; run < 3; run++ {
        // Setup: Create identical data each run
        config := createStandardConfig()  // Same config every run

        // Execute: Operation must produce identical results
        result := processConfig(config)

        // Verify: Results match across runs
        assert.Equal(t, expectedResult, result)
    }
}

# Run stress tests (current: 50 concurrent)
make test-stress

# Run with Docker for full integration (requires PostgreSQL + Redis)
docker-compose -f docker-compose.test.yml up
go test ./tests/integration -v

# Run benchmarks
go test -bench=. ./internal/executor ./internal/pipeline ./internal/detection

# Load testing with k6
k6 run scripts/k6-load-test.js  # ready to implement

go build ./...     # All packages compile, zero errors
go build -o sparki-api ./cmd/api/main.go  # 14MB binary

go test ./internal/executor ./internal/pipeline ./internal/detection
# Result: 60+ tests passing, 98%+ pass rate