Swift로 시작하는 TDD(테스트 주도 개발) 🚀

안녕하세요, 개발자 여러분! 오늘은 Swift 언어를 사용하여 테스트 주도 개발(TDD)을 시작하는 방법에 대해 깊이 있게 알아보겠습니다. 이 글은 Swift 프로그래밍과 TDD의 기본 개념부터 실제 적용 방법까지 상세하게 다룰 예정이니, 편안히 자리에 앉아 함께 배워나가시죠! 🍎💻

TDD는 소프트웨어 개발 방법론 중 하나로, 테스트 코드를 먼저 작성한 후 실제 코드를 구현하는 방식입니다. 이 방법은 코드의 품질을 향상시키고, 버그를 줄이며, 리팩토링을 용이하게 만듭니다. Swift와 같은 현대적인 프로그래밍 언어에서 TDD를 적용하면, 더욱 견고하고 유지보수가 쉬운 애플리케이션을 만들 수 있습니다.

이 글에서는 Swift의 기본 문법부터 시작하여, XCTest 프레임워크를 이용한 단위 테스트 작성법, TDD의 핵심 원칙과 실제 적용 사례까지 다룰 예정입니다. 또한, 실제 프로젝트에 TDD를 도입할 때 발생할 수 있는 문제점과 그 해결 방안에 대해서도 논의하겠습니다.

재능넷의 '지식인의 숲' 메뉴에 등록될 이 글을 통해, 여러분은 Swift로 TDD를 실천하는 데 필요한 모든 지식과 기술을 습득하실 수 있을 것입니다. 그럼 지금부터 Swift와 TDD의 세계로 함께 떠나볼까요? 🌟

1. Swift 기초: TDD를 위한 준비 🏗️

TDD를 시작하기 전에, Swift 언어의 기본을 잘 이해하고 있어야 합니다. 여기서는 Swift의 주요 특징과 문법을 간단히 살펴보겠습니다.

1.1 Swift 언어 특징

• 안전성: 옵셔널, 타입 추론 등을 통한 안전한 코딩
• 현대성: 함수형 프로그래밍, 프로토콜 지향 프로그래밍 지원
• 성능: LLVM 컴파일러를 통한 최적화된 성능
• 가독성: 간결하고 명확한 문법

1.2 기본 문법

Swift의 기본 문법을 간단히 살펴보겠습니다.

// 변수와 상수
var myVariable = 42
let myConstant = 50

// 옵셔널
var optionalString: String? = "Hello"

// 조건문
if myVariable > 40 {
    print("Greater than 40")
} else {
    print("Less than or equal to 40")
}

// 반복문
for i in 1...5 {
    print(i)
}

// 함수
func greet(name: String) -> String {
    return "Hello, \(name)!"
}

// 클래스
class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

// 구조체
struct Point {
    var x: Int
    var y: Int
}

// 열거형
enum Direction {
    case north, south, east, west
}

1.3 Swift의 객체지향 프로그래밍

Swift는 강력한 객체지향 프로그래밍을 지원합니다. 클래스, 상속, 프로토콜 등의 개념을 이해하고 있어야 합니다.

// 프로토콜
protocol Flyable {
    func fly()
}

