Devin.KR

AI 개발 · 실무

AI 시대의 보안 코딩과 보안 점검 - AI 가 짠 코드를 안전하게

보안 요구를 담은 요청문과 AI 코드 리뷰 습관

요청문에 보안 요구사항 적기, AI 답을 diff 로 검토하는 순서, 점검표 기반 리뷰, 신뢰 경계 표시, 완성 코드는 코드 변경(diff 문자열)에서 위험 패턴(eval·셸 실행·비밀값·검증 없는 입력)을 찾아 리뷰 의견을 출력

개발자KR · 원고 갱신

이 장에서 배우는 것

앞 장에서 살펴본 위험을 게시판의 첫 변경에 적용해 본다. 글쓰기 화면에서 제목을 받아 게시글 초안을 만드는 작은 변경이다. AI에게 기능만 설명하면 예시 입력으로는 동작하는 코드가 돌아올 수 있다. 이 장에서는 제목을 어떤 데이터로 다뤄야 하는지 요청문에 먼저 적고, 코드 변경분(diff)을 읽으면서 그 약속이 지켜졌는지 확인한다. 사람이 반복해서 확인하는 항목 중 일부는 짧은 Python 프로그램으로 옮긴다.

  • 게시판 기능의 보안 요구를 입력 조건, 금지 동작, 실패 처리로 나누어 요청문에 적는다.
  • 요청에서 들어온 데이터가 어디서 검사되고 어디로 전달되는지 신뢰 경계에 표시한다.
  • AI가 제안한 변경을 파일, 데이터 흐름, 테스트 순서로 검토하고 점검표에 근거를 남긴다.
  • 변경분에서 코드 평가, 셸 실행, 비밀값 후보, 검증이 보이지 않는 입력 읽기를 찾아 줄 번호와 함께 출력한다.

문제 상황

작은 게시판의 글쓰기 화면에 제목 입력란을 붙였다. 기존의 build_post(form)은 임시 제목을 반환한다. 이번 변경에서는 화면에서 받은 제목을 반환하도록 바꾼다. 처음에는 AI에게 다음 한 문장을 보냈다고 하자.

글쓰기 화면에서 받은 제목으로 게시글 초안을 만들어 줘. 기존 함수 이름과 반환 형식은 유지해 줘.

이 요청에는 제목이 빠졌을 때 어떻게 처리할지, 공백을 어디서 정리할지, 외부 입력에 어떤 연산을 허용할지가 빠져 있다. 검토할 변경에는 폼에서 제목을 곧바로 읽는 줄과, 요청 범위 밖의 계산 평가, 셸 실행, 토큰 대입이 함께 들어왔다고 가정한다. 이 장에서 검토할 코드는 그런 상황을 재현하기 위해 새로 작성한 문자열이다. 계산 평가에는 고정된 산술식이, 셸 실행에는 예제용 명령 이름이, 토큰 대입에는 가짜 값이 들어 있다.

제목에 정상 문자열을 넣고 반환값만 비교하면 변경이 하는 다른 일을 놓치기 쉽다. 이 함수의 계약에는 제목을 돌려준다는 결과와 함께 호출 중 허용되는 동작도 들어 있어야 한다. 초안 생성에 프로세스 실행이 필요 없다는 합의가 있으면, 추가된 실행 호출은 반환값을 살펴보기 전에 수정 요청을 할 근거가 된다. 같은 방식으로 빈 제목이 거부되어야 한다는 합의가 있으면, 리뷰에서 예외 처리와 테스트를 구체적으로 확인할 수 있다.

요청문에 검토할 계약을 적는다

AI에 요청하기 전에 사람이 결정해야 할 것은 제목의 계약이다. 이 예제에서는 문자열만 받는다. 앞뒤 공백을 제거한 뒤 길이가 1자 이상 80자 이하여야 한다. 길이는 Python의 len으로 잰다. 제목이 없거나 규칙을 어기면 ValueError를 발생시킨다. 성공하면 기존처럼 {"title": 제목} 형태로 돌려준다. 호출부는 함수가 성공했을 때 반환된 초안으로 다음 작업을 이어갈 수 있다.

