Devin.KR

AI 개발 · 실무

웹 서비스 해부도 - 서버·백엔드·프런트엔드·보안 구성요소 실무

백엔드 구조 - 컨트롤러·서비스·저장소 나누기

계층 나누기의 이유, 요청 검증 위치, 트랜잭션 경계, 의존성 주입으로 테스트 쉽게 하기, AI 가 한 함수에 다 몰아 쓴 코드를 나누는 리팩터링, 완성 코드는 주문 생성 흐름을 계층으로 나누고 가짜 저장소로 테스트

개발자KR · 원고 갱신

이 장에서 배우는 것

앞 장에서 리버스 프록시가 받은 요청을 백엔드에 넘기는 모습을 보았다. 이제 작은 온라인 서점의 백엔드 안으로 들어가 책 한 종류를 주문하는 요청을 따라간다. 요청에서 수량을 읽고, 주문할 수 있는지 판단하고, 재고와 주문 기록을 바꾸는 일은 한 번의 요청 안에서 일어난다. 하지만 각 일이 바뀌는 이유는 다르다. 요청 필드 이름은 화면과의 약속이 바뀌면 달라지고, 주문 가능 조건은 서점의 운영 규칙에 따라 달라지며, 데이터를 저장하는 코드는 저장 방식이 바뀌면 달라진다.

  • 주문 생성 흐름을 컨트롤러, 서비스, 저장소로 나누고 각 계층의 입력과 출력을 설명한다.
  • 요청의 형태를 검사하는 위치와 현재 재고를 확인하는 위치를 구분한다.
  • 재고 차감과 주문 기록을 하나의 트랜잭션으로 묶는다.
  • 서비스에 저장소를 주입하고 가짜 저장소로 성공과 실패를 재현한다.
  • AI가 한 함수에 작성한 코드를 나눈 뒤 실행, 테스트, 변경분 검토로 동작을 확인한다.

문제 상황

서점에는 상품 코드가 PY-01인 책이 세 권 있다. 고객이 두 권을 주문하면 판매 가능한 재고가 한 권으로 줄고 주문 기록이 한 건 생겨야 한다. 그런데 첫 구현에서 요청을 처리하는 함수 하나가 필드를 읽고, 수량을 정수로 바꾸고, 재고를 조회하고, 재고를 차감하고, 주문을 기록하고, 응답을 만들었다. 재고 차감 직후에 변경을 확정하는 코드도 들어 있었다.

개발 중에 주문 기록을 쓰는 단계에서 오류가 나자 함수는 실패 응답을 돌려주었지만, 재고는 이미 한 권으로 줄어 있었다. 같은 요청을 다시 보내면 이번에는 재고 부족 응답이 돌아왔다. 화면에서 본 두 응답은 모두 실패였고 주문 내역도 비어 있었지만 두 권은 판매 가능한 수량에서 빠졌다. 이 문제를 조사할 때 실패 응답만 검사하면 재고가 줄어든 지점을 놓친다. 실패한 요청의 처리 전후에 재고와 주문 기록을 함께 확인해야 한다.

기존 함수에 새 기능을 더하는 일도 어려웠다. 같은 주문 규칙을 관리 화면에서도 쓰려면 요청 사전과 응답 상태 코드까지 따라왔다. 화면에서 보낸 수량이 잘못된 경우를 시험하려 해도 데이터베이스부터 준비해야 했다. 어느 코드를 옮길지 정하려면 먼저 각 줄이 무엇을 알아야 하는지, 그 줄의 동작을 관찰하려면 무엇을 준비해야 하는지 살펴봐야 한다.

요청을 해석하는 곳과 주문을 결정하는 곳

컨트롤러(controller)는 요청을 받아 서비스가 사용할 값으로 바꾸고, 서비스 호출 결과를 응답으로 바꾼다. 이 장에서는 이미 해석된 요청 본문을 파이썬 사전으로 전달한다. 컨트롤러는 본문이 사전인지, 상품 코드가 비어 있지 않은 문자열인지, 수량이 정수인지 확인한다. 상품 코드 앞뒤의 공백을 제거한 뒤 두 값을 서비스에 넘긴다. 응답은 상태 코드와 본문을 담은 튜플로 돌려준다. 앞단에서 이 함수를 호출한다고 생각하면 요청부터 응답까지 서버를 띄우지 않고 따라갈 수 있다.