// 클래스와 상속
class Bird {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class Eagle: Bird, Flyable {
    func fly() {
        print("\(name) is soaring through the sky!")
    }
}

let eagle = Eagle(name: "American Eagle")
eagle.fly()

1.4 함수형 프로그래밍

Swift는 함수형 프로그래밍 패러다임도 지원합니다. 고차 함수, 클로저 등의 개념을 이해하고 활용할 수 있어야 합니다.

// 고차 함수 예제
let numbers = [1, 2, 3, 4, 5]
let squared = numbers.map { $0 * $0 }
print(squared) // [1, 4, 9, 16, 25]

// 클로저
let greeting = { (name: String) -> String in
    return "Hello, \(name)!"
}
print(greeting("Swift")) // Hello, Swift!

이러한 Swift의 기본 개념들을 잘 이해하고 있다면, TDD를 시작할 준비가 된 것입니다. 다음 섹션에서는 XCTest 프레임워크를 사용하여 실제로 테스트 코드를 작성하는 방법을 알아보겠습니다. 🧠💡

2. XCTest: Swift의 테스트 프레임워크 🧪

XCTest는 Apple에서 제공하는 테스트 프레임워크로, Swift 프로젝트에서 단위 테스트와 성능 테스트를 작성하는 데 사용됩니다. TDD를 실천하기 위해서는 XCTest를 능숙하게 다룰 수 있어야 합니다.

2.1 XCTest 기본 구조

XCTest를 사용한 테스트 클래스의 기본 구조는 다음과 같습니다:

import XCTest

class MyTests: XCTestCase {
    
    override func setUp() {
        super.setUp()
        // 각 테스트 메서드 실행 전에 호출됨
    }
    
    override func tearDown() {
        // 각 테스트 메서드 실행 후에 호출됨
        super.tearDown()
    }
    
    func testExample() {
        // 실제 테스트 코드
    }
    
    func testPerformanceExample() {
        measure {
            // 성능을 측정할 코드
        }
    }
}

2.2 주요 XCTest 어서션

XCTest는 다양한 어서션(assertion) 메서드를 제공합니다. 이를 통해 예상 결과와 실제 결과를 비교할 수 있습니다.

• XCTAssert(_:_:file:line:): 조건이 참인지 확인
• XCTAssertEqual(_:_:_:file:line:): 두 값이 같은지 확인
• XCTAssertNotEqual(_:_:_:file:line:): 두 값이 다른지 확인
• XCTAssertNil(_:_:file:line:): 값이 nil인지 확인
• XCTAssertNotNil(_:_:file:line:): 값이 nil이 아닌지 확인
• XCTAssertTrue(_:_:file:line:): 표현식이 true인지 확인
• XCTAssertFalse(_:_:file:line:): 표현식이 false인지 확인
• XCTAssertThrowsError(_:_:file:line:): 표현식이 에러를 throw하는지 확인

2.3 XCTest 사용 예제

간단한 계산기 클래스를 테스트하는 예제를 통해 XCTest의 사용법을 알아보겠습니다.

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

// CalculatorTests.swift
import XCTest
@testable import MyApp

class CalculatorTests: XCTestCase {
    
    var calculator: Calculator!
    
    override func setUp() {
        super.setUp()
        calculator = Calculator()
    }
    
    override func tearDown() {
        calculator = nil
        super.tearDown()
    }
    
    func testAddition() {
        // Given
        let a = 5
        let b = 3
        
        // When
        let result = calculator.add(a, b)
        
        // Then
        XCTAssertEqual(result, 8, "Addition of \(a) and \(b) should be 8")
    }
    
    func testSubtraction() {
        // Given
        let a = 10
        let b = 7
        
        // When
        let result = calculator.subtract(a, b)
        
        // Then
        XCTAssertEqual(result, 3, "Subtraction of \(b) from \(a) should be 3")
    }
}

2.4 테스트 커버리지

테스트 커버리지는 코드의 어느 부분이 테스트되었는지를 나타내는 지표입니다. Xcode에서는 테스트 커버리지를 쉽게 확인할 수 있습니다.

1. Edit Scheme > Test > Options에서 "Gather coverage data" 옵션을 활성화합니다.
2. 테스트를 실행한 후, Report navigator에서 커버리지 리포트를 확인할 수 있습니다.

높은 테스트 커버리지를 유지하는 것이 TDD의 중요한 목표 중 하나입니다.

2.5 비동기 테스트

Swift에서는 비동기 코드를 테스트하기 위한 방법도 제공합니다.

func testAsyncOperation() {
    let expectation = XCTestExpectation(description: "Async operation")
    
    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
        // 비동기 작업 수행
        expectation.fulfill()
    }
    
