#Tests, Modernisierungsmuster und Refactoring-Regeln

1. Smoke Test
2. Charakterisierungstest
3. Integrationstest
4. Contract Test
5. Regressionstest für Bugs
6. Test für extrahierte Use Cases

Kann die App starten?
Kann Login funktionieren?
Kann Hauptseite geladen werden?
Kann ein einfacher Use Case laufen?

@Test
void auditIsCommittedEvenWhenOrderCreationFails() {
    try {
        orderService.createOrderThatFailsAfterAudit();
    } catch (Exception ignored) {
    }

    assertTrue(auditRepository.contains("ORDER_CREATED"));
    assertFalse(orderRepository.exists(orderId));
}

src/test/resources/golden/customer-update-request.xml
src/test/resources/golden/customer-update-response.xml

@Test
void duplicateOrderCreatedMessage_doesNotCreateSecondInvoice() {
    handler.handle(message);
    handler.handle(message);

    assertEquals(1, invoiceRepository.countByOrderId(orderId));
}

public interface OrderEventPublisher {
    void publishOrderCreated(OrderId orderId);
}

public class JmsOrderEventPublisher implements OrderEventPublisher {

    private final QueueSender sender;

    public JmsOrderEventPublisher(QueueSender sender) {
        this.sender = sender;
    }

    @Override
    public void publishOrderCreated(OrderId orderId) {
        sender.send("ORDER_CREATED", orderId.value());
    }
}

public class CreateOrderUseCase {

    private final OrderRepository orderRepository;
    private final AuditPort auditPort;
    private final OrderEventPublisher eventPublisher;

    public CreateOrderUseCase(
            OrderRepository orderRepository,
            AuditPort auditPort,
            OrderEventPublisher eventPublisher
    ) {
        this.orderRepository = orderRepository;
        this.auditPort = auditPort;
        this.eventPublisher = eventPublisher;
    }

    public OrderId execute(CreateOrderCommand command) {
        Order order = Order.create(command.customerId(), command.items());
        orderRepository.save(order);
        auditPort.orderCreated(order.id());
        eventPublisher.publishOrderCreated(order.id());
        return order.id();
    }
}

public ApprovalCommand toCommand(CustomerApprovalSoapType soapType) {
    return new ApprovalCommand(
            new CustomerId(soapType.getCustomerNo()),
            "Y".equals(soapType.getApprovedFlag())
    );
}

@Transactional
public void createOrder() {
    orderRepository.save(order);
    jmsPublisher.publish(new OrderCreatedEvent(order.id()));
}

In derselben DB-Transaktion:
- Order speichern
- Outbox Event speichern

Nach Commit:
- Publisher liest Outbox
- sendet JMS/Kafka/etc.
- markiert Event als published

CREATE TABLE outbox_event (
    id VARCHAR(36) PRIMARY KEY,
    aggregate_id VARCHAR(36),
    event_type VARCHAR(100),
    payload CLOB,
    status VARCHAR(20),
    created_at TIMESTAMP,
    published_at TIMESTAMP
);

KEEP     → vorerst lassen
WRAP     → hinter Interface kapseln
EXTRACT  → Fachlogik in Plain Java ziehen
REPLACE  → Technologie ersetzen
DELETE   → ungenutzten Code entfernen
SPLIT    → fachlich trennen

# Modernization Candidate: <Name>

## Fachlicher Zweck

## Aktuelle technische Form
- EJB / JSP / SOAP / JMS / DAO / Batch:
- Klasse:
- Modul:
- Deployment-Artefakt:

## Entry Points
- Wird aufgerufen von:
- Ruft selbst auf:

## Transaktion
- TransactionAttribute:
- Nested TX:
- Rollback-Regeln:
- XA beteiligt:

## Side Effects
- DB Writes:
- JMS Sends:
- SOAP Calls:
- Files:
- Emails:

## Risiken

| Risiko | Beschreibung | Schwere |
|---|---|---|
| Transaktion | ... | hoch |
| Messaging | ... | mittel |

## Tests vorhanden
- Unit Tests:
- Integration Tests:
- Manuelle Tests:
- Logs/Monitoring:

## Empfohlene Strategie
- KEEP / WRAP / EXTRACT / REPLACE / DELETE / SPLIT

## Erster sicherer Schritt

## Nicht anfassen ohne Test
- Transaktion
- Exception Handling
- SOAP Payload
- Queue Semantik
- Security