gugbab2's GitBook
  • Language
    • C++
      • 강의
        • C++ 언매니지드 프로그래밍
          • C++ 프로그래밍
          • 출력(Output)
          • 입력(Input)
          • bool 타입, Reference
          • 상수(const)
          • 문자열(string)
          • 파일 입출력
          • 개체지향 프로그래밍1
          • 개체지향 프로그래밍2
          • 개체지향 프로그래밍3
          • 캐스팅(형변환, casting)
          • 인라인 함수
          • static 키워드
          • 예외(Exception)
          • STL(Standard Template Library) 컨테이너(Container) - Vector
          • STL 컨테이너 - Map
          • STL 컨테이너 - Queue, Stack, Set, List
          • 템플릿(Template) 프로그래밍
          • 새로운 키워드(C++11 ~) 1
          • 새로운 키워드(C++11 ~) 2
          • 새로운 자료형
          • 새로운 STL 컨테이너
          • 스마트(smart) 포인터
          • 이동생성자 및 이동대입연산자
          • constexpr
          • Lamda Expression
      • 책
        • The C++ Programming Lanuaage
          • 2부 : 기본 기능
            • 6. 타입과 선언
            • 7. 포인터, 배열, 참조
            • 8. 구조체(struct), 공용체(union), 열거형(enum)
            • 10. 표현식
            • 11. 선택 연산
            • 12. 함수
            • 13. 예외 처리
            • 15. 소스 파일과 프로그램
          • 3부 : 추상화 메커니즘
            • 16. 클래스
            • 17. 생성, 소멸, 복사와 이동
            • 18. 연산자 오버로딩
            • 19. 특수 연산자
            • 20. 파생클래스
        • 씹어먹는 C++
          • 2. C++ 참조자(reference) 의 도입
          • 5.1 연산자 오버로딩(비교, 대입 연산자)
          • 5-2. 연산자 오버로딩(이항, 입출력, 타입변환, 증감 연산자)
          • 6-2. 가상(virtual) 함수와 다형성
          • 6-3. 가상 함수에 대한 지식들
          • 9-1. 코드를 찍어내는 틀 - C++ 템플릿(template)
          • 9-2. 가변 길이 템플릿(Variadic template)
          • 9-3. 템플릿 메타 프로그래밍 (Template Meta Programming)
          • 9-4. 템플릿 메타 프로그래밍2
          • 16.1 유니폼 초기화(Uniform Initialization)
          • 토막글 2. 람다(lambda)
    • Java
      • 강의
        • 김영한의 실전 자바 - 기본편
          • 절차 지향 vs 객체 지향
            • 절차 지향 프로그래밍
            • 객체 지향 프로그래밍
          • 변수
            • 클래스 변수 / 인스턴스 변수, 멤버 변수 / 지역 변수
            • 기본형 vs 참조형
          • 패키지
            • 패키지
            • CLI 환경에서 .java 파일 컴파일 && 실행
          • 접근 제어자
            • 접근 제어자 - 기본
            • 캡슐화
          • static
            • 자바 메모리 구조
            • static 기본
            • 스택 영역, 힙 영역
              • 스택 영역, 힙 영역 - 기본
              • 메소드가 실행될 때 어떤일이 일어나는가?
          • 상속
            • 상속 기본
          • 다형성(Pilymorphism)
            • 다형성 기본
            • 다형성의 활용
              • 다형성의 활용 - 기본
              • 다형성의 활용 - 추상클래스
              • 다형성의 활용 - 인터페이스
            • 다형성과 설계
              • 좋은 객체 지향 프로그래밍
        • 김영한의 실전 자바 - 중급1편
          • 1. Object 클래스
          • 2. 불변 객체
          • 3. String 클래스
          • 4. 래퍼, Class 클래스
          • 5. 열거형 - ENUM
          • 6. 날짜와 시간
          • 7. 중첩 클래스, 내부 클래스1
          • 8. 중첩 클래스, 내부 클래스2
          • 9. 예외 처리1 - 이론
          • 10. 예외 처리 - 실습
        • 김영한의 실전 자바 - 중급2편
          • 1. 제네릭 - Generic1
          • 2. 제네릭 - Generic2
          • 3. 컬렉션 프레임워크 - ArrayList
          • 4. 컬렉션 프레임워크 - LinkedList
          • 5. 컬렉션 프레임워크 - List
          • 6. 컬렉션 프레임워크 - 해시(Hash)
          • 7. 컬렉션 프레임워크 - HashSet
          • 8. 컬렉션 프레임워크 - Set
            • 레드 블랙 트리
          • 9. 컬렉션 프레임워크 - Map, Stack, Queue
            • 왜(?) Set 은 내부에서 Map 을 사용할까?
          • 10. 컬렉션 프레임워크 - 순회, 정렬, 전체 정리
        • 김영한의 실전 자바 - 고급 1편, 멀티스레드와 동시성
          • 프로세스와 스레드 소개
          • 스레드 생성과 실행
          • 스레드 제어와 생명 주기1
          • 스레드 제어와 생명 주기2
          • 메모리 가시성
          • 동기화 - synchronized
            • synchronized 키워드 이해도 체크
          • 고급 동기화 - concurrent.Lock
          • 생산자 소비자 문제1
          • 생산자 소비자 문제2
          • CAS - 동기화와 원자적 연산
          • 동시성 컬렉션
          • 스레드 풀과 Executor 프레임워크1
          • 스레드 풀과 Executor 프레임워크2
        • 김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션
          • 문자 인코딩
          • I/O 기본1
          • I/O 기본2
          • I/O 활용
          • File, Files
          • 네트워크 - 프로그램1
          • 네트워크 - 프로그램2
          • 채팅 프로그램
          • HTTP 서버 만들기
          • 리플렉션
          • 애노테이션
          • HTTP 서버 활용
        • 김영한의 실전 자바 - 고급3편, 람다, 스트림, 함형 프로그래밍
          • 람다가 필요한 이유
          • 람다
          • 함수형 인터페이스
          • 람다 활용
          • 람다 vs 익명 클래스
          • 메서드 참조
          • 스트림API1 - 기본
          • 스트림 API2 - 기능
          • 스트림 API3 - 컬렉터
          • Optional
          • 디폴트 메서드
          • 병렬 스트림
          • 함수형 프로그래밍
        • 기초 탄탄! 독하게 시작하는 Java - Part2: OOP 와 JVM
          • 2. 클래스 - 첫 번째
          • 3. 클래스 - 두번째
          • 4. 상속과 관계
          • 6. JVM(Java Virtual machine) 기본 이론
          • 7. JVM 과 GC 그리고 객체
          • 8. 불변 객체와 String 클래스
      • 책
        • 자바의 신
          • 변수
            • 클래스 변수(static) 사용 주의 케이스
            • Java volatile 과 Atomic 변수(+CAS)
          • 연산자
            • 비트 연산자 활용 예제
          • 배열
          • 참조 자료형
          • 상속
          • Object 클래스
          • interface, abstract class, enum
          • 예외
          • String 클래스
            • String 구조
            • String 문자열을 byte 로 변환하기
            • String 클래스에서 자주 사용되는 메서드
            • String 클래스로 살펴보는 불변(Immutable)객체
            • StringBuilder, StringBuffer
          • Nested 클래스
          • 어노테이션
            • 어노테이션 기본
            • 어노테이션의 사용
          • JVM 이해하기
            • 왜 JVM 을 사용해?
            • JVM, JRE, JDK
            • JVM 구조 이해하기
            • 클래스 로더 시스템
            • JIT(Just-In-Time) 컴파일러
            • GC(Garbage Collector)
              • GC Part.1
              • GC Part.2
              • GC 튜닝
          • java.lang
            • Wrapper 클래스
            • System 클래스
          • Generic
            • 제네릭 기본
            • 와일드카드
            • 와일드카드 GET / SET 경계
            • 와일드카드 extends / super 사용시기
            • 혼동할 수 있는 와일드카드 표현
          • Collection
            • 자료구조
              • 이진 탐색 트리 vs 레드 블랙 트리
            • Collection
            • List
              • ArrayList
              • Vector
              • Stack
              • LinkedList
            • Set, Queue
              • HashSet
              • LinkedHashSet
              • TreeSet
              • Priority Queue
              • ArrayDeque
            • Map
              • HashMap
              • Hashtable
              • LinkedHashMap
              • TreeMap
          • Thread
            • Thread 기본
            • Thread 와 관련이 많은, Synchronized
            • Thread 를 통제하는 메서드
            • ThreadGroup
          • I/O
            • InputStream, OutputStream
            • Reader, Writer
          • Serializable, NIO
            • Serializable
            • NIO (New IO)
          • 네트워크 프로그래밍
            • 네트워크 기본 & TCP 통신
            • UDP 통신
          • 람다
            • 함수형 인터페이스
            • 람다란?
        • 벨둥(Bealdung)
          • Java Concurrency
            • Java Concurrency Basics
              • Overview of the java.util.concurrent
              • Guide to the Synchronized Keyword in Java
              • Guide to the Volatile Keyword in Java
              • Guide to the java.util.concurrent.Future
              • ThreadLocal in Java
      • 그 외
        • 시스템 콜과 자바에서의 시스템 콜 사용례
        • 자바 NIO 의 동작원리 및 IO 모델
        • 함수형 인터페이스(FunctionInterface) - 자바8
  • Spring
    • 강의
      • 스프링 핵심 원리 - 기본편
        • 큰 흐름 잡기
        • 스프링 핵심 원리 이해1 - 예제 만들기
        • 스프링 핵심 원리 이해2 - 객체 지향 원리 적용
        • 스프링 컨테이너와 스프링 빈
        • 싱글톤 컨테이너
        • 컴포넌트 스캔
        • 의존관계 자동 주입
        • 빈 생명주기 콜백
        • 빈 스코프
      • 토비의 스프링6 - 이해와 원리
        • 3. 오브젝트와 의존관계1
        • 3. 오브젝트와 의존관계2
        • 4. 테스트
        • 5. 템플릿
        • 6.예외
        • 7. 서비스 추상화
      • 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술
        • 서블릿
    • 책
      • JSP 2.3 웹 프로그래밍
        • Servlet
        • JSP
        • 쿠키 / 세션
        • MVC 패턴
        • 실무 때 고민할 만한 부분
      • 스프링 입문을 위한 자바 객체지향의 원리와 이해
        • 자바와 절차적/구조적 프로그래밍
        • 객체지향의 4대 특성
        • 객체지향 설계의 5원칙
        • 스프링이 사랑한 디자인 패턴
        • IoC / DI
        • AOP(Aspect Oriented Programming), 관점 지향 프로그래밍
      • 토비의 스프링 3.1
        • Spring vs Spring Boot
        • 1. 오브젝트와 의존관계
          • 1.4 제어의 역전(IoC)
          • 1.5 스프링의 IoC
          • 1.6 싱글톤 레지스트리와 오브젝트 스코프
    • 그 외
      • 스프링 부트(SpringBoot) 탄생 배경
  • CS
    • DATA STRUCTURES
      • 선택 정렬(Selection Sort)
      • 버블 정렬(Bubble Sort)
      • 삽입 정렬(Insertion Sort)
    • OS
      • 강의
      • 책
        • 혼자 공부하는 컴퓨터구조 + 운영체제
          • 1. 컴퓨터 구조 시작하기
          • 2. 데이터
          • 3. 명령어
          • 4. CPU 의 작동원리
          • 5. CPU 성능 향상 기법
          • 6. 메모리와 캐시메모리
          • 7. 보조기억장치
          • 8. 입출력장치
          • 9. 운영체제 시작하기
          • 10. 프로세스와 스레드
    • NETWORK
      • 그 외
        • REST API
          • REST API
          • URI & MIME type
          • Collection Pattern
          • Collection Pattern 적용
          • Spring Web MVC 구현
        • SSL 인증 동작
        • DTO & JSON & CROS
          • DTO
          • 직렬화(Serialization)
          • Jackson ObjectMapper
          • CROS
        • Connection Timeout / Read Timeout
      • 강의
        • 외워서 끝내는 네트워크 핵심이론 - 기초
          • Internet 기반 네트워크 입문
            • Host 는 이렇게 외우자
            • 스위치가 하는 일과 비용
          • L2 수준에서 외울 것들
            • NIC, L2 Frame, LAN 카드 그리고 MAC 주소
            • L2 스위치에 대해서
            • LAN 과 WAN 의 경계 그리고 Broadcast
          • L3 수준에서 외울 것들
            • IPv4 주소의 기본 구조
            • L3 IP Packet 으로 외워라
            • 패킷의 생성과 전달 및 계층별 데이터 단위
            • 이해하면 인생이 바뀌는 TCP/IP 송, 수신 구조
            • IP 헤더 형식
            • 서브넷 마스크와 CIDR
            • Broadcast IP 주소와 Localhost
            • TTL 과 단편화
            • 인터넷 설정 자동화를 위한 DHCP
            • ARP 과 Ping(RTT : Round Trip Time)
          • L4 수준 대표주자 TCP 와 UDP
            • TCP 와 UDP 개요
            • TCP 연결 및 상태 변화
            • TCP 연결 종료 및 상태 변화
            • TCP, UDP 헤더 형식과 게임서버 특징
            • TCP 가 연결이라는 착각
            • TCP 연결과 게임버그
          • 웹을 이루는 핵심기술
            • DNS
            • URL, URI
        • 외워서 끝내는 네트워크 핵심 이론 - 응용
          • 네트워크 장치의 구조
            • 세 가지 네트워크 장치 구조
            • Inline 구조
            • Out of path 구조와 DPI 그리고 망중립
            • Proxy(클라이언트 입장) - 우회
            • Proxy(클라이언트 입장) - 보호와 감시
            • Reverse Proxy(서버 입장)
          • 인터넷 공유기의 작동 원리
            • 공유기 개요
            • Symmetric NAT
            • Full Cone 방식
            • Restricted Cone, Port Restricted Cone
            • 포트 포워딩
            • UPnP 와 NAT
          • 부하분산 시스템 작동 원리
            • L4 부하분산 무정지 시스템
            • 대규모 부하분산을 위한 GSLB
          • VPN과 네트워크 보안 솔루션
            • PN 과 VPN
            • IPSec VPN 과 터널링 개념
            • VPN 과 재택근무
        • 외워서 끝내는 SSL 과 최소한의 암호기술
          • 기초이론
            • Checksum (검사합)
            • Hash
          • 암호기술에 대한 이해
            • 대칭키
            • 비대칭키
          • PKI 시스템과 인터넷
            • 인터넷을 위한 비대칭키 체계
            • 공개키 신뢰를 위한 검증체계
            • 웹서비스와 공인인증서
      • 책
        • 그림으로 배우는 네트워크 원리
          • 1. 네트워크 기본
          • 2. 네트워크를 만드는 것
          • 3. 네트워크의 공통 언어 TCP/IP
    • SECURITY
      • 그 외
        • Basic Auth
        • HMAC 기반 인증
    • 그 외
      • 동기/비동기 & 블로킹/논블록킹
  • DB
    • 그 외
      • 인덱스(Index)
      • 트랜잭션(TRANSACTION)
      • 실무에서 외래키를 사용하지 않는 이유
      • ORM vs SQL Mapper
      • 문자열 vs DATE
      • EXPLAIN 명령어
    • 강의
      • Real MySQL 시즌 1
        • Part.1
          • 1강. CHAR vs VARCHAR
          • 2강. VARCHAR vs TEXT
          • 3강. COUNT(*) & COUNT(DISTINCT) 튜닝
          • 4강. 페이징 쿼리 작성
          • 5강. Stored Function
      • 토크온 41차. JPA 프로그래밍 기본 다지기
        • 1. JPA 소개
        • 2. JPA 기초와 매핑
        • 3. 필드와 컬럼 매핑
        • 4. 연관관계 매핑
        • 5. 양방향 매핑
        • 6. JPA 내부구조
        • 7. JPA 객체지향쿼리
        • 8. Spring Data JPA 와 QueryDSL 이해
    • 책
  • Software Development Methodology
    • TDD
      • 강의
        • Spring Boot TDD - 입문부터 실전까지 정확하게
          • 세션2. TDD 소개
          • 세션5. API 설계
          • 세션6. TDD 주기 첫 번째 경험
          • 세션7. TDD 주기 반복
          • 세션8. 시스템 데이터
      • 그 외
        • 단위 테스트(Unit Test) 작성의 필요성
        • JUnit5
          • A Guide to JUnit 5
          • Guide to JUnit 5 Parameterized Tests
          • AssertJ Exception Assertions
          • Testing in Spring Boot
          • Junit 과 Mockito 기반의 Spring 단위 테스트 코드 작성법
        • Code Coverage
          • Code Coverage?
    • DDD
      • 책
        • 도메인 주도 설계(Domain-Driven Design)
          • 04 - 도메인의 격리
          • 05 - 소프트웨어에서 표현되는 모델
          • 06 - 도메인 객체의 생명주기
          • 07 - 언어의 사용(확장 예제) (1)
          • 07 - 언어의 사용(확장 예제) (2)
        • 도메인 주도 개발 시작하기
          • 1. 도메인 모델 시작하기
          • 2. 아키텍처 개요
          • 3. 애그리거트
          • 4. 리포지터리와 모델 구현
            • DAO vs Repository
      • 강의
        • DDD 세레나데(NEXTSTEP)
          • 1주차
            • 도메인 주도 설계 등장 배경
            • 레거시 코드
            • 유연한 설계 - ASSERTION
          • 2주차
            • 전략적 설계 - UBIQUITOUS LANGUAGE
            • 전략적 설계 - BOUNDED CONTEXT
          • 3주차
            • 전술적 설계 - VALUE OBJECT 와 ENTITY
            • 전술적 설계 - AGGREGATE 와 REPOSITORY
            • 전술적 설계 - SERVICE
    • REFACTORING
      • 일급 컬렉션(First Class Collection) 소개와 사용해야하는 이유
  • ARCHITECTURE
    • Event Driven Architecture
  • 멘토링
    • F-Lab
      • 10회차(2024.12.29)