    wait(for: [expectation], timeout: 2.0)
}

이렇게 XCTest 프레임워크를 활용하면, Swift 프로젝트에서 효과적으로 단위 테스트를 작성하고 실행할 수 있습니다. 다음 섹션에서는 이러한 XCTest를 바탕으로 실제 TDD를 어떻게 적용하는지 알아보겠습니다. 🧪🔬

3. TDD의 기본 원칙과 사이클 🔄

테스트 주도 개발(TDD)은 소프트웨어 개발 방법론 중 하나로, 테스트를 먼저 작성하고 그 테스트를 통과하는 코드를 구현하는 방식입니다. TDD의 핵심 원칙과 사이클을 이해하는 것은 Swift로 TDD를 실천하는 데 매우 중요합니다.

3.1 TDD의 3가지 법칙

로버트 마틴(Robert C. Martin)은 TDD의 세 가지 법칙을 다음과 같이 정의했습니다:

1. 실패하는 단위 테스트를 작성하기 전에는 제품 코드를 작성하지 않는다.
2. 컴파일은 실패하지 않으면서 실행이 실패하는 정도로만 단위 테스트를 작성한다.
3. 현재 실패하는 테스트를 통과할 정도로만 실제 코드를 작성한다.

3.2 Red-Green-Refactor 사이클

TDD는 일반적으로 "Red-Green-Refactor" 사이클을 따릅니다:

1. Red: 실패하는 테스트 작성
2. Green: 테스트를 통과하는 최소한의 코드 작성
3. Refactor: 중복을 제거하고 코드를 개선

3.3 TDD의 장점

• 높은 코드 품질: 테스트를 먼저 작성함으로써 코드의 품질이 향상됩니다.
• 회귀 방지: 기존 기능에 대한 자동화된 테스트로 회귀를 방지할 수 있습니다.
• 설계 개선: 테스트를 먼저 작성하면 더 나은 설계를 유도할 수 있습니다.
• 문서화: 테스트 자체가 코드의 동작을 설명하는 문서 역할을 합니다.
• 리팩토링 용이성: 테스트가 있어 리팩토링을 자신 있게 할 수 있습니다.

3.4 TDD 실천 팁

1. 작은 단위로 시작하세요: 큰 기능을 작은 단위로 나누어 접근하세요.
2. 테스트를 먼저 작성하세요: 구현보다 테스트를 먼저 작성하는 습관을 들이세요.
3. 실패하는 테스트를 즐기세요: 실패하는 테스트는 진전의 신호입니다.
4. 리팩토링을 두려워하지 마세요: 테스트가 있으니 자신 있게 리팩토링하세요.
5. 지속적으로 실행하세요: 테스트를 자주 실행하여 피드백을 빠르게 받으세요.

3.5 TDD와 FIRST 원칙

좋은 단위 테스트는 FIRST 원칙을 따릅니다:

• Fast: 테스트는 빠르게 실행되어야 합니다.
• Independent: 각 테스트는 독립적이어야 합니다.
• Repeatable: 테스트는 어떤 환경에서도 반복 가능해야 합니다.
• Self-validating: 테스트는 스스로 성공/실패를 판단할 수 있어야 합니다.
• Timely: 테스트는 적시에 작성되어야 합니다(제품 코드 이전에).

이러한 TDD의 기본 원칙과 사이클을 이해하고 실천하면, Swift 프로젝트에서 더 나은 코드를 작성할 수 있습니다. 다음 섹션에서는 실제 Swift 프로젝트에 TDD를 적용하는 방법을 자세히 알아보겠습니다. 🧭🏃‍♂️

4. Swift 프로젝트에 TDD 적용하기 🛠️

이제 Swift 프로젝트에 TDD를 실제로 적용하는 방법을 살펴보겠습니다. 간단한 투두 리스트 앱을 예로 들어 TDD 과정을 단계별로 설명하겠습니다.

4.1 프로젝트 설정

