A system that is hard to test is usually a system with hidden decisions, hidden time, hidden state, hidden IO, or hidden coupling.

A system that is hard to measure is usually a system with unclear boundaries, missing workload model, invisible resource usage, or no stable observation points.

public void escalate(String caseId, String reason) {
    var now = Instant.now();
    var conn = DriverManager.getConnection(System.getenv("DB_URL"));
    var caseFile = loadCase(conn, caseId);

    if (caseFile.status().equals("CLOSED")) {
        throw new IllegalStateException("closed");
    }

    var auditPayload = "case=" + caseId + ",reason=" + reason + ",time=" + now;
    new HttpClient().send(auditPayload);

    updateStatus(conn, caseId, "ESCALATION_REVIEW");
    logger.info("Escalated " + caseId);
}

pure domain core + application orchestration + effectful adapters

enum CaseStatus {
    DRAFT,
    SUBMITTED,
    UNDER_REVIEW,
    ESCALATION_REQUESTED,
    ESCALATION_REVIEW,
    DECIDED,
    CLOSED
}

record CaseId(String value) {
    CaseId {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException("case id must not be blank");
        }
    }
}

record OfficerId(String value) {}
record EscalationReason(String value) {
    EscalationReason {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException("escalation reason is required");
        }
    }
}

sealed interface CaseEvent permits CaseEscalated, CaseEscalationRejected {}

record CaseEscalated(
    CaseId caseId,
    OfficerId officerId,
    EscalationReason reason,
    Instant occurredAt
) implements CaseEvent {}

record CaseEscalationRejected(
    CaseId caseId,
    OfficerId officerId,
    String reason,
    Instant occurredAt
) implements CaseEvent {}

record Decision<T>(T state, List<CaseEvent> events) {
    static <T> Decision<T> of(T state, List<CaseEvent> events) {
        return new Decision<>(state, List.copyOf(events));
    }
}

record CaseFile(
    CaseId id,
    CaseStatus status,
    Optional<OfficerId> activeOwner,
    Optional<Instant> escalationStartedAt
) {
    Decision<CaseFile> escalate(
        OfficerId officerId,
        EscalationReason reason,
        Instant now
    ) {
        if (status == CaseStatus.CLOSED) {
            return Decision.of(
                this,
                List.of(new CaseEscalationRejected(id, officerId, "case is closed", now))
            );
        }

        if (status == CaseStatus.ESCALATION_REVIEW) {
            return Decision.of(this, List.of()); // idempotent no-op
        }

        var next = new CaseFile(
            id,
            CaseStatus.ESCALATION_REVIEW,
            activeOwner,
            Optional.of(now)
        );

        return Decision.of(
            next,
            List.of(new CaseEscalated(id, officerId, reason, now))
        );
    }
}

@Test
void closedCaseCannotBeEscalated() {
    var now = Instant.parse("2026-07-02T10:00:00Z");
    var file = new CaseFile(
        new CaseId("CASE-1"),
        CaseStatus.CLOSED,
        Optional.of(new OfficerId("OFF-1")),
        Optional.empty()
    );

    var decision = file.escalate(
        new OfficerId("OFF-1"),
        new EscalationReason("High public risk"),
        now
    );

    assertThat(decision.state().status()).isEqualTo(CaseStatus.CLOSED);
    assertThat(decision.events()).containsExactly(
        new CaseEscalationRejected(
            new CaseId("CASE-1"),
            new OfficerId("OFF-1"),
            "case is closed",
            now
        )
    );
}

interface CaseRepository {
    Optional<CaseFile> findById(CaseId id);
    void save(CaseFile caseFile);
}

interface CaseEventPublisher {
    void publish(List<CaseEvent> events);
}

interface TransactionRunner {
    <T> T inTransaction(Supplier<T> operation);
}

interface CaseMetrics {
    void escalationAttempted();
    void escalationSucceeded();
    void escalationRejected(String reason);
}

record EscalateCaseCommand(
    CaseId caseId,
    OfficerId officerId,
    EscalationReason reason,
    UUID commandId
) {}