서비스(service)는 주문을 생성할 수 있는지 판단한다. 한 권 이상이어야 한다는 규칙은 어떤 화면이나 함수에서 호출하더라도 적용되므로 서비스에 둔다. 상품이 있는지, 필요한 수량이 남아 있는지는 저장소에 묻는다. 주문이 가능하면 차감할 수량과 기록할 주문을 저장소에 전달한다. 이렇게 하면 관리 화면과 고객 화면이 각각 다른 요청 형식을 쓰더라도 같은 주문 규칙을 공유할 수 있다.

저장소(repository)는 데이터를 읽고 쓰는 방법을 맡는다. 이 장에서는 상품 코드로 현재 재고를 읽고, 재고를 갱신하고, 주문을 기록하는 메서드를 제공한다. 서비스는 이 메서드의 이름과 반환값을 알면 된다. 실제 저장소는 SQL을 실행하고 가짜 저장소는 사전과 리스트를 다룬다. 서비스가 재고 조회 결과로 받는 None은 상품이 없다는 뜻이고, 정수 0은 상품은 있지만 재고가 없다는 뜻이다. 둘을 구분해야 상품 없음과 재고 부족을 각기 다른 결과로 돌려줄 수 있다.

컨트롤러가 요청을 해석하고 서비스가 주문을 결정하면 저장소가 재고와 주문을 기록한다.

주문 생성에서 각 계층이 맡는 판단과 작업
계층맡는 일판단의 예
컨트롤러요청을 파이썬 값으로 변환하고 응답을 구성한다.문자열 "2"는 정수 수량으로 받지 않는다.
서비스주문 규칙을 적용하고 저장 작업의 범위를 정한다.정수 0은 주문 수량으로 허용하지 않는다.
저장소상품 조회, 재고 갱신, 주문 기록을 구현한다.조회한 행이 없으면 None을 반환한다.

수량이 문자열일 때와 정수 0일 때 예제는 모두 상태 코드 400을 반환한다. 두 경우를 어느 계층에서 검사할지는 상태 코드로 결정하지 않는다. 문자열을 정수로 받지 않기로 한 것은 요청 형식에 관한 약속이다. 한 권부터 주문할 수 있다는 것은 서점 운영 규칙이다. 형식을 검사할 때는 type(quantity) is int를 사용한다. 파이썬에서는 bool이 int의 하위 타입이어서 isinstance(True, int)가 참이기 때문이다. 여기서 서비스의 호출 계약은 상품 코드 문자열과 정수 수량이다. 새 호출 지점도 이 계약에 맞춰 값을 전달한다.

저장 작업의 경계와 테스트용 저장소

트랜잭션(transaction)은 여러 데이터 변경을 한 단위로 처리하는 범위다. 예제에서 그 범위는 현재 재고를 읽기 직전에 시작하고, 재고를 줄이고 주문 기록을 추가한 뒤 끝난다. 두 쓰기가 모두 성공하면 변경을 확정하고, 도중에 오류가 나면 이번 요청의 변경을 되돌린다. 조회도 이 범위에 넣어, 무엇을 읽고 어떤 상태를 바꿨는지 하나의 주문 처리 안에서 추적할 수 있게 한다.

서비스는 with store.atomic()으로 경계를 정한다. 저장소는 이 블록에 들어갈 때와 나올 때 해야 할 작업을 구현한다. 실제 저장소에서는 BEGIN IMMEDIATE로 시작해 다른 쓰기 작업과 겹친 상태에서 재고를 읽고 갱신하는 일을 막는다. 각 쓰기 메서드 안에서 따로 확정하면 재고 차감과 주문 추가를 함께 되돌릴 수 없으므로 확정은 블록 끝에서 한 번만 한다. 잘못된 요청 형태와 0 이하의 수량은 저장소에 접근하기 전에 판별한다. 상품 없음이나 재고 부족은 현재 상태를 조회해야 하므로 블록 안에서 판별한다.

