콘텐츠 대표 이미지 - Swift 고인물로 가는 지름길, 단위 테스트 완전 정복하기

Swift 고인물로 가는 지름길, 단위 테스트 완전 정복하기

코딩? 버그 잡느라 시간 다 보내는 거, 이제 그만!
진짜 프로는 코드를 짜는 게 아니라, '잘 돌아가는' 코드를 짜는 거야. 그 비결, 바로 단위 테스트에 있어.

안녕! 우리 이제 '테스트'랑 좀 친해져 볼까?

"아, 또 테스트... 그거 귀찮은 거 아니야?"
"기능 구현할 시간도 없는데 언제 테스트 코드까지 짜..."

혹시 이렇게 생각했다면, 오늘 이 글을 끝까지 읽어봐. 생각이 180도 바뀔 테니까. 😉
단위 테스트(Unit Test)는 그냥 '버그 찾기'가 아니야. 이건 내 코드에 대한 **자신감**이고, 미래의 나를 위한 **보험**이고, 동료 개발자와의 **원활한 소통을 위한 언어**야.

상상해봐. 새로운 기능을 추가했는데, 갑자기 전혀 상관없어 보이던 로그인 기능이 먹통이 되는 거야. 최악이지? 이런 '사이드 이펙트(Side Effect)'의 공포에서 우리를 구원해 줄 영웅이 바로 단위 테스트라고.

이 글에서는 Swift 개발자라면 반드시 알아야 할 `XCTest` 프레임워크를 가지고, 단위 테스트의 A부터 Z까지 전부 파헤쳐 볼 거야. 완전 초보도 따라올 수 있게, 친구한테 설명하듯 쉽고 재미있게 알려줄게. 준비됐어?

그래서, '단위 테스트'가 정확히 뭔데?

단위 테스트를 한마디로 정의하면, **'코드의 가장 작은 단위를 검증하는 자동화된 테스트'**야.

여기서 '가장 작은 단위'가 뭘까? 보통 함수(function)나 메서드(method) 하나를 의미해. 예를 들어, 이메일 형식이 맞는지 확인하는 함수, 두 숫자를 더하는 함수, 사용자가 입력한 비밀번호가 유효한지 검사하는 메서드 같은 것들 말이야.

우리가 앱을 만들 때, 이런 작은 함수와 메서드들이 수백, 수천 개가 모여서 하나의 거대한 시스템을 이루게 돼. 만약 이 작은 부품(단위) 하나하나가 완벽하게 작동한다는 걸 보장할 수 있다면? 전체 시스템의 안정성은 말할 것도 없겠지. 마치 레고 블록 하나하나가 완벽해야 멋진 성을 만들 수 있는 것처럼 말이야.

Unit Testing 개념도 My App (전체 애플리케이션) 구성 요소 Unit 1 (Function A) Unit 2 (Method B) Unit 3 (Class C) Unit 4 (Function D) Unit 5 (Struct E) Unit 6 (Buggy Func) Test 1 PASS Test 2 PASS Test 3 FAIL ❌ FAILS! Test 4 PASS Test 5 PASS Test 6 FAIL ❌ FAILS! Unit Testing의 핵심 개념 앱을 구성하는 작은 단위(Unit)들을 각각 개별적으로 테스트하여 버그를 미리 찾아내고 수정합니다.

Xcode와 XCTest: 우리의 전투 장비

다행히도, 우리는 이 전쟁을 맨손으로 치를 필요가 없어. Apple이 `Xcode` 안에 `XCTest`라는 강력한 프레임워크를 기본으로 넣어줬거든.

Xcode 프로젝트를 처음 만들 때 "Include Tests" 체크박스를 본 적 있을 거야. 그걸 체크하면 `[YourProjectName]Tests` 라는 이름의 폴더(Test Target)가 자동으로 생겨. 바로 거기가 우리 테스트 코드들의 집이야.

이 테스트 타겟은 실제 앱과 분리되어 있어. 그래서 테스트 코드가 앱의 성능에 영향을 주거나, 앱과 함께 배포될 걱정은 전혀 하지 않아도 돼. 오직 개발 과정에서만 우리를 돕는 든든한 지원군인 셈이지.

테스트 케이스 해부하기: 뼈대부터 살펴보자

자, 이제 실제 테스트 코드가 어떻게 생겼는지 들여다볼 시간이야. `[YourProjectName]Tests` 폴더 안에 있는 `...Tests.swift` 파일을 열어봐. 아마 이런 비슷한 코드가 보일 거야.


// 1. XCTest 프레임워크를 가져온다.
import XCTest
// 2. 테스트할 프로젝트를 가져온다. '@testable'이 핵심!
@testable import YourAppName

// 3. XCTestCase를 상속받는 테스트 클래스를 만든다.
final class YourAppNameTests: XCTestCase {

    // 4. 각 테스트 메서드가 실행되기 *전*에 호출된다.
    override func setUpWithError() throws {
        // Put setup code here. This method is called before the invocation of each test method in the class.
        // 테스트 환경을 설정하는 코드를 여기에 작성한다. (예: 객체 생성)
    }

    // 5. 각 테스트 메서드가 실행된 *후*에 호출된다.
    override func tearDownWithError() throws {
        // Put teardown code here. This method is called after the invocation of each test method in the class.
        // 테스트 환경을 정리하는 코드를 여기에 작성한다. (예: 객체 해제)
    }

    // 6. 'test'로 시작하는 실제 테스트 메서드.
    func testExample() throws {
        // This is an example of a functional test case.
        // Use XCTAssert and related functions to verify your tests produce the correct results.
        // Any test you write for XCTest can be annotated with throws and async.
        // Mark your test throws to produce an unexpected failure when your test encounters an uncaught error.
        // Mark your test async to allow awaiting for asynchronous code to complete. Check the results with assertions afterwards.
    }

