// Stub: always returns the same user regardless of input
const userServiceStub = {
  getUser: (id) => ({ id, name: "Test User", email: "test@example.com" })
}
// Use when: you need a dependency to return specific data for your test scenario

// Mock: verify that the email service was called with the right arguments
const emailServiceMock = mock(EmailService)
orderService.placeOrder(order)
verify(emailServiceMock).sendConfirmation("user@example.com", order.id)
// Use when: the behavior you are testing IS the interaction (e.g., "placing an order sends an email")

// Fake: an in-memory database that actually stores and retrieves data
class FakeUserRepository {
  users = new Map()
  save(user) { this.users.set(user.id, user) }
  findById(id) { return this.users.get(id) || null }
}
// Use when: you need a real-ish dependency but cannot use the actual one (database, file system)

// Spy: track calls to the real logger without replacing it
const loggerSpy = spy(realLogger)
orderService.placeOrder(order)
assert(loggerSpy.info).wasCalledWith("Order placed", { orderId: order.id })
// Use when: you want the real behavior but also want to verify what happened

// Java + JUnit 5 + Testcontainers example
@Testcontainers
class OrderRepositoryIntegrationTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Test
    void shouldPersistOrderWithLineItems() {
        // Arrange: create an order with 2 line items
        Order order = new Order("customer-123", List.of(
            new LineItem("SKU-A", 2, Money.of(10.00)),
            new LineItem("SKU-B", 1, Money.of(25.00))
        ));

        // Act: save and retrieve
        orderRepository.save(order);
        Order loaded = orderRepository.findById(order.getId());

        // Assert: full round-trip works with real Postgres
        assertThat(loaded.getLineItems()).hasSize(2);
        assertThat(loaded.getTotal()).isEqualTo(Money.of(45.00));
    }
}

// Node.js + Jest + Testcontainers example
const { PostgreSqlContainer } = require("@testcontainers/postgresql");

let container;
let db;

beforeAll(async () => {
  container = await new PostgreSqlContainer("postgres:16").start();
  db = createPool({ connectionString: container.getConnectionUri() });
  await runMigrations(db); // apply your real schema
}, 60_000);

afterAll(async () => {
  await db.end();
  await container.stop();
});

test("order persists with line items", async () => {
  const orderId = await createOrder(db, {
    customerId: "cust-123",
    items: [{ sku: "SKU-A", qty: 2, price: 10.0 }]
  });

  const order = await getOrderById(db, orderId);
  expect(order.items).toHaveLength(1);
  expect(order.total).toBe(20.0);
});

// Consumer-side Pact test (Node.js)
const { PactV3 } = require("@pact-foundation/pact");

const provider = new PactV3({
  consumer: "OrderService",
  provider: "UserService",
});

describe("User API contract", () => {
  it("returns user details", async () => {
    provider
      .given("user 123 exists")
      .uponReceiving("a request for user 123")
      .withRequest({ method: "GET", path: "/users/123" })
      .willRespondWith({
        status: 200,
        body: {
          id: 123,
          name: "Jane Doe",
          email: "jane@example.com",
        },
      });

    await provider.executeTest(async (mockServer) => {
      const user = await fetchUser(mockServer.url, 123);
      expect(user.name).toBe("Jane Doe");
    });
  });
});

// BAD: testing implementation details
test("placeOrder calls validateInventory then processPayment", () => {
  const spy1 = jest.spyOn(orderService, "validateInventory");
  const spy2 = jest.spyOn(orderService, "processPayment");
  orderService.placeOrder(order);
  expect(spy1).toHaveBeenCalledBefore(spy2); // who cares about the order?
});

// GOOD: testing behavior
test("placeOrder creates an order and charges the customer", () => {
  const result = orderService.placeOrder(order);
  expect(result.status).toBe("confirmed");
  expect(result.chargedAmount).toBe(49.99);
});