재고를 차감하고 주문을 기록한 뒤 성공하면 둘을 확정하고 오류가 나면 둘을 되돌린다.

의존성 주입(dependency injection)은 함수가 필요한 객체를 내부에서 직접 만들지 않고 호출하는 쪽에서 받는 방식이다. create_order는 저장소를 인자로 받으므로 주문 규칙을 바꾸지 않고 저장소를 교체할 수 있다. 어떤 객체를 넘길지 결정하는 곳은 프로그램의 시작 부분이나 테스트 준비 코드다. 실제 저장소와 가짜 저장소는 둘 다 atomic, get_stock, set_stock, add_order를 제공한다. OrderStore는 이 호출 계약을 코드에 적은 프로토콜이며 실행 시 메서드나 반환값을 검사하는 장치는 아니다.

가짜 저장소는 트랜잭션에 들어갈 때 재고 사전과 주문 리스트를 복사해 둔다. 오류가 나면 복사해 둔 값으로 되돌린다. 주문 기록을 리스트에 추가한 직후 일부러 오류를 내면 테스트는 두 변경이 모두 사라졌는지 확인할 수 있다. 이 가짜 저장소는 주문 결정과 경계 배치를 확인하는 데 쓴다. SQL이 실제로 실행되는지와 데이터베이스의 변경이 되돌아가는지는 인메모리 데이터베이스로 같은 실패 지점을 다시 시험한다.

한 함수에 모인 코드를 나누는 순서

리팩터링(refactoring)을 시작하기 전에 기존 함수에 본문을 직접 전달하고 반환값과 저장 상태를 기록한다. 예를 들어 두 권 주문 성공, 세 권을 넘는 주문 거절, 문자열 수량 거절을 고른다. 각 테스트에는 재고 세 권과 빈 주문 목록을 새로 준비한다. 이전 테스트에서 줄어든 재고를 다음 테스트가 그대로 쓰면, 재고 부족의 원인이 테스트 입력인지 실행 순서인지 알기 어렵다.

다음으로 기존 함수의 줄을 요청 처리, 주문 판단, 데이터 접근으로 표시한다. 먼저 입출력 변환을 정리해 서비스에 어떤 인자를 넘길지 드러낸다. 이어 재고 조회와 두 쓰기를 이름 있는 메서드로 옮기고, 주문을 생성하는 서비스에서 그 호출을 순서대로 읽을 수 있게 만든다. 이때 상품 코드와 수량의 형식, 기존 상태 코드, 주문 기록에 넣는 값이 추출 전후에 같은지 확인한다. 재고만 줄어드는 결함은 새로 고칠 동작으로 기록해, 의도한 수정이 어느 부분인지 변경분(diff)에서 찾을 수 있게 한다.

온라인 서점의 주문 생성 함수를 컨트롤러, 서비스, 저장소로 나눠 달라. 요청의 상태 코드와 응답 본문을 유지하고, 재고 차감과 주문 기록은 한 트랜잭션에 넣어 달라. 주문 기록 직후 실패를 재현해서 재고와 주문 기록이 모두 복구되는지 가짜 저장소와 인메모리 데이터베이스에서 검사해 달라. 표준 라이브러리만 쓰는 main.py 한 파일로 작성하고, 기존 동작을 바꾼 부분이 있으면 그 이유를 알려 달라.

AI가 만든 변경분에서 우선 두 쓰기 메서드와 확정 코드를 찾는다. 두 쓰기가 같은 블록에 들었는지, 저장소가 오류를 밖으로 전달하는지, 실패 테스트가 실제로 쓰기 뒤에 오류를 내는지 확인한다. 그다음 코드를 실행해 입력 거절, 정상 주문, 저장 실패 후 복구를 확인한다. 테스트가 예외 자체만 보거나, 재고 차감 전에 오류를 내면 가장 중요한 실패 경로가 비어 있을 수 있다. 테스트의 이름과 실제로 실행된 줄을 함께 읽는 이유다.