    // 7. 성능을 테스트하는 메서드.
    func testPerformanceExample() throws {
        // This is an example of a performance test case.
        self.measure {
            // Put the code you want to measure the time of here.
        }
    }
}
    

복잡해 보이지만, 하나씩 뜯어보면 별거 아니야.

  1. `import XCTest`: 테스트에 필요한 모든 도구가 들어있는 `XCTest` 프레임워크를 불러오는 거야. 필수!
  2. `@testable import YourAppName`: 이게 진짜 마법 같은 키워드야. 보통 우리 코드에서 `private`이나 `internal`로 선언된 속성이나 메서드는 외부에서 접근할 수 없잖아? 하지만 `@testable`을 붙이면, 이 테스트 파일 안에서는 `internal` 접근 수준을 가진 코드들에 접근할 수 있게 돼. 테스트를 위해 모든 걸 `public`으로 바꿀 필요가 없다는 뜻이지. 엄청나게 중요해!
  3. `class YourAppNameTests: XCTestCase`: 모든 테스트 클래스는 `XCTestCase`를 상속받아야 해. 그래야 Xcode가 "아, 이게 테스트 파일이구나!" 하고 알아챌 수 있거든.
  4. `setUpWithError()`: 각각의 테스트 함수(`test...()`)가 실행되기 *직전에* 매번 호출되는 함수야. 여러 테스트에서 공통으로 사용되는 객체를 여기서 생성해주면 코드가 깔끔해져. 마치 시험 보기 전에 책상 정리하고 필기구 세팅하는 것과 같아.
  5. `tearDownWithError()`: `setUpWithError()`와는 반대로, 각각의 테스트 함수가 끝난 *직후에* 매번 호출돼. `setUpWithError()`에서 만들었던 객체들을 여기서 `nil`로 만들어주는 등, 테스트 환경을 깨끗하게 정리하는 역할을 해. 다음 시험에 영향 주지 않도록 책상을 깨끗이 치우는 거지.
  6. `testExample()`: 드디어 주인공 등장! 실제 테스트 로직이 들어가는 곳이야. 중요한 규칙은 **메서드 이름이 반드시 'test'로 시작해야 한다는 것!** 그래야 Xcode가 테스트로 인식하고 실행시켜줘.
  7. `testPerformanceExample()`: 특정 코드 블록이 실행되는 데 걸리는 시간을 측정하고 싶을 때 사용해. 지금은 일단 이런 게 있다는 것만 알아두자.

단위 테스트의 황금률: AAA 패턴

"좋아, 구조는 알겠어. 근데 `test...()` 함수 안에는 뭘 어떻게 써야 하는 거야?"

아주 좋은 질문이야. 테스트 코드를 아무렇게나 막 짜면 나중에 내가 봐도 이해하기 힘든 코드가 돼버려. 그래서 전 세계 개발자들이 약속처럼 사용하는 패턴이 있어. 바로 **AAA 패턴**이야.

AAA는 **Arrange, Act, Assert**의 앞 글자를 딴 거야.

  • **Arrange (준비)**: 테스트에 필요한 모든 것을 세팅하는 단계. 테스트할 객체를 만들고, 필요한 입력값을 정의하고, 객체의 상태를 설정하는 등, 테스트를 위한 '무대'를 준비하는 과정이야.
  • **Act (실행)**: 준비된 환경에서 실제로 테스트하고 싶은 코드를 실행하는 단계. 보통 딱 한 줄, 즉 테스트 대상이 되는 함수나 메서드를 호출하는 부분이야.
  • **Assert (검증)**: 실행 결과가 우리가 예상한 것과 같은지 확인하는 단계. "Act 단계의 결과가 ~일 것이라고 단언(Assert)한다!" 라고 외치는 부분이지. 여기서 `XCTAssert...` 함수들이 활약하게 돼.
The AAA (Arrange-Act-Assert) Pattern 1. Arrange (준비)

테스트를 위한 환경을 설정합니다.

• 테스트할 객체(SUT) 생성
• 입력값 정의
• Mock/Stub 객체 설정
• 초기 상태 세팅

2. Act (실행)

테스트할
메서드를
호출합니다.
(보통 한 줄)

3. Assert (검증)

실행 결과가 예상과
일치하는지 확인합니다.

• `XCTAssertEqual(...)`
• `XCTAssertTrue(...)`
• `XCTAssertNil(...)`
• ... 등 사용

이 패턴을 따르면 테스트의 목적이 명확해지고, 읽고 유지보수하기 쉬워집니다.

간단한 계산기 예시를 통해 AAA 패턴을 실제로 적용해볼까?

먼저, 테스트할 대상인 `Calculator` 클래스를 만들어보자. (이 코드는 `YourAppName` 타겟에 있어야 해)


// YourAppName/Calculator.swift

class Calculator {
    func add(_ a: Int, _ b: Int) -> Int {
        return a + b
    }
}
    

이제 `CalculatorTests.swift` 파일에 이 `add` 함수를 테스트하는 코드를 AAA 패턴에 맞춰 작성해볼게.


// YourAppNameTests/CalculatorTests.swift

import XCTest
@testable import YourAppName

class CalculatorTests: XCTestCase {

    func testAdd_twoNumbers_returnsSum() {
        // Arrange (준비)
        let calculator = Calculator() // 테스트할 객체 생성
        let num1 = 5
        let num2 = 10
        let expected = 15 // 기대하는 결과값
        
        // Act (실행)
        let result = calculator.add(num1, num2) // 테스트할 메서드 호출
        
        // Assert (검증)
        XCTAssertEqual(result, expected, "5 + 10은 15여야 합니다.")
    }
}
    

