Composition Root와 실패 경계

Dependency Injection = 필요한 것을 내부에서 만들지 않고 외부에서 받는다
Composition Root = 애플리케이션 시작 지점에서 객체 그래프를 조립한다
Constructor Boundary = 필수 의존성은 생성자에서 드러낸다
Lifetime Policy = singleton / scoped / transient 수명을 조립 계층에서 결정한다
No Service Locator = 실행 객체가 전역 registry를 직접 조회하지 않는다
Predictable Failure = 검증 같은 예측 가능한 실패는 예외가 아니라 Result로 표현하는 편이 명확하다.

- 주문 정보를 영수증 HTML로 렌더링한다.
- 이메일을 발송한다.
- 현재 시각을 영수증에 넣는다.
- 성공 결과를 반환한다.

ReceiptEmailService
-> new SystemClock()
-> new HtmlReceiptRenderer()
-> new SmtpEmailSender()

ReceiptEmailService = orchestration
ReceiptRenderer     = 주문 -> HTML 변환
EmailSender         = 이메일 I/O
Clock               = 현재 시각 의존성
Composition Root    = 실제 구현 객체 조립

using System;
using System.Threading;
using System.Threading.Tasks;

public enum ReceiptError
{
    EmptyOrderId,
    EmptyCustomerEmail,
    NegativeTotal,
}

public readonly struct Result<TValue, TError>
{
    private readonly TValue value;
    private readonly TError error;
    private readonly bool isOk;
    private readonly bool isInitialized;

    private Result(
        bool isOk,
        TValue value,
        TError error)
    {
        this.isOk = isOk;
        this.value = value;
        this.error = error;
        this.isInitialized = true;
    }

    public bool IsOk
    {
        get
        {
            EnsureInitialized();
            return this.isOk;
        }
    }

    public static Result<TValue, TError> Ok(TValue value)
    {
        return new Result<TValue, TError>(true, value, default!);
    }

    public static Result<TValue, TError> Fail(TError error)
    {
        return new Result<TValue, TError>(false, default!, error);
    }

    public bool TryGetValue(out TValue value)
    {
        EnsureInitialized();
        value = this.value;
        return this.isOk;
    }

    public TResult Match<TResult>(
        Func<TValue, TResult> onOk,
        Func<TError, TResult> onFail)
    {
        EnsureInitialized();

        if (this.isOk)
        {
            return onOk(this.value);
        }

        return onFail(this.error);
    }

    private void EnsureInitialized()
    {
        if (!this.isInitialized)
        {
            throw new InvalidOperationException(
                "Result가 초기화되지 않았습니다. Ok 또는 Fail로 생성해야 합니다.");
        }
    }
}

public sealed record OrderReceipt
{
    public string OrderId { get; }

    public string CustomerEmail { get; }

    public long TotalCents { get; }

    private OrderReceipt(
        string orderId,
        string customerEmail,
        long totalCents)
    {
        this.OrderId = orderId;
        this.CustomerEmail = customerEmail;
        this.TotalCents = totalCents;
    }

    public static Result<OrderReceipt, ReceiptError> TryCreate(
        string orderId,
        string customerEmail,
        long totalCents)
    {
        if (string.IsNullOrWhiteSpace(orderId))
        {
            return Result<OrderReceipt, ReceiptError>.Fail(ReceiptError.EmptyOrderId);
        }

        if (string.IsNullOrWhiteSpace(customerEmail))
        {
            return Result<OrderReceipt, ReceiptError>.Fail(ReceiptError.EmptyCustomerEmail);
        }

        if (totalCents < 0)
        {
            return Result<OrderReceipt, ReceiptError>.Fail(ReceiptError.NegativeTotal);
        }

        OrderReceipt receipt = new OrderReceipt(
            orderId,
            customerEmail,
            totalCents);

        return Result<OrderReceipt, ReceiptError>.Ok(receipt);
    }
}