final class EscalateCaseHandler {
    private final CaseRepository repository;
    private final CaseEventPublisher publisher;
    private final TransactionRunner tx;
    private final Clock clock;
    private final CaseMetrics metrics;

    EscalateCaseHandler(
        CaseRepository repository,
        CaseEventPublisher publisher,
        TransactionRunner tx,
        Clock clock,
        CaseMetrics metrics
    ) {
        this.repository = repository;
        this.publisher = publisher;
        this.tx = tx;
        this.clock = clock;
        this.metrics = metrics;
    }

    void handle(EscalateCaseCommand command) {
        metrics.escalationAttempted();

        tx.inTransaction(() -> {
            var file = repository.findById(command.caseId())
                .orElseThrow(() -> new CaseNotFoundException(command.caseId()));

            var decision = file.escalate(
                command.officerId(),
                command.reason(),
                Instant.now(clock)
            );

            repository.save(decision.state());
            publisher.publish(decision.events());

            if (decision.events().stream().anyMatch(CaseEscalated.class::isInstance)) {
                metrics.escalationSucceeded();
            }

            return null;
        });
    }
}

@Test
void handlerPersistsEscalationAndPublishesEvent() {
    var repository = new InMemoryCaseRepository();
    var publisher = new RecordingCaseEventPublisher();
    var tx = new ImmediateTransactionRunner();
    var clock = Clock.fixed(Instant.parse("2026-07-02T10:00:00Z"), ZoneOffset.UTC);
    var metrics = new RecordingCaseMetrics();

    var caseId = new CaseId("CASE-1");
    repository.save(new CaseFile(
        caseId,
        CaseStatus.UNDER_REVIEW,
        Optional.of(new OfficerId("OFF-1")),
        Optional.empty()
    ));

    var handler = new EscalateCaseHandler(repository, publisher, tx, clock, metrics);

    handler.handle(new EscalateCaseCommand(
        caseId,
        new OfficerId("OFF-1"),
        new EscalationReason("High public risk"),
        UUID.fromString("00000000-0000-0000-0000-000000000001")
    ));

    assertThat(repository.findById(caseId)).get()
        .extracting(CaseFile::status)
        .isEqualTo(CaseStatus.ESCALATION_REVIEW);

    assertThat(publisher.events()).hasSize(1);
    assertThat(metrics.succeeded()).isEqualTo(1);
}

if (Instant.now().isAfter(caseFile.slaDeadline())) {
    escalate(caseFile);
}

final class SlaEvaluator {
    private final Clock clock;

    SlaEvaluator(Clock clock) {
        this.clock = clock;
    }

    boolean isBreached(CaseFile file) {
        return Instant.now(clock).isAfter(file.slaDeadline());
    }
}

boolean isBreachedAt(Instant now) {
    return now.isAfter(slaDeadline);
}

Domain method: pass time as value.
Application service: owns Clock.
Infrastructure: maps external time formats.

final class MutableClock extends Clock {
    private Instant instant;
    private final ZoneId zone;

    MutableClock(Instant instant, ZoneId zone) {
        this.instant = instant;
        this.zone = zone;
    }

    void advance(Duration duration) {
        instant = instant.plus(duration);
    }

    @Override public ZoneId getZone() { return zone; }
    @Override public Clock withZone(ZoneId zone) { return new MutableClock(instant, zone); }
    @Override public Instant instant() { return instant; }
}

var caseId = UUID.randomUUID();

interface IdGenerator<T> {
    T nextId();
}

final class UuidCaseIdGenerator implements IdGenerator<CaseId> {
    @Override
    public CaseId nextId() {
        return new CaseId(UUID.randomUUID().toString());
    }
}

final class FixedIdGenerator<T> implements IdGenerator<T> {
    private final Queue<T> ids;

    FixedIdGenerator(List<T> ids) {
        this.ids = new ArrayDeque<>(ids);
    }

    @Override
    public T nextId() {
        return ids.remove();
    }
}

Production may use randomness. Tests need reproducibility.

caseFile.setStatus("ESCALATION_REVIEW");
caseFile.setEscalated(true);
caseFile.setUpdatedAt(Instant.now());

Decision<CaseFile> decision = caseFile.escalate(officerId, reason, now);

Given current state + command + time/context,
what is the next state + emitted events/rejections?