어때? 주석으로 `Arrange`, `Act`, `Assert`를 달아놓으니 코드의 의도가 한눈에 싹 들어오지?

💡 꿀팁: 테스트 메서드 이름 잘 짓기

`testExample()` 같은 이름은 최악이야. 테스트 이름만 봐도 뭘 테스트하는지 알 수 있도록 자세하게 짓는 게 좋아.
`test_` + `[테스트할 메서드 이름]` + `_` + `[어떤 조건에서]` + `_` + `[기대하는 결과]`
이런 형식을 많이 사용해. 예를 들면, 위 테스트는 `test_add_withPositiveNumbers_shouldReturnCorrectSum()` 처럼 지을 수 있겠지. 이건 팀의 컨벤션에 따라 자유롭게 정하면 돼!

Assert 완전 정복: 내 코드의 진실을 밝히는 탐정들

AAA 패턴의 마지막 단계인 Assert(검증)는 테스트의 심장이야. `XCTest`는 다양한 상황에 쓸 수 있는 여러 종류의 `XCTAssert` 함수들을 제공해. 이것들을 자유자재로 쓸 수 있어야 진짜 테스트 고수라고 할 수 있지.

자주 쓰이는 Assert 탐정들을 만나보자!

`XCTAssertEqual(expression1, expression2, ...)`

가장 기본이자 가장 많이 쓰는 녀석. 두 개의 값이 같은지 비교해. 위 계산기 예제에서 봤지? 세 번째 파라미터로 테스트가 실패했을 때 보여줄 메시지를 넣어줄 수 있어.


func test_stringConcatenation() {
    // Arrange
    let str1 = "Hello"
    let str2 = " World"
    let expected = "Hello World"
    
    // Act
    let result = str1 + str2
    
    // Assert
    XCTAssertEqual(result, expected)
}
    

`XCTAssertTrue(expression, ...)` & `XCTAssertFalse(expression, ...)`

어떤 표현식(expression)의 결과가 `true`인지 `false`인지 검증할 때 사용해. Boolean 값을 반환하는 함수를 테스트할 때 딱이지.


func isEmailValid(_ email: String) -> Bool {
    let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
    let emailPred = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
    return emailPred.evaluate(with: email)
}

func test_isEmailValid_withValidEmail_returnsTrue() {
    // Arrange
    let email = "test@example.com"
    
    // Act & Assert
    XCTAssertTrue(isEmailValid(email), "유효한 이메일 형식이 true를 반환해야 합니다.")
}

func test_isEmailValid_withInvalidEmail_returnsFalse() {
    // Arrange
    let email = "test@example" // .com이 없음
    
    // Act & Assert
    XCTAssertFalse(isEmailValid(email), "유효하지 않은 이메일 형식은 false를 반환해야 합니다.")
}
    

`XCTAssertNil(expression, ...)` & `XCTAssertNotNil(expression, ...)`

Swift의 꽃, 옵셔널을 위한 Assert! 어떤 값이 `nil`인지 아닌지 검증할 때 사용해.


func test_userInitialization_withValidId_returnsUserObject() {
    // Arrange
    let user = User(id: "123") // User(id:)가 Failable Initializer라고 가정
    
    // Act & Assert
    XCTAssertNotNil(user, "유효한 ID로 생성된 유저는 nil이 아니어야 합니다.")
}

func test_userInitialization_withInvalidId_returnsNil() {
    // Arrange
    let user = User(id: "") // 빈 ID는 유효하지 않다고 가정
    
    // Act & Assert
    XCTAssertNil(user, "유효하지 않은 ID로 유저를 생성하면 nil이어야 합니다.")
}
    

`XCTAssertThrowsError(expression, ...)` & `XCTAssertNoThrow(expression, ...)`

Swift의 에러 처리(`throws`, `try`, `catch`)를 테스트하기 위한 필수 Assert야. 특정 코드를 실행했을 때 에러가 발생하는지, 또는 발생하지 않는지를 검증해.


enum PasswordError: Error {
    case tooShort
}

func validatePassword(_ password: String) throws {
    if password.count < 8 {
        throw PasswordError.tooShort
    }
}

func test_validatePassword_withShortPassword_throwsError() {
    // Arrange
    let shortPassword = "123"
    
    // Act & Assert
    // validatePassword(shortPassword)를 실행하면 PasswordError.tooShort 에러가 발생할 것을 기대한다.
    XCTAssertThrowsError(try validatePassword(shortPassword)) { error in
        XCTAssertEqual(error as? PasswordError, .tooShort, "8자 미만 비밀번호는 tooShort 에러를 던져야 합니다.")
    }
}

func test_validatePassword_withValidPassword_doesNotThrowError() {
    // Arrange
    let validPassword = "password123"
    
    // Act & Assert
    // validatePassword(validPassword)를 실행하면 어떤 에러도 발생하지 않을 것을 기대한다.
    XCTAssertNoThrow(try validatePassword(validPassword), "유효한 비밀번호는 에러를 던지지 않아야 합니다.")
}
    

`XCTUnwrap(expression, ...)`

이건 좀 특별한 녀석이야. Assert 함수라기보다는 테스트용 유틸리티에 가까워. 옵셔널 값을 안전하게 언래핑해주는데, 만약 값이 `nil`이면 테스트를 즉시 실패 처리하고 에러를 던져. `guard let ... else { XCTFail(...) }`의 축약 버전이라고 생각하면 편해.


func test_unwrapExample() throws {
    // Arrange
    let optionalName: String? = "Steve"
    
    // Act
    // optionalName이 nil이 아니라고 확신하고, 언래핑해서 non-optional 상수에 담는다.
    // 만약 optionalName이 nil이었다면, 이 라인에서 테스트가 바로 실패한다.
    let unwrappedName = try XCTUnwrap(optionalName, "이름은 nil이 아니어야 합니다.")
    
    // Assert
    XCTAssertEqual(unwrappedName, "Steve")
}
    