public sealed record SendReceiptResult(
    string OrderId,
    string CustomerEmail,
    DateTimeOffset SentAt);

public interface ReceiptRenderer
{
    string RenderHtml(
        OrderReceipt receipt,
        DateTimeOffset issuedAt);
}

public interface EmailSender
{
    ValueTask SendAsync(
        string toEmail,
        string subject,
        string htmlBody,
        CancellationToken cancellationToken);
}

public interface Clock
{
    DateTimeOffset GetUtcNow();
}

public sealed class ReceiptEmailService
{
    private readonly ReceiptRenderer renderer;
    private readonly EmailSender emailSender;
    private readonly Clock clock;

    public ReceiptEmailService(
        ReceiptRenderer renderer,
        EmailSender emailSender,
        Clock clock)
    {
        this.renderer = renderer ?? throw new ArgumentNullException(nameof(renderer));
        this.emailSender = emailSender ?? throw new ArgumentNullException(nameof(emailSender));
        this.clock = clock ?? throw new ArgumentNullException(nameof(clock));
    }

    public async ValueTask<SendReceiptResult> SendAsync(
        OrderReceipt receipt,
        CancellationToken cancellationToken)
    {
        DateTimeOffset issuedAt = this.clock.GetUtcNow();
        string htmlBody = this.renderer.RenderHtml(receipt, issuedAt);

        await this.emailSender.SendAsync(
            receipt.CustomerEmail,
            $"Receipt for order {receipt.OrderId}",
            htmlBody,
            cancellationToken);

        return new SendReceiptResult(
            receipt.OrderId,
            receipt.CustomerEmail,
            issuedAt);
    }
}

public sealed class SystemClock : Clock
{
    public DateTimeOffset GetUtcNow()
    {
        return DateTimeOffset.UtcNow;
    }
}

public sealed class HtmlReceiptRenderer : ReceiptRenderer
{
    public string RenderHtml(
        OrderReceipt receipt,
        DateTimeOffset issuedAt)
    {
        return $"<h1>Order {receipt.OrderId}</h1><p>Total: {receipt.TotalCents}</p><p>{issuedAt:O}</p>";
    }
}

type ReceiptError =
  | "EmptyOrderId"
  | "EmptyCustomerEmail"
  | "InvalidTotal";

type Result<TValue, TError> =
  | Readonly<{ ok: true; value: TValue }>
  | Readonly<{ ok: false; error: TError }>;

type OrderReceipt = Readonly<{
  orderId: string;
  customerEmail: string;
  totalCents: number;
}>;

type SendReceiptResult = Readonly<{
  orderId: string;
  customerEmail: string;
  sentAt: Date;
}>;

type ReceiptRenderer = Readonly<{
  renderHtml: (
    receipt: OrderReceipt,
    issuedAt: Date,
  ) => string;
}>;

type EmailSender = Readonly<{
  sendAsync: (
    toEmail: string,
    subject: string,
    htmlBody: string,
    signal?: AbortSignal,
  ) => Promise<void>;
}>;

type Clock = Readonly<{
  getUtcNow: () => Date;
}>;

export function tryCreateOrderReceipt(
  orderId: string,
  customerEmail: string,
  totalCents: number,
): Result<OrderReceipt, ReceiptError>
{
  if (orderId.trim().length === 0) {
    return { ok: false, error: "EmptyOrderId" };
  }

  if (customerEmail.trim().length === 0) {
    return { ok: false, error: "EmptyCustomerEmail" };
  }

  if (!Number.isInteger(totalCents) || totalCents < 0) {
    return { ok: false, error: "InvalidTotal" };
  }

  return {
    ok: true,
    value: { orderId, customerEmail, totalCents },
  };
}

export class ReceiptEmailService
{
  readonly #renderer: ReceiptRenderer;
  readonly #emailSender: EmailSender;
  readonly #clock: Clock;