완성 코드

main.py

아래 코드는 요청 처리 함수를 직접 호출한다. 가짜 저장소와 실제 저장소에는 같은 상품과 같은 초기 수량을 준비한다. 성공한 요청의 결과를 출력하고, 실패 경로의 상태까지 검사한 뒤 프로그램을 종료한다.

import sqlite3
from contextlib import closing, contextmanager
from dataclasses import dataclass
from typing import ContextManager, Protocol


@dataclass(frozen=True)
class Order:
    sku: str
    quantity: int


class OrderRejected(Exception):
    def __init__(self, reason: str):
        super().__init__(reason)
        self.reason = reason


class OrderStore(Protocol):
    def atomic(self) -> ContextManager[None]: ...

    def get_stock(self, sku: str) -> int | None: ...

    def set_stock(self, sku: str, quantity: int) -> None: ...

    def add_order(self, order: Order) -> None: ...


def create_order(store: OrderStore, sku: str, quantity: int) -> Order:
    if quantity < 1:
        raise OrderRejected("invalid_quantity")

    with store.atomic():
        stock = store.get_stock(sku)
        if stock is None:
            raise OrderRejected("unknown_book")
        if stock < quantity:
            raise OrderRejected("insufficient_stock")

        order = Order(sku, quantity)
        store.set_stock(sku, stock - quantity)
        store.add_order(order)

    return order


REJECTION_STATUS = {
    "invalid_quantity": 400,
    "unknown_book": 404,
    "insufficient_stock": 409,
}


def post_order(body: object, store: OrderStore) -> tuple[int, dict]:
    if not isinstance(body, dict):
        return 400, {"error": "invalid_body"}

    sku = body.get("sku")
    if not isinstance(sku, str) or not sku.strip():
        return 400, {"error": "invalid_sku"}

    quantity = body.get("quantity")
    if type(quantity) is not int:
        return 400, {"error": "invalid_quantity_type"}

    try:
        order = create_order(store, sku.strip(), quantity)
    except OrderRejected as error:
        return REJECTION_STATUS[error.reason], {"error": error.reason}

    return 201, {"sku": order.sku, "quantity": order.quantity}


class SQLiteOrderStore:
    def __init__(self, connection: sqlite3.Connection):
        self.connection = connection

    @contextmanager
    def atomic(self):
        self.connection.execute("BEGIN IMMEDIATE")
        try:
            yield
            self.connection.execute("COMMIT")
        except BaseException:
            if self.connection.in_transaction:
                self.connection.execute("ROLLBACK")
            raise

    def get_stock(self, sku: str) -> int | None:
        row = self.connection.execute(
            "SELECT stock FROM books WHERE sku = ?", (sku,)
        ).fetchone()
        return None if row is None else row[0]

    def set_stock(self, sku: str, quantity: int) -> None:
        self.connection.execute(
            "UPDATE books SET stock = ? WHERE sku = ?", (quantity, sku)
        )

    def add_order(self, order: Order) -> None:
        self.connection.execute(
            "INSERT INTO orders (sku, quantity) VALUES (?, ?)",
            (order.sku, order.quantity),
        )


class FakeOrderStore:
    def __init__(self):
        self.stock = {"PY-01": 3}
        self.orders: list[Order] = []

    @contextmanager
    def atomic(self):
        saved_stock = self.stock.copy()
        saved_orders = self.orders.copy()
        try:
            yield
        except BaseException:
            self.stock = saved_stock
            self.orders = saved_orders
            raise

    def get_stock(self, sku: str) -> int | None:
        return self.stock.get(sku)

    def set_stock(self, sku: str, quantity: int) -> None:
        self.stock[sku] = quantity

    def add_order(self, order: Order) -> None:
        self.orders.append(order)


class SimulatedWriteError(Exception):
    pass


class FailingFakeStore(FakeOrderStore):
    def add_order(self, order: Order) -> None:
        super().add_order(order)
        raise SimulatedWriteError