이 외에도 `XCTAssertGreaterThan`, `XCTAssertLessThanOrEqual` 등 다양한 비교 Assert들이 있으니, 필요할 때마다 공식 문서를 찾아보는 습관을 들이면 좋아!

실전 투입! ViewModel 테스트하기

지금까지는 간단한 함수들만 테스트해봤어. 이제 좀 더 현실적인 시나리오, 바로 **ViewModel**을 테스트해볼 차례야. MVVM 패턴을 사용하는 iOS 개발자라면 ViewModel 테스트는 피할 수 없는 숙명이지.

사용자 이름과 비밀번호를 입력받는 간단한 `LoginViewModel`을 만들어보자.

테스트 대상 코드: `LoginViewModel.swift`


// YourAppName/LoginViewModel.swift
import Combine

class LoginViewModel: ObservableObject {
    @Published var username = ""
    @Published var password = ""
    @Published var isLoginButtonEnabled = false
    @Published var errorMessage: String?
    
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        setupValidation()
    }
    
    private func setupValidation() {
        // username과 password가 모두 비어있지 않을 때만 로그인 버튼 활성화
        Publishers.CombineLatest($username, $password)
            .map { username, password in
                return !username.isEmpty && !password.isEmpty
            }
            .assign(to: \.isLoginButtonEnabled, on: self)
            .store(in: &cancellables)
    }
    
    func login() {
        // 실제 로그인 로직 (예: 네트워크 요청)
        // 지금은 간단하게 성공/실패만 시뮬레이션
        if username == "test" && password == "password" {
            errorMessage = nil
            print("로그인 성공!")
        } else {
            errorMessage = "아이디 또는 비밀번호가 잘못되었습니다."
            print("로그인 실패!")
        }
    }
}
    

자, 이 ViewModel에서 우리가 테스트해야 할 건 뭘까?

  1. ViewModel이 처음 생성됐을 때, 초기 상태는 올바른가? (`username`, `password`는 비어있고, `isLoginButtonEnabled`는 `false`여야 함)
  2. `username`과 `password`가 입력됨에 따라 `isLoginButtonEnabled` 상태가 올바르게 바뀌는가?
  3. `login()` 메서드를 호출했을 때, 성공/실패 시나리오에 따라 `errorMessage`가 올바르게 업데이트되는가?

이 시나리오들을 테스트 코드로 옮겨보자.

테스트 코드: `LoginViewModelTests.swift`


import XCTest
import Combine
@testable import YourAppName

class LoginViewModelTests: XCTestCase {

    var viewModel: LoginViewModel!
    var cancellables: Set<AnyCancellable>!

    override func setUpWithError() throws {
        // Arrange (공통 준비)
        viewModel = LoginViewModel()
        cancellables = []
    }

    override func tearDownWithError() throws {
        viewModel = nil
        cancellables = nil
    }

    // 1. 초기 상태 테스트
    func test_initialState_isCorrect() {
        // Assert
        XCTAssertEqual(viewModel.username, "")
        XCTAssertEqual(viewModel.password, "")
        XCTAssertFalse(viewModel.isLoginButtonEnabled)
        XCTAssertNil(viewModel.errorMessage)
    }

    // 2. 로그인 버튼 활성화 로직 테스트
    func test_loginButtonEnabled_whenBothFieldsAreFilled() {
        // Arrange
        let expectation = XCTestExpectation(description: "isLoginButtonEnabled should become true")
        
        // isLoginButtonEnabled가 true로 바뀌면 expectation을 충족시킨다.
        viewModel.$isLoginButtonEnabled
            .dropFirst() // 초기값 false는 무시
            .sink { isEnabled in
                if isEnabled {
                    expectation.fulfill()
                }
            }
            .store(in: &cancellables)
        
        // Act
        viewModel.username = "some_user"
        viewModel.password = "some_password"
        
        // Assert
        // 1초 동안 expectation이 충족되기를 기다린다.
        wait(for: [expectation], timeout: 1.0)
    }
    
    func test_loginButtonDisabled_whenOneFieldIsEmpty() {
        // Arrange
        viewModel.username = "some_user"
        
        // Act
        viewModel.password = "" // 비밀번호를 비운다.
        
        // Assert
        // Combine의 @Published는 비동기적으로 업데이트되므로, 약간의 딜레이를 주고 확인한다.
        // (더 좋은 방법은 아래 비동기 테스트에서!)
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
            XCTAssertFalse(self.viewModel.isLoginButtonEnabled)
        }
    }

    // 3. 로그인 로직 테스트
    func test_login_withValidCredentials_clearsErrorMessage() {
        // Arrange
        viewModel.username = "test"
        viewModel.password = "password"
        
        // Act
        viewModel.login()
        
        // Assert
        XCTAssertNil(viewModel.errorMessage)
    }
    
    func test_login_withInvalidCredentials_setsErrorMessage() {
        // Arrange
        viewModel.username = "wrong_user"
        viewModel.password = "wrong_password"
        
        // Act
        viewModel.login()
        
        // Assert
        XCTAssertNotNil(viewModel.errorMessage)
        XCTAssertEqual(viewModel.errorMessage, "아이디 또는 비밀번호가 잘못되었습니다.")
    }
}
    

⚠️ 잠깐! Combine과 비동기 테스트

위 `test_loginButtonEnabled_...` 테스트에서 `XCTestExpectation`이라는 낯선 친구가 보이지? SwiftUI와 Combine을 사용하면 `@Published` 프로퍼티의 값 변경이 즉시 일어나지 않고, 다음 런루프(Run Loop)에서 비동기적으로 처리될 때가 많아.

