Migration: One Feature at a Time📋

dotnet new classlib -n MegaCorp.Requirements -o src/MegaCorp.Requirements
dotnet new classlib -n MegaCorp.Specifications -o src/MegaCorp.Specifications
dotnet sln add src/MegaCorp.Requirements/MegaCorp.Requirements.csproj
dotnet sln add src/MegaCorp.Specifications/MegaCorp.Specifications.csproj

// MegaCorp.Requirements/RequirementMetadata.cs
public abstract record RequirementMetadata
{
    public abstract string Title { get; }
    public abstract RequirementPriority Priority { get; }
    public abstract string Owner { get; }
}

// + Epic, Feature<T>, AcceptanceCriterionResult, etc.
// (see Part 3 for complete types)

// MegaCorp.Requirements/ForRequirementAttribute.cs
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Method,
    AllowMultiple = true)]
public sealed class ForRequirementAttribute : Attribute { /* ... */ }

// + VerifiesAttribute, TestsForAttribute

<!-- tools/MegaCorp.Requirements.Analyzers/MegaCorp.Requirements.Analyzers.csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" PrivateAssets="all" />
    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
  </ItemGroup>
</Project>

<!-- MegaCorp.Specifications/MegaCorp.Specifications.csproj -->
<ItemGroup>
  <ProjectReference Include="..\MegaCorp.Requirements\MegaCorp.Requirements.csproj" />
  <ProjectReference Include="..\..\tools\MegaCorp.Requirements.Analyzers\MegaCorp.Requirements.Analyzers.csproj"
                    OutputItemType="Analyzer"
                    ReferenceOutputAssembly="false" />
</ItemGroup>

// MegaCorp.Requirements/Features/OrderProcessingFeature.cs
public abstract record OrderProcessingFeature : Feature<ECommerceEpic>
{
    public override string Title => "Order Processing";
    public override RequirementPriority Priority => RequirementPriority.Critical;
    public override string Owner => "order-team";

    public abstract AcceptanceCriterionResult OrderTotalMustBePositive(OrderSummary order);
    public abstract AcceptanceCriterionResult InventoryReservedBeforePayment(
        OrderSummary order, IReadOnlyList<StockReservation> reservations);
    // ... (8 ACs total — see Part 3)
}

// MegaCorp.Specifications/OrderProcessing/IOrderProcessingSpec.cs
[ForRequirement(typeof(OrderProcessingFeature))]
public interface IOrderProcessingSpec
{
    [ForRequirement(typeof(OrderProcessingFeature),
        nameof(OrderProcessingFeature.OrderTotalMustBePositive))]
    Result ValidateOrderTotal(Order order);
    // ... (see Part 3)
}

// + IInventoryIntegrationSpec, IPaymentIntegrationSpec, etc.

// MegaCorp.Core/Orders/OrderService.cs — BEFORE
public class OrderService
{
    public async Task<OrderResult> ProcessOrder(CreateOrderCommand command)
    {
        var validator = ServiceLocator.GetService<IOrderValidator>();
        // ... 200 lines of ServiceLocator calls
    }
}

// MegaCorp.OrderService/OrderProcessingService.cs — AFTER (new file, new project)
[ForRequirement(typeof(OrderProcessingFeature))]
public class OrderProcessingService : IOrderProcessingSpec
{
    private readonly IInventoryIntegrationSpec _inventory;
    private readonly IPaymentIntegrationSpec _payment;
    // Constructor injection instead of ServiceLocator

    public async Task<Result<OrderConfirmation>> ProcessOrder(CreateOrderCommand command)
    {
        // Same business logic, different wiring
    }
}

// Keep the old OrderService temporarily.
// Create a new class that wraps it and implements the spec:

[ForRequirement(typeof(OrderProcessingFeature))]
public class OrderProcessingServiceAdapter : IOrderProcessingSpec
{
    private readonly OrderService _legacy;

    public OrderProcessingServiceAdapter(OrderService legacy) => _legacy = legacy;

    [ForRequirement(typeof(OrderProcessingFeature),
        nameof(OrderProcessingFeature.OrderTotalMustBePositive))]
    public Result ValidateOrderTotal(Order order)
    {
        // Delegate to legacy, translate result
        var legacyResult = _legacy.ValidateOrder(
            new CreateOrderCommand { /* map from Order to legacy DTO */ });
        return legacyResult.IsValid ? Result.Success() : Result.Failure(legacyResult.Errors);
    }