Powered by GitBook
On this page
  • 1. 인터페이스 설계와 구현 설계
  • 시스템
  • 클라이언트
  • 인터페이스 설계
  • 구현 설계
  • 리팩터링
  • 2. 테스트와 설계
  • 테스트 시나리오
  • 자동화된 테스트
  • 설계 관점의 테스트
  • 구현 설계에 의존하는 테스트와 구현 설계 변경의 여파
  • 3. TDD(Test-Driven Development) 절차
  • Kent Beck 이 정의한 TDD 절차 (생각보다 간단하다)
  • 1. 다루고자 하는 테스트 시나리오의 목록을 작성한다.
  • 2. 목록에서 정확히 한 가지 항목을 실제 실행 가능한 구체적인 테스트로 전환한다.
  • 3. 전환된 테스트(및 모든 이전 테스트) 를 통과하도록 코드를 변경한다.
  • 4. 선택적으로 리팩터링하여 구현 설계를 개선한다.(리팩터링)
  • 5. 목록이 비워졌는가?
  • 4. 지금 시점의 TDD 의 의미
  • TDD 는 우리를
  • 생성형 AI 보급이 프로그래머에 미치는 영향
  • 생성형 AI 보급과 TDD
  • 5. 거짓 양성과 거짓 음성
  • 거짓 양성(false positive)
  • 거짓 음성(false nogative)
  • 소프트웨어 테스트에서의 거짓 양성과 거짓 음성
  • 6. TDD 에 대한 오해
  • Mock 을 잘 사용해야 TDD 를 잘 할 수 있다.
  • 테스트를 위해 프로젝트 구조를 설계해야 TDD 를 잘 할 수 있다.
  • 인터페이스 형식을 많이 사용해야 TDD 를 잘할 수 있다.
  • 클래스를 작게 나눠야 TDD 를 잘할 수 있다.
  • 클린 아키텍처 또는 헥사고날 아키텍처를 사용해야 TDD 를 잘할 수 있다.
  • 단위 테스트와 통합 테스트를 잘 분리해야 한다.
  • 테스트 실행 시 데이터베이스 엔진 사용을 피해야 한다.
  • Spring 컨테이너를 사용하는 테스트는 몹시 불편할 정도로 느리다.
  1. Software Development Methodology
  2. TDD
  3. 강의
  4. Spring Boot TDD - 입문부터 실전까지 정확하게