class FailingSQLiteStore(SQLiteOrderStore):
    def add_order(self, order: Order) -> None:
        super().add_order(order)
        raise SimulatedWriteError


def check_rollback(store: OrderStore) -> None:
    try:
        post_order({"sku": "PY-01", "quantity": 2}, store)
    except SimulatedWriteError:
        pass
    else:
        raise AssertionError("저장 실패가 전달되어야 한다")

    assert store.get_stock("PY-01") == 3


def test_fake_store() -> None:
    store = FakeOrderStore()
    cases = [
        (None, 400, "invalid_body"),
        ({"quantity": 2}, 400, "invalid_sku"),
        ({"sku": "PY-01", "quantity": "2"}, 400, "invalid_quantity_type"),
        ({"sku": "PY-01", "quantity": True}, 400, "invalid_quantity_type"),
        ({"sku": "PY-01", "quantity": 0}, 400, "invalid_quantity"),
        ({"sku": "MISSING", "quantity": 1}, 404, "unknown_book"),
        ({"sku": "PY-01", "quantity": 4}, 409, "insufficient_stock"),
    ]
    for body, status, error in cases:
        assert post_order(body, store) == (status, {"error": error})
        assert store.get_stock("PY-01") == 3
        assert store.orders == []

    response = post_order({"sku": " PY-01 ", "quantity": 2}, store)
    assert response == (201, {"sku": "PY-01", "quantity": 2})
    assert store.get_stock("PY-01") == 1
    assert store.orders == [Order("PY-01", 2)]

    failing_store = FailingFakeStore()
    check_rollback(failing_store)
    assert failing_store.orders == []


def prepare_database(connection: sqlite3.Connection) -> None:
    connection.executescript(
        """
        CREATE TABLE books (sku TEXT PRIMARY KEY, stock INTEGER NOT NULL);
        CREATE TABLE orders (sku TEXT NOT NULL, quantity INTEGER NOT NULL);
        INSERT INTO books (sku, stock) VALUES ('PY-01', 3);
        """
    )


def main() -> None:
    test_fake_store()
    print("가짜 저장소 검사 통과")

    with closing(sqlite3.connect(":memory:", autocommit=True)) as connection:
        prepare_database(connection)
        check_rollback(FailingSQLiteStore(connection))
        assert connection.execute("SELECT sku, quantity FROM orders").fetchall() == []
        assert not connection.in_transaction
        print("SQLite 롤백 검사 통과")

        store = SQLiteOrderStore(connection)
        status, body = post_order({"sku": "PY-01", "quantity": 2}, store)
        stock = store.get_stock("PY-01")
        orders = connection.execute("SELECT sku, quantity FROM orders").fetchall()
        assert (status, body) == (201, {"sku": "PY-01", "quantity": 2})
        assert stock == 1 and orders == [("PY-01", 2)]
        assert not connection.in_transaction

        print(f"주문 응답 {status} {body['sku']} {body['quantity']}권")
        print(f"남은 재고 {stock}권")
        print(f"기록된 주문 {len(orders)}건")


if __name__ == "__main__":
    main()

줄별 해설

@dataclass(frozen=True)가 붙은 Order에는 상품 코드와 주문 수량만 담긴다. 생성 뒤에는 필드를 바꿀 수 있으리라고 기대하는 코드가 없고, 같은 필드 값을 가진 주문끼리는 값으로 비교할 수 있다. 따라서 테스트에서 주문 목록이 [Order("PY-01", 2)]와 같은지 검사하면 건수와 두 필드를 한꺼번에 확인할 수 있다. OrderRejected는 서비스가 거절 이유를 전달하는 예외다. 응답 상태 코드는 그 아래에 정의한 REJECTION_STATUS에 있다.

create_order의 첫 if는 재고와 무관한 수량 규칙을 검사한다. 이어지는 with 안에서는 stock is None을 먼저 확인한다. 상품이 없을 때는 재고를 수량과 비교할 수 없고, 상품이 있다면 재고가 0이어도 수량과 비교할 수 있다. 두 조건을 통과하면 차감 후 재고를 계산하고 주문을 기록한다. return order는 with 바깥에 있으므로 실제 저장소에서 확정 단계까지 성공해야 호출자가 주문을 받는다.