  public constructor(
    renderer: ReceiptRenderer,
    emailSender: EmailSender,
    clock: Clock,
  )
  {
    if (renderer === undefined || renderer === null) {
      throw new TypeError("renderer is required.");
    }

    if (emailSender === undefined || emailSender === null) {
      throw new TypeError("emailSender is required.");
    }

    if (clock === undefined || clock === null) {
      throw new TypeError("clock is required.");
    }

    this.#renderer = renderer;
    this.#emailSender = emailSender;
    this.#clock = clock;
  }

  public async sendAsync(
    receipt: OrderReceipt,
    signal?: AbortSignal,
  ): Promise<SendReceiptResult>
  {
    const issuedAt = this.#clock.getUtcNow();
    const htmlBody = this.#renderer.renderHtml(receipt, issuedAt);

    await this.#emailSender.sendAsync(
      receipt.customerEmail,
      `Receipt for order ${receipt.orderId}`,
      htmlBody,
      signal,
    );

    return {
      orderId: receipt.orderId,
      customerEmail: receipt.customerEmail,
      sentAt: issuedAt,
    };
  }
}

export const systemClock: Clock = {
  getUtcNow: () => new Date(),
};

export const htmlReceiptRenderer: ReceiptRenderer = {
  renderHtml: (receipt, issuedAt) => {
    return `<h1>Order ${receipt.orderId}</h1><p>Total: ${receipt.totalCents}</p><p>${issuedAt.toISOString()}</p>`;
  },
};

from dataclasses import dataclass
from datetime import UTC, datetime
from enum import Enum, auto
from typing import Generic, Protocol, TypeVar

TValue = TypeVar("TValue")
TError = TypeVar("TError")

class ReceiptError(Enum):
    EMPTY_ORDER_ID = auto()
    EMPTY_CUSTOMER_EMAIL = auto()
    NEGATIVE_TOTAL = auto()

@dataclass(frozen=True)
class Ok(Generic[TValue]):
    value: TValue

@dataclass(frozen=True)
class Err(Generic[TError]):
    error: TError

@dataclass(frozen=True)
class OrderReceipt:
    order_id: str
    customer_email: str
    total_cents: int

@dataclass(frozen=True)
class SendReceiptResult:
    order_id: str
    customer_email: str
    sent_at: datetime

class ReceiptRenderer(Protocol):
    def render_html(
        self,
        receipt: OrderReceipt,
        issued_at: datetime,
    ) -> str:
        ...

class EmailSender(Protocol):
    async def send_async(
        self,
        to_email: str,
        subject: str,
        html_body: str,
    ) -> None:
        ...

class Clock(Protocol):
    def get_utc_now(self) -> datetime:
        ...

def try_create_order_receipt(
    order_id: str,
    customer_email: str,
    total_cents: int,
) -> Ok[OrderReceipt] | Err[ReceiptError]:
    if order_id.strip() == "":
        return Err(ReceiptError.EMPTY_ORDER_ID)

    if customer_email.strip() == "":
        return Err(ReceiptError.EMPTY_CUSTOMER_EMAIL)

    if total_cents < 0:
        return Err(ReceiptError.NEGATIVE_TOTAL)

    return Ok(
        OrderReceipt(
            order_id=order_id,
            customer_email=customer_email,
            total_cents=total_cents,
        )
    )

class ReceiptEmailService:
    def __init__(
        self,
        renderer: ReceiptRenderer,
        email_sender: EmailSender,
        clock: Clock,
    ) -> None:
        self._renderer = renderer
        self._email_sender = email_sender
        self._clock = clock

    async def send_async(
        self,
        receipt: OrderReceipt,
    ) -> SendReceiptResult:
        issued_at = self._clock.get_utc_now()
        html_body = self._renderer.render_html(receipt, issued_at)

        await self._email_sender.send_async(
            receipt.customer_email,
            f"Receipt for order {receipt.order_id}",
            html_body,
        )

        return SendReceiptResult(
            order_id=receipt.order_id,
            customer_email=receipt.customer_email,
            sent_at=issued_at,
        )