// Written solely to hit coverage — asserts nothing useful
test("constructor creates instance", () => {
  const service = new OrderService();
  expect(service).toBeDefined(); // congratulations, you tested the "new" keyword
});

2025-03-15 14:23:01 INFO OrderService - User user-456 placed order ord-789 for $120.50 from IP 192.168.1.42

{
  "timestamp": "2025-03-15T14:23:01.123Z",
  "level": "info",
  "service": "order-service",
  "message": "Order placed",
  "traceId": "abc-123-def-456",
  "spanId": "span-789",
  "userId": "user-456",
  "orderId": "ord-789",
  "amount": 120.50,
  "currency": "USD",
  "ip": "192.168.1.42",
  "duration_ms": 234
}

{
  "timestamp": "2025-03-15T14:23:01.123Z",
  "level": "error",
  "service": "payment-service",
  "trace_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "span_id": "span-001",
  "request_id": "req-xyz-789",
  "user_id": "user-456",
  "action": "payment.charge",
  "duration_ms": 3042,
  "http_method": "POST",
  "http_path": "/api/v1/payments",
  "http_status": 502,
  "error": {
    "code": "GATEWAY_TIMEOUT",
    "message": "Stripe API did not respond within 3000ms",
    "retry_count": 2
  },
  "order_id": "ord-789",
  "amount": 120.50,
  "currency": "USD",
  "ip": "203.0.113.42",
  "environment": "production",
  "version": "v2.14.3"
}

Phase          │ Database State           │ Application Behavior       │ Risk Level
───────────────┼──────────────────────────┼────────────────────────────┼───────────
               │                          │                            │
Day 1          │ [username] exists         │ Reads/writes username      │ NONE
EXPAND         │ [username] + [display_    │ Reads/writes username      │ (safe to
               │  name] both exist         │                            │  roll back)
               │                          │                            │
Day 2          │ Both columns exist        │ Writes to BOTH columns     │ LOW
DUAL-WRITE     │ Sync trigger keeps them  │ Reads from username        │ (either
               │ consistent               │                            │  column is
               │                          │                            │  valid)
               │                          │                            │
Day 3          │ Both columns exist        │ Writes to BOTH columns     │ LOW
BACKFILL       │ Batch copy old → new     │ Reads from username        │ (data
               │ for existing rows         │                            │  converging)
               │                          │                            │
Day 4-5        │ Both columns exist,       │ Writes to BOTH columns     │ LOW
SWITCH READS   │ all data synced          │ Reads from display_name    │ (new column
               │                          │                            │  is source
               │                          │                            │  of truth)
               │                          │                            │
Week 2-4       │ Both columns exist        │ Writes ONLY display_name  │ MEDIUM
MIGRATE        │                          │ All consumers updated      │ (verify no
CONSUMERS      │                          │                            │  stragglers)
               │                          │                            │
Week 5         │ Both columns exist        │ Monitor old column for     │ LOW
VERIFY         │                          │ any remaining access       │ (final
               │                          │                            │  safety
               │                          │                            │  check)
               │                          │                            │
Week 6         │ [display_name] only      │ Reads/writes display_name  │ NONE
CONTRACT       │ Old column dropped       │                            │ (migration
               │                          │                            │  complete)

-- Migration 001: add new column (non-breaking)
ALTER TABLE users ADD COLUMN display_name VARCHAR(255);

# Application code writes to both columns
user.username = new_value
user.display_name = new_value  # write to new column too
db.save(user)

-- Migration 002: backfill (run as a batch job, not in a transaction lock)
UPDATE users SET display_name = username WHERE display_name IS NULL;
-- For large tables, do this in batches of 1000-10000 rows to avoid locking

# Application now reads from display_name
name = user.display_name  # new column is the source of truth

user.display_name = new_value
# no longer writing to user.username

-- Migration 003: remove old column (only after all app instances are on Step 5)
ALTER TABLE users DROP COLUMN username;