세션2. TDD 소개

1. 인터페이스 설계와 구현 설계

시스템

  • 특정한 목적을 달성하기 위해 여러 구성 요소가 함께 상호작용하며 작동하는 단위

  • 시스템은 시스템을 외부와 구별하는 경계를 가지고 인터페이스를 통해 외부와 소통

  • 하나의 시스템은 여러 하위 시스템으로 구성될 수 있다.

  • 응용프로그램, 모듈, 클래스, 함수, ...

클라이언트

  • 시스템이 제공하는 기능을 사용하는 주체

  • 인터페이스를 통해서 시스템에 접근

  • 시스템을 이용하며 대가를 지불하는 고객같은 사용자가 있다.

  • 외부 응용프로그램이나 한 클래스를 사용하는 다른 클래스가 있다.

인터페이스 설계

  • 인터페이스는 클라이언트와 상호작용하기 위한 소통 약속이다.

  • 인터페이스 설계는 클라이언트의 요구사항 반영한다.

  • 인터페이스 설계 변경은 클라이언트에 영향을 준다.

    • 만약 클라이언트가 이런 영향을 거부한다면 인터페이스 설계 변경은 불가능하다..

구현 설계

  • 구현 설계는 인터페이스를 통해 제공되는 기능 요구 사항을 충족시킨다.

  • 구현 설계는 비기능 요구사항(성능, 보안, 개발 생산성...)도 충족시키며 제작공정의 품질에 영향을 준다.

  • 변경 여파가 미치는 범위가 시스템 내부로 한정된다.

  • 때문에, 대안의 폭이 넓고 변경이 잦다..