요청문에 “안전하게 구현해 줘”라고만 적으면 무엇을 테스트할지 합의하기 어렵다. 같은 요구를 정상 입력, 거부할 입력, 허용하지 않는 동작으로 나누면 코드와 테스트에서 확인할 위치가 생긴다. 다음 요청문은 기존 함수와 제목 검증 함수를 AI에 함께 제공했다는 상황을 전제로 한다.

게시판의 build_post(form)에서 임시 제목 대신 폼의 title을 사용해 줘. 함수 이름과 반환 형식은 유지하고, 변경은 이 함수에 한정해 줘.

폼은 요청에서 들어온 값이다. form.get("title")로 값을 읽어 기존 validate_title에 넘기고, 반환된 문자열을 초안에 담아 줘. 검증 함수는 문자열의 앞뒤 공백을 제거하고 길이 1자부터 80자까지를 허용한다. 누락, 문자열 이외의 값, 공백뿐인 값, 80자를 넘는 값에는 ValueError가 그대로 전달되어야 한다.

이 변경에는 Python 코드 평가, 외부 프로세스 실행, 자격 증명 값의 직접 대입이 필요 없다. 네트워크와 외부 패키지도 사용하지 않아야 한다. 제안한 변경분과 함께 어떤 줄에서 폼의 제목이 검증되는지 설명해 줘. 정상 제목, 누락, 공백뿐인 제목, 숫자, 80자 제목과 81자 제목의 예상 결과도 적어 줘. 실제 실행 여부를 구분해 줘.

AI가 돌려준 설명은 검토할 주장이다. “기존 검증을 재사용했다”는 설명을 받으면 함수 이름이 보이는지만 확인하지 말고, 검증 함수의 반환값이 실제 초안에 들어가는지 따라간다. 검증한 뒤 원래 폼 값을 다시 읽는 코드라면 공백 제거 결과가 사라진다. 테스트 목록에 경계값이 적혀 있다면 80자와 81자의 기대 결과가 서로 다른지도 본다. 실행을 맡은 사람은 자신의 작업 환경에서 결과를 재현한 뒤 리뷰 기록에 남긴다.

신뢰 경계를 표시하고 변경분을 읽는다

신뢰 경계(trust boundary)는 데이터를 받아들이는 쪽이 어떤 조건을 아직 보장할 수 없는지 표시하는 자리다. 브라우저 화면에서 입력 길이를 제한하더라도 build_post에 들어오는 제목은 요청에서 온 값이다. 이 함수는 폼에서 읽은 직후에 제목 검증을 호출한다. 검증에 성공한 제목에는 이 장에서 약속한 타입, 공백 처리, 길이 조건이 성립한다. 그 보장은 제목 값에만 적용된다. 같은 폼의 다른 칸은 각자 계약을 확인해야 한다.

요청에서 온 제목은 타입과 길이 검사를 통과한 뒤 게시글 초안에 들어간다

리뷰에서 표시할 것은 세 군데다. 값이 들어오는 줄, 조건을 확인하는 줄, 값이 쓰이는 줄이다. 검증을 별도 함수에 맡겼다면 호출 이름에서 읽기를 멈추지 않는다. 검증 함수가 허용하는 조건을 확인하고, 호출 결과가 쓰이는 위치까지 따라간다. 실패 경로도 같은 방법으로 읽는다. 이 예제에서는 검증 함수가 예외를 내면 초안의 딕셔너리를 만드는 줄에 도달하지 않는다. 예외를 잡는 코드가 추가되면, 빈 제목을 임의의 기본값으로 바꾸는 등 계약이 달라졌는지 확인한다.

변경 검토는 다음 순서로 진행한다. 먼저 바뀐 파일 이름과 함수 범위를 훑는다. 제목 변경인데 의존성이나 다른 기능의 파일이 함께 바뀌었다면, 각 변경이 제목 계약의 어느 부분에 필요한지 근거를 확인한다. 다음으로 추가된 줄과 삭제된 줄을 함께 읽는다. 검증 호출이 추가되는 경우만큼 기존 검증 호출이 삭제되는 경우도 중요하다. 그다음 변경 주변의 원래 코드를 열어 데이터 흐름을 따라간다. 마지막으로 의심한 지점에 입력을 넣고 승인 조건을 재현한다. 변경분에 나타난 줄은 출발점이고, 테스트 결과는 그 변경이 실제로 어떻게 동작했는지 보여 주는 기록이다.