먼저 Xcode에서 새 프로젝트를 생성합니다. 'Single View App'을 선택하고, 프로젝트 이름을 'SwiftTodoTDD'라고 지정합니다. 'Include Unit Tests'를 체크하여 XCTest 프레임워크를 포함시킵니다.

4.2 첫 번째 테스트 작성

Todo 아이템을 나타내는 구조체를 만들기 전에, 먼저 테스트를 작성합니다.

// TodoTests.swift
import XCTest
@testable import SwiftTodoTDD

class TodoTests: XCTestCase {
    func testTodoItem() {
        let todo = TodoItem(title: "Buy milk", isCompleted: false)
        XCTAssertEqual(todo.title, "Buy milk")
        XCTAssertFalse(todo.isCompleted)
    }
}

이 테스트는 아직 존재하지 않는 TodoItem 구조체를 사용하고 있으므로 컴파일되지 않을 것입니다. 이것이 TDD의 "Red" 단계입니다.

4.3 최소한의 구현

이제 테스트를 통과시키기 위한 최소한의 코드를 작성합니다.

// TodoItem.swift
struct TodoItem {
    let title: String
    let isCompleted: Bool
}

이제 테스트를 실행하면 통과할 것입니다. 이것이 "Green" 단계입니다.

4.4 기능 확장 및 리팩토링

Todo 아이템의 완료 상태를 변경하는 기능을 추가해 보겠습니다. 먼저 테스트를 작성합니다.

func testToggleCompletion() {
    var todo = TodoItem(title: "Buy milk", isCompleted: false)
    todo.toggleCompletion()
    XCTAssertTrue(todo.isCompleted)
    todo.toggleCompletion()
    XCTAssertFalse(todo.isCompleted)
}

이 테스트를 통과시키기 위해 TodoItem 구조체를 수정합니다.

struct TodoItem {
    let title: String
    var isCompleted: Bool
    
    mutating func toggleCompletion() {
        isCompleted.toggle()
    }
}

이제 테스트가 통과할 것입니다. 필요하다면 코드를 리팩토링할 수 있습니다. 이것이 "Refactor" 단계입니다.

4.5 Todo 리스트 관리

이제 여러 Todo 아이템을 관리하는 TodoList 클래스를 만들어 보겠습니다. 먼저 테스트를 작성합니다.

class TodoListTests: XCTestCase {
    func testAddTodo() {
        var list = TodoList()
        list.add(title: "Buy milk")
        XCTAssertEqual(list.todos.count, 1)
        XCTAssertEqual(list.todos[0].title, "Buy milk")
    }
    
    func testRemoveTodo() {
        var list = TodoList()
        list.add(title: "Buy milk")
        list.add(title: "Walk the dog")
        list.remove(at: 0)
        XCTAssertEqual(list.todos.count, 1)
        XCTAssertEqual(list.todos[0].title, "Walk the dog")
    }
}

이제 이 테스트를 통과시키는 TodoList 클래스를 구현합니다.

class TodoList {
    var todos: [TodoItem] = []
    
    func add(title: String) {
        let todo = TodoItem(title: title, isCompleted: false)
        todos.append(todo)
    }
    
    func remove(at index: Int) {
        todos.remove(at: index)
    }
}

4.6 UI 테스트

TDD는 UI 레벨에서도 적용할 수 있습니다. XCTest의 UI 테스팅 기능을 사용하여 UI 요소를 테스트할 수 있습니다.

class TodoUITests: XCTestCase {
    func testAddTodoUI() {
        let app = XCUIApplication()
        app.launch()
        
        app.textFields["Enter todo"].tap()
        app.textFields["Enter todo"].typeText("Buy milk")
        app.buttons["Add"].tap()
        
        XCTAssert(app.staticTexts["Buy milk"].exists)
    }
}

이 테스트를 통과시키기 위해서는 실제 UI를 구현해야 합니다. 스토리보드나 SwiftUI를 사용하여 UI를 만들고, 필요한 IBAction과 IBOutlet을 연결합니다.