리팩터링

  • 제작공정 품질을 높이기 위해 기능과 인터페이스 설계를 유지하며 구현 설계를 변경할 수 있다.

  • 이런 활동을 리팩터링(refectoring)이라고 부른다.

    • 클라이언트가 사용하는 인터페이스의 설계 변경을 포함하는 활동은 리팩터링이 아니며, 리디자인(redesign) 이라 표현하기도 한다.

  • 기능과 인터페이스 설계가 유지되기 때문에, 리팩터링은 클라이언트에 아무런 영향을 주지 않는다.

  • 리디자인은 클라이언트에게 영향이 가기 때문에, 많은 자원을 계획적으로 할당해야 하는 반면,

    • 다른 동료에게 리디자인에 대한 일정 공유는 필수적이다! (영향이 많다!)

  • 리팩토링은 클라이언트에게 영향이 가지 않기 때문에, 특별한 자원 할당 없이 일상적인 개발 과정의 일부로 수행된다.

    • 다른 동료에게 리팩토링에 대한 일정 공유는 필요 없다.. (영향이 없으니,,)

2. 테스트와 설계

테스트 시나리오

  • 제품이 갖춰야 할 기능을 검증하는 작은 단위

  • 다양한 제품 요구사항 표현 방법 중 하나이다.

  • 대부분 클라이언트 관점에서 작성된다.

  • 제품의 가치와 품질을 결정하는 주요 요소이다.

  • 모든 프로그래머는 의식적으로 또는 무의식적으로, 문서화하든 또는 머릿속에서만 정리하든, 명확하게 또는 희미하게 테스트 시나리오를 구성한다.

  • 해당 강의에서 '테스트 시나리오'는 명확하게 문서화한 테스트 시나리오를 의미한다.