그래서 "값이 바뀔 때까지 기다려줘!"라고 알려주는 장치가 필요한데, 그게 바로 `XCTestExpectation`이야.

  1. `XCTestExpectation(description: ...)`으로 기대 조건을 만든다.
  2. 값이 바뀌는 것을 감지하는 `sink` 클로저 안에서, 원하는 조건이 충족되면 `expectation.fulfill()`을 호출한다.
  3. `wait(for: [expectation], timeout: ...)`으로 일정 시간 동안 `fulfill()`이 호출되기를 기다린다. 타임아웃 시간 내에 호출되지 않으면 테스트는 실패!

비동기 코드를 테스트하는 건 조금 까다롭지만, 이 `XCTestExpectation`만 잘 이해하면 대부분 해결할 수 있어.

TDD: 코드를 짜기 전에 실패부터 하라?

지금까지 우리는 이미 만들어진 코드를 '검증'하는 방식으로 테스트를 작성했어. 이걸 'Test-Last Development'라고 부를 수 있겠지.

그런데, 순서를 완전히 뒤집어서 **테스트를 먼저 작성하고, 그 테스트를 통과시키기 위한 코드를 나중에 작성하는** 개발 방식이 있어. 바로 **TDD(Test-Driven Development, 테스트 주도 개발)**야.

"아니, 코드가 없는데 어떻게 테스트를 짜?" 라는 생각이 들지? TDD는 아주 단순하고 강력한 사이클을 따라.

TDD Cycle: Red-Green-Refactor RED 실패하는 테스트를 작성한다 GREEN 테스트를 통과시키는 코드를 작성한다 REFACTOR 코드를 리팩토링한다 (테스트는 유지) 1. Write a Test 2. Write Code & Refactor
  1. **RED**: 먼저 **실패하는** 테스트를 작성한다. 아직 기능 코드가 없으니 당연히 실패하겠지? 컴파일 에러가 나도 괜찮아. 이게 바로 우리가 구현해야 할 기능의 '요구사항'이 되는 거야.
  2. **GREEN**: 이제 방금 작성한 테스트를 **통과시킬 최소한의 코드**를 작성한다. 예쁘게 짤 필요 없어. 일단 돌아가게만 만들면 돼. 목표는 오직 '빨간불'을 '초록불'로 바꾸는 것!
  3. **REFACTOR**: 테스트가 초록불이 되면, 안심하고 코드 개선 작업(리팩토링)을 시작한다. 중복 코드를 제거하고, 변수 이름을 바꾸고, 구조를 개선하는 등... 이때 중요한 건, **리팩토링을 하는 동안에도 테스트는 계속 초록불을 유지해야 한다는 것!** 테스트가 있으니 과감하게 코드를 바꿀 수 있는 자신감이 생기는 거지.

이 Red-Green-Refactor 사이클을 계속 반복하면서 기능을 하나씩 완성해 나가는 게 TDD의 핵심이야.

TDD로 FizzBuzz 문제 풀어보기

코딩 인터뷰 단골 문제인 FizzBuzz를 TDD로 풀어보자.

**요구사항:** 숫자를 입력받아서, 3의 배수면 "Fizz", 5의 배수면 "Buzz", 3과 5의 공배수면 "FizzBuzz", 그 외에는 그냥 숫자를 문자열로 반환하는 함수를 만들어라.

1단계: RED - 가장 간단한 케이스부터!

아무것도 아닌 숫자(예: 1)를 넣으면 그냥 그 숫자가 나와야 해.


// FizzBuzzTests.swift
func test_say_withNumber1_returns1() {
    // Arrange
    let fizzBuzz = FizzBuzz() // 아직 FizzBuzz 클래스는 없어! 컴파일 에러 -> RED 상태
    
    // Act
    let result = fizzBuzz.say(1) // say 메서드도 없어! -> RED 상태
    
    // Assert
    XCTAssertEqual(result, "1")
}
    

이 코드를 치면 Xcode는 `FizzBuzz`도, `say`도 모르겠다고 화를 낼 거야. 완벽한 RED 상태!

2단계: GREEN - 최소한의 코드로 통과시키기

이제 저 테스트를 통과시킬 최소한의 코드를 짜보자.


// FizzBuzz.swift
class FizzBuzz {
    func say(_ number: Int) -> String {
        return "1" // 일단 하드코딩!
    }
}
    

이렇게 하고 테스트를 돌리면? `fizzBuzz.say(1)`은 "1"을 반환하고, `XCTAssertEqual("1", "1")`은 참이니까 테스트가 통과돼! GREEN!

3단계: REFACTOR - 지금은 리팩토링할 게...

코드가 너무 단순해서 아직 리팩토링할 건 없네. 다음 단계로!

다시 1단계: RED - 다음 케이스 추가

이번엔 3을 넣으면 "Fizz"가 나와야 해.


// FizzBuzzTests.swift
func test_say_withNumber3_returnsFizz() {
    // Arrange
    let fizzBuzz = FizzBuzz()
    
    // Act
    let result = fizzBuzz.say(3)
    
    // Assert
    XCTAssertEqual(result, "Fizz")
}
    

이 테스트를 추가하고 돌리면? `say(3)`은 여전히 "1"을 반환하므로 테스트는 실패! 다시 RED!

다시 2단계: GREEN - 두 번째 테스트 통과시키기

이제 `say` 메서드를 좀 더 똑똑하게 만들어야 해.


// FizzBuzz.swift
class FizzBuzz {
    func say(_ number: Int) -> String {
        if number == 3 {
            return "Fizz"
        }
        return String(number) // 하드코딩을 실제 로직으로 변경
    }
}
    

이렇게 바꾸고 모든 테스트(`test_say_withNumber1...`과 `test_say_withNumber3...`)를 돌리면? 둘 다 통과! GREEN!