변경 파일의 범위를 확인한 뒤 입력의 흐름을 읽고 테스트로 계약을 확인한다
게시판 제목 변경에서 리뷰어가 남길 근거
점검 항목확인할 근거리뷰 의견 예시
변경 범위기존 함수의 인자와 반환 형식이 유지되는가제목 초안 함수에 추가된 계산 평가와 프로세스 실행의 필요성을 확인해 달라.
입력 경계폼에서 읽은 값을 검증하고 그 반환값을 사용하는가폼에서 읽은 제목을 검증 함수에 넘기고 검증 결과를 초안에 담아 달라.
실패 경로누락과 잘못된 값에서 같은 예외가 발생하는가누락, 공백, 숫자 입력이 각각 ValueError를 내는지 확인해 달라.
경계값과 부수 동작80자와 81자의 결과가 다르고 실행과 비밀값 대입이 추가되지 않았는가길이 경계를 테스트하고 초안 생성에 필요한 연산만 남겨 달라.

리뷰 의견에는 위치와 바라는 변경을 함께 적는다. 예를 들어 “입력 검증 필요”라는 문장보다 “폼에서 제목을 읽는 줄에서 validate_title을 호출하고, 공백뿐인 제목에서 ValueError가 나는 테스트를 추가해 달라”가 작업으로 이어지기 쉽다. 비밀값 후보를 발견했을 때는 파일과 줄 번호만 남겨도 같은 위치를 찾을 수 있다. 이 장의 점검기는 의심되는 값과 원본 코드 줄을 출력하지 않는다.

완성 코드

main.py

아래 파일은 같은 기존 코드에서 출발한 수정 전후의 변경분을 만들고, 두 변경분에 리뷰 규칙을 적용한다. 위험 후보가 담긴 제안은 문자열 상태로 분석한다. 실행 검사는 고친 함수에만 적용한다. 두 제안에 공통으로 쓰이는 제목 검증 함수는 파일 안에 들어 있다.

import ast
import re
from difflib import unified_diff


BASE = """def build_post(form):
    return {"title": "임시 제목"}
"""

PROPOSED = """def build_post(form):
    title = form["title"]
    eval("1 + 1")
    subprocess.run(["true"], shell=True)
    api_token = "demo-placeholder"
    return {"title": title}
"""


def validate_title(value):
    if isinstance(value, str):
        title = value.strip()
        if 1 <= len(title) <= 80:
            return title
    raise ValueError("제목은 공백을 정리한 뒤 1~80자여야 한다.")


FIXED = """def build_post(form):
    title = validate_title(form.get("title"))
    return {"title": title}
"""


HUNK = re.compile(
    r"@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@(?: .*)?"
)
MESSAGES = {
    "EVAL": "코드 평가 호출을 제거하고 필요한 연산을 직접 표현한다.",
    "SHELL": "초안 생성에 필요 없는 셸 실행을 제거한다.",
    "SECRET": "비밀값 후보를 확인하고 코드에 직접 넣지 않는다.",
    "INPUT": "폼 값을 읽은 뒤 검증 결과를 사용하도록 바꾼다.",
}


def make_diff(candidate):
    return "\n".join(
        unified_diff(
            BASE.splitlines(),
            candidate.splitlines(),
            fromfile="a/board.py",
            tofile="b/board.py",
            lineterm="",
        )
    )


def added_lines(diff):
    path = ""
    line_number = 0
    remaining = 0

    for line in diff.splitlines():
        hunk = HUNK.fullmatch(line)
        if hunk:
            line_number = int(hunk[1])
            remaining = int(hunk[2]) if hunk[2] is not None else 1
        elif remaining and line.startswith(("+", " ")):
            if line.startswith("+"):
                yield path, line_number, line[1:]
            line_number += 1
            remaining -= 1
        elif not remaining and line.startswith("+++ "):
            path = line[4:]


def is_name(node, name):
    return isinstance(node, ast.Name) and node.id == name