post_order의 앞부분은 본문의 자료형, 상품 코드, 수량 자료형을 차례로 검사한다. 형식이 맞으면 상품 코드의 앞뒤 공백을 제거해 서비스를 호출한다. except OrderRejected는 서비스가 전달한 이유만 응답으로 바꾼다. 예제의 저장 오류는 호출 지점까지 전달되므로 해당 테스트가 오류를 직접 확인할 수 있다. 정상 경로에서 상태 코드 201은 주문이 생성됐다는 뜻이며, 응답 본문에는 서비스가 반환한 주문의 값이 들어간다.

SQLiteOrderStore.atomic의 yield는 서비스의 with 본문이 실행되는 지점이다. 본문이 끝나면 SQL COMMIT을 실행한다. yield를 지나거나 확정하는 도중에 예외가 발생하면 트랜잭션이 열려 있는지 확인하고 ROLLBACK을 실행한 뒤 같은 예외를 다시 전달한다. 연결을 열 때 autocommit=True를 지정했으므로 이 예제에서 트랜잭션의 시작과 끝은 모두 SQL 문으로 명시한다. 시작에 실패한 경우에는 yield에 도달하기 전에 그 오류가 호출자에게 전달된다.

실제 저장소에서 상품 코드와 수량은 SQL문의 물음표에 대응하는 인자로 전달된다. 가짜 저장소에서 같은 값은 사전 키나 주문 객체로 쓰인다. 가짜 저장소의 복구에 얕은 복사로 충분한 이유는 재고 값이 정수이고 주문 객체도 변경할 수 없기 때문이다. 나중에 주문 안에 수정 가능한 목록을 추가한다면 같은 방식으로 스냅샷을 복원할 수 있는지 다시 따져야 한다.

두 실패용 저장소는 super().add_order(order)로 부모 클래스의 실제 쓰기를 실행한 직후 예외를 낸다. check_rollback은 예외가 전달됐는지와 재고가 세 권으로 돌아왔는지를 공통으로 검사한다. 주문 기록은 각 저장 방식에서 직접 읽어 빈 상태임을 확인한다. 실제 저장소에서는 같은 연결로 바로 정상 주문도 수행한다. 이 순서 덕분에 되돌린 뒤 열린 트랜잭션이 남았는지와 같은 연결이 다음 요청을 처리할 수 있는지도 확인한다.

실행 결과

본문의 코드를 main.py에 저장하고 아래 명령을 차례대로 실행한다. 첫 명령은 경고를 오류로 취급해 소스의 컴파일 여부를 검사하며, 성공하면 아무것도 출력하지 않는다. 두 번째 명령은 기본 모드에서 실행하므로 코드의 assert가 동작한다.

python3 -W error -m py_compile main.py
python3 main.py

두 번째 명령의 예상 출력은 다음과 같다.

가짜 저장소 검사 통과
SQLite 롤백 검사 통과
주문 응답 201 PY-01 2권
남은 재고 1권
기록된 주문 1건

실무에서 자주 틀리는 것

다음 코드는 main.py를 저장한 디렉터리에서 각각 실행할 수 있는 짧은 비교 예제다.

형식 검사 중에 값을 바꿔 버린다

요청을 읽으면서 바로 int를 호출하면 클라이언트가 어떤 자료형을 보냈는지에 관한 정보가 사라진다. 아래 코드는 참값을 한 권이라는 수량으로 바꿔 주문을 받아들인다. 문자열을 받은 경우에도 같은 문제가 생긴다.

from main import FakeOrderStore, create_order

body = {"sku": "PY-01", "quantity": True}
store = FakeOrderStore()
order = create_order(store, body["sku"], int(body["quantity"]))
print(order.quantity)