void approve() {
    this.status = APPROVED;
    auditService.record(...);
    notificationService.send(...);
}

Decision<Order> approve(Approver approver, Instant now) {
    var next = withStatus(OrderStatus.APPROVED);
    return Decision.of(next, List.of(new OrderApproved(id, approver.id(), now)));
}

interface CaseRepository {
    void insert(CaseEntity entity);
    void update(CaseEntity entity);
    List<CaseEntity> select(String sql);
}

interface CaseRepository {
    Optional<CaseFile> findById(CaseId id);
    void save(CaseFile file);
    boolean hasActiveEscalation(CaseId id);
}

interface CaseSearchRepository {
    Page<CaseSummary> findCasesForOfficer(
        OfficerId officerId,
        CaseSearchFilter filter,
        PageRequest page
    );
}

final class InMemoryCaseRepository implements CaseRepository {
    private final Map<CaseId, CaseFile> files = new HashMap<>();

    @Override
    public Optional<CaseFile> findById(CaseId id) {
        return Optional.ofNullable(files.get(id));
    }

    @Override
    public void save(CaseFile file) {
        files.put(file.id(), file);
    }
}

Use fakes for application behavior.
Use real dependencies for dependency semantics.

@Transactional
public void handle(Command command) {
    repository.save(...);
    publisher.publish(...);
}

interface Outbox {
    void append(List<CaseEvent> events);
}

final class EscalateCaseHandler {
    void handle(EscalateCaseCommand command) {
        tx.inTransaction(() -> {
            var file = repository.get(command.caseId());
            var decision = file.escalate(command.officerId(), command.reason(), Instant.now(clock));

            repository.save(decision.state());
            outbox.append(decision.events());
            return null;
        });
    }
}

state and outbox are updated atomically

paymentGateway.charge(request);

interface PaymentGateway {
    ChargeResult charge(ChargeRequest request) throws PaymentGatewayException;
}

final class FailingPaymentGateway implements PaymentGateway {
    private final RuntimeException failure;

    FailingPaymentGateway(RuntimeException failure) {
        this.failure = failure;
    }

    @Override
    public ChargeResult charge(ChargeRequest request) {
        throw failure;
    }
}

CompletableFuture.runAsync(() -> publisher.publish(event));

interface TaskExecutor {
    void execute(Runnable task);
}

final class JavaExecutorTaskExecutor implements TaskExecutor {
    private final Executor executor;

    JavaExecutorTaskExecutor(Executor executor) {
        this.executor = executor;
    }

    @Override
    public void execute(Runnable task) {
        executor.execute(task);
    }
}

final class RecordingTaskExecutor implements TaskExecutor {
    private final List<Runnable> tasks = new ArrayList<>();

    @Override
    public void execute(Runnable task) {
        tasks.add(task);
    }

    void runAll() {
        tasks.forEach(Runnable::run);
        tasks.clear();
    }
}

handler.handle(command);
assertThat(publisher.events()).isEmpty();
executor.runAll();
assertThat(publisher.events()).hasSize(1);

interface CaseMetrics {
    void escalationAttempted();
    void escalationSucceeded();
    void escalationRejected(String reason);
    void invariantViolation(String invariantName);
}

assertThat(metrics.counter("case.escalation.succeeded")).isEqualTo(1);

import jdk.jfr.Category;
import jdk.jfr.Event;
import jdk.jfr.Label;
import jdk.jfr.Name;

@Name("com.example.CaseSearch")
@Label("Case Search")
@Category({"Application", "Case"})
final class CaseSearchEvent extends Event {
    @Label("Officer ID")
    String officerId;

    @Label("Result Count")
    int resultCount;

    @Label("Filter Count")
    int filterCount;
}

List<CaseSummary> search(CaseSearchQuery query) {
    var event = new CaseSearchEvent();
    event.officerId = query.officerId().value();
    event.filterCount = query.filters().size();

    event.begin();
    try {
        var result = repository.search(query);
        event.resultCount = result.size();
        return result;
    } finally {
        event.commit();
    }
}

Performance-critical use cases should have stable observation points.