class SystemClock:
    def get_utc_now(self) -> datetime:
        return datetime.now(UTC)

class HtmlReceiptRenderer:
    def render_html(
        self,
        receipt: OrderReceipt,
        issued_at: datetime,
    ) -> str:
        return (
            f"<h1>Order {receipt.order_id}</h1>"
            f"<p>Total: {receipt.total_cents}</p>"
            f"<p>{issued_at.isoformat()}</p>"
        )

use async_trait::async_trait;
use time::OffsetDateTime;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ReceiptError {
    EmptyOrderId,
    EmptyCustomerEmail,
    NegativeTotal,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OrderReceipt {
    order_id: String,
    customer_email: String,
    total_cents: i64,
}

impl OrderReceipt {
    pub fn try_new(
        order_id: String,
        customer_email: String,
        total_cents: i64,
    ) -> Result<Self, ReceiptError> {
        if order_id.trim().is_empty() {
            return Err(ReceiptError::EmptyOrderId);
        }

        if customer_email.trim().is_empty() {
            return Err(ReceiptError::EmptyCustomerEmail);
        }

        if total_cents < 0 {
            return Err(ReceiptError::NegativeTotal);
        }

        Ok(Self {
            order_id,
            customer_email,
            total_cents,
        })
    }

    pub fn order_id(&self) -> &str {
        &self.order_id
    }

    pub fn customer_email(&self) -> &str {
        &self.customer_email
    }

    pub fn total_cents(&self) -> i64 {
        self.total_cents
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SendReceiptResult {
    order_id: String,
    customer_email: String,
    sent_at: OffsetDateTime,
}

impl SendReceiptResult {
    pub fn order_id(&self) -> &str {
        &self.order_id
    }

    pub fn customer_email(&self) -> &str {
        &self.customer_email
    }

    pub fn sent_at(&self) -> OffsetDateTime {
        self.sent_at
    }
}

pub trait ReceiptRenderer: Send + Sync {
    fn render_html(
        &self,
        receipt: &OrderReceipt,
        issued_at: OffsetDateTime,
    ) -> String;
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EmailSendError {
    Timeout,
    DnsFailure,
    AuthenticationFailed,
    TransportFailed,
}

#[async_trait]
pub trait EmailSender: Send + Sync {
    async fn send_async(
        &self,
        to_email: &str,
        subject: &str,
        html_body: &str,
    ) -> Result<(), EmailSendError>;
}

pub trait Clock: Send + Sync {
    fn get_utc_now(&self) -> OffsetDateTime;
}

pub struct ReceiptEmailService<TRenderer, TEmailSender, TClock>
where
    TRenderer: ReceiptRenderer,
    TEmailSender: EmailSender,
    TClock: Clock,
{
    renderer: TRenderer,
    email_sender: TEmailSender,
    clock: TClock,
}

impl<TRenderer, TEmailSender, TClock>
    ReceiptEmailService<TRenderer, TEmailSender, TClock>
where
    TRenderer: ReceiptRenderer,
    TEmailSender: EmailSender,
    TClock: Clock,
{
    pub fn new(
        renderer: TRenderer,
        email_sender: TEmailSender,
        clock: TClock,
    ) -> Self {
        Self {
            renderer,
            email_sender,
            clock,
        }
    }

    pub async fn send_async(
        &self,
        receipt: &OrderReceipt,
    ) -> Result<SendReceiptResult, EmailSendError> {
        let issued_at = self.clock.get_utc_now();
        let html_body = self.renderer.render_html(receipt, issued_at);
        let subject = format!("Receipt for order {}", receipt.order_id());

        self.email_sender
            .send_async(
                receipt.customer_email(),
                &subject,
                &html_body,
            )
            .await?;

        Ok(SendReceiptResult {
            order_id: receipt.order_id().to_owned(),
            customer_email: receipt.customer_email().to_owned(),
            sent_at: issued_at,
        })
    }
}

pub struct SystemClock;

impl Clock for SystemClock {
    fn get_utc_now(&self) -> OffsetDateTime {
        OffsetDateTime::now_utc()
    }
}

pub struct HtmlReceiptRenderer;

impl ReceiptRenderer for HtmlReceiptRenderer {
    fn render_html(
        &self,
        receipt: &OrderReceipt,
        issued_at: OffsetDateTime,
    ) -> String {
        format!(
            "<h1>Order {}</h1><p>Total: {}</p><p>{}</p>",
            receipt.order_id(),
            receipt.total_cents(),
            issued_at
        )
    }
}

type AppServices = Readonly<{
  receiptEmailService: ReceiptEmailService;
}>;

class SmtpEmailSender implements EmailSender
{
  readonly #host: string;

  public constructor(host: string)
  {
    if (host.trim().length === 0) {
      throw new RangeError("host는 비어 있을 수 없습니다.");
    }

    this.#host = host;
  }

  public async sendAsync(
    toEmail: string,
    subject: string,
    htmlBody: string,
    _signal?: AbortSignal,
  ): Promise<void>
  {
    console.info("smtp.send", {
      host: this.#host,
      toEmail,
      subject,
      bodyLength: htmlBody.length,
    });
  }
}

export function buildAppServices(): AppServices
{
  const emailSender = new SmtpEmailSender("smtp.example.com");
  const receiptEmailService = new ReceiptEmailService(
    htmlReceiptRenderer,
    emailSender,
    systemClock,
  );

  return {
    receiptEmailService,
  };
}

export async function handlePaymentCompletedAsync(
  input: Readonly<{
    orderId: string;
    customerEmail: string;
    totalCents: number;
  }>,
  services: AppServices,
  signal?: AbortSignal,
): Promise<Result<SendReceiptResult, ReceiptError>>
{
  const receiptResult = tryCreateOrderReceipt(
    input.orderId,
    input.customerEmail,
    input.totalCents,
  );

  if (!receiptResult.ok) {
    return receiptResult;
  }

  const sentAt = await services.receiptEmailService.sendAsync(
    receiptResult.value,
    signal,
  );

  return {
    ok: true,
    value: sentAt,
  };
}

buildAppServices             = Composition Root, 실제 구현과 lifetime 조립
tryCreateOrderReceipt        = 입력 검증, 예측 가능한 실패를 Result로 반환
ReceiptEmailService          = 영수증 발송 use case orchestration, 실행만 담당
ReceiptRenderer              = 순수 HTML 변환
EmailSender                  = 외부 이메일 I/O
Clock                        = 시간 의존성
handlePaymentCompletedAsync  = 이벤트/API 경계에서 검증 Result 처리 후 use case 호출

이 객체가 필요한 의존성은 무엇인가
-> 그 의존성이 생성자나 함수 인자로 드러나는가
-> 객체 내부에서 new/환경변수/전역 registry를 직접 조회하지 않는가
-> 실제 구현 선택은 Composition Root에 모여 있는가
-> 예측 가능한 검증 실패가 예외가 아니라 Result로 표현되는가
-> 그 검증이 생성 경계(팩토리)에 모여 있는가
-> lifetime이 singleton/scoped/transient 중 무엇인가
-> 테스트에서 fake 구현을 넣을 수 있는가
-> I/O 의존성과 순수 변환 의존성이 분리되어 있는가

- 서비스 내부에서 new SmtpEmailSender()를 직접 호출함
- 서비스가 전역 container/service locator를 직접 조회함
- 예측 가능한 검증 실패를 예외/패닉으로 처리해 실행부로 새어 나옴
- singleton 객체가 request-scoped 상태를 들고 있음
- transient로 만들어야 할 무거운 client를 매 요청마다 새로 생성함
- 테스트에서 실제 SMTP/DB/clock을 사용함
- interface가 너무 많아 순수 값 객체까지 불필요하게 추상화됨
- Composition Root가 여러 곳으로 흩어져 객체 그래프를 추적할 수 없음
- configuration 읽기와 use case 실행이 같은 클래스에 섞임

class BadReceiptEmailService
{
  public async sendAsync(receipt: OrderReceipt): Promise<SendReceiptResult>
  {
    const renderer = htmlReceiptRenderer;
    const clock = systemClock;
    const emailSender = new SmtpEmailSender("smtp.example.com");

    const issuedAt = clock.getUtcNow();
    const htmlBody = renderer.renderHtml(receipt, issuedAt);

    await emailSender.sendAsync(
      receipt.customerEmail,
      `Receipt for order ${receipt.orderId}`,
      htmlBody,
    );

    return {
      orderId: receipt.orderId,
      customerEmail: receipt.customerEmail,
      sentAt: issuedAt,
    };
  }
}

- 서비스 내부에서 실제 SMTP 구현을 직접 생성한다.
- 테스트에서 fake EmailSender를 넣을 수 없다.
- 현재 시각을 고정하기 어렵다.
- SMTP host 설정이 Composition Root가 아니라 use case 안에 박혀 있다.
- 서비스 생성 비용과 SMTP client lifetime을 제어할 수 없다.
- 의존성이 생성자 서명에 드러나지 않아 코드 리뷰가 어렵다.

class LocatorBasedReceiptEmailService
{
  public async sendAsync(receipt: OrderReceipt): Promise<SendReceiptResult>
  {
    const emailSender = globalContainer.resolve<EmailSender>("emailSender");
    const clock = globalContainer.resolve<Clock>("clock");
    const renderer = globalContainer.resolve<ReceiptRenderer>("renderer");

    const issuedAt = clock.getUtcNow();
    const htmlBody = renderer.renderHtml(receipt, issuedAt);

    await emailSender.sendAsync(receipt.customerEmail, "Receipt", htmlBody);

    return {
      orderId: receipt.orderId,
      customerEmail: receipt.customerEmail,
      sentAt: issuedAt,
    };
  }
}

import assert from "node:assert/strict";
import test from "node:test";

class RecordingEmailSender implements EmailSender
{
  readonly #sentMessages: Array<Readonly<{
    toEmail: string;
    subject: string;
    htmlBody: string;
  }>> = [];

  public async sendAsync(
    toEmail: string,
    subject: string,
    htmlBody: string,
  ): Promise<void>
  {
    this.#sentMessages.push({
      toEmail,
      subject,
      htmlBody,
    });
  }

  public getSentMessages(): readonly Readonly<{
    toEmail: string;
    subject: string;
    htmlBody: string;
  }>[]
  {
    return this.#sentMessages;
  }
}

const fixedClock: Clock = {
  getUtcNow: () => new Date("2026-07-08T00:00:00.000Z"),
};

const testRenderer: ReceiptRenderer = {
  renderHtml: (receipt, issuedAt) => {
    return `order=${receipt.orderId}; total=${receipt.totalCents}; issuedAt=${issuedAt.toISOString()}`;
  },
};

test("tryCreateOrderReceipt는 빈 orderId를 Err로 반환한다", () => {
  const result = tryCreateOrderReceipt("", "[email protected]", 12_000);

  assert.equal(result.ok, false);
  if (result.ok) {
    return;
  }

  assert.equal(result.error, "EmptyOrderId");
});

test("ReceiptEmailService는 이메일 발송 의도를 EmailSender에 전달한다", async () => {
  const emailSender = new RecordingEmailSender();
  const service = new ReceiptEmailService(
    testRenderer,
    emailSender,
    fixedClock,
  );

  const receiptResult = tryCreateOrderReceipt(
    "ord-1",
    "[email protected]",
    12_000,
  );

  assert.equal(receiptResult.ok, true);
  if (!receiptResult.ok) {
    return;
  }

  const result = await service.sendAsync(receiptResult.value);

  assert.equal(result.sentAt.toISOString(), "2026-07-08T00:00:00.000Z");
  assert.deepEqual(emailSender.getSentMessages(), [
    {
      toEmail: "[email protected]",
      subject: "Receipt for order ord-1",
      htmlBody: "order=ord-1; total=12000; issuedAt=2026-07-08T00:00:00.000Z",
    },
  ]);
});

class FailingEmailSender implements EmailSender
{
  readonly #error: Error;

  public constructor(error: Error)
  {
    this.#error = error;
  }

  public async sendAsync(
    _toEmail: string,
    _subject: string,
    _htmlBody: string,
  ): Promise<void>
  {
    throw this.#error;
  }
}

test("ReceiptEmailService는 이메일 발송 실패를 상위 경계로 전파한다", async () => {
  const emailSender = new FailingEmailSender(
    new Error("smtp transport failed"),
  );

  const service = new ReceiptEmailService(
    testRenderer,
    emailSender,
    fixedClock,
  );

  const receiptResult = tryCreateOrderReceipt(
    "ord-1",
    "[email protected]",
    12_000,
  );

  assert.equal(receiptResult.ok, true);
  if (!receiptResult.ok) {
    return;
  }

  await assert.rejects(
    () => service.sendAsync(receiptResult.value),
    /smtp transport failed/,
  );
});

struct FailingEmailSender;

#[async_trait]
impl EmailSender for FailingEmailSender {
    async fn send_async(
        &self,
        _to_email: &str,
        _subject: &str,
        _html_body: &str,
    ) -> Result<(), EmailSendError> {
        Err(EmailSendError::Timeout)
    }
}

#[tokio::test]
async fn send_failure_is_propagated_as_err() {
    let receipt = OrderReceipt::try_new(
        "ord-1".to_owned(),
        "[email protected]".to_owned(),
        12_000,
    )
    .expect("valid receipt");

    let service = ReceiptEmailService::new(
        HtmlReceiptRenderer,
        FailingEmailSender,
        SystemClock,
    );

    let result = service.send_async(&receipt).await;

    assert_eq!(result, Err(EmailSendError::Timeout));
}

API handler
event handler
background worker
message consumer
scheduler

RecordingEmailSender = 성공 경로에서 서비스가 무엇을 하려고 했는지 기록한다.
FailingEmailSender   = I/O 실패가 상위 경계로 전파되는지 확인한다.

ReceiptEmailService     = transient 또는 scoped, 요청/use case 단위
HtmlReceiptRenderer     = singleton, 상태 없는 순수 변환
SystemClock             = singleton, 상태 없음
SmtpEmailSender         = singleton 또는 pooled, connection 관리 정책에 따름
Configuration           = singleton, 부팅 시 검증된 immutable config
RequestContext          = scoped, 요청별 correlation/user 정보

- use case 클래스 내부에 new 외부 I/O client가 없는가?
- constructor만 보고 필수 의존성을 알 수 있는가?
- Composition Root가 실행 진입점마다 하나로 모여 있는가?
- 예측 가능한 검증 실패가 예외가 아니라 Result로 반환되는가?
- 그 검증이 생성 경계에 모여 있고 실행부는 실행만 하는가?
- singleton이 mutable request state를 들고 있지 않은가?
- 테스트가 fake clock/fake sender/fake repository로 실행되는가?
- 성공 Fake뿐 아니라 fault-injecting fake로 I/O 실패 경로도 테스트되는가?
- 실패 복구 정책이 use case가 아니라 호출 경계에 있는가?
- Service Locator 호출이 application core로 새지 않는가?

실행 객체는 의존성을 만들지 말고, 조립 계층이 만들어서 넘겨야 한다.

비즈니스 객체는 의존성을 찾거나 만들지 말고, 조립된 의존성을 받아 실행만 해야 한다.