이런 식으로 5("Buzz"), 15("FizzBuzz") 케이스를 하나씩 추가하고, Red-Green-Refactor 사이클을 돌다 보면 어느새 FizzBuzz 기능이 완성되어 있을 거야.

TDD의 장점은 뭘까?

  • **설계 개선**: 테스트하기 쉬운 코드를 짜다 보면 자연스럽게 역할과 책임이 명확한, 결합도가 낮은 코드를 설계하게 돼.
  • **자신감**: 모든 기능에 대한 테스트가 있으니, 리팩토링이나 기능 추가 시에 코드를 망가뜨릴 걱정이 줄어들어.
  • **살아있는 문서**: 테스트 코드 자체가 해당 기능의 요구사항이자 사용법을 보여주는 명확한 문서가 돼.

TDD는 처음엔 좀 답답하고 느리게 느껴질 수 있어. 하지만 익숙해지면 오히려 개발 속도를 높이고 코드의 품질을 극적으로 향상시키는 강력한 무기가 될 거야.

의존성과의 싸움: Mock과 Stub이라는 용병을 고용하라

현실 세계의 코드는 `Calculator`나 `FizzBuzz`처럼 혼자서 모든 일을 처리하지 않아. 대부분 다른 객체들과 협력해서 일을 처리하지. 예를 들면,

  • `UserManager`는 `ApiService`를 통해 서버에서 사용자 정보를 가져온다.
  • `PurchaseViewModel`은 `DatabaseService`에 구매 내역을 저장한다.
  • `AnalyticsManager`는 `Logger`를 이용해 로그를 남긴다.

이런 경우 `UserManager`를 테스트하려고 할 때 문제가 생겨. `ApiService`가 실제로 네트워크 통신을 해버리면?

  • 테스트가 네트워크 상태에 따라 성공/실패한다. (불안정)
  • 테스트가 느려진다.
  • 서버 API 비용이 발생할 수도 있다.
  • 서버가 다운되면 테스트를 할 수 없다.

우리가 테스트하고 싶은 건 오직 `UserManager`의 로직이지, `ApiService`의 네트워크 통신 능력이 아니야. **테스트는 다른 외부 요인으로부터 '격리(Isolated)'되어야 해.**

이 문제를 해결하기 위해 '가짜 객체'를 만들어 실제 객체 대신 사용하는 기법이 있어. 이런 가짜 객체들을 통틀어 **테스트 더블(Test Double)**이라고 불러. 스턴트 배우(Stunt Double)처럼, 위험한 일을 대신해주는 거지.

테스트 더블에는 여러 종류가 있지만, 가장 대표적인 두 용병, **Stub**과 **Mock**에 대해 알아보자.

Stub (스텁): 정해진 대답만 하는 앵무새

**스텁**은 미리 정해진 '가짜' 데이터를 반환하는 단순한 객체야. 테스트 대상 객체가 외부 의존성(dependency)의 메서드를 호출하면, 스텁은 실제 로직을 수행하는 대신 그냥 우리가 준비해둔 값을 툭 던져줘.

예를 들어, `ApiService`의 `fetchUser(id:)` 메서드를 테스트한다고 해보자. 우리는 이 메서드가 성공했을 때와 실패했을 때 `UserManager`가 어떻게 동작하는지 보고 싶어.

1. 프로토콜로 의존성 분리하기

스텁을 사용하려면, `UserManager`가 `ApiService`라는 구체적인 클래스가 아니라, 추상적인 **프로토콜**에 의존하도록 만드는 게 핵심이야. 이걸 **의존성 역전 원칙(Dependency Inversion Principle)**이라고 해.


// YourAppName/ApiService.swift

// 1. 프로토콜 정의
protocol ApiServiceProtocol {
    func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void)
}

struct User { let name: String }

// 2. 실제 네트워크 통신을 하는 클래스
class ApiService: ApiServiceProtocol {
    func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void) {
        // 실제 URLSession 네트워크 요청 코드...
        // ...
    }
}

// 3. UserManager는 구체적인 ApiService가 아닌, ApiServiceProtocol에 의존한다.
class UserManager {
    private let apiService: ApiServiceProtocol
    var user: User?
    var error: Error?
    
    init(apiService: ApiServiceProtocol) {
        self.apiService = apiService
    }
    
    func loadUser(id: String) {
        apiService.fetchUser(id: id) { [weak self] result in
            switch result {
            case .success(let user):
                self?.user = user
            case .failure(let error):
                self?.error = error
            }
        }
    }
}
    

2. Stub 객체 만들기

이제 테스트를 위한 가짜 `ApiService`인 `ApiServiceStub`을 만들 거야. 이 녀석은 실제 네트워크 통신 없이, 우리가 원하는 결과를 즉시 반환해 줄 거야.


// YourAppNameTests/ApiServiceStub.swift

@testable import YourAppName
import Foundation

// ApiServiceProtocol을 채택한 가짜 객체
class ApiServiceStub: ApiServiceProtocol {
    
    // 이 스텁이 반환할 결과를 미리 정해둔다.
    var fetchUserResult: Result<User, Error>!
    
    func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void) {
        // 실제 네트워크 요청 대신, 미리 준비된 결과를 completion으로 전달한다.
        completion(fetchUserResult)
    }
}
    

3. Stub을 이용해 테스트하기

이제 `UserManagerTests`에서 실제 `ApiService` 대신 `ApiServiceStub`을 주입해서 테스트할 수 있어.


// YourAppNameTests/UserManagerTests.swift
import XCTest
@testable import YourAppName

class UserManagerTests: XCTestCase {