요청에 들어온 값 그대로 컨트롤러를 호출하면 정수 형식 검사를 통과하지 못한다. 응답과 재고를 함께 검사하면 잘못된 입력이 재고 갱신까지 도달했는지 알 수 있다.

from main import FakeOrderStore, post_order

store = FakeOrderStore()
response = post_order({"sku": "PY-01", "quantity": True}, store)
assert response == (400, {"error": "invalid_quantity_type"})
assert store.get_stock("PY-01") == 3

같은 주문의 두 쓰기를 따로 확정한다

각 메서드를 따로 호출하기 쉽게 만들려고 재고 갱신과 주문 추가를 서로 다른 블록에 두는 경우가 있다. 아래에서는 주문을 기록하다 실패해도 이미 첫 블록이 끝났으므로 재고가 한 권으로 남는다.

from main import FailingFakeStore, Order, SimulatedWriteError

store = FailingFakeStore()
try:
    with store.atomic():
        store.set_stock("PY-01", 1)
    with store.atomic():
        store.add_order(Order("PY-01", 2))
except SimulatedWriteError:
    print(store.get_stock("PY-01"))

같은 주문에 속한 두 변경을 한 블록 안에 둔다. 오류는 블록 바깥에서 받는다. 그래야 블록을 빠져나갈 때 저장소가 오류를 보고 되돌릴 수 있다.

from main import FailingFakeStore, Order, SimulatedWriteError

store = FailingFakeStore()
try:
    with store.atomic():
        store.set_stock("PY-01", 1)
        store.add_order(Order("PY-01", 2))
except SimulatedWriteError:
    assert store.get_stock("PY-01") == 3
    assert store.orders == []
else:
    raise AssertionError("저장 실패가 전달되어야 한다")

함수 안에서 저장소를 새로 만든다

아래 도우미는 호출할 때마다 초기 재고가 세 권인 저장소를 새로 만든다. 같은 저장소에 대해 두 번 주문하는 상황이나 쓰기가 실패하는 상황을 호출자가 구성할 수 없다. 예제에서는 두 권씩 주문을 두 번 보내도 둘 다 성공한다.

from main import FakeOrderStore, post_order


def submit(body):
    return post_order(body, FakeOrderStore())


body = {"sku": "PY-01", "quantity": 2}
print(submit(body)[0], submit(body)[0])

호출 지점에서 저장소를 한 번 만들고 두 요청에 전달한다. 첫 요청이 남긴 재고를 두 번째 요청에서 읽으므로, 두 번째 요청은 재고 부족으로 거절되어야 한다. 같은 방식으로 실패용 저장소를 전달해 저장 실패를 시험할 수 있다.

from main import FakeOrderStore, post_order

store = FakeOrderStore()
body = {"sku": "PY-01", "quantity": 2}
assert post_order(body, store)[0] == 201
assert post_order(body, store) == (409, {"error": "insufficient_stock"})
assert store.get_stock("PY-01") == 1
assert len(store.orders) == 1

한눈에 보기

AI가 구현을 맡았을 때는 계층 이름이 붙었는지보다 해당 코드가 어떤 값을 받고, 어느 변경까지 책임지는지 확인한다. 변경분의 호출 위치와 실행 결과를 함께 보면 코드 이동으로 달라진 동작을 찾기 쉽다.

AI가 나눈 주문 처리 코드를 검토할 때 확인할 항목
항목변경분에서 확인할 곳실행으로 확인할 결과
요청 형식컨트롤러가 수량을 변환하기 전에 자료형을 검사하는지 본다.문자열과 참값을 보내면 400을 돌려주고 재고가 유지된다.
주문 규칙서비스가 최소 수량과 가용 재고를 확인하는지 본다.수량 0은 거절되고, 남은 재고와 같은 수량은 주문할 수 있다.
저장 경계재고 조회와 두 쓰기를 감싼 블록, 블록 끝의 확정 위치를 본다.주문 기록 직후 오류가 나면 재고가 복구되고 주문 기록이 비워진다.
의존성 주입서비스가 인자로 받은 저장소를 통해 읽고 쓰는지 본다.같은 요청 처리 함수에 가짜 저장소와 실제 저장소를 넘길 수 있다.