def find_rules(source):
    try:
        tree = ast.parse(source.strip())
    except SyntaxError:
        return ()

    rules = set()
    parents = {
        child: node
        for node in ast.walk(tree)
        for child in ast.iter_child_nodes(node)
    }

    for node in ast.walk(tree):
        if isinstance(node, ast.Call):
            function = node.func
            if is_name(function, "eval"):
                rules.add("EVAL")

            if (
                isinstance(function, ast.Attribute)
                and is_name(function.value, "subprocess")
                and function.attr in {"run", "Popen", "call", "check_call",
                                      "check_output"}
                and any(
                    keyword.arg == "shell"
                    and isinstance(keyword.value, ast.Constant)
                    and keyword.value.value is True
                    for keyword in node.keywords
                )
            ):
                rules.add("SHELL")

        if (
            isinstance(node, ast.Assign)
            and isinstance(node.value, ast.Constant)
            and isinstance(node.value.value, str)
            and node.value.value
            and any(
                isinstance(target, ast.Name)
                and target.id.lower() in {"api_key", "api_token", "password",
                                          "secret", "token"}
                for target in node.targets
            )
        ):
            rules.add("SECRET")

        reads_form = (
            isinstance(node, ast.Subscript) and is_name(node.value, "form")
            and isinstance(node.ctx, ast.Load)
        ) or (
            isinstance(node, ast.Call)
            and isinstance(node.func, ast.Attribute)
            and is_name(node.func.value, "form")
            and node.func.attr == "get"
        )
        if reads_form:
            parent = parents.get(node)
            directly_validated = (
                isinstance(parent, ast.Call)
                and is_name(parent.func, "validate_title")
                and len(parent.args) == 1
                and parent.args[0] is node
                and not parent.keywords
            )
            if not directly_validated:
                rules.add("INPUT")

    return tuple(rule for rule in MESSAGES if rule in rules)


def review(diff):
    return [
        (path, number, rule)
        for path, number, source in added_lines(diff)
        for rule in find_rules(source)
    ]


def print_review(label, comments):
    print(f"[{label}]")
    for path, number, rule in comments:
        print(f"{path}:{number} [{rule}] {MESSAGES[rule]}")
    if not comments:
        print("이 점검기의 규칙에 해당하는 추가 줄이 없다.")
    print()


def check_parser():
    diff = make_diff(PROPOSED)
    assert list(added_lines(diff)) == [
        ("b/board.py", 2, '    title = form["title"]'),
        ("b/board.py", 3, '    eval("1 + 1")'),
        ("b/board.py", 4, '    subprocess.run(["true"], shell=True)'),
        ("b/board.py", 5, '    api_token = "demo-placeholder"'),
        ("b/board.py", 6, '    return {"title": title}'),
    ]
    unary_diff = "\n".join((
        "--- a/example.py",
        "+++ b/example.py",
        "@@ -0,0 +1 @@",
        "+++ value",
    ))
    assert list(added_lines(unary_diff)) == [
        ("b/example.py", 1, "++ value")
    ]
    assert find_rules('note = \'eval("1")\'') == ()
    assert find_rules('title = form.get("title")') == ("INPUT",)


def check_fixed():
    namespace = {"validate_title": validate_title}
    compiled = compile(FIXED, "board.py", "exec")
    exec(compiled, namespace)
    build_post = namespace["build_post"]

    assert build_post({"title": "  첫 글  "}) == {"title": "첫 글"}
    assert build_post({"title": "가" * 80}) == {"title": "가" * 80}
    print("정상 제목과 80자 제목을 받았다.")

    for form in ({}, {"title": "   "}, {"title": 7}, {"title": "가" * 81}):
        try:
            build_post(form)
        except ValueError:
            continue
        raise AssertionError("잘못된 제목을 허용했다.")
    print("누락, 공백, 숫자, 81자 제목을 거부했다.")


def main():
    check_parser()
    before = review(make_diff(PROPOSED))
    after = review(make_diff(FIXED))
    assert [(number, rule) for _, number, rule in before] == [
        (2, "INPUT"), (3, "EVAL"), (4, "SHELL"), (5, "SECRET")
    ]
    assert after == []

    print_review("수정 전 제안", before)
    print_review("수정 후 제안", after)
    print("[수정 후 동작 검사]")
    check_fixed()


if __name__ == "__main__":
    main()

줄별 해설

