// runnable
import java.util.*;

// ---------------- Domain: pure rules, no framework, no I/O ----------------
record Money(long cents) {
    Money {
        if (cents < 0) throw new IllegalArgumentException("money cannot be negative");
    }
    Money plus(Money other) { return new Money(cents + other.cents); }
    Money times(int n) { return new Money(cents * n); }
    @Override public String toString() { return String.format("%d.%02d", cents / 100, cents % 100); }
}

record OrderLine(String sku, int qty, Money unitPrice) {
    Money total() { return unitPrice.times(qty); }
}

/** Aggregate root: the only way to change an order, so its invariants always hold. */
class Order {
    enum Status { NEW, PAID, CANCELLED }

    private final String id;
    private final List<OrderLine> lines = new ArrayList<>();
    private Status status = Status.NEW;

    Order(String id) { this.id = id; }

    String id() { return id; }
    Status status() { return status; }

    void addLine(String sku, int qty, Money unitPrice) {
        requireStatus(Status.NEW);
        if (qty <= 0) throw new IllegalArgumentException("quantity must be positive");
        lines.add(new OrderLine(sku, qty, unitPrice));
    }

    Money total() {
        return lines.stream().map(OrderLine::total).reduce(new Money(0), Money::plus);
    }

    void markPaid() {
        requireStatus(Status.NEW);
        if (lines.isEmpty()) throw new IllegalStateException("cannot pay for an empty order");
        status = Status.PAID;
    }

    void cancel() {
        if (status == Status.PAID) throw new IllegalStateException("a paid order cannot be cancelled, refund it instead");
        status = Status.CANCELLED;
    }

    private void requireStatus(Status expected) {
        if (status != expected) throw new IllegalStateException("order is " + status + ", expected " + expected);
    }
}

// ---------------- Ports: what the application needs from the outside world ----------------
interface OrderRepository {
    void save(Order order);
    Optional<Order> find(String id);
}
interface PaymentGateway {
    boolean charge(String orderId, Money amount);
}
interface EventPublisher {
    void publish(String event);
}

// ---------------- Application service: one use case, orchestrates ports and domain ----------------
class CheckoutService {
    private final OrderRepository orders;
    private final PaymentGateway payments;
    private final EventPublisher events;

    CheckoutService(OrderRepository orders, PaymentGateway payments, EventPublisher events) {
        this.orders = orders; this.payments = payments; this.events = events;
    }

    void checkout(String orderId) {
        Order order = orders.find(orderId).orElseThrow(() -> new NoSuchElementException("no order " + orderId));
        if (!payments.charge(order.id(), order.total())) throw new IllegalStateException("payment declined");
        order.markPaid();                                   // the domain enforces the rules
        orders.save(order);
        events.publish("OrderPaid:" + order.id() + ":" + order.total());
    }
}

// ---------------- Adapters: infrastructure implementations (fakes here, SQL and HTTP in production) ----------------
class InMemoryOrderRepository implements OrderRepository {
    private final Map<String, Order> store = new HashMap<>();
    public void save(Order order) { store.put(order.id(), order); }
    public Optional<Order> find(String id) { return Optional.ofNullable(store.get(id)); }
}
class FakePaymentGateway implements PaymentGateway {
    boolean approve = true;
    public boolean charge(String orderId, Money amount) { return approve; }
}
class RecordingPublisher implements EventPublisher {
    final List<String> published = new ArrayList<>();
    public void publish(String event) { published.add(event); }
}

// ---------------- Composition root: the only place that knows the concrete classes ----------------
public class Main {
    public static void main(String[] args) {
        InMemoryOrderRepository repo = new InMemoryOrderRepository();
        FakePaymentGateway gateway = new FakePaymentGateway();
        RecordingPublisher events = new RecordingPublisher();
        CheckoutService checkout = new CheckoutService(repo, gateway, events);

        Order paid = new Order("A-1");
        paid.addLine("K1", 1, new Money(4500));
        paid.addLine("M2", 2, new Money(2000));
        repo.save(paid);
        checkout.checkout("A-1");
        System.out.println("A-1 status: " + repo.find("A-1").get().status() + ", events: " + events.published);

        gateway.approve = false;                             // a failure scenario needs no mocking framework, just a fake
        Order declined = new Order("B-2");
        declined.addLine("K1", 1, new Money(4500));
        repo.save(declined);
        try { checkout.checkout("B-2"); } catch (IllegalStateException e) { System.out.println("B-2: " + e.getMessage()); }
        System.out.println("B-2 status: " + repo.find("B-2").get().status() + ", events so far: " + events.published.size());

        try { paid.addLine("X9", 1, new Money(100)); } catch (IllegalStateException e) { System.out.println("invariant: " + e.getMessage()); }
        try { new Order("C-3").addLine("K1", 0, new Money(100)); } catch (IllegalArgumentException e) { System.out.println("invariant: " + e.getMessage()); }
        try { new Order("D-4").markPaid(); } catch (IllegalStateException e) { System.out.println("invariant: " + e.getMessage()); }
    }
}