    func test_loadUser_onSuccess_setsUser() {
        // Arrange (준비)
        let stub = ApiServiceStub()
        let userToReturn = User(name: "Test User")
        // 성공 시나리오: 스텁이 성공 결과를 반환하도록 설정
        stub.fetchUserResult = .success(userToReturn)
        
        let userManager = UserManager(apiService: stub)
        
        // Act (실행)
        userManager.loadUser(id: "123")
        
        // Assert (검증)
        XCTAssertNotNil(userManager.user)
        XCTAssertEqual(userManager.user?.name, "Test User")
        XCTAssertNil(userManager.error)
    }
    
    func test_loadUser_onFailure_setsError() {
        // Arrange (준비)
        let stub = ApiServiceStub()
        enum TestError: Error { case networkFailed }
        // 실패 시나리오: 스텁이 실패 결과를 반환하도록 설정
        stub.fetchUserResult = .failure(TestError.networkFailed)
        
        let userManager = UserManager(apiService: stub)
        
        // Act (실행)
        userManager.loadUser(id: "456")
        
        // Assert (검증)
        XCTAssertNil(userManager.user)
        XCTAssertNotNil(userManager.error)
        XCTAssertTrue(userManager.error is TestError)
    }
}
    

어때? 스텁 덕분에 네트워크 상태와 상관없이 `UserManager`의 로직(성공 시 `user` 프로퍼티 설정, 실패 시 `error` 프로퍼티 설정)을 완벽하게 격리해서 테스트할 수 있게 됐지!

Mock (목): 호출 여부를 감시하는 스파이

**목 객체**는 스텁의 기능(미리 정해진 값을 반환)을 포함하면서, 한 가지 중요한 역할을 더 해. 바로 **'행위 검증(Behavior Verification)'**이야.

즉, "네가 이 메서드를 호출했니? 몇 번 호출했니? 어떤 파라미터로 호출했니?" 같은 것들을 기록하고 검증할 수 있는 스파이 같은 녀석이지.

예를 들어, 어떤 버튼을 눌렀을 때 로그를 남기는 `AnalyticsManager`가 제대로 `log` 메서드를 호출하는지 테스트하고 싶다고 해보자.


// Logger.swift
protocol LoggerProtocol {
    func log(event: String)
}

class Logger: LoggerProtocol {
    func log(event: String) {
        // 실제 로그를 서버로 보내거나 파일에 저장하는 로직
        print("Logged event: \(event)")
    }
}

// AnalyticsManager.swift
class AnalyticsManager {
    private let logger: LoggerProtocol
    
    init(logger: LoggerProtocol) {
        self.logger = logger
    }
    
    func userDidTapLoginButton() {
        // ... 다른 로직들 ...
        logger.log(event: "login_button_tapped")
    }
}
    

이때는 `log` 메서드가 반환하는 값이 없기 때문에 스텁만으로는 테스트하기 애매해. `log` 메서드가 '호출되었다'는 사실 자체가 중요하니까. 이럴 때 목 객체가 나서는 거야.


// LoggerMock.swift (in Tests target)
@testable import YourAppName

class LoggerMock: LoggerProtocol {
    
    // 스파이 변수들
    var loggedEvent: String?
    var logCallCount = 0
    
    func log(event: String) {
        // 실제 로직 대신, 호출 정보를 기록한다.
        loggedEvent = event
        logCallCount += 1
    }
}

// AnalyticsManagerTests.swift
import XCTest
@testable import YourAppName

class AnalyticsManagerTests: XCTestCase {

    func test_userDidTapLoginButton_callsLogger() {
        // Arrange
        let mockLogger = LoggerMock()
        let analyticsManager = AnalyticsManager(logger: mockLogger)
        
        // Act
        analyticsManager.userDidTapLoginButton()
        
        // Assert (행위 검증)
        XCTAssertEqual(mockLogger.logCallCount, 1, "log 메서드는 정확히 1번 호출되어야 합니다.")
        XCTAssertEqual(mockLogger.loggedEvent, "login_button_tapped", "로그 이벤트 이름이 올바르지 않습니다.")
    }
}
    

`LoggerMock`은 `log` 메서드가 호출될 때마다 호출 횟수(`logCallCount`)와 전달받은 파라미터(`loggedEvent`)를 자신의 프로퍼티에 저장해. 그리고 테스트의 Assert 단계에서 이 프로퍼티들을 확인해서 `AnalyticsManager`가 기대한 대로 동작했는지 검증하는 거지.

💡 Stub vs Mock, 언제 뭘 쓸까?

- **Stub**: 테스트 대상의 **'상태'**를 검증하고 싶을 때 사용. "어떤 메서드를 호출했더니, 객체의 프로퍼티가 이렇게 바뀌었나?"를 확인할 때. (State Verification)
- **Mock**: 테스트 대상의 **'행위'**를 검증하고 싶을 때 사용. "어떤 메서드를 호출했더니, 다른 객체의 메서드를 올바르게 호출했나?"를 확인할 때. (Behavior Verification)

사실 실무에서는 스텁과 목의 경계가 모호할 때도 많고, 두 가지 역할을 모두 하는 테스트 더블을 만들기도 해. 중요한 건 '왜' 테스트 더블을 쓰는지, 즉 **테스트를 격리시켜 예측 가능하고 안정적으로 만드는 것**이라는 본질을 이해하는 거야.

이런 의존성 관리나 테스트 더블 설계가 어렵게 느껴진다면, **재능넷** 같은 플랫폼에서 숙련된 시니어 개발자에게 코드 리뷰나 멘토링을 받아보는 것도 좋은 방법이야. 복잡한 아키텍처에 대한 고민을 함께 나누고 해결책을 찾을 수 있을 거야.

고급 스킬 & 베스트 프랙티스

이제 너는 단위 테스트의 기본기를 모두 갖췄어! 하지만 진짜 고수가 되려면 몇 가지 고급 기술과 좋은 습관들을 더 알아둬야 해.

