Ver2.5 iOS 앱 테스팅: XCTest 프레임워크 완전 정복 🚀

iOS 앱 테스팅: XCTest 프레임워크 완전 정복 🚀
버그와 작별하고 싶은 모든 iOS 개발자들을 위한 필독서!
내 앱의 퀄리티를 수직 상승시키는 XCTest의 모든 것을 파헤쳐봅니다.
👋 들어가며: "테스트, 그거 꼭 해야 돼?"
안녕! 코딩의 세계에 발을 들인 우리 동료 개발자 친구들. 오늘도 스위프트한 하루 보내고 있어? ☀️
앱 하나를 뚝딱 만들어내고 나면 세상을 다 가진 것 같은 기분이 들지. 스토어에 올리고, 사용자들이 다운받고... 상상만 해도 짜릿하잖아.
그런데 말이야, 우리가 공들여 만든 앱이 사용자의 손에서 어이없이 튕겨버린다면? 특정 버튼만 누르면 앱이 얼어버린다면? 상상만 해도 아찔하지. 😱
사용자는 뒤도 안 돌아보고 앱을 삭제할 거고, 별점 1점과 함께 무시무시한 리뷰를 남길지도 몰라. "이 앱은 제 인생의 낭비였습니다." 같은...
이런 대참사를 막아주는 우리들의 수호천사가 바로 '테스트'야.
"아, 테스트... 그거 귀찮은 거 아니야? 기능 개발할 시간도 없는데..." 라고 생각했다면, 오늘 이 글을 끝까지 읽어봐. 생각이 180도 바뀔 테니까.
테스트는 귀찮은 추가 업무가 아니라, 미래의 나를 구원해 줄 타임머신이자, 내 앱의 퀄리티를 보장하는 '품질 보증서' 같은 거야. 마치 튼튼한 건물을 짓기 전에 설계도를 꼼꼼히 검토하고, 자재 하나하나의 강도를 시험해보는 것과 같지. 기초가 튼튼해야 높은 빌딩을 올릴 수 있는 것처럼, 탄탄한 테스트 코드는 내 앱을 더 높고 안정적인 곳으로 이끌어줄 거야.
특히 iOS 개발에서는 Apple이 우리에게 아주 강력한 무기를 쥐여줬어. 바로 XCTest 프레임워크! Xcode에 내장되어 있어서 별도의 설치도 필요 없고, 사용법도 직관적이라서 우리 같은 앱 개발자들에게는 정말 축복 같은 존재지.
이 글에서는 XCTest라는 무기를 어떻게 갈고 닦아서 사용해야 하는지, 아주 기초적인 개념부터 실전에서 써먹을 수 있는 고급 스킬까지, 친구한테 설명해주듯 쉽고 재미있게 알려줄게. 이 글이 끝날 때쯤이면, 당신도 '테스트'라는 단어에 자신감이 붙고, 버그를 두려워하지 않는 단단한 개발자로 성장해 있을 거야.
자, 그럼 이제 버그 없는 앱을 향한 여정, 함께 떠나볼까? 🚀
🤔 XCTest 프레임워크, 너 정체가 뭐니?
좋아, 테스트의 중요성은 알겠어. 그럼 XCTest는 대체 뭘까? 이름부터 뭔가 'X'가 들어가서 특별해 보이는데... 맞아, 특별해! Apple 생태계의 테스트를 책임지는 공식 프레임워크니까.
XCTest는 Xcode에 통합된 테스트 프레임워크로, 우리가 만든 앱의 코드 단위(Unit)나 사용자 인터페이스(UI)가 예상대로 정확하게 동작하는지 검증할 수 있게 해주는 도구 모음이야. Swift와 Objective-C를 모두 지원하고, iOS, macOS, watchOS, tvOS 등 모든 Apple 플랫폼에서 사용할 수 있지. 한마디로 Apple 개발자들의 필수 교양이라고 할 수 있어.
XCTest의 핵심 구성원 삼대장 👑
XCTest를 이해하려면 먼저 이 세 친구와 친해져야 해. 바로 Test Target, XCTestCase, 그리고 Assertions이야.
1. 테스트 타겟 (Test Target)
Xcode 프로젝트를 만들 때, 'Include Tests' 체크박스를 본 적 있을 거야. 이걸 체크하면 `[프로젝트이름]Tests`와 `[프로젝트이름]UITests`라는 두 개의 폴더(정확히는 타겟)가 생기지.
- Unit Test Target: 우리 앱의 내부 로직, 즉 눈에 보이지 않는 코드의 작은 단위들(함수, 메서드, 클래스)을 테스트하는 코드가 사는 동네야. 계산기 앱의 '더하기' 기능이 정말로 1+1=2를 반환하는지 같은 걸 확인하는 곳이지.
- UI Test Target: 사용자가 앱 화면을 직접 누르고 스크롤하는 것처럼, 앱의 겉모습과 상호작용을 테스트하는 코드가 사는 동네야. '로그인' 버튼을 누르면 정말 다음 화면으로 넘어가는지 같은 걸 확인해.
이 타겟들은 우리 본체 앱(App Target)과는 별개로 존재해. 그래서 테스트 코드가 실제 앱의 성능에 영향을 주지 않고, 독립적으로 실행될 수 있는 거야. 똑똑하지? 😉
2. XCTestCase
`XCTestCase`는 테스트 케이스를 작성하기 위한 기본 설계도, 즉 '클래스'야. 우리는 이 클래스를 상속받아서 우리만의 테스트 클래스를 만들고, 그 안에 테스트 메서드들을 채워 넣게 돼.
테스트 메서드는 반드시 이름이 `test`로 시작해야 해. 예를 들면 `testLoginButtonTapped()` 처럼. Xcode는 이 `test` 접두사를 보고 "아, 이건 테스트해야 할 메서드구나!"라고 인식하고 실행시켜 줘.
import XCTest
@testable import MyApp // 중요! 내 앱 모듈을 가져와야 해
class LoginViewModelTests: XCTestCase {
// 테스트 클래스가 시작되기 전에 딱 한 번 호출돼.
override func setUpWithError() throws {
// 테스트에 필요한 초기 설정들을 여기에!
// 예를 들어, 테스트용 데이터베이스를 준비한다거나.
}
// 테스트 클래스가 끝나기 전에 딱 한 번 호출돼.
override func tearDownWithError() throws {
// 테스트가 끝나고 남은 찌꺼기들을 청소하는 곳!
// 예를 들어, 만들었던 테스트용 파일을 삭제한다거나.
}
// 각각의 test...() 메서드가 실행되기 *직전*에 호출돼.
func setUp() {
// 각 테스트 케이스에 필요한 공통 초기화 작업
}
// 각각의 test...() 메서드가 실행된 *직후*에 호출돼.
func tearDown() {
// 각 테스트 케이스가 남긴 상태를 정리
}
// 실제 테스트 코드!
func testExample() throws {
// 여기가 진짜 테스트 로직이 들어가는 곳이야.
}
// 성능을 측정하고 싶을 때 사용하는 테스트
func testPerformanceExample() throws {
self.measure {
// 성능을 측정하고 싶은 코드를 이 안에 넣어.
}
}
}
`setUp`과 `tearDown` 메서드들이 보이지? 이들은 각각의 테스트 메서드가 독립적이고 깨끗한 환경에서 실행될 수 있도록 도와주는 청소부 역할을 해. A 테스트가 B 테스트에 영향을 주면 안 되니까!
3. 단언 (Assertions)
테스트의 심장이야. 💖 "나는 A가 B와 같을 것이라고 단언한다!"라고 외치는 부분이지. 만약 내 단언이 사실이면 테스트는 통과(✅), 거짓이면 실패(❌)가 돼.
XCTest는 다양한 상황에 쓸 수 있는 풍부한 단언 함수들을 제공해. 이름만 봐도 뭘 하는지 감이 올 거야.
- `XCTAssert(expression, "message")`: `expression`이 참(true)인지 확인. 가장 기본!
- `XCTAssertTrue(expression, "message")`: 위와 동일. 이름이 더 명확할 뿐.
- `XCTAssertFalse(expression, "message")`: `expression`이 거짓(false)인지 확인.
- `XCTAssertEqual(expression1, expression2, "message")`: 두 값이 같은지 확인. (가장 많이 씀!)
- `XCTAssertNotEqual(expression1, expression2, "message")`: 두 값이 다른지 확인.
- `XCTAssertNil(expression, "message")`: 값이 nil인지 확인.
- `XCTAssertNotNil(expression, "message")`: 값이 nil이 아닌지 확인.
- `XCTFail("message")`: 그냥 무조건 테스트를 실패시킴. 특정 조건에 도달하면 안 될 때 사용.
이 단언들이 없다면, 테스트 코드는 그냥 실행만 되고 끝나는 아무 의미 없는 코드가 될 거야. 단언을 통해 우리는 코드의 동작이 '우리의 예상과 일치하는지'를 비로소 검증할 수 있게 되는 거지.
테스트의 황금률: Arrange-Act-Assert (AAA) 패턴
좋은 테스트 코드는 보통 세 부분으로 나뉘어. 바로 Arrange(준비), Act(실행), Assert(단언). 줄여서 AAA 패턴이라고 불러. 이건 거의 모든 테스트 코드의 불문율 같은 거니까 꼭 기억해둬!
코드로 보면 더 와닿을 거야.
func testAddition() {
// 1. Arrange (준비)
let calculator = Calculator() // 테스트할 객체 생성
let a = 5
let b = 10
let expectedResult = 15 // 예상 결과값 준비
// 2. Act (실행)
let actualResult = calculator.add(a, b) // 테스트할 메서드 호출
// 3. Assert (단언)
XCTAssertEqual(actualResult, expectedResult, "5 + 10은 15여야 합니다.")
}
어때? 코드가 훨씬 깔끔하고 이해하기 쉽지? 주석으로 `// given`, `// when`, `// then` 이라고 써주기도 해. 이 패턴을 따르면 "이 테스트가 뭘 하려는 거지?" 하고 헷갈릴 일이 거의 없어져.
자, 이제 XCTest의 기본 개념과 구조는 마스터했어. 운동하기 전에 스트레칭을 끝낸 셈이지. 다음 챕터부터는 진짜 근육을 키우러 가보자고! 유닛 테스트의 세계로 풍덩 빠져볼 준비 됐어? 💪
🎯 유닛 테스트 실전 돌입! (feat. TDD 맛보기)
이론은 충분해! 이제 직접 코드를 만져보며 유닛 테스트와 친해질 시간이야. 유닛 테스트(Unit Test)는 이름 그대로 코드의 가장 작은 '단위(Unit)'를 테스트하는 거야. 보통 함수나 메서드 하나가 그 단위가 되지. 건물로 치면 벽돌 하나하나가 규격에 맞게 잘 만들어졌는지 검사하는 것과 같아.
유닛 테스트의 가장 큰 장점은 빠르고, 격리된 환경에서 테스트할 수 있다는 점이야. 네트워크 통신이나 데이터베이스 같은 외부 요인에 의존하지 않기 때문에, 순수한 로직의 정합성만을 확인할 수 있지. 그래서 버그가 발생했을 때 원인을 찾기도 훨씬 쉬워.
실전 예제 1: 세상에서 제일 간단한 계산기 만들기
백문이 불여일견! 간단한 `Calculator` 클래스를 만들고, 이 친구의 기능을 유닛 테스트로 검증해볼게.
먼저, 우리 앱 타겟(App Target)에 `Calculator.swift` 파일을 만들자.
import Foundation
class Calculator {
func add(_ a: Int, _ b: Int) -> Int {
return a + b
}
func subtract(_ a: Int, _ b: Int) -> Int {
return a - b
}
// 일부러 버그를 심어놓은 곱셈 함수!
func multiply(_ a: Int, _ b: Int) -> Int {
return a + b // 앗! 곱셈인데 덧셈을 하고 있네?
}
func divide(_ a: Int, _ b: Int) -> Int? {
if b == 0 {
return nil // 0으로 나누는 것은 불가능!
}
return a / b
}
}
자, 이제 이 계산기가 제대로 작동하는지 확인해 볼 테스트 코드를 작성할 차례야. 테스트 타겟(`[프로젝트이름]Tests`)에 `CalculatorTests.swift` 파일을 만들어보자.
import XCTest
@testable import MyAwesomeApp // `@testable`을 붙여야 internal 멤버에도 접근 가능!
class CalculatorTests: XCTestCase {
var calculator: Calculator! // 테스트할 객체를 담을 변수
// 각 테스트 메서드가 실행되기 전에 호출돼.
// 여기서 calculator 객체를 새로 만들어주면, 모든 테스트가 깨끗한 상태에서 시작할 수 있어.
override func setUp() {
super.setUp()
calculator = Calculator()
}
// 각 테스트 메서드가 끝난 후에 호출돼.
// 메모리에서 객체를 해제해줘.
override func tearDown() {
calculator = nil
super.tearDown()
}
func testAddFunction() {
// Arrange
let num1 = 5
let num2 = 3
let expected = 8
// Act
let result = calculator.add(num1, num2)
// Assert
XCTAssertEqual(result, expected, "덧셈 결과가 예상과 다릅니다.")
}
func testSubtractFunction() {
// Arrange
let num1 = 10
let num2 = 4
// Act & Assert를 한번에!
XCTAssertEqual(calculator.subtract(num1, num2), 6, "뺄셈 결과가 올바르지 않습니다.")
}
func testMultiplyFunction_ShouldReturnCorrectProduct() { // 테스트 이름은 구체적일수록 좋아!
// Arrange
let num1 = 7
let num2 = 7
let expected = 49
// Act
let result = calculator.multiply(num1, num2)
// Assert
XCTAssertEqual(result, expected, "곱셈 결과가 49여야 하는데, 다른 값이 나왔어요!")
}
func testDivideFunction_WhenDividingByZero_ShouldReturnNil() {
// Arrange
let num1 = 10
let num2 = 0
// Act
let result = calculator.divide(num1, num2)
// Assert
XCTAssertNil(result, "0으로 나눌 경우 nil이 반환되어야 합니다.")
}
func testDivideFunction_WithValidNumbers_ShouldReturnCorrectQuotient() {
// Arrange
let num1 = 20
let num2 = 5
// Act
let result = calculator.divide(num1, num2)
// Assert
XCTAssertNotNil(result) // 우선 nil이 아닌지 확인하고
XCTAssertEqual(result, 4) // 그 다음에 값을 비교하는 것이 안전해.
}
}
이제 Xcode에서 다이아몬드 모양(◆)의 테스트 실행 버튼을 누르거나, 단축키 `Cmd + U`를 눌러서 테스트를 실행해보자.
결과는? 아마 `testMultiplyFunction...` 테스트에서 빨간색 ❌ 표시와 함께 실패가 뜰 거야. 로그를 보면 "XCTAssertEqual failed: ("14") is not equal to ("49") - 곱셈 결과가 49여야 하는데..." 라는 친절한 메시지가 보일 거야.
이걸 통해 우리는 `multiply` 함수에 버그가 있다는 사실을 아주 쉽고 빠르게 알아냈어! 이제 `Calculator.swift`로 돌아가서 `return a + b`를 `return a * b`로 고치고 다시 테스트를 돌려봐. 모든 테스트가 초록색 체크(✅) 표시와 함께 통과하는 아름다운 광경을 목격할 수 있을 거야. 🎉
실전 예제 2: 비동기 코드 테스트하기 (feat. XCTestExpectation)
현실 세계의 앱은 계산기처럼 단순하지 않아. 대부분 네트워크 통신을 통해 서버에서 데이터를 받아오지. 이런 비동기(Asynchronous) 코드는 테스트하기가 좀 더 까다로워. 왜냐하면 테스트 함수는 코드를 실행하고 바로 끝나버리는데, 네트워크 응답은 몇 초 뒤에 올 수도 있으니까.
이럴 때 사용하는 비장의 무기가 바로 `XCTestExpectation`이야. "나는 특정 작업이 완료될 것이라고 기대(Expect)한다!"라고 선언하고, 그 기대가 충족될 때까지 테스트가 기다리게 만드는 거지.
예를 들어, 포켓몬 정보를 API로 받아오는 `PokemonService`가 있다고 상상해보자.
import Foundation
struct Pokemon: Codable, Equatable {
let id: Int
let name: String
let height: Int
}
class PokemonService {
func fetchPokemon(id: Int, completion: @escaping (Result<Pokemon, Error>) -> Void) {
guard let url = URL(string: "https://pokeapi.co/api/v2/pokemon/\(id)") else {
// ... 에러 처리
return
}
URLSession.shared.dataTask(with: url) { data, response, error in
// ... 데이터 파싱 및 completion 핸들러 호출
// (실제 코드는 생략)
// 예시로 성공 케이스를 가정
DispatchQueue.main.asyncAfter(deadline: .now() + 1) { // 1초 딜레이 흉내
let dummyPokemon = Pokemon(id: id, name: "pikachu", height: 4)
completion(.success(dummyPokemon))
}
}.resume()
}
}
이 `fetchPokemon` 메서드를 어떻게 테스트할까? `XCTestExpectation`을 사용하면 돼!
import XCTest
@testable import MyAwesomeApp
class PokemonServiceTests: XCTestCase {
var service: PokemonService!
override func setUp() {
super.setUp()
service = PokemonService()
}
override func tearDown() {
service = nil
super.tearDown()
}
func testFetchPokemon_WhenRequestSucceeds_ShouldReturnPokemon() {
// Arrange
let pokemonId = 25 // 피카츄!
let expectedPokemon = Pokemon(id: 25, name: "pikachu", height: 4)
// 1. "기대"를 생성한다. 설명은 디버깅할 때 유용해.
let promise = expectation(description: "포켓몬 데이터를 성공적으로 받아와야 함")
var resultPokemon: Pokemon?
var resultError: Error?
// Act
service.fetchPokemon(id: pokemonId) { result in
switch result {
case .success(let pokemon):
resultPokemon = pokemon
case .failure(let error):
resultError = error
}
// 2. 기대했던 작업이 완료되면, fulfill()을 호출해서 "기대 충족!"을 알려준다.
promise.fulfill()
}
// 3. 최대 5초까지 기다린다. 5초 안에 promise.fulfill()이 호출되지 않으면 테스트는 실패!
wait(for: [promise], timeout: 5.0)
// Assert
XCTAssertNil(resultError)
XCTAssertEqual(resultPokemon, expectedPokemon)
}
}
위 코드의 흐름을 잘 봐.
- `expectation(description:)`으로 '기대' 객체(`promise`)를 만들어.
- 비동기 작업의 완료 클로저 안에서, 모든 작업이 끝났을 때 `promise.fulfill()`을 호출해.
- `wait(for:timeout:)`을 호출해서 `fulfill()`이 불릴 때까지 기다리게 해. `timeout` 시간 안에 `fulfill()`이 호출되지 않으면 테스트는 시간 초과로 실패 처리돼.
- 기다림이 끝나면, 비동기 작업의 결과(여기서는 `resultPokemon`)를 가지고 `Assert`를 수행하는 거야.
이렇게 하면 비동기 코드도 문제없이 테스트할 수 있어! 🤩
의존성 주입과 Mock 객체: 테스트의 진정한 친구
그런데 방금 위 `PokemonServiceTests`에는 한 가지 큰 문제가 있어. 바로 실제 네트워크 통신을 한다는 거야.
이게 왜 문제일까?
- 느리다: 실제 네트워크는 느리고, 테스트는 수백, 수천 개가 될 수 있어. 매번 기다릴 순 없지.
- 불안정하다: 내 와이파이가 끊기거나, 포켓몬 API 서버가 점검 중이면 테스트는 실패해. 내 코드의 문제가 아닌데도!
- 비용이 발생할 수 있다: 유료 API라면 테스트할 때마다 돈이 나갈 수도 있어.
그래서 우리는 '가짜 객체', 즉 Mock 객체를 만들어서 실제 네트워크 통신 부분을 대체할 거야. 이걸 가능하게 하려면 의존성 주입(Dependency Injection, DI)이라는 디자인 패턴을 사용해야 해. 말이 좀 어렵지? 쉽게 말해, 객체가 필요로 하는 다른 객체(의존성)를 외부에서 만들어서 넣어주는 거야.
먼저 프로토콜을 사용해서 `PokemonService`의 기능을 추상화해보자.
// ... Pokemon struct는 동일 ...
protocol PokemonServiceProtocol {
func fetchPokemon(id: Int, completion: @escaping (Result<Pokemon, Error>) -> Void)
}
// 실제 네트워크 통신을 하는 클래스는 이 프로토콜을 준수(conform)하게 만들어.
class PokemonService: PokemonServiceProtocol {
// ... fetchPokemon 메서드 구현은 동일 ...
}
이제 테스트를 위한 가짜 서비스, `MockPokemonService`를 만들자. 이 친구도 똑같이 `PokemonServiceProtocol`을 준수해야 해.
// ...
// 테스트용 가짜 서비스! 실제 네트워크 통신을 하지 않아.
class MockPokemonService: PokemonServiceProtocol {
// 이 Mock 객체가 반환할 결과를 미리 설정해둘 수 있는 변수
var fetchPokemonResult: Result<Pokemon, Error>?
func fetchPokemon(id: Int, completion: @escaping (Result<Pokemon, Error>) -> Void) {
if let result = fetchPokemonResult {
completion(result)
}
}
}
class PokemonViewModelTests: XCTestCase { // 이제 ViewModel을 테스트한다고 가정해보자
func testFetchPokemon_WhenSucceeds_UpdatesPokemonProperty() {
// Arrange
let mockService = MockPokemonService()
let expectedPokemon = Pokemon(id: 1, name: "bulbasaur", height: 7)
// Mock 객체에 성공 시나리오를 미리 주입!
mockService.fetchPokemonResult = .success(expectedPokemon)
// ViewModel에 실제 서비스가 아닌 Mock 서비스를 주입!
let viewModel = PokemonViewModel(service: mockService)
// Act
viewModel.fetchPokemon(id: 1)
// Assert
// (비동기가 아니므로 expectation이 필요 없어짐!)
XCTAssertEqual(viewModel.pokemon, expectedPokemon)
}
func testFetchPokemon_WhenFails_UpdatesErrorMessage() {
// Arrange
let mockService = MockPokemonService()
let expectedError = NSError(domain: "TestError", code: 123, userInfo: nil)
// Mock 객체에 실패 시나리오를 주입!
mockService.fetchPokemonResult = .failure(expectedError)
let viewModel = PokemonViewModel(service: mockService)
// Act
viewModel.fetchPokemon(id: 999)
// Assert
XCTAssertNotNil(viewModel.errorMessage)
XCTAssertEqual(viewModel.errorMessage, "에러가 발생했습니다: TestError")
}
}
이제 우리의 테스트는 더 이상 실제 네트워크에 의존하지 않아. ⚡️
- 엄청나게 빨라졌고,
- 인터넷 연결이나 외부 서버 상태와 상관없이 항상 동일한 결과를 보장하며,
- 성공 케이스와 실패 케이스를 내 마음대로 시뮬레이션할 수 있게 됐어!
이 의존성 주입과 Mock 객체 활용은 견고한 유닛 테스트의 핵심이야. 처음에는 좀 복잡해 보일 수 있지만, 한번 익숙해지면 테스트 코드의 퀄리티가 달라지는 걸 느낄 수 있을 거야. 이런 고급 테크닉에 대해 더 깊이 배우고 싶다면, 재능넷 같은 플랫폼에서 실무 경험이 풍부한 개발자 멘토에게 코칭을 받아보는 것도 성장에 큰 도움이 될 수 있어.
유닛 테스트, 이제 좀 감이 잡히지? 다음은 사용자의 입장에서 앱을 테스트하는 UI 테스트의 세계로 떠나보자! 🗺️
📱 UI 테스트, 사용자의 눈으로 앱을 보다
유닛 테스트가 앱의 내부 장기들을 하나하나 검사하는 '내과 진료'였다면, UI 테스트는 사용자의 눈과 손이 되어 앱의 겉모습과 행동을 확인하는 '외과 진료' 또는 '행동 관찰'에 가까워.
"로그인 버튼을 누르면, 정말 홈 화면으로 이동하는가?"
"회원가입 폼에 잘못된 이메일을 입력하면, 에러 메시지가 제대로 표시되는가?"
"다크 모드로 전환했을 때, 글자 색이 배경에 묻히지 않고 잘 보이는가?"
이런 것들을 코드로 자동화해서 테스트하는 게 바로 UI 테스트(User Interface Test)야. 유닛 테스트보다 실행 속도는 훨씬 느리지만, 앱의 핵심적인 사용자 플로우가 깨지지 않았는지 보장해주는 아주 중요한 역할을 하지. 특히 여러 화면과 기능이 복잡하게 얽혀있는 앱일수록 그 가치는 더욱 빛나. ✨
UI 테스트의 주인공: XCUIApplication & XCUIElement
UI 테스트를 하려면 두 명의 주인공을 알아야 해.
- `XCUIApplication`: 테스트 대상이 되는 우리 앱 그 자체를 의미하는 객체야. 앱을 실행(`launch()`)하거나 종료(`terminate()`)하는 등, 앱의 생명주기를 관리하는 역할을 해.
- `XCUIElement`: 화면에 보이는 모든 요소(버튼, 텍스트 필드, 레이블, 이미지 등)를 나타내는 객체야. 우리는 이 `XCUIElement`를 찾아서 탭(`tap()`)하거나, 텍스트를 입력(`typeText()`)하거나, 스와이프(`swipeUp()`)하는 등의 상호작용을 하게 돼.
마치 우리가 리모컨(`XCUIApplication`)으로 TV(`앱`)를 켜고, 채널 버튼이나 볼륨 버튼(`XCUIElement`)을 누르는 것과 비슷하다고 생각하면 쉬워.
import XCTest
class MyAwesomeAppUITests: XCTestCase {
func testExample() throws {
// UI 테스트는 실패하더라도 계속 진행하지 않도록 설정하는 것이 일반적이야.
continueAfterFailure = false
// 1. 앱을 실행한다.
let app = XCUIApplication()
app.launch()
// 2. 화면의 UI 요소를 찾는다.
let emailTextField = app.textFields["email_textfield"]
let passwordTextField = app.secureTextFields["password_textfield"]
let loginButton = app.buttons["login_button"]
// 3. UI 요소와 상호작용한다.
emailTextField.tap()
emailTextField.typeText("test@example.com")
passwordTextField.tap()
passwordTextField.typeText("password1234")
loginButton.tap()
// 4. 결과를 단언한다. (예: 홈 화면의 환영 메시지가 나타났는지 확인)
let welcomeLabel = app.staticTexts["welcome_message"]
XCTAssertTrue(welcomeLabel.exists)
}
}
그런데 여기서 궁금한 점이 생길 거야. `app.textFields["email_textfield"]` 같은 문자열은 대체 어디서 나오는 걸까? 내가 코드에 `id = "email_textfield"` 라고 설정한 적도 없는데 말이야.
바로 여기서 UI 테스트의 안정성을 좌우하는 가장 중요한 개념, Accessibility Identifier가 등장해.
안정적인 UI 테스트의 핵심: Accessibility Identifier
UI 테스트 코드가 화면 요소를 찾는 방법은 여러 가지가 있어. 예를 들어 `app.buttons["로그인"]`처럼 버튼에 표시된 텍스트로 찾을 수도 있지. 하지만 이건 아주 위험한 방법이야. 만약 디자이너가 " '로그인'보다 '시작하기'가 더 친근한 것 같아요!" 라고 해서 버튼 텍스트를 바꾸면? 우리의 테스트 코드는 곧바로 실패하게 될 거야. 😱
그래서 우리는 UI 요소에 주민등록번호처럼 고유하고 변하지 않는 식별자를 부여해야 해. 그것이 바로 'Accessibility Identifier'야.
스토리보드나 SwiftUI 코드에서 아주 간단하게 설정할 수 있어.
UIKit (스토리보드)에서 설정하기:
스토리보드에서 원하는 UI 요소(UILabel, UIButton 등)를 선택하고, 우측의 Identity Inspector(신분증 모양 아이콘) 탭으로 가봐. 'Accessibility' 섹션에 'Identifier'라는 입력 필드가 보일 거야. 여기에 고유한 ID를 적어주면 끝!
SwiftUI에서 설정하기:
SwiftUI에서는 `.accessibilityIdentifier()` 수정자(modifier)를 사용하면 돼.
import SwiftUI
struct LoginView: View {
@State private var email = ""
var body: some View {
VStack {
TextField("이메일", text: $email)
.accessibilityIdentifier("email_textfield") // 바로 여기!
Button("로그인") {
// 로그인 로직
}
.accessibilityIdentifier("login_button") // 여기도!
}
}
}
이렇게 식별자를 부여해두면, 나중에 버튼 텍스트가 '로그인'에서 'Let's Go!'로 바뀌든, 앱이 다른 언어(영어, 일본어 등)로 표시되든 상관없이 우리의 테스트 코드는 항상 꿋꿋하게 제 할 일을 할 수 있게 돼. UI 테스트를 제대로 하려면 Accessibility Identifier 설정은 선택이 아닌 필수라는 것, 꼭 기억해!
마법 같은 기능: UI 테스트 녹화 (Test Recorder)
"와... 근데 저런 코드를 일일이 다 손으로 쳐야 한다니, 너무 막막한데?" 라고 생각했다면, 걱정 마. Xcode에는 우리의 수고를 덜어줄 마법 같은 기능이 있으니까! 바로 UI 테스트 녹화 기능이야.
말 그대로, 내가 시뮬레이터에서 앱을 직접 조작하는 행동을 Xcode가 지켜보고 있다가 그대로 UI 테스트 코드로 옮겨 적어주는 기능이야. 백문이 불여일견, 한번 따라 해보자.
- UI 테스트 타겟에 새로운 테스트 메서드를 하나 만들어. 내용은 비워둬.
- 메서드 안쪽에 커서를 위치시켜.
- Xcode 창 하단에 있는 빨간색 녹화 버튼(●)을 눌러.
- 앱이 시뮬레이터에서 실행될 거야. 이제 평소처럼 앱을 사용해봐. 이메일을 입력하고, 비밀번호를 입력하고, 로그인 버튼을 누르고...
- 내가 하는 모든 행동이 실시간으로 Xcode 편집기 창에 코드로 생성되는 걸 볼 수 있을 거야! 🤯
- 원하는 시나리오 녹화가 끝나면, 다시 녹화 버튼을 눌러서 종료하면 돼.
이 녹화 기능을 활용하면 UI 테스트 작성에 대한 부담을 크게 줄일 수 있어. 처음에는 녹화 기능으로 시작해서 생성된 코드를 분석하며 `XCUIElement`를 다루는 법을 익히고, 점차 직접 코드를 작성하는 방식으로 나아가는 걸 추천해.
UI 테스트 실전 팁: 기다림의 미학
UI 테스트를 하다 보면 종종 '타이밍' 문제 때문에 테스트가 실패하는 경우가 있어. 예를 들어, 로그인 버튼을 누르고 다음 화면으로 넘어가는 데 네트워크 속도 때문에 2초가 걸린다고 해보자. 그런데 우리 테스트 코드는 버튼을 누르자마자 0.1초 만에 "다음 화면의 요소가 보여야 해!" 라고 확인해버리면, 아직 화면이 로딩 중이라서 테스트는 실패하게 되겠지.
이럴 때를 대비해 XCTest는 UI 요소를 기다려주는 똑똑한 메커니즘을 내장하고 있어.
func testLogin_Success() {
// ... (앱 실행 및 로그인 정보 입력) ...
app.buttons["login_button"].tap()
// 'welcome_message'라는 식별자를 가진 staticText가 나타날 때까지
// 기본 타임아웃(보통 몇 초) 동안 기다린다.
let welcomeLabel = app.staticTexts["welcome_message"]
// .exists는 요소가 나타날 때까지 기다렸다가 true/false를 반환해.
XCTAssertTrue(welcomeLabel.exists)
}
`welcomeLabel.exists`를 확인하는 저 한 줄의 코드에는 사실 '기다림'이 포함되어 있어. 무작정 "지금 당장 있어?" 라고 묻는 게 아니라, "혹시 나타날 거니? 몇 초만 기다려볼게" 라고 말하는 것과 같지.
하지만 때로는 더 명시적으로 기다림을 표현해야 할 때도 있어. 그럴 땐 `waitForExistence(timeout:)`을 사용할 수 있어.
func testProfileImage_LoadsAfterDelay() {
// ...
let profileImage = app.images["profile_image"]
// 10초 안에 profileImage가 나타나는 것을 기다린다.
// 10초가 지나도 나타나지 않으면 false를 반환하고, 테스트는 실패하게 된다.
let imageExists = profileImage.waitForExistence(timeout: 10)
XCTAssertTrue(imageExists, "프로필 이미지가 10초 내에 로드되지 않았습니다.")
}
이런 '기다림'의 기술을 잘 활용하면, 네트워크 딜레이나 애니메이션 같은 비동기적인 UI 이벤트 때문에 테스트가 간헐적으로 실패하는 'Flaky Test' 현상을 크게 줄일 수 있어. 안정적인 UI 테스트를 위한 필수 스킬이니 꼭 기억해둬!
자, 이제 우리는 앱의 속과 겉을 모두 테스트할 수 있는 능력을 갖추게 됐어. 하지만 여기서 멈추면 고수가 될 수 없지! 다음 챕터에서는 당신의 테스트 코드를 한 단계 더 업그레이드해 줄 XCTest의 고급 기능과 꿀팁들을 대방출할게. 기대해도 좋아! 😉
🚀 XCTest 고급 스킬 & 꿀팁 대방출
기본기를 탄탄히 다졌으니, 이제 남들보다 한 발 앞서나갈 수 있는 고급 기술들을 연마할 시간이야. 이 챕터에서 소개할 기능들은 당신의 테스트 프로세스를 더욱 효율적이고 전문적으로 만들어 줄 거야. 마치 게임에서 기본 무기만 쓰다가 레어 아이템을 장착하는 느낌이랄까? ⚔️
성능 테스트: 내 코드, 얼마나 빠를까? (Performance Testing)
"이 기능, 왠지 좀 느린 것 같은데...?" 라는 느낌을 받아본 적 없어? 사용자는 1초의 버벅임도 견디지 못해. 코드의 정확성만큼이나 '성능'도 중요해. XCTest에는 특정 코드 블록이 실행되는 데 걸리는 시간을 측정하고, 그 성능을 지속적으로 추적할 수 있는 강력한 기능이 있어. 바로 `measure` 블록이야.
사용법은 아주 간단해. `XCTestCase`를 만들 때 기본으로 생성되는 `testPerformanceExample()` 메서드를 기억해? 그 안에 있는 `self.measure { ... }` 클로저 안에 성능을 측정하고 싶은 코드를 넣기만 하면 돼.
class DataProcessingTests: XCTestCase {
func testLargeArraySortingPerformance() {
// Arrange: 테스트를 위한 대용량 데이터 준비
let largeUnsortedArray = (0..<10000).map { _ in Int.random(in: 0...100000) }
self.measure {
// Act: 성능을 측정하고 싶은 코드를 이 안에!
// 이 블록은 10번 반복 실행되며 평균 실행 시간을 측정해.
_ = largeUnsortedArray.sorted()
}
}
}
이 테스트를 처음 실행하고 나면, Xcode는 측정된 시간을 '기준선(Baseline)'으로 설정할 거냐고 물어봐. 'Set Baseline'을 클릭하면 이 시간이 기록돼. 그리고 앞으로 이 테스트를 실행할 때마다, 측정된 시간이 이 기준선보다 현저히 느려지면 Xcode는 테스트를 실패 처리하고 경고를 보내줘.
이게 왜 강력하냐면, 나도 모르게 추가한 코드가 앱의 성능을 갉아먹는 상황을 막아주기 때문이야. 예를 들어, 오늘 내가 수정한 로직 때문에 데이터 정렬 속도가 20%나 느려졌다면, 이 성능 테스트가 "잠깐! 이거 뭔가 이상한데?" 하고 바로 알려주는 거지. 성능 저하를 조기에 발견하고 예방할 수 있는 최고의 안전장치인 셈이야.
코드 커버리지: 내 테스트는 얼마나 꼼꼼할까? (Code Coverage)
테스트 코드를 열심히 짰는데, "내가 과연 빼놓은 부분 없이 테스트를 잘 하고 있는 걸까?" 라는 의문이 들 때가 있어. 이럴 때 참고할 수 있는 지표가 바로 코드 커버리지(Code Coverage)야.
코드 커버리지는 우리가 작성한 테스트 코드가 실제 앱의 코드를 얼마나 '커버'하는지, 즉 실행시키는지 백분율로 보여주는 지표야. 예를 들어 코드 커버리지가 85%라면, 내 앱의 전체 코드 중 85%가 테스트 중에 한 번 이상 실행되었다는 뜻이지.
활성화 방법:
Xcode에서 `Product` > `Scheme` > `Edit Scheme...` 메뉴로 들어가. (단축키: `Cmd + Shift + ,`)
왼쪽에서 `Test`를 선택하고, `Options` 탭으로 이동한 뒤, `Code Coverage` 체크박스를 켜주면 끝!
이제 테스트(`Cmd + U`)를 실행하고 나면, Report Navigator(`Cmd + 9`) 탭에서 방금 실행한 테스트 리포트를 볼 수 있어. 리포트를 클릭하고 `Coverage` 탭으로 이동하면 파일별, 함수별로 상세한 커버리지 정보를 확인할 수 있지. 심지어 소스 코드 편집기에서 테스트가 실행한 라인은 초록색으로, 실행하지 않은 라인은 빨간색으로 표시해주기도 해.
따라서 커버리지는 '내가 아직 테스트하지 않은 영역이 어디인가?'를 찾는 '탐색 도구'로 활용하는 것이 가장 바람직해. "어? 이 `if`문의 `else` 블록은 왜 커버가 안 됐지? 아, 에러 상황에 대한 테스트를 빼먹었구나!" 와 같이 말이야.
테스트 계획: 상황에 맞게 테스트하기 (Test Plans)
앱이 복잡해지다 보면, 다양한 환경에서 테스트를 실행해야 할 필요가 생겨.
- 앱의 언어를 영어로 설정하고 UI 테스트를 돌려보고 싶을 때
- 특정 기능을 켜고 끄는 'Launch Argument'를 전달해서 테스트하고 싶을 때
- 메모리 진단 도구(Sanitizer)를 켠 상태로 테스트를 돌려보고 싶을 때
예전에는 이런 설정들을 매번 Scheme에서 바꿔줘야 해서 번거로웠어. 하지만 이제는 테스트 계획(Test Plans) 기능 덕분에 이런 다양한 테스트 구성을 체계적으로 관리할 수 있게 됐지.
테스트 계획 생성하기:
`Product` > `Scheme` > `Edit Scheme...` 메뉴에서 `Test` 액션을 선택하고, 하단의 'Convert to use Test Plans...' 버튼을 누르면 `.xctestplan` 파일이 생성돼.
이 `.xctestplan` 파일을 열어보면, 다양한 테스트 구성을 추가하고 각각의 설정(Arguments, Options, Localizations 등)을 다르게 지정할 수 있어.
예를 들어, 'Default' 구성 외에 'Localization_German'이라는 구성을 새로 만들고, 'Application Language'를 독일어로 설정해두면, 이제부터는 테스트 네비게이터에서 원하는 테스트 계획을 선택하기만 하면 해당 설정으로 테스트가 실행돼. 정말 편리하지?
팀원들과 공유하기도 쉽고, 특히 나중에 설명할 CI/CD 환경에서 특정 구성의 테스트만 실행하도록 명령할 수 있어서 확장성도 매우 뛰어나.
CI/CD 와의 연동: 자동화의 끝판왕
CI/CD는 'Continuous Integration(지속적 통합)'과 'Continuous Deployment(지속적 배포)'의 약자야. 개발자가 코드를 원격 저장소(예: GitHub)에 푸시할 때마다, 자동으로 빌드, 테스트, 배포 과정을 실행해주는 시스템을 말해.
우리가 지금까지 배운 XCTest는 바로 이 CI/CD 파이프라인의 핵심적인 부분이야. 새로운 코드가 기존의 기능을 망가뜨리지 않았는지 자동으로 검증해주는 '문지기' 역할을 하거든.
CI/CD 서버(GitHub Actions, Jenkins, Bitrise 등)는 터미널 명령어를 통해 Xcode 프로젝트를 다루는데, 이때 `xcodebuild`라는 커맨드라인 도구를 사용해.
# 터미널에서 아래 명령어를 실행하면,
# MyAwesomeApp 프로젝트의 MyAwesomeAppScheme에 대해
# iPhone 14 Pro 시뮬레이터에서 테스트를 실행한다.
xcodebuild test \
-project MyAwesomeApp.xcodeproj \
-scheme MyAwesomeApp \
-destination 'platform=iOS Simulator,name=iPhone 14 Pro,OS=16.2'
이 명령어를 CI/CD 스크립트에 넣어두면, 이제부터는 코드를 푸시할 때마다 서버가 알아서 테스트를 실행하고, 만약 테스트가 하나라도 실패하면 즉시 개발자에게 알림을 보내고 배포를 중단시켜. 덕분에 버그가 있는 버전이 사용자에게 전달되는 끔찍한 사태를 원천적으로 막을 수 있게 되는 거지.
우리가 열심히 작성한 테스트 코드가 이렇게 자동화 시스템의 일부가 되어 24시간 내내 우리 앱의 품질을 지켜주는 모습을 상상해봐. 정말 든든하지 않아? 🤖
이처럼 XCTest는 단순히 버그를 찾는 도구를 넘어, 성능을 관리하고, 테스트 범위를 시각화하며, 팀의 개발 프로세스 전체를 자동화하고 안정화하는 데까지 기여하는 매우 강력한 프레임워크야.
🎉 마무리하며: 버그 없는 앱을 향한 여정
와, 정말 긴 여정이었어! 여기까지 함께 달려온 당신, 정말 대단해. 👏
이제 '테스트'라는 단어를 들으면 더 이상 막막하거나 귀찮은 기분 대신, "아, 내 앱을 더 단단하게 만들어 줄 친구!" 라는 생각이 들지 않아?
우리는 오늘 XCTest의 기본 개념부터 시작해서, 앱의 심장인 로직을 검증하는 유닛 테스트, 사용자의 경험을 보장하는 UI 테스트, 그리고 테스트의 효율과 깊이를 더해주는 고급 스킬들까지, XCTest 프레임워크의 거의 모든 것을 맛봤어.
기억해줘. 테스트 코드를 작성하는 것은 결코 시간을 낭비하는 일이 아니야. 오히려 미래에 버그를 수정하느라 낭비할 수많은 시간을 절약해주는 가장 현명한 투자야. 테스트는 우리에게 다음과 같은 자신감을 선물해줘.
- 리팩토링에 대한 자신감: "이 코드를 더 효율적으로 바꿔도 괜찮을까?" 걱정할 필요 없어. 테스트가 지켜보고 있으니까!
- 새로운 기능 추가에 대한 자신감: 새로운 코드가 기존 기능을 망가뜨렸다면, 테스트가 바로 알려줄 거야.
- 배포에 대한 자신감: 모든 테스트를 통과한 빌드는 적어도 우리가 예상한 범위 내에서는 안정적으로 동작할 거라는 믿음을 줘.
물론, 오늘 배운 내용이 전부는 아니야. 테스트의 세계는 더 깊고 넓어서, 테스트 더블(Test Double)의 종류, 스냅샷 테스팅(Snapshot Testing), BDD(Behavior-Driven Development) 등 더 파고들 주제들이 많아.
하지만 가장 중요한 건 '시작하는 것'이야. 오늘 당장 당신의 프로젝트에 돌아가서, 아주 작은 기능 하나에 대한 유닛 테스트라도 추가해보는 건 어떨까? 처음에는 어색하고 시간이 걸리겠지만, 그 작은 한 걸음이 당신을 더 뛰어난 개발자로 만들어 줄 거야.
만약 혼자서 이 길을 가는 것이 막막하게 느껴진다면, 주변의 동료 개발자들과 스터디를 하거나 지식을 공유하는 것도 좋은 방법이야. 때로는 전문가의 도움이 필요할 수도 있지. 그럴 땐 재능넷과 같은 재능 공유 플랫폼에서 경험 많은 시니어 개발자에게 코드 리뷰나 멘토링을 요청해보는 것도 당신의 성장에 엄청난 부스터가 되어줄 수 있어.
테스트는 목적지가 아니라, 더 나은 소프트웨어를 향한 끊임없는 여정이야. 이 여정에서 XCTest는 당신의 가장 든든한 동반자가 되어줄 거야.
이제, 버그와는 작별 인사를 고하고, 자신감 넘치는 코딩을 시작할 시간이야! Happy Testing! 🥳
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.