이 장에서 정한 경계는 주문 한 건을 처리할 때 데이터 변경을 어디서 시작하고 끝낼지 보여 준다. 다음에 데이터베이스를 다룰 때는 이 경계 안에서 실행되는 조회와 쓰기가 테이블 구조에 어떤 요구를 하는지 살펴본다.

연습 문제

  1. 새 가짜 저장소에 초기 재고와 같은 세 권을 주문한다. 상태 코드, 남은 재고, 주문 목록을 검사한다. 같은 상품을 한 권 더 요청했을 때의 응답을 예상하고 확인한다.
  2. 상품 코드가 공백뿐인 요청과 수량이 음수인 요청을 준비한다. 두 요청을 어느 함수에서 거절해야 하는지, 응답의 오류 이름이 무엇인지 설명한다.
  3. 재고 차감만 되돌리고 주문 목록은 되돌리지 않는 가짜 저장소를 생각해 본다. 완성 코드의 어느 검사가 이 결함을 발견하는지 찾고, 그 검사가 주문 쓰기 뒤의 오류를 사용해야 하는 이유를 설명한다.
  4. AI가 add_order 호출을 with 바깥으로 이동한 변경분을 만들었다. 정상 주문과 저장 실패에서 각각 어떤 상태가 남을지 적고, 어떤 테스트가 변경을 잡아내는지 확인한다.

정답과 해설

  1. 첫 요청은 201을 반환한다. 재고는 0이고 주문 목록은 [Order("PY-01", 3)]이다. 두 번째 요청은 409와 {"error": "insufficient_stock"}을 반환한다. 같은 저장소에서 재고 0이 읽히며 주문 목록에는 첫 주문만 남는다. 예제의 비교식은 stock < quantity이므로 주문 수량과 재고가 동일한 경우는 통과한다.

  2. 공백뿐인 상품 코드는 post_order에서 거절하고 invalid_sku를 돌려준다. 음수는 정수 형식 검사를 통과하지만 create_order의 최소 수량 검사에서 거절되고 컨트롤러가 invalid_quantity를 돌려준다. 두 경우 모두 상태 코드는 400이며 저장소의 트랜잭션을 열기 전에 처리가 끝난다.

  3. test_fake_store 끝의 assert failing_store.orders == []가 발견한다. check_rollback의 재고 검사만 통과하면 주문 목록에 남은 행을 놓친다. 주문을 추가하기 전에 예외를 내도록 바꾸면 원래 비어 있던 목록을 검사하는 셈이므로 주문 복구 코드에 결함이 있어도 테스트가 통과한다.

  4. 정상 주문에서는 재고가 한 권으로 줄고 주문 한 건이 남으므로 성공 경로만 보면 변경을 알아채기 어렵다. 실패용 저장소로 같은 요청을 보내면 재고 차감이 이미 확정된 뒤 주문 추가 코드가 실행되고 예외가 전달된다. 예제의 실패용 저장소는 예외를 내기 전에 주문도 추가하므로 두 저장소 모두 재고 한 권과 주문 한 건이 남는다. 두 저장소에 적용되는 check_rollback에서 재고가 세 권이라는 검사가 먼저 실패한다. 변경분에서는 add_order를 다시 블록 안에 두어 두 쓰기가 같은 경계에 들어가도록 고친다.

오탈자·오류 제보 비공개로 접수되어 원고 수정에 반영됩니다

이메일 등 개인정보는 받지 않습니다. 답변이 필요한 질문은 아래 댓글을 이용해 주세요.

READER FEEDBACK

질문·의견

내용에 관한 질문이나 더 나은 설명을 위한 의견을 남겨 주세요. 오탈자는 위의 제보 양식이 더 빨리 반영됩니다. 이 댓글은 원래 게시글과 같은 자리에 쌓입니다.

댓글 0

아직 댓글이 없습니다. 첫 댓글을 남겨 보세요.

댓글을 남기려면 로그인이 필요합니다.