코드 커버리지 (Code Coverage)

**코드 커버리지**는 네가 작성한 테스트 코드가 실제 앱 코드의 몇 퍼센트를 실행시켰는지를 나타내는 지표야. Xcode에서 아주 쉽게 확인할 수 있어.

`Product` > `Test` 메뉴를 누르기 전에 `Option` 키를 누르면 `Test`가 `Test with Coverage`로 바뀔 거야. 이걸 클릭하거나, 단축키 `Cmd + Shift + U`를 누르면 돼. 테스트가 끝나고 나면, 소스 코드 옆에 각 라인이 몇 번 실행됐는지 숫자가 표시되고, 실행되지 않은 라인은 빨간색으로 표시될 거야.

높은 코드 커버리지(보통 80% 이상)는 좋은 신호야. 그만큼 내 코드의 많은 부분이 테스트되고 있다는 뜻이니까. 하지만 여기에 함정이 있어.

**100% 커버리지가 100% 완벽한 테스트를 의미하지는 않아.** 코드가 '실행'되었다는 사실이 그 코드가 '올바르게' 동작한다는 걸 보장해주진 않거든. Assert가 부실하면 커버리지는 100%인데도 버그를 놓칠 수 있어. 커버리지는 유용한 참고 자료일 뿐, 맹신해서는 안 돼.

테스트는 빠르고, 독립적이고, 반복 가능해야 한다 (F.I.R.S.T 원칙)

좋은 단위 테스트가 갖춰야 할 조건들을 앞 글자를 따서 F.I.R.S.T 원칙이라고 불러.

  • **Fast (빠르게)**: 단위 테스트는 수백, 수천 개가 될 수 있어. 이게 느리다면 개발자들이 테스트 돌리기를 꺼리게 되겠지. 테스트는 빨라야 해. (그래서 네트워크나 DB 접근을 피하는 거야)
  • **Independent/Isolated (독립적으로/격리되어)**: 각 테스트는 서로에게 영향을 주면 안 돼. 한 테스트의 결과가 다른 테스트에 영향을 미치면 안 된다는 뜻. `setUp`과 `tearDown`을 사용해서 매번 깨끗한 환경에서 테스트를 시작하는 이유지.
  • **Repeatable (반복 가능하게)**: 테스트는 어떤 환경(내 컴퓨터, 동료 컴퓨터, CI 서버)에서 몇 번을 돌려도 항상 같은 결과를 내야 해.
  • **Self-Validating (스스로 검증하는)**: 테스트 결과는 `XCTAssert`를 통해 성공/실패가 명확하게 나와야 해. 로그를 눈으로 보고 결과를 판단해야 한다면 그건 좋은 테스트가 아니야.
  • **Timely (시기적절하게)**: TDD에서 강조하는 것처럼, 기능 코드와 거의 동시에, 혹은 그 이전에 작성하는 것이 가장 좋아. 나중에 한꺼번에 몰아서 쓰려고 하면 훨씬 더 힘들어.

UI 테스트 vs 단위 테스트

가끔 단위 테스트와 UI 테스트를 헷갈리는 경우가 있어. 둘은 목적이 완전히 달라.

  • **단위 테스트 (Unit Test)**: 코드의 논리적인 부분을 테스트. 눈에 보이지 않는 내부 로직(ViewModel, Service, Model 등)이 올바르게 동작하는지 확인. 빠르고 안정적.
  • **UI 테스트 (UI Test)**: 사용자의 관점에서 앱의 흐름을 테스트. "로그인 버튼을 누르면, 다음 화면으로 넘어간다" 같은 시나리오를 확인. 실제 앱을 실행시키기 때문에 느리고 깨지기 쉬움.

둘 다 중요하지만, 일반적으로는 **빠르고 안정적인 단위 테스트의 비중을 훨씬 높게 가져가는 것이 좋아.** (테스트 피라미드 이론)

마무리하며: 이제 당신도 '테스트하는 개발자'

와, 정말 긴 여정이었어! 여기까지 따라왔다면, 너는 이제 더 이상 테스트를 두려워하는 주니어가 아니야. 단위 테스트의 '왜'와 '어떻게'를 이해하고, 실전에 적용할 수 있는 든든한 기본기를 갖춘 거지.

단위 테스트는 단순히 버그를 줄여주는 걸 넘어, 우리에게 많은 선물을 줘.

  • 코드를 리팩토링할 수 있는 **용기**
  • 내 코드가 잘 돌아갈 것이라는 **자신감**
  • 미래에 발생할지 모를 버그에 대한 **안정감**
  • 동료와 협업할 때의 **신뢰감**

물론, 처음부터 모든 코드에 완벽한 테스트를 작성하기는 어려울 거야. 괜찮아! 오늘 당장, 네가 만든 가장 간단한 유틸리티 함수 하나부터 테스트를 추가해보는 건 어때? 작은 성공이 모여 큰 변화를 만드는 법이니까.

코드를 짜는 시간보다 테스트를 짜는 시간이 더 길어질 수도 있어. 하지만 기억해. 그렇게 아낀 시간은 나중에 버그를 잡고, 예상치 못한 사이드 이펙트를 해결하느라 썼을 시간보다 훨씬 값질 거야.

이제 너의 Xcode를 켜고, `Cmd + U`를 누를 준비가 되었기를 바라. 해피 코딩, 그리고 해피 테스팅! 🚀

만약 혼자서 이 모든 것을 적용하기 막막하다면, 재능 공유 플랫폼 **재능넷**에서 TDD나 클린 아키텍처 전문가의 도움을 받아보는 것도 성장을 위한 좋은 투자가 될 수 있을 거야. 함께 성장하는 개발자가 되자고!

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.