BASE, PROPOSED, FIXED는 각각 기존 코드, 수정 전 제안, 수정 후 제안이다. make_diff는 어느 제안을 넘겨도 같은 기존 코드와 비교한다. 두 결과를 각각 살펴보면 각 제안에서 무엇을 새로 들여오는지 비교할 수 있다. 출력에 나오는 board.py는 비교에 붙인 파일 이름이다. 예제는 디스크에 그 파일을 만들지 않는다.

added_lines는 통합 변경분(unified diff)의 +++ 파일 헤더와 @@ 구간 헤더를 읽는다. 구간 헤더에서 변경 후 시작 줄 번호와 줄 수를 얻는다. 변경 후 줄 수가 생략되면 한 줄로 본다. 새 파일에도 존재하는 문맥 줄과 추가 줄은 번호를 한 칸씩 전진시킨다. 삭제 줄은 새 파일에 자리가 없으므로 번호를 전진시키지 않는다. 추가 줄을 돌려줄 때는 변경분 표시인 첫 +만 뗀다. 그래서 구간 안의 +++ value는 파일 헤더가 아니라 ++ value를 추가한 줄로 처리된다. check_parser가 이 경우와 예제 제안의 줄 번호를 확인한다.

find_rules의 첫 줄은 추가된 한 줄의 바깥 공백을 정리한 뒤 추상 구문 트리(abstract syntax tree)로 읽는다. 트리에서는 같은 글자가 들어 있더라도 함수 호출과 문자열 리터럴의 노드 종류가 다르다. 따라서 메모 문자열에 적힌 eval이나 주석에 적힌 호출 모양은 실행 호출로 세지 않는다. 줄 하나만으로 구문이 완성되지 않으면 해당 줄의 분석을 건너뛴다. 함수 선언 직후나 여러 줄에 걸친 호출이 대표적이다. 리뷰에서 여러 줄에 나뉜 호출을 만나면 파일에서 호출 전체를 읽어야 한다.

호출 노드를 만났을 때 EVAL은 함수 자리에 이름 eval이 직접 쓰였는지 본다. SHELL은 예제에 적은 subprocess 호출 형태에서 shell=True가 직접 전달되는지 본다. 별칭을 통한 호출이나 변수로 전달하는 옵션은 이 규칙의 범위 밖이다. SECRET은 정해 둔 이름에 비어 있지 않은 문자열을 직접 대입하는 줄을 찾는다. 이름과 대입 형태가 일치하면 예제용 문자열도 후보가 된다. 값의 성격은 리뷰어가 판단하며, 리뷰 출력에는 값이 들어가지 않는다.

parents는 각 구문 노드의 바로 위 노드를 찾는 사전이다. INPUT은 form["title"] 같은 첨자 읽기와 form.get("title") 같은 호출을 찾는다. 읽기 표현식이 validate_title의 유일한 위치 인자일 때는 이 예제에서 약속한 검증 형태로 본다. 값을 한 줄에서 읽고 다음 줄에서 검증하는 코드도 올바르게 작성할 수 있다. 그런 경우 읽는 줄에는 후보가 뜨고, 사람은 다음 줄에서 검증이 이루어지는지와 이후에 어떤 값을 사용하는지 확인한다.

review는 파일 경로, 변경 후 줄 번호, 규칙 이름을 묶는다. 같은 줄에 여러 규칙이 맞으면 MESSAGES에 정의한 순서로 의견을 낸다. main의 단언문은 수정 전 제안에서 네 후보의 위치가 맞는지, 수정 후 제안에서 후보가 사라졌는지 확인한다. 점검 결과가 비어 있으면 그 변경분에 대해 이 규칙들이 후보를 내지 않았다는 뜻이다. 삭제된 검증이나 그대로 남은 주변 코드의 문제는 사람이 변경분과 원래 파일을 함께 읽어서 확인한다.

check_fixed의 compile과 exec가 받는 것은 저자가 파일에 적어 둔 FIXED 상수다. 리뷰를 통과한 임의의 입력을 이 실행 경로에 넣지 않는다. 이렇게 고정된 코드 문자열에서 함수를 꺼내 호출하면, 점검한 수정 후 코드와 동작을 검사한 코드가 일치한다. namespace는 실습 함수에 필요한 validate_title 이름을 제공한다. 제목 검사는 정상 입력에서 공백이 제거되는지, 허용되는 최대 길이에서 원문이 유지되는지, 거부 입력이 각각 계약대로 실패하는지 확인한다.