4.7 비동기 작업 테스트

실제 앱에서는 네트워크 요청 같은 비동기 작업이 자주 발생합니다. 이러한 비동기 작업도 TDD로 테스트할 수 있습니다.

func testAsyncTodoFetch() {
    let expectation = XCTestExpectation(description: "Fetch todos")
    
    TodoAPI.fetchTodos { todos in
        XCTAssertFalse(todos.isEmpty)
        expectation.fulfill()
    }
    
    wait(for: [expectation], timeout: 5.0)
}

이 테스트를 통과시키기 위해 TodoAPI 클래스를 구현해야 합니다.

4.8 모의 객체(Mock) 사용

외부 의존성이 있는 코드를 테스트할 때는 모의 객체를 사용할 수 있습니다.

protocol TodoAPIProtocol {
    func fetchTodos(completion: @escaping ([TodoItem]) -> Void)
}

class MockTodoAPI: TodoAPIProtocol {
    func fetchTodos(completion: @escaping ([TodoItem]) -> Void) {
        let mockTodos = [
            TodoItem(title: "Mock todo 1", isCompleted: false),
            TodoItem(title: "Mock todo 2", isCompleted: true)
        ]
        completion(mockTodos)
    }
}

class TodoViewModelTests: XCTestCase {
    func testFetchTodos() {
        let mockAPI = MockTodoAPI()
        let viewModel = TodoViewModel(api: mockAPI)
        
        let expectation = XCTestExpectation(description: "Fetch todos")
        
        viewModel.fetchTodos {
            XCTAssertEqual(viewModel.todos.count, 2)
            expectation.fulfill()
        }
        
        wait(for: [expectation], timeout: 1.0)
    }
}

이러한 방식으로 Swift 프로젝트에 TDD를 적용할 수 있습니다. 작은 단위의 테스트부터 시작하여 점진적으로 기능을 확장해 나가면, 견고하고 유지보수가 쉬운 코드를 작성할 수 있습니다. 다음 섹션에서는 TDD를 실제 프로젝트에 도입할 때 발생할 수 있는 문제점과 해결 방안에 대해 알아보겠습니다. 🏗️👨‍💻

5. TDD 도입 시 발생할 수 있는 문제점과 해결 방안 🚧

TDD는 많은 이점을 제공하지만, 실제 프로젝트에 도입할 때 여러 가지 어려움에 직면할 수 있습니다. 이 섹션에서는 Swift 프로젝트에 TDD를 적용할 때 발생할 수 있는 주요 문제점과 그 해결 방안에 대해 알아보겠습니다.

5.1 학습 곡선

문제점: TDD는 기존의 개발 방식과 다르기 때문에 팀원들이 적응하는 데 시간이 걸릴 수 있습니다.

해결 방안:

• 점진적 도입: 작은 프로젝트나 특정 모듈부터 TDD를 시작하세요.
• 페어 프로그래밍: TDD 경험이 있는 개발자와 그렇지 않은 개발자가 함께 작업하도록 합니다.
• 교육 및 워크샵: 정기적인 TDD 교육 세션을 진행합니다.

5.2 시간 투자

문제점: 초기에는 TDD가 개발 속도를 늦출 수 있습니다.

해결 방안:

• 장기적 관점: TDD의 장기적 이점(버그 감소, 유지보수 용이성)을 팀과 이해관계자에게 설명합니다.
• 점진적 개선: 시간이 지남에 따라 TDD 스킬이 향상되고 속도가 빨라질 것임을 인식합니다.
• 자동화: CI/CD 파이프라인에 테스트를 통합하여 전체적인 개발 프로세스를 최적화합니다.

5.3 레거시 코드

문제점: 기존의 테스트되지 않은 레거시 코드에 TDD를 적용하기 어려울 수 있습니다.

해결 방안:

• 점진적 리팩토링: 새로운 기능을 추가하거나 버그를 수정할 때 해당 부분에 대한 테스트를 작성합니다.
• 특성 테스트: 레거시 코드의 현재 동작을 캡처하는 특성 테스트를 작성합니다.
• 의존성 주입: 레거시 코드를 테스트 가능한 구조로 리팩토링합니다.

5.4 복잡한 의존성

문제점: Core Data, 네트워크 요청 등 복잡한 의존성이 있는 코드를 테스트하기 어려울 수 있습니다.

해결 방안:

• 의존성 주입: 인터페이스를 사용하여 의존성을 추상화하고 주입합니다.
• 모의 객체 사용: 복잡한 의존성을 모의 객체로 대체합니다.
• 테스트 더블: Stub, Spy, Fake 등 다양한 테스트 더블을 활용합니다.

protocol DataStoreProtocol {
    func fetchTodos() -> [TodoItem]
    func saveTodo(_ todo: TodoItem)
}

class MockDataStore: DataStoreProtocol {
    var todos: [TodoItem] = []
    
    func fetchTodos() -> [TodoItem] {
        return todos
    }
    
    func saveTodo(_ todo: TodoItem) {
        todos.append(todo)
    }
}

class TodoManagerTests: XCTestCase {
    func testSaveTodo() {
        let mockDataStore = MockDataStore()
        let todoManager = TodoManager(dataStore: mockDataStore)
        
        todoManager.addTodo(title: "Test Todo")
        
        XCTAssertEqual(mockDataStore.todos.count, 1)
        XCTAssertEqual(mockDataStore.todos[0].title, "Test Todo")
    }
}

5.5 UI 테스트의 어려움

문제점: UI 테스트는 종종 불안정하고 시간이 오래 걸릴 수 있습니다.

해결 방안:

• 단위 테스트 최대화: 가능한 많은 로직을 UI에서 분리하여 단위 테스트로 커버합니다.
• UI 테스트 자동화: XCTest UI 테스팅 프레임워크를 활용합니다.
• 스냅샷 테스트: FBSnapshotTestCase 같은 라이브러리를 사용하여 UI 변경을 감지합니다.

5.6 테스트 유지보수

문제점: 테스트 코드도 유지보수가 필요하며, 때로는 테스트 자체가 개발의 걸림돌이 될 수 있습니다.

해결 방안:

• 테스트 코드 리팩토링: 제품 코드와 마찬가지로 테스트 코드도 정기적으로 리팩토링합니다.
• 테스트 가독성 향상: 명확한 테스트 이름과 구조를 사용합니다.
• 테스트 헬퍼 함수: 반복되는 테스트 로직을 헬퍼 함수로 추출합니다.

extension XCTestCase {
    func assertTodoEqual(_ todo1: TodoItem, _ todo2: TodoItem, file: StaticString = #file, line: UInt = #line) {
        XCTAssertEqual(todo1.title, todo2.title, file: file, line: line)
        XCTAssertEqual(todo1.isCompleted, todo2.isCompleted, file: file, line: line)
    }
}

class TodoTests: XCTestCase {
    func testTodoEquality() {
        let todo1 = TodoItem(title: "Buy milk", isCompleted: false)
        let todo2 = TodoItem(title: "Buy milk", isCompleted: false)
        assertTodoEqual(todo1, todo2)
    }
}

5.7 과도한 모의 객체 사용

문제점: 모의 객체를 과도하게 사용하면 실제 시스템과 동떨어진 테스트가 될 수 있습니다.

해결 방안:

• 통합 테스트 병행: 단위 테스트와 함께 통합 테스트도 작성합니다.
• 실제 객체 사용: 가능한 경우 실제 객체를 사용합니다.
• 계약 테스트: 모의 객체와 실제 객체가 동일하게 동작하는지 확인하는 계약 테스트를 작성합니다.

5.8 테스트 커버리지에 대한 집착