public ResponseEntity<?> search(HttpServletRequest request) {
    var user = auth.currentUser();
    var filters = parse(request);
    var result = repository.search(user, filters);
    return ResponseEntity.ok(mapper.toJson(result));
}

final class CaseSearchService {
    SearchResult search(CaseSearchQuery query) {
        var normalized = normalizer.normalize(query);
        var page = repository.search(normalized);
        return assembler.assemble(page);
    }
}

@Benchmark
public SearchResult searchHotOfficer(SearchBenchmarkState state) {
    return state.service.search(state.hotOfficerQuery);
}

String payload = cases.stream()
    .map(c -> c.id() + ":" + c.status() + ":" + c.owner().orElse(""))
    .collect(Collectors.joining("\n"));

Case summary mapping is called for every search request.
Typical page size: 50.
P99 page size: 500.
Must not allocate more than 2 MB per request at P99 size.

throw new RuntimeException("failed");

sealed interface EscalateCaseError permits CaseNotFound, CaseAlreadyClosed, UnauthorizedOfficer {}

record CaseNotFound(CaseId caseId) implements EscalateCaseError {}
record CaseAlreadyClosed(CaseId caseId) implements EscalateCaseError {}
record UnauthorizedOfficer(OfficerId officerId, CaseId caseId) implements EscalateCaseError {}

sealed interface EscalateCaseResult permits EscalateCaseSucceeded, EscalateCaseRejected {}

record EscalateCaseSucceeded(CaseId caseId, List<CaseEvent> events) implements EscalateCaseResult {}
record EscalateCaseRejected(CaseId caseId, EscalateCaseError error) implements EscalateCaseResult {}

A case cannot have more than one active owner.

boolean hasActiveOwner() {
    return activeOwner.isPresent();
}

CREATE UNIQUE INDEX ux_case_active_owner
ON case_assignment(case_id)
WHERE active = true;

SELECT case_id, COUNT(*)
FROM case_assignment
WHERE active = true
GROUP BY case_id
HAVING COUNT(*) > 1;

case_assignment.active_owner_violation.count

@Test
void cannotAssignSecondActiveOwner() {
    // domain or integration-level test depending on ownership model
}

@Entity
class CaseEntity {
    @PrePersist
    void beforeSave() {
        this.updatedAt = Instant.now();
        if (status.equals("CLOSED")) {
            throw new RuntimeException("...");
        }
    }
}

CaseFile next = caseFile.close(now);
repository.save(next);

interface StringTrimmer {
    String trim(String value);
}

A seam should correspond to a meaningful boundary or source of nondeterminism.

var file = new CaseFile(
    new CaseId("1"),
    CaseStatus.UNDER_REVIEW,
    Optional.of(new OfficerId("abc")),
    Optional.empty()
);

final class CaseFileBuilder {
    private CaseId id = new CaseId("CASE-1");
    private CaseStatus status = CaseStatus.UNDER_REVIEW;
    private Optional<OfficerId> activeOwner = Optional.of(new OfficerId("OFF-1"));
    private Optional<Instant> escalationStartedAt = Optional.empty();

    static CaseFileBuilder aCaseFile() {
        return new CaseFileBuilder();
    }

    CaseFileBuilder closed() {
        this.status = CaseStatus.CLOSED;
        return this;
    }

    CaseFileBuilder withoutOwner() {
        this.activeOwner = Optional.empty();
        return this;
    }

    CaseFile build() {
        return new CaseFile(id, status, activeOwner, escalationStartedAt);
    }
}

var file = aCaseFile().closed().build();

closed()
underReview()
withActiveOwner("OFF-1")
withoutEscalation()

status(CLOSED)
activeOwner(Optional.empty())

TestFixtures.validCase()

var file = aCaseFile()
    .underReview()
    .withActiveOwner("OFF-1")
    .withoutEscalation()
    .build();

Hide irrelevant setup. Expose facts that affect the assertion.

Map<String, Object> response = new HashMap<>();
response.put("id", caseFile.id().value());
response.put("status", caseFile.status().name());
response.put("owner", caseFile.activeOwner().map(OfficerId::value).orElse(null));

record CaseResponse(
    String id,
    String status,
    String ownerId
) {}