자동화된 테스트

  • 테스트 시나리오의 구체적인 내용이 동작하는 코드의 문법으로 작성된 문서이다.

    • Junit 과 같은 테스트 프레임워크

  • 저렴하게 테스트 시나리오를 검증한다.

  • 반복 실행하기 쉽다.

  • 검증 결과의 신뢰도가 높다.

설계 관점의 테스트

  • "단위 테스트 운영 API 의 첫 번째 클라이언트입니다" - Mark Seemann

    • 기능을 사용하기 위해서 시스템의 인터페이스를 개발 후 가장 먼저 호출할 수 있다.

  • 클라이언트는 공개된 인터페이스 설계에만 의존하는 것이 원칙이다.

    • 내부의 구현 설계와는 직접적인 관련이 없다.

    • 클라이언트가 시스템 내부에 감춰진 구현 설계에 의존하게 되면 시스템은 다양한 위험에 노출된다.

  • 구현 설계에 의존하지 않는 원칙은 클라이언트의 일종인 테스트에도 동일하게 적용된다.

구현 설계에 의존하는 테스트와 구현 설계 변경의 여파

  • 대부분 구현 설계의 여파는 시스템 내부로 한정되고 그 여파는 크지 않다.

    • 클라이언트에게 전파되지 않는다.

  • 하지만, 구현 설계의 변경이 외부로 전파된다면 모든 클라이언트(테스트) 가 해당 변경에 대응해야 한다.

    • 만약 해당 구현 설계와 수많은 테스트가 연관되어 있다면 모든 테스트가 변경에 대응해야 한다.

3. TDD(Test-Driven Development) 절차

Kent Beck 이 정의한 TDD 절차 (생각보다 간단하다)

  1. 다루고자 하는 테스트 시나리오의 목록을 작성한다.

  2. 목록에서 정확히 한 가지 항목을 실제 실행 가능한 구체적인 테스트로 전환한다.

  3. 전환된 테스트(및 모든 이전 테스트) 를 통과하도록 코드를 변경한다.

    1. 테스트 시나리오가 발견되는 대로 항목 추가

  4. 선택적으로 리팩터링하여 구현 설계를 개선한다.(리팩터링)

  5. 목록이 비워졌는지 확인한다.

    1. 비워졌다면 종료한다.

    2. 아니라면 2. 로 돌아간다.