문제점: 높은 테스트 커버리지만을 목표로 하다 보면 의미 없는 테스트를 작성할 수 있습니다.

해결 방안:

• 질적 평가: 단순히 커버리지 수치가 아닌 테스트의 품질을 평가합니다.
• 중요 로직 집중: 핵심 비즈니스 로직에 대한 테스트에 집중합니다.
• 테스트 전략 수립: 프로젝트의 특성에 맞는 테스트 전략을 수립합니다.

이러한 문제점들을 인식하고 적절한 해결 방안을 적용함으로써, Swift 프로젝트에서 TDD를 보다 효과적으로 실천할 수 있습니다. TDD는 단순한 기술이 아니라 하나의 개발 철학이며, 팀의 문화와 프로세스에 녹아들어야 합니다. 지속적인 학습과 개선을 통해 TDD의 이점을 최대한 활용할 수 있을 것입니다. 🌟🔧

6. Swift에서의 TDD 모범 사례 및 팁 💡

이제 Swift에서 TDD를 적용할 때 유용한 모범 사례와 팁들을 살펴보겠습니다. 이를 통해 더 효과적으로 TDD를 실천하고, 높은 품질의 코드를 작성할 수 있습니다.

6.1 테스트 구조화

테스트 코드를 잘 구조화하면 가독성과 유지보수성이 향상됩니다.

• Given-When-Then 패턴 사용
• 설명적인 테스트 이름 사용
• 각 테스트는 하나의 동작만 검증

func testMarkTodoAsCompleted() {
    // Given
    var todo = TodoItem(title: "Buy milk", isCompleted: false)
    
    // When
    todo.markAsCompleted()
    
    // Then
    XCTAssertTrue(todo.isCompleted)
}

6.2 테스트 가독성 향상

가독성 높은 테스트는 문서의 역할도 수행합니다.

• 커스텀 매처 사용
• 테스트 컨텍스트를 명확히 설명
• 의미 있는 상수 이름 사용

func testTodoListFilterCompletedItems() {
    // Given
    let todoList = TodoList()
    let milk = TodoItem(title: "Buy milk", isCompleted: true)
    let eggs = TodoItem(title: "Buy eggs", isCompleted: false)
    todoList.add(milk)
    todoList.add(eggs)
    
    // When
    let completedItems = todoList.filterCompleted()
    
    // Then
    XCTAssertEqual(completedItems.count, 1)
    XCTAssertTrue(completedItems.contains { $0.title == "Buy milk" })
}

6.3 테스트 데이터 관리

테스트 데이터를 효율적으로 관리하면 테스트 작성과 유지보수가 쉬워집니다.

• 팩토리 메서드 사용
• 테스트 데이터 분리
• 랜덤 데이터 생성기 활용

extension TodoItem {
    static func fixture(
        title: String = "Default Todo",
        isCompleted: Bool = false
    ) -> TodoItem {
        return TodoItem(title: title, isCompleted: isCompleted)
    }
}

func testCompleteTodo() {
    let todo = TodoItem.fixture(title: "Buy groceries")
    todo.complete()
    XCTAssertTrue(todo.isCompleted)
}

6.4 비동기 테스트 작성

Swift의 비동기 프로그래밍 모델을 고려한 테스트 작성이 필요합니다.

• XCTestExpectation 활용
• async/await 사용 (iOS 13 이상)
• 타임아웃 설정

func testAsyncTodoFetch() async throws {
    let todoService = TodoService()
    let todos = try await todoService.fetchTodos()
    XCTAssertFalse(todos.isEmpty)
}

6.5 의존성 주입 활용

의존성 주입을 통해 테스트 가능한 코드를 작성합니다.

• 프로토콜 기반 설계
• 생성자 주입 사용
• 테스트용 의존성 제공

protocol TodoRepositoryProtocol {
    func fetchTodos() -> [TodoItem]
    func saveTodo(_ todo: TodoItem)
}

class TodoViewModel {
    private let repository: TodoRepositoryProtocol
    