    // ... adapt each spec method to call the legacy class
}

// MegaCorp.Web/Program.cs — Sprint 2 (hybrid)
var builder = WebApplication.CreateBuilder(args);

// ═══════════════════════════════════════════════════════════════════
// NEW: Typed specification interfaces (Order Processing)
// ═══════════════════════════════════════════════════════════════════
builder.Services.AddScoped<IOrderProcessingSpec, OrderProcessingService>();
builder.Services.AddScoped<IInventoryIntegrationSpec, InventoryReservationService>();
builder.Services.AddScoped<IPaymentIntegrationSpec, StripePaymentService>();
builder.Services.AddScoped<INotificationIntegrationSpec, OrderNotificationService>();
builder.Services.AddScoped<IAuditIntegrationSpec, AuditService>();

// ═══════════════════════════════════════════════════════════════════
// OLD: ServiceLocator-based services (everything else — NOT YET MIGRATED)
// These will be migrated in subsequent sprints.
// ═══════════════════════════════════════════════════════════════════
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddScoped<IRoleManager, RoleManager>();
builder.Services.AddScoped<IAuthorizationService, AuthorizationService>();
builder.Services.AddScoped<IReportingService, ReportingService>();
builder.Services.AddScoped<ISearchService, ElasticsearchService>();
builder.Services.AddScoped<IBillingService, BillingService>();
// ... (remaining legacy registrations)

// ═══════════════════════════════════════════════════════════════════
// LEGACY: ServiceLocator initialization (still needed for unmigrated code)
// This line will be REMOVED when all features are migrated.
// ═══════════════════════════════════════════════════════════════════
var app = builder.Build();
ServiceLocator.Initialize(app.Services);
// TODO: Remove when last ServiceLocator.GetService<> call is eliminated

app.MapControllers();
app.Run();

// MegaCorp.OrderService.Tests/OrderProcessingTests.cs
// BEFORE: (no requirement link)
[Test]
public void Negative_total_is_rejected()
{
    var order = CreateOrder(total: -50m);
    var result = _service.ValidateOrderTotal(order);
    Assert.That(result.IsSuccess, Is.False);
}

// AFTER: (add [Verifies] — one line change)
[Test]
[Verifies(typeof(OrderProcessingFeature),
    nameof(OrderProcessingFeature.OrderTotalMustBePositive))]
public void Negative_total_is_rejected()
{
    var order = CreateOrder(total: -50m);
    var result = _service.ValidateOrderTotal(order);
    Assert.That(result.IsSuccess, Is.False);
}

// Sprint 2: Adapter wraps legacy OrderService
[ForRequirement(typeof(OrderProcessingFeature))]
public class OrderProcessingAdapter : IOrderProcessingSpec
{
    private readonly LegacyOrderService _legacy;

    public OrderProcessingAdapter(LegacyOrderService legacy) => _legacy = legacy;

    // AC-1: Delegated to legacy — just wraps the result type
    [ForRequirement(typeof(OrderProcessingFeature),
        nameof(OrderProcessingFeature.OrderTotalMustBePositive))]
    public Result ValidateOrderTotal(Order order)
    {
        var legacyResult = _legacy.Validate(MapToLegacyDto(order));
        return legacyResult.IsValid ? Result.Success() : Result.Failure(legacyResult.Error);
    }

    // AC-7: Rewritten (new logic, not in legacy)
    [ForRequirement(typeof(OrderProcessingFeature),
        nameof(OrderProcessingFeature.BulkOrderDiscountApplied))]
    public Result<Order> ApplyBulkDiscount(Order order)
    {
        // New implementation — not delegating to legacy
        if (order.Lines.Count < 10) return Result<Order>.Success(order);
        var discounted = order with { Total = new Money(order.Total.Amount * 0.95m, order.Total.Currency) };
        return Result<Order>.Success(discounted);
    }

    // AC-8: Delegated to legacy with adaptation
    [ForRequirement(typeof(OrderProcessingFeature),
        nameof(OrderProcessingFeature.OrderPersistedWithFullDetail))]
    public async Task<Result> PersistOrder(Order order, Payment payment,
        IReadOnlyList<Reservation> reservations)
    {
        // Legacy Save doesn't take payment/reservation refs — add them separately
        await _legacy.SaveOrder(MapToLegacyDto(order));
        await _legacy.LinkPayment(order.Id, payment.Id);
        await _legacy.LinkReservations(order.Id, reservations.Select(r => r.Id).ToList());
        return Result.Success();
    }