// runnable
const { test, describe, mock } = require('node:test');
const assert = require('node:assert/strict');

// Code under test: dependencies are injected, so tests control them
function makeGreeter({ userRepo, clock }) {
  return {
    async greeting(id) {
      const user = await userRepo.find(id);
      if (!user) throw Object.assign(new Error('user not found'), { code: 'NOT_FOUND' });
      const partOfDay = clock().getUTCHours() < 12 ? 'morning' : 'afternoon';
      return `Good ${partOfDay}, ${user.name}`;
    },
  };
}

describe('greeter', () => {
  test('greets by time of day (a stub repository and a fixed clock)', async () => {
    const userRepo = { find: mock.fn(async () => ({ id: 1, name: 'Ana' })) };     // stub that also records calls (a spy)
    const morning = makeGreeter({ userRepo, clock: () => new Date('2026-05-01T09:00:00Z') });
    const afternoon = makeGreeter({ userRepo, clock: () => new Date('2026-05-01T15:00:00Z') });

    assert.equal(await morning.greeting(1), 'Good morning, Ana');
    assert.equal(await afternoon.greeting(1), 'Good afternoon, Ana');
    assert.equal(userRepo.find.mock.callCount(), 2);
    assert.deepEqual(userRepo.find.mock.calls[0].arguments, [1]);
  });

  test('rejects for an unknown user', async () => {
    const greeter = makeGreeter({ userRepo: { find: async () => null }, clock: () => new Date() });
    await assert.rejects(() => greeter.greeting(99), { code: 'NOT_FOUND' });
  });

  test('fake timers make time-dependent code deterministic', async (t) => {
    t.mock.timers.enable({ apis: ['setTimeout'] });
    let fired = false;
    setTimeout(() => { fired = true; }, 60_000);                                   // a one-minute timer
    assert.equal(fired, false);
    t.mock.timers.tick(60_000);                                                    // advance the fake clock instantly
    assert.equal(fired, true);
  });
});

// Unit test of the use case with fakes, no Spring involved
class CheckoutServiceTest {
    @Test
    void declinedPaymentLeavesOrderUnpaidAndPublishesNothing() {
        var repo = new InMemoryOrderRepository();
        var gateway = new FakePaymentGateway();
        gateway.approve = false;
        var events = new RecordingPublisher();
        var order = new Order("B-2");
        order.addLine("K1", 1, new Money(4500));
        repo.save(order);

        assertThrows(IllegalStateException.class, () -> new CheckoutService(repo, gateway, events).checkout("B-2"));

        assertEquals(Order.Status.NEW, repo.find("B-2").orElseThrow().status());
        assertTrue(events.published.isEmpty());
    }
}

// Web slice test: only the MVC layer, the service is mocked
@WebMvcTest(UserController.class)
class UserControllerTest {
    @Autowired MockMvc mvc;
    @MockitoBean UserService users;

    @Test
    void returns404ForUnknownUser() throws Exception {
        when(users.find(99)).thenThrow(new NotFoundException("user 99"));
        mvc.perform(get("/api/users/99")).andExpect(status().isNotFound());
    }
}

// Integration test against a real PostgreSQL in a container
@Testcontainers
@DataJpaTest
@AutoConfigureTestDatabase(replace = NONE)
class UserRepositoryIT {
    @Container @ServiceConnection
    static PostgreSQLContainer<?> db = new PostgreSQLContainer<>("postgres:17");

    @Autowired UserRepository repo;

    @Test
    void findsByEmail() {
        repo.save(new User("Ana", "ana@example.com"));
        assertTrue(repo.findByEmail("ana@example.com").isPresent());
    }
}

Correctness   Edge cases, null and empty, concurrency, idempotent retries, transaction boundaries
API           Right status codes, validation at the boundary, error shape, no breaking changes, pagination
Security      Authn and authz on every route, object-level checks, parameterized SQL, no secrets or PII in logs
Data          Migrations backward compatible and reversible plan, indexes for new queries, N+1 avoided
Performance   Queries per request, payload size, blocking calls on the event loop, timeouts and limits
Reliability   Timeouts and retries on outbound calls, graceful failure, behavior when a dependency is down
Observability Logs with correlation id, metrics for new paths, traces, alerts for new failure modes
Tests         Behavior covered, failure paths, no flakiness, fast, readable names
Design        Dependencies point inward, small functions, clear names, no leaked internals in DTOs
Operations    Config via environment, feature flag or rollout plan, rollback plan, docs and runbook