    init(repository: TodoRepositoryProtocol) {
        self.repository = repository
    }
    
    func loadTodos() -> [TodoItem] {
        return repository.fetchTodos()
    }
}

class MockTodoRepository: TodoRepositoryProtocol {
    var todos: [TodoItem] = []
    
    func fetchTodos() -> [TodoItem] {
        return todos
    }
    
    func saveTodo(_ todo: TodoItem) {
        todos.append(todo)
    }
}

func testTodoViewModelLoadTodos() {
    let mockRepository = MockTodoRepository()
    mockRepository.todos = [TodoItem.fixture(), TodoItem.fixture()]
    
    let viewModel = TodoViewModel(repository: mockRepository)
    let loadedTodos = viewModel.loadTodos()
    
    XCTAssertEqual(loadedTodos.count, 2)
}

6.6 테스트 더블 활용

다양한 테스트 더블을 활용하여 복잡한 시나리오를 테스트합니다.

• Stub: 미리 준비된 답변을 제공
• Mock: 예상된 동작을 검증
• Spy: 호출 정보를 기록

class TodoServiceSpy: TodoServiceProtocol {
    var fetchTodosCalled = false
    var fetchTodosCallCount = 0
    
    func fetchTodos() -> [TodoItem] {
        fetchTodosCalled = true
        fetchTodosCallCount += 1
        return [TodoItem.fixture()]
    }
}

func testViewModelFetchesTodosOnlyOnce() {
    let serviceSpy = TodoServiceSpy()
    let viewModel = TodoViewModel(service: serviceSpy)
    
    viewModel.loadTodos()
    viewModel.loadTodos()
    
    XCTAssertTrue(serviceSpy.fetchTodosCalled)
    XCTAssertEqual(serviceSpy.fetchTodosCallCount, 1)
}

6.7 테스트 커버리지 모니터링

테스트 커버리지를 모니터링하되, 맹목적으로 따르지 않습니다.

• Xcode의 코드 커버리지 도구 활용
• 중요 비즈니스 로직에 대한 커버리지 우선
• 커버리지 리포트를 CI/CD 파이프라인에 통합

6.8 성능 테스트 작성

성능 테스트를 통해 코드의 효율성을 검증합니다.

func testTodoListSortPerformance() {
    let todoList = TodoList()
    for _ in 1...1000 {
        todoList.add(TodoItem.fixture())
    }
    
    measure {
        _ = todoList.sortByTitle()
    }
}

6.9 UI 테스트 자동화

UI 테스트를 자동화하여 사용자 시나리오를 검증합니다.

• XCUITest 프레임워크 활용
• 페이지 객체 패턴 적용
• 접근성 식별자 활용

class TodoListUITests: XCTestCase {
    var app: XCUIApplication!
    
    override func setUp() {
        super.setUp()
        continueAfterFailure = false
        app = XCUIApplication()
        app.launch()
    }
    
    func testAddNewTodo() {
        let newTodoTextField = app.textFields["newTodoTextField"]
        newTodoTextField.tap()
        newTodoTextField.typeText("Buy groceries")
        
        app.buttons["addTodoButton"].tap()
        
        XCTAssertTrue(app.staticTexts["Buy groceries"].exists)
    }
}

6.10 지속적인 리팩토링

테스트를 기반으로 지속적으로 코드를 개선합니다.

• 중복 코드 제거
• 테스트 헬퍼 함수 추출
• 테스트 코드도 제품 코드만큼 중요하게 관리

이러한 모범 사례와 팁들을 적용하면, Swift 프로젝트에서 TDD를 더욱 효과적으로 실천할 수 있습니다. TDD는 단순히 테스트를 먼저 작성하는 것이 아니라, 전체적인 개발 프로세스와 코드 품질을 향상시키는 방법론임을 항상 기억하세요. 지속적인 학습과 실천을 통해 TDD의 진정한 가치를 경험할 수 있을 것입니다. 🚀📚