1. 다루고자 하는 테스트 시나리오의 목록을 작성한다.

  • 대상 기능에 대한 떠올릴 수 있는 모든 테스트 시나리오를 나열한다.

    • 성공, 실패 모두 포함

  • Kent Beck 은 테스트 시나리오 목록 작성을 본인의 책에서 설명하였지만 많은 사람들이 그걸 놓친 것 같다 말했다.

  • 테스트 시나리오 목록은 TDD 과정 뿐 아니라 제품의 품질에 큰 영향을 미친다. (그만큼 중요하다!)

2. 목록에서 정확히 한 가지 항목을 실제 실행 가능한 구체적인 테스트로 전환한다.

  • 테스트 시나리오 목록에서 정확히 하나를 선택해서 이 시나리오에 해당하는 자동화된 테스트를 작성한다.

  • 테스트에 의해 인터페이스가 처음으로 사용된다.

    • 핵심: 이 시점에는 테스트에 사용되는 클래스가 아직 존재하지 않거나, 존재하더라도 메서드가 아직 구현되지 않았거나, 잘못 구현되어 있어야 한다.

  • 테스트 작성이 완료되면 실행해서 실패 결과를 확인한다.

    • 운영 코드를 변경하지 않은 이유로 인해 실패해야 한다.

      • 방금 작성한 테스트를 실행하면 반드시 실패해야 한다. 왜냐하면 메서드를 아직 구현하지 않았거나, 잘못 구현했기 때문이다.

      • 만약 테스트가 성공한다면? 뭔가 잘못된 것이다. (해당 케이스는 이후 내용에서 다룬다..)

    • 이 단계에서 테스트가 실패하는 것이 정상이다. 만약 성공했다면, 그것은 테스트 코드 자체를 다시 검토해야 한다는 신호이다.

인터페이스 설계 시점

  • 독립적인 작업(외부 의존성X)이라면 "2. 목록에서 정확히 한 가지 항목을 실제 실행 가능한 구체적인 테스트로 전환한다." 단계에서 시작할 수 있다.

  • 협업에 필요한 인터페이스라면 "1. 다루고자 하는 테스트 시나리오의 목록을 작성한다." 단계에서 초안이 작성될 수 있다.

    • 예를 들어, 여러 개발자가 함께 작업해야 하는 기능, 특히 프론트엔드-백엔드 간, 또는 다른 모듈 간의 연동이 필요한 경우를 말한다. 이 경우에는 기능 구현 이전에 '어떤 시나리오로 테스트할 것인지'에 대한 목록을 먼저 작성하여 인터페이스의 초안을 함께 정의하는 것이 중요하다. 이는 일종의 "계약서"를 미리 작성하는 것과 같다.

  • 독립적인 작업인 경우에도 1번 단계에서 테스트 시나리오 목록과 인터페이스 설계 초안을 함께 작성하면 두 작업이 서로 긍정적인 영향을 끼친다.

    • "사용자 정보 유효성 검증"과 같은 독립적인 기능도, 바로 테스트를 작성하기보다는 어떤 케이스를 테스트할지 목록을 먼저 만들고 그 과정에서 인터페이스를 구체화하면 더 좋다.

3. 전환된 테스트(및 모든 이전 테스트) 를 통과하도록 코드를 변경한다.

  • 모든 테스트를 통과하도록 운영 코드를 변경한다.

  • 테스틑 통과하게 만드는 데 집중한다.

    • 코드가 깨끗한지 또는 중복되는지는 중요하지 않다.

  • 모든 테스트가 통과하는 것을 확인 후. 새로 추가한 테스트에 해당하는 시나리오에 완료 표시한다.

  • 이 단계에서 "1. 다루고자 하는 테스트 시나리오의 목록을 작성한다." 단계에서 떠올리지 못한 새로운 테스트 시나리오가 발견되면 목록에 추가한다.

4. 선택적으로 리팩터링하여 구현 설계를 개선한다.(리팩터링)

  • 구현 설계를 개선할 필요가 있다면 판단되면 리팩터링한다.

  • 이 단계는 선택적이다.

    • 하지만, 리팩터링을 해야할지 판단하는 과정을 쉽지 않다..

  • 리팩터링이 완료되면 모든 테스트를 통과하는지 다시 확인한다.

5. 목록이 비워졌는가?

  • 비워졌다면 종료한다.

  • 아니라면 2. 로 돌아간다.

4. 지금 시점의 TDD 의 의미

TDD 는 우리를

  • 의식적으로 구체적인 테스트 시나리오 목록을 기록하게 한다. (구조적인 이점)

  • 두려워하지 않고 앞으로 나아갈 수 있게 한다. (감정적인 이점)

  • 구현 코드의 설계보다 제품의 가치에 집중하게 한다. (효율적인 이점)