final class CaseResponseMapper {
    CaseResponse toResponse(CaseFile file) {
        return new CaseResponse(
            file.id().value(),
            file.status().name(),
            file.activeOwner().map(OfficerId::value).orElse(null)
        );
    }
}

final class JdbcCaseRepository implements CaseRepository {
    private final DataSource dataSource;

    JdbcCaseRepository(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public Optional<CaseFile> findById(CaseId id) {
        // SQL mapping lives here
    }

    @Override
    public void save(CaseFile file) {
        // SQL mapping lives here
    }
}

saveAndLoadPreservesEscalationState

closedCaseCannotBeEscalated

Decision<CaseFile> escalate(OfficerId officerId, EscalationReason reason, Instant now)

Escalate(case, officer) ==
  IF status[case] = CLOSED THEN unchanged
  ELSE status' = [status EXCEPT ![case] = ESCALATION_REVIEW]

If you cannot describe the transition relation clearly, the code is probably too implicit.

Where is time spent?
Where is allocation happening?
Where is blocking happening?
What changed?
Which workload is affected?
Which resource saturated?

Entry point:
Expected input size:
External dependencies:
Timeout budget:
Metrics:
Trace attributes:
JFR event if needed:
Benchmark scenario:
Load test scenario:
Known bottleneck candidates:

Use case: Search active cases for officer
Entry point: CaseSearchService.search
Typical page size: 50
P99 page size: 500
Dependencies: PostgreSQL, authorization service cache
Timeout budget: 300 ms P99
Metrics: case_search.duration, case_search.result_count
Trace attrs: officer_id_hash, filter_count, page_size
JFR event: com.example.CaseSearch
Benchmark: mapping/filter normalization JMH
Load test: 200 rps mixed hot/cold officers
Bottlenecks: DB index, JSON serialization, authorization expansion

final class MeasuredCaseSearchService {
    private final CaseSearchService delegate;
    private final CaseSearchMetrics metrics;

    SearchResult search(CaseSearchQuery query) {
        long start = System.nanoTime();
        try {
            var result = delegate.search(query);
            metrics.success(Duration.ofNanos(System.nanoTime() - start), result.size());
            return result;
        } catch (RuntimeException ex) {
            metrics.failure(Duration.ofNanos(System.nanoTime() - start), ex.getClass().getSimpleName());
            throw ex;
        }
    }
}

interface CaseAssignmentRepository {
    Map<CaseId, Assignment> findActiveAssignments(Set<CaseId> caseIds);
}

CaseRules.canEscalate(caseFile)

var repository = ServiceLocator.get(CaseRepository.class);

if (dto.status().equals("CLOSED")) reject();

verify(entityManager).createQuery(...)

Thread.sleep(5000);

Correctness
- What are the invariants?
- What are invalid states?
- What are expected business failures?
- Are state transitions explicit?
- Are side effects returned or observable?

Testability
- Can domain logic run without DB/network?
- Can time be fixed?
- Can IDs/randomness be deterministic?
- Can external failures be injected?
- Can async work be controlled?
- Are fixtures minimal and semantic?

Integration
- Which dependency semantics must be tested for real?
- Which fake semantics are safe?
- Are transaction boundaries visible?
- Are schema/contract boundaries explicit?

Performance
- What is the expected workload?
- What is the latency/throughput/resource target?
- Is there a stable benchmark entrypoint?
- Are allocation/time/blocking observable?
- Are metrics/traces/JFR events available for critical paths?

Production
- Which invariant violations should be monitored?
- Which metrics indicate degradation?
- What evidence will be captured during incidents?

1. Identify the behavior you need to protect.
2. Write a characterization test if possible.
3. Extract time/randomness/config access behind parameters or ports.
4. Extract pure decision logic from IO shell.
5. Introduce semantic result/event object.
6. Add focused unit/component tests around extracted logic.
7. Add integration tests around adapters.
8. Add metrics around critical operations.
9. Add benchmark/profiling only for performance-sensitive paths.

public void process(CaseRequest request) {
    // 300 lines: parse, validate, DB, rules, HTTP, logging, metrics
}

CaseDecision decision = decisionEngine.decide(request.toCommand(), now);