실행 결과

코드를 main.py로 저장한다. 먼저 구문을 컴파일하고, 이어서 Python의 기본 실행 모드에서 스크립트를 실행한다. 동작 검사에 단언문이 포함되어 있으므로 표시된 명령을 그대로 사용한다. 아래 출력은 두 번째 명령의 예상 결과다.

python3 -W error -m py_compile main.py
python3 main.py
[수정 전 제안]
b/board.py:2 [INPUT] 폼 값을 읽은 뒤 검증 결과를 사용하도록 바꾼다.
b/board.py:3 [EVAL] 코드 평가 호출을 제거하고 필요한 연산을 직접 표현한다.
b/board.py:4 [SHELL] 초안 생성에 필요 없는 셸 실행을 제거한다.
b/board.py:5 [SECRET] 비밀값 후보를 확인하고 코드에 직접 넣지 않는다.

[수정 후 제안]
이 점검기의 규칙에 해당하는 추가 줄이 없다.

[수정 후 동작 검사]
정상 제목과 80자 제목을 받았다.
누락, 공백, 숫자, 81자 제목을 거부했다.

첫 결과의 줄 번호는 제안이 적용되었을 때의 파일을 기준으로 한다. 수정 전 제안의 두 번째 줄을 열면 폼을 바로 읽는 표현식을 찾을 수 있다. 수정 후 결과에서는 그 표현식이 검증 호출 안으로 이동했다. 실행 결과 중 정상 제목 검사는 그 검증 함수가 반환한 정리된 제목이 실제 초안에 쓰였음을 확인한다.

실무에서 자주 틀리는 것

기호만 보고 추가 줄을 고른다

틀린 코드인 lines = [line[1:] for line in diff.splitlines() if line.startswith("+")]는 새 파일 헤더도 코드 후보에 넣고 변경 후 줄 번호를 잃는다. 고친 코드인 lines = list(added_lines(diff))는 구간 안에서만 추가 줄을 고르고 파일 이름과 줄 번호를 함께 보관한다. 이 정보가 있어야 리뷰 의견에서 동료가 같은 위치를 열 수 있다.

함수 이름을 부분 문자열로 찾는다

틀린 코드인 has_eval = "eval(" in source는 메모 문자열 속 글자에도 반응한다. 고친 코드인 has_eval = "EVAL" in find_rules(source)는 호출 노드의 함수 이름을 확인한다. 탐지 범위를 확장할 때는 실제로 찾고 싶은 호출과 같은 글자를 포함하는 문자열을 함께 테스트하면 규칙이 어디에서 반응하는지 확인하기 쉽다.

검증 호출 뒤 원래 값을 다시 사용한다

틀린 코드에서는 validate_title(form.get("title"))를 호출하고, 다음 줄에서 return {"title": form["title"]}을 실행한다. 제목의 적합성은 확인했지만 앞뒤 공백을 제거한 결과를 버렸다. 고친 코드는 title = validate_title(form.get("title"))로 받은 값을 return {"title": title}에 사용한다. 앞뒤 공백이 붙은 정상 제목을 테스트에 넣으면 두 방식의 반환값 차이가 드러난다.

비밀값이 담긴 줄을 리뷰 의견에 복사한다

틀린 코드인 print(path, number, source)는 리뷰 로그에 원본 줄을 복사한다. 고친 코드인 print(f"{path}:{number} [SECRET] {MESSAGES['SECRET']}")는 위치와 조치만 전달한다. 검토할 권한이 있는 사람은 그 위치에서 값을 확인할 수 있다. 예제에서는 원래 값이 가짜여도 실제 코드에 같은 규칙을 적용할 때와 동일한 형식으로 출력한다.

한눈에 보기

요청문, 변경 검토, 실행 검사에 남기는 근거
단계남길 근거이 장의 예시
요청문입력 조건, 실패 형태, 허용할 동작정리한 제목 1~80자, 실패 시 ValueError, 외부 프로세스 실행 금지
데이터 흐름 읽기입력, 검증, 사용 위치폼 읽기 → validate_title → 게시글 초안
변경분 점검새 파일 기준 위치와 확인할 규칙b/board.py:2 [INPUT]
실행 검사정상과 실패 양쪽의 관찰 결과80자는 허용하고 81자는 거부한다.

