Legacy-Parallelbetriebs-Lab

package com.example.enterprise.run7c;

public final class DemoMain {
    public static void main(String[] args) {
        InMemoryOutbox outbox = new InMemoryOutbox();
        InMemoryOrderRepository repository = new InMemoryOrderRepository();
        PaymentPort payment = new FakePaymentAdapter();
        LegacyOrderProcessor legacy = new LegacyOrderProcessor(payment, repository, outbox);
        RefactoredOrderProcessor modern = new RefactoredOrderProcessor(new ValidationService(), new PricingService(), new TaxService(), new ShippingService(), payment, repository, outbox);
        InMemoryFeatureToggleService toggles = new InMemoryFeatureToggleService();
        toggles.setDefaultMode(ProcessingMode.SHADOW);
        ParityReporter reporter = new ParityReporter();
        RefactoringRouter router = new RefactoringRouter(legacy, modern, toggles, reporter);
        OrderResult result = router.process(TestData.standardOrder("REQ-7C"));
        System.out.println("RUN7C_DEMO_OK " + result.decision() + " parityEvents=" + reporter.events().size());
    }
}

package com.example.enterprise.run7c;

// Pattern: Branch by Abstraction + Feature Toggle - alter und neuer Pfad sind hinter einem stabilen Einstiegspunkt steuerbar.
public final class RefactoringRouter {
    private final LegacyOrderProcessor legacy;
    private final RefactoredOrderProcessor modern;
    private final FeatureToggleService toggles;
    private final ParityReporter parityReporter;

    public RefactoringRouter(LegacyOrderProcessor legacy, RefactoredOrderProcessor modern,
                             FeatureToggleService toggles, ParityReporter parityReporter) {
        this.legacy = legacy; this.modern = modern; this.toggles = toggles; this.parityReporter = parityReporter;
    }

    public OrderResult process(OrderRequest request) {
        ProcessingMode mode = toggles.modeFor(request.customer());
        return switch (mode) {
            case LEGACY -> legacy.process(request);
            case SHADOW -> shadow(request);
            case NEW_WITH_FALLBACK -> newWithFallback(request);
            case NEW -> modern.process(request);
        };
    }

    private OrderResult shadow(OrderRequest request) {
        OrderResult legacyResult = legacy.process(request);
        try {
            OrderResult modernResult = modern.process(request);
            parityReporter.compare(request, legacyResult, modernResult);
        } catch (RuntimeException ex) {
            parityReporter.compare(request, legacyResult, OrderResult.rejected("modern exception: " + ex.getClass().getSimpleName()));
        }
        return legacyResult;
    }

    private OrderResult newWithFallback(OrderRequest request) {
        try {
            return modern.process(request);
        } catch (RuntimeException ex) {
            return legacy.process(request);
        }
    }
}

package com.example.enterprise.run7c;

import java.util.HashMap;
import java.util.Map;

public final class InMemoryFeatureToggleService implements FeatureToggleService {
    private ProcessingMode defaultMode = ProcessingMode.LEGACY;
    private final Map<String, ProcessingMode> customerModes = new HashMap<>();
    public void setDefaultMode(ProcessingMode defaultMode) { this.defaultMode = defaultMode; }
    public void setModeForCustomer(String customerId, ProcessingMode mode) { customerModes.put(customerId, mode); }
    @Override public ProcessingMode modeFor(CustomerProfile customer) { return customerModes.getOrDefault(customer.customerId(), defaultMode); }
}

package com.example.enterprise.run7c;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

// Legacy-Beispiel: bewusst gemischte Verantwortungen. Nicht als Zielarchitektur verwenden.
public final class LegacyOrderProcessor {
    private final PaymentPort payment;
    private final OrderRepository repository;
    private final OutboxPort outbox;

    public LegacyOrderProcessor(PaymentPort payment, OrderRepository repository, OutboxPort outbox) {
        this.payment = payment; this.repository = repository; this.outbox = outbox;
    }