생성형 AI 보급이 프로그래머에 미치는 영향

  • 제품 개발의 궁극적인 목적은 사람에게 가치를 전달하는 것이다.

  • 제품 개발자는 가치 전달 과정에서 발생할 수 있는 기대하지 않은 피해를 차단해야 한다.

  • 주어진 요구사항에 대한 구현 코드나 그 초안을 만드는 생성형 AI 의 능력은 빠르게 향상되고 있다.

  • 프로그래머는 구현 코드의 설계보다 올바른 가치 전달을 위해 필요한 논리적이고 모순되지 않으며 구체적인 요구사항 제시에 더욱 기여해야 한다.

생성형 AI 보급과 TDD

  • TDD 는 올바른 요구사항 제시를 유도 또는 장려한다.

  • 유사한 흐름을 공유하는 테스트를 반복해서 작성할 때 생성형 AI 는 뛰어난 도구이다.

  • 테스트로 표현된 요구사항은 생성형 AI 에게 구현 코드 작성을 주문하는 효과적인 입력이다.

  • 생성형 AI 는 테스트 작성과 구현 코드 작성에서 모두 TDD 비용을 줄여 준다.

  • AI 코드 생성 능력은 프로그래머가 구현 코드가 아닌 소프트웨어 가치에 집중할 수 있게 한다.

    • 소프트웨어의 본질적인 존재 목적이 아닐까?

  • TDD 를 통해 확보된 소프트웨어 가치에 기반한 테스트 집합은 시스템에 지속적으로 추가되는 AI 생성 코드가 가질 수 있는 오류와 위험을 효과적으로 방어할 수 있다.

    • 결론적으로, TDD 는 더 필요해질 수 밖에 없다.

    • AI 를 통한 생산성 향상으로 인한 코드에 대한 안전망 필요 = 테스트코드

    • 그 테스트 코드마저 AI 에게 요청 가능 = 비용 절감

5. 거짓 양성과 거짓 음성

거짓 양성(false positive)

  • 주어진 조건이 존재하지 않을 때 존재한다고 나타내는 결과이다.

  • 예를 들어, 여성이 임신하지 않았는데, 임신했다고 나타내는 임신 테스트나 무고한 사람의 유죄 판결이 있다.

거짓 음성(false nogative)

  • 조건이 유지되지 않음을 잘못 나타내는 테스트 결과이다.

  • 예를 들어, 임신 검사에서 여성이 임신하지 않았다고 표시되지만 실제로는 임신한 경우, 또는 범죄를 저지른 사람이 무죄 판결을 받는 경우가 있다.

소프트웨어 테스트에서의 거짓 양성과 거짓 음성

  • 거짓 양성은 성가신 문제이다. 테스트의 오류를 수정하거나 테스트 환경을 안정화하면 해결할 수 있다. 간헐적으로 발생하는 경우 우리를 더 귀찮게 한다.

  • 거짓 음성은 위험하다. 운영 코드에 문제가 있음에도 불구하고 아무런 신호도 주지 않아, 적절한 조취를 취할 수 없기 때문이다. 결국 클라이언트가 피해를 입게 된다.

6. TDD 에 대한 오해

Mock 을 잘 사용해야 TDD 를 잘 할 수 있다.

  • "저는 테스트 대역을 거의 사용하지 않습니다." - Kent Beck

  • Java 의 경우 Mockito 를 잘 사용해야 한다는 주장이 있다.

  • 테스트 환경에서 실제 구성 요소를 대체하는 시스템을 지칭할 때, '테스트 대역(test double)' 이라는 표현이 명확하다.

  • xUnit 테스트 패턴에서 Mock 은 테스트 대역의 여러 가지 유형 중 하나이다.

    • http://xunitpatterns.com/Mocks, Fakes, Stubs and Dummies.html

  • 테스트 대역이 유용한 경우가 분명이 있지만, 남용하면 운영 코드와 테스트 간의 정보 공유가 비대해져 설계 변경 비용이 증가하고, 테스트 환경의 가정을 확대해 거짓 음성이 발생할 가능성이 높아진다.

  • 테스트 대역을 사용하더라도 반드시 별도의 도구가 필요한 것은 아니다.

  • 본 강의의 실습은 테스트 대역을 사용하지 않는다.

테스트를 위해 프로젝트 구조를 설계해야 TDD 를 잘 할 수 있다.

  • Java 의 경우 패키지 구조를 잘 설계하는 것은 다양한 이점이 있을 수 있으나 테스트에 미치는 영향은 미비하다.

  • 오히려 외부에 드러난 인터페이스 설계와 내부에 감춰진 구현 설계의 명확한 구분이 테스트 작성에 많은 영향을 준다.

  • 시스템의 적응력을 높이기 위한 아키텍팅의 결과로 모듈이 분리되었다면 자연스럽게 테스트 작성 비용이 낮아지겠지만, 설계 숙련도가 충분하지 않은 채 테스트 용이성만을 목적으로 모듈을 분리하면 오히려 거짓 음성을 야기할 수 있다.