연습 문제

  1. build_post의 반환 형식을 유지하면서 제목 앞뒤의 공백을 제거하도록 AI에 요청하는 문장을 써 본다. 누락과 공백뿐인 입력의 처리, 검토에 필요한 증거를 포함한다.
  2. 새 파일의 10번째 줄에서 시작하는 변경 구간에 문맥 줄 하나, 삭제 줄 하나, 추가 줄 두 개가 차례로 등장한다. 두 추가 줄의 번호를 구하고, 삭제 줄이 번호 계산에 미치는 영향을 설명한다.
  3. title = form.get("title")과 title = validate_title(title)을 서로 다른 줄에 추가했다고 하자. 점검기가 어느 줄에 무슨 의견을 내는지 쓰고, 리뷰어가 그다음 확인할 부분을 설명한다.
  4. 제목 최소 길이 1자를 검사하고 싶다. 공백 정리와 최소 길이를 함께 확인할 입력 하나와 예상 반환값을 적는다. 같은 검사에 넣을 거부 입력도 하나 고른다.

정답과 해설

  1. build_post(form)의 반환 형식을 유지해 줘. 폼의 제목을 기존 검증 함수에 넘기고, 앞뒤 공백이 제거된 반환값을 초안에 담아 줘. 제목이 없거나 공백뿐이면 ValueError가 발생해야 한다. 변경분과 함께 검증 결과가 사용되는 줄을 표시하고, 정상 입력과 두 실패 입력의 예상 결과를 적어 줘.

    반환 형식, 값이 달라지는 위치, 확인할 정상·실패 경로가 모두 들어 있다. 리뷰할 때는 설명에 표시된 줄과 실제 초안 반환식을 비교한다.

  2. 추가 줄은 11번과 12번이다. 문맥 줄이 새 파일의 10번을 차지한다. 그 뒤의 삭제 줄은 기존 파일에만 있으므로 새 파일의 번호를 소비하지 않는다. 첫 추가 줄을 11번에 기록한 뒤 번호를 전진시켜 두 번째 추가 줄을 12번에 기록한다.

  3. 첫 줄에 INPUT이 나온다. 폼 읽기 표현식의 바로 위 노드는 검증 호출이 아니다. 리뷰어는 읽기와 검증 사이에서 값을 사용하는 곳이 있는지, 검증 이후에 재대입된 title이 초안에 들어가는지 확인한다. 그 흐름이 맞다면 이 규칙의 한 줄 분석 범위에서 생긴 후보라고 기록할 수 있다.

  4. {"title": " 가 "}의 예상 반환값은 {"title": "가"}다. 공백 정리 후 1자가 되어 허용된다. {"title": ""}는 정리 후 0자이므로 ValueError가 발생한다. 두 입력을 함께 두면 최소 길이 조건의 양쪽을 확인할 수 있다.

현업에서 이렇게 본다

작은 변경의 리뷰 의견은 동료가 파일을 열었을 때 바로 확인할 수 있는 문장일수록 좋다. 제목의 경우에는 “이 줄에서 폼을 읽고, 다음 줄에서 검증한 값을 반환한다”까지 적을 수 있다. 문제가 있다면 어떤 입력에서 어떤 결과를 기대하는지도 함께 적는다. 다음 리뷰어는 그 근거로 변경을 다시 판단할 수 있다.

자동 점검에서 같은 후보가 여러 번 나타나면 제품 코드의 흐름부터 읽는다. 팀에서 검증을 두 줄에 나누어 쓰는 경우가 많다면, 첫 줄에 붙는 경고는 그 자체로 결함 건수가 아니다. 규칙이 실제 리뷰에서 해결하고 싶은 질문을 표현하는지 확인하고, 사람의 판단이 필요한 후보는 위치와 이유를 남긴다. 다음 장에서는 이 제목처럼 요청에서 들어온 값을 어떤 조건으로 받아들이고, 사용할 위치에 맞춰 어떻게 출력할지 다룬다.

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

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

READER FEEDBACK

질문·의견

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

댓글 0

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

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