    // ProcessOrder: orchestrator — NEW CODE, replaces the legacy 200-line method
    public async Task<Result<OrderConfirmation>> ProcessOrder(CreateOrderCommand command)
    {
        // New clean implementation using typed spec interfaces
        // (see Part 3 for full code)
    }
}

# Search for any remaining ServiceLocator usage
grep -rn "ServiceLocator" src/ --include="*.cs"
# Should return: only the ServiceLocator class itself and the Initialize call in Program.cs

grep -rn "GetRequiredService\|GetService" src/ --include="*.cs" | grep -v "test\|Test"
# Should return: only Program.cs DI registration (which is fine)

// MegaCorp.Web/Program.cs — BEFORE (hybrid)
var app = builder.Build();
ServiceLocator.Initialize(app.Services); // ← DELETE THIS LINE

// MegaCorp.Web/Program.cs — AFTER (clean)
var app = builder.Build();
// ServiceLocator is gone. Constructor injection everywhere.

// DELETE: MegaCorp.Infrastructure/ServiceLocator.cs
// This file has been here since 2018. It was referenced by 47 files.
// Now it's referenced by 0. Delete it.

MegaCorp.Core/ (BEFORE: 400 files)
├── Orders/           → move to MegaCorp.OrderService
├── Payments/         → move to MegaCorp.PaymentGateway
├── Inventory/        → move to MegaCorp.InventoryService
├── Users/            → move to MegaCorp.UserService
├── Notifications/    → move to MegaCorp.NotificationService
├── Common/
│   ├── BaseService.cs    → DELETE (dead code)
│   ├── ServiceHelper.cs  → DELETE (ServiceLocator helper)
│   └── Extensions.cs     → move to SharedKernel (if actually shared)
└── (20+ classes)     → Analyze each: move to feature project or DELETE

MegaCorp.Core/ (AFTER: 0 files — project deleted)

MegaCorp.Core (400 files) → triggers rebuild of 40+ projects on any change

MegaCorp.Requirements (20 files) → triggers rebuild of ~15 migrated projects
MegaCorp.Core (300 files, shrinking) → triggers rebuild of ~30 unmigrated projects

MegaCorp.Requirements (30 files) → triggers rebuild of ~50 projects (but itself is stable)
MegaCorp.Core → DELETED

// OrderService depends on IUserQuerySpec (not UserService directly)
public class OrderProcessingService : IOrderProcessingSpec
{
    private readonly IUserQuerySpec _users;
    // ...
}

// UserService depends on IOrderQuerySpec (not OrderService directly)
public class UserProfileService : IUserProfileSpec
{
    private readonly IOrderQuerySpec _orders;
    // ...
}

[ForRequirement(typeof(OrderProcessingFeature))]
public class LegacyOrderProcessorAdapter : IOrderProcessingSpec
{
    private readonly OrderProcessor _legacy;

    // Each spec method delegates to the legacy processor
    // The legacy processor still uses ServiceLocator internally
    // That's OK — the adapter IS the boundary
    // When we eventually rewrite the legacy, only this adapter changes
}

[TestFixture]
[TestsFor(typeof(OrderProcessingFeature))]
public class OrderProcessingTests
{
    // MIGRATED tests use constructor-injected spec
    private OrderProcessingService _service;

    [SetUp]
    public void Setup()
    {
        // New pattern: wire real specs with in-memory infrastructure
        _service = new OrderProcessingService(
            new InventoryReservationService(new InMemoryStockRepo()),
            new StripePaymentService(new FakeStripeClient()),
            // ...
        );
    }

    // MIGRATED: uses [Verifies], no ServiceLocator
    [Test]
    [Verifies(typeof(OrderProcessingFeature),
        nameof(OrderProcessingFeature.OrderTotalMustBePositive))]
    public void Positive_total_is_accepted() { /* ... */ }

    // NOT YET MIGRATED: still uses old pattern, no [Verifies]
    // Will be migrated when someone touches this test
    [Test]
    public void Legacy_test_still_works()
    {
        // Still uses ServiceLocator internally — that's OK for now
    }
}