인터페이스 형식을 많이 사용해야 TDD 를 잘할 수 있다.

  • Java 언어의 인터페이스 형식은 운영 코드의 변경과 확장 용이성을 확보하기 위해서 사용할 수 있다.

  • 테스트 작성만을 고려해 인터페이스 형식을 도입한다면 테스트 대상 시스템, SUT(system under test) 가 의존하는 구성요소, 실제 DOC(depended-on component) 를 추상화해 테스트 환경에서 테스트 대역 사용을 사용하는 것이 유일한 목적이다.

  • 이런 경우 실제 DOC의 행위가 변경되었을 때 테스트 환경에서 테스트와 SUT 는 실제 DOC 가 아닌 테스트 대역에만 의존하기 때문에, 거짓 음성이 발생할 수 있다.

  • 만약 테스트 환경에서 실제 DOC 를 구동하거나 제어할 수 없는 상황이라면 거짓 음성의 위험과 SUT 코드를 테스트하는 효과의 거래도 고려할 만 하다.

  • 하지만 그렇지 않다면, 테스트 작성만을 위한 인터페이스 형식 도입은 시스템의 설계 복잡도를 높이고 테스트 결과의 신뢰도를 떨어뜨리는 실수이다.

클래스를 작게 나눠야 TDD 를 잘할 수 있다.

  • 구현 설계가 테스트에 노출된 경우가 아니라면 내부에 감춰진 구현 코드를 이루는 클래스나 함수의 크기는 테스트 작성과 TDD 에 영향을 주지 않는다.

  • 클라이언트는 오직 인터페이스와 소통한다.

클린 아키텍처 또는 헥사고날 아키텍처를 사용해야 TDD 를 잘할 수 있다.

  • 적응력 높은 설계를 확보하면 그 효과중 하나로 테스트 작성 비용이 감소할 수는 있다. 그러나 팀과 코드 기반이 특정 아키텍처 도입에 충분히 준비되어 있지 않다면, 테스트 작성만을 목적으로 해당 아키텍처 도입 비용을 지불하는 것은 좋지 않은 결정일 가능성이 높다.

  • 본 강의 실습의 시스템은 매우 단순한 아키텍처로 만들어지지만 모든 코드는 큰 불편함 없이 TDD 로 작성된다.

단위 테스트와 통합 테스트를 잘 분리해야 한다.

  • 단위 테스트가 다루는 운영 코드 범위에 대한 명확한 합의는 아직 없다.

  • 때문에, 단위 테스트와 통합 테스트를 구분하는 것은 쉽지 않을 뿐더러 더 중요하게는 강사 본인은 둘의 구분이 주는 긍정적인 효과를 거의 느끼지 못한다.

  • 단위 테스트와 통합 테스트의 구분보다 요구사항 검증이 자동화되었는지 여부가 더욱 중요하다!

  • 오히려 단위 테스트와 통합 테스트를 분명하게 나누려는 시도는 단위 테스트가 다루는 운영 코드 범위를 극도로 제한하려는 심리를 만들며, 이는 다음과 같은 현상을 유도해 거짓 음성 가능성과 설계 비용을 높인다.

    • 과도하게 테스트 대역을 사용한다.

    • 클라이언트에 제공되는 기능 수준의 설계보다 작은 단위의 하위 시스템 설계에 집중한다..

  • 본 강의는 단위 테스트, 통합 테스트라는 용어를 거의 사용하지 않는다.

테스트 실행 시 데이터베이스 엔진 사용을 피해야 한다.

  • 데스트 환경 전용 데이터베이스가 있다면 충분히 활용할 수 있다.

  • 데이터베이스 엔진 사용이 너무 느려서 테스트를 실행하는 프로그래머가 답답함을 느끼거나 연결이 안정적이지 않다면 테스트 대역을 고려할 수 있고, 첫 번째 후보는 인메모리 데이터베이스 엔진이다.

  • 본 강의 실습의 모든 테스트는 H2 인메모리 데이터베이스 엔진을 사용하며 불편하지 않을 정도의 속도를 보여준다.

  • 데이터베이스 엔진 사용 시 롤백과 관련된 고민을 하고 있다면 본 강의 실습에서 소개하는 임의 테스트 데이터 생성을 통해 애초에 롤백이 필요없도록 할 수 있다.

Spring 컨테이너를 사용하는 테스트는 몹시 불편할 정도로 느리다.

  • 불편함과 느림은 상대적인 척도이기 때문에, 명백하게 틀린 주장이라고 할 수는 없다.

  • 동일한 기능을 다룰 때 Spring 컨테이너를 사용하지 않는 테스트가 대부분 더 빠른 것은 사실이다.

  • 수십 회 HTTP 요청을 사용하는 복잡한 테스트 여럿을 포함한 본 강의 실습의 120여 개 테스트는 모두 Spring 컨테이너를 사용하며 전체 실행 시간은 약 25초이다. 강의 후반의 ‘테스트 성능 개선’ 수업에서는 실행 시간을 크게 줄여서 약 6초로 감소된다.

    *강의 영상에서는 화면 녹화 중인 이유로 더 긴 시간이 소요됩니다.

  • 본 강의 실습은 Spring Boot 응용프로그램 개발에 TDD를 사용하는 가장 쉽고 기본적인 기법만을 소개한다. 실무에서 다양한 기법을 활용하는 경우 비슷한 수의 테스트 실행 속도는 몇 배 더 빨라질 수 있다.

PreviousSpring Boot TDD - 입문부터 실전까지 정확하게Next세션5. API 설계

Last updated 1 day ago

https://github.com/vanilla-manifesto/vanilla-di-manifesto