    public OrderResult process(OrderRequest request) {
        List<String> messages = new ArrayList<>();
        if (request.customer().blocked()) return OrderResult.rejected("customer blocked");
        if (request.lines().isEmpty()) return OrderResult.rejected("empty order");

        Money net = Money.eur("0");
        Money tax = Money.eur("0");
        for (OrderLine line : request.lines()) {
            if (line.sku().startsWith("DISCONTINUED")) return OrderResult.rejected("discontinued sku " + line.sku());
            Money lineNet = line.netTotal();
            net = net.add(lineNet);
            tax = tax.add(lineNet.multiply(line.taxRate()));
        }

        if (request.customer().premium()) {
            net = net.subtract(net.multiply(new BigDecimal("0.05")));
            messages.add("premium discount applied");
        }
        Money shipping = switch (request.shippingMethod()) {
            case "EXPRESS" -> Money.eur("19.90");
            case "PICKUP" -> Money.eur("0.00");
            default -> request.customer().premium() ? Money.eur("0.00") : Money.eur("5.90");
        };
        Money grand = net.add(tax).add(shipping);
        PaymentReceipt receipt = payment.authorize(request.customer().customerId(), grand);
        if (!receipt.approved()) return OrderResult.rejected("payment declined: " + receipt.reason());
        String orderId = "ORD-" + request.requestId();
        OrderResult result = new OrderResult(OrderDecision.ACCEPTED, orderId, net, tax, shipping, grand, messages);
        repository.save(orderId, request, result);
        outbox.append(orderId, "OrderAccepted", "grandTotal=" + grand.amount());
        return result;
    }
}

package com.example.enterprise.run7c;

// Pattern: Application Service - orchestriert den Use Case, ohne alle Fachregeln selbst zu besitzen.
public final class RefactoredOrderProcessor {
    private final ValidationService validation;
    private final PricingService pricing;
    private final TaxService taxService;
    private final ShippingService shippingService;
    private final PaymentPort payment;
    private final OrderRepository repository;
    private final OutboxPort outbox;

    public RefactoredOrderProcessor(ValidationService validation, PricingService pricing, TaxService taxService,
                                    ShippingService shippingService, PaymentPort payment, OrderRepository repository,
                                    OutboxPort outbox) {
        this.validation = validation; this.pricing = pricing; this.taxService = taxService; this.shippingService = shippingService;
        this.payment = payment; this.repository = repository; this.outbox = outbox;
    }

    public OrderResult process(OrderRequest request) {
        return new OrderProcessingWorkflow(validation, pricing, taxService, shippingService, payment, repository, outbox).execute(request);
    }
}

package com.example.enterprise.run7c;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

// Pattern: Observer/Reporter - Shadow-Ergebnisse werden gemeldet, ohne den Use Case zu blockieren.
public final class ParityReporter {
    private final List<ParityEvent> events = new ArrayList<>();
    public void compare(OrderRequest request, OrderResult legacy, OrderResult modern) {
        boolean same = legacy.decision() == modern.decision()
                && Objects.equals(legacy.grandTotal(), modern.grandTotal())
                && Objects.equals(legacy.messages(), modern.messages());
        events.add(new ParityEvent(request.requestId(), same, same ? "EXACT_MATCH" : "BUSINESS_DIFFERENCE",
                "legacy=" + legacy + " modern=" + modern));
    }
    public List<ParityEvent> events() { return List.copyOf(events); }
}

package com.example.enterprise.run7c;

import java.util.ArrayList;
import java.util.List;

// Pattern: Method Object - zerlegt eine lange Methode in einen zustandsbehafteten, benannten Workflow.
public final class OrderProcessingWorkflow {
    private final ValidationService validation;
    private final PricingService pricing;
    private final TaxService taxService;
    private final ShippingService shippingService;
    private final PaymentPort payment;
    private final OrderRepository repository;
    private final OutboxPort outbox;

    private OrderRequest request;
    private Money net;
    private Money tax;
    private Money shipping;
    private Money grand;
    private final List<String> messages = new ArrayList<>();

    public OrderProcessingWorkflow(ValidationService validation, PricingService pricing, TaxService taxService,
                                   ShippingService shippingService, PaymentPort payment, OrderRepository repository,
                                   OutboxPort outbox) {
        this.validation = validation; this.pricing = pricing; this.taxService = taxService; this.shippingService = shippingService;
        this.payment = payment; this.repository = repository; this.outbox = outbox;
    }

    public OrderResult execute(OrderRequest request) {
        this.request = request;
        var error = validation.validate(request);
        if (error.isPresent()) return OrderResult.rejected(error.get());
        calculateTotals();
        PaymentReceipt receipt = payment.authorize(request.customer().customerId(), grand);
        if (!receipt.approved()) return OrderResult.rejected("payment declined: " + receipt.reason());
        return persistAndPublish();
    }

    private void calculateTotals() {
        net = pricing.netTotal(request);
        tax = taxService.taxTotal(request);
        shipping = shippingService.shipping(request);
        if (request.customer().premium()) messages.add("premium discount applied");
        grand = net.add(tax).add(shipping);
    }

    private OrderResult persistAndPublish() {
        String orderId = "ORD-" + request.requestId();
        OrderResult result = new OrderResult(OrderDecision.ACCEPTED, orderId, net, tax, shipping, grand, List.copyOf(messages));
        repository.save(orderId, request, result);
        outbox.append(orderId, "OrderAccepted", "grandTotal=" + grand.amount());
        return result;
    }
}

package com.example.enterprise.run7c;

public final class Run7CTestRunner {
    public static void main(String[] args) {
        shouldKeepParityInShadowMode();
        shouldRejectBlockedCustomerInBothPaths();
        shouldRouteToNewPathWhenEnabled();
        System.out.println("RUN7C_TESTS_OK");
    }
    private static void shouldKeepParityInShadowMode() {
        TestFixture fixture = TestFixture.create();
        fixture.toggles.setDefaultMode(ProcessingMode.SHADOW);
        OrderResult result = fixture.router.process(TestData.standardOrder("REQ-SHADOW"));
        assertTrue(result.accepted(), "legacy result should be accepted");
        assertEquals(1, fixture.reporter.events().size(), "shadow parity event expected");
        assertTrue(fixture.reporter.events().get(0).match(), "legacy and modern should match");
    }
    private static void shouldRejectBlockedCustomerInBothPaths() {
        TestFixture fixture = TestFixture.create();
        fixture.toggles.setDefaultMode(ProcessingMode.SHADOW);
        OrderResult result = fixture.router.process(TestData.blockedOrder());
        assertEquals(OrderDecision.REJECTED, result.decision(), "blocked customer rejected");
        assertTrue(fixture.reporter.events().get(0).match(), "blocked customer parity");
    }
    private static void shouldRouteToNewPathWhenEnabled() {
        TestFixture fixture = TestFixture.create();
        fixture.toggles.setDefaultMode(ProcessingMode.NEW);
        OrderResult result = fixture.router.process(TestData.standardOrder("REQ-NEW"));
        assertTrue(result.accepted(), "new path accepted");
        assertEquals(0, fixture.reporter.events().size(), "new mode does not shadow compare");
    }
    private static void assertTrue(boolean condition, String message) { if (!condition) throw new AssertionError(message); }
    private static void assertEquals(Object expected, Object actual, String message) { if (!java.util.Objects.equals(expected, actual)) throw new AssertionError(message + " expected=" + expected + " actual=" + actual); }
    private record TestFixture(RefactoringRouter router, InMemoryFeatureToggleService toggles, ParityReporter reporter) {
        static TestFixture create() {
            InMemoryOutbox outbox = new InMemoryOutbox();
            InMemoryOrderRepository repository = new InMemoryOrderRepository();
            PaymentPort payment = new FakePaymentAdapter();
            LegacyOrderProcessor legacy = new LegacyOrderProcessor(payment, repository, outbox);
            RefactoredOrderProcessor modern = new RefactoredOrderProcessor(new ValidationService(), new PricingService(), new TaxService(), new ShippingService(), payment, repository, outbox);
            InMemoryFeatureToggleService toggles = new InMemoryFeatureToggleService();
            ParityReporter reporter = new ParityReporter();
            return new TestFixture(new RefactoringRouter(legacy, modern, toggles, reporter), toggles, reporter);
        }
    }
}