Add large-scale pipeline tests (100+ modules)

[thomhurst]

Summary

The test suite lacks tests for pipelines with large numbers of modules, missing potential scalability issues, performance regressions, and edge cases that only appear at scale.

Current Test Coverage

• 251+ test modules defined
• Most tests use small module graphs (2-10 modules)
• CircularDependencyDetectionTests.cs tests dependency patterns but not scale
• No stress tests or performance benchmarks

Missing Test Scenarios

Scale Tests

1. Large module count

   • 100 modules with simple dependencies
   • 500 modules in complex dependency graph
   • 1000+ modules (stress test)

2. Deep dependency chains

   • Chain of 50 sequential modules
   • Wide fan-out (1 module → 100 dependents)
   • Wide fan-in (100 modules → 1 dependent)

3. Memory pressure

   • Modules with large result objects
   • Many concurrent module executions
   • Result retention during long pipelines

Performance Benchmarks

[MemoryDiagnoser]
public class PipelineScaleBenchmarks
{
    [Params(10, 100, 500)]
    public int ModuleCount { get; set; }
    
    [Benchmark]
    public async Task ExecutePipeline()
    {
        var pipeline = CreatePipelineWithModules(ModuleCount);
        await pipeline.ExecuteAsync();
    }
    
    [Benchmark]
    public void DependencyResolution()
    {
        var modules = CreateModulesWithComplexDependencies(ModuleCount);
        var resolver = new DependencyResolver();
        resolver.Resolve(modules);
    }
}

Proposed Test Structure

test/ModularPipelines.ScaleTests/
├── LargeModuleCountTests.cs
├── DeepDependencyChainTests.cs
├── MemoryPressureTests.cs
├── ConcurrencyLimitTests.cs
├── Benchmarks/
│   ├── ExecutionBenchmarks.cs
│   ├── DependencyResolutionBenchmarks.cs
│   └── MemoryBenchmarks.cs
└── Generators/
    └── ModuleGraphGenerator.cs  // Creates test module graphs

Test Scenarios

1. Large Module Count

[Test]
public async Task Pipeline_With100Modules_CompletesSuccessfully()
{
    var modules = GenerateModuleChain(100);
    var result = await Pipeline.Run(modules);
    Assert.That(result.FailedModules, Is.Empty);
}

2. Parallel Execution Limits

[Test]
public async Task Pipeline_With100ParallelModules_RespectsLimit()
{
    // 100 modules, all independent, max parallelism = 10
    var concurrentCount = 0;
    var maxConcurrent = 0;
    
    // Verify max concurrent never exceeds limit
}

3. Memory Usage

[Test]
public async Task Pipeline_WithLargeResults_DoesNotLeakMemory()
{
    var initialMemory = GC.GetTotalMemory(true);
    await ExecutePipelineWithLargeResults();
    GC.Collect();
    var finalMemory = GC.GetTotalMemory(true);
    
    Assert.That(finalMemory - initialMemory, Is.LessThan(ThresholdBytes));
}

Deliverables

1. New test project: ModularPipelines.ScaleTests
2. Module graph generator for creating test scenarios
3. Basic scale tests (100, 500, 1000 modules)
4. BenchmarkDotNet performance benchmarks
5. CI integration (run scale tests on dedicated job)

Impact

• Non-breaking: New tests only
• Improves: Confidence in scalability, regression detection

Labels

• testing
• enhancement
• performance