Ver3.0 ๐งช ์ค์ํํธ ํ ์คํ ๊ณผ XCTest๋ฅผ ํ์ฉํ ๋จ์ยทํตํฉยทUI ํ ์คํธ ์๋ฒฝ ๊ฐ์ด๋

๐งช ์ค์ํํธ ํ ์คํ ๊ณผ XCTest๋ฅผ ํ์ฉํ ๋จ์ยทํตํฉยทUI ํ ์คํธ ์๋ฒฝ ๊ฐ์ด๋
์น๊ตฌ์ฒ๋ผ ์ฝ๊ฒ ๋ฐฐ์ฐ๋ iOS ์ฑ ํ ์คํธ์ ๋ชจ๋ ๊ฒ
๐ฏ ์ ํ ์คํธ๊ฐ ํ์ํ ๊น? ๊ฐ๋ฐ์์ ์์ ๋ง
์๋ ! ์ค๋์ iOS ๊ฐ๋ฐ์๋ผ๋ฉด ๊ผญ ์์์ผ ํ ํ ์คํ ์ ๋ํด ์ด์ผ๊ธฐํด๋ณผ๊ฒ. ํน์ ์ฝ๋ ์์ ํ๋ค๊ฐ ์ฑ์ด ํฐ์ ธ์ ์์๋ ํ๋ฆฐ ๊ฒฝํ ์์ด? ๐ ๋๋ ์ฒ์์ "๋ด ์ฝ๋๋ ์๋ฒฝํด!"๋ผ๊ณ ์๊ฐํ๋๋ฐ, ์ค์ ๋ก ์ฌ์ฉ์๋ค์ด ์ฐ๋ค ๋ณด๋ฉด ์์์น ๋ชปํ ๋ฒ๊ทธ๊ฐ ํ์ด๋์ค๋๋ผ๊ณ .
ํ ์คํธ๋ ๋ง์น ์์ ๋ฒจํธ ๊ฐ์ ๊ฑฐ์ผ. ์ฐจ๋ฅผ ์ด์ ํ ๋ ์์ ๋ฒจํธ๋ฅผ ๋งค๋ ๊ฒ ๊ท์ฐฎ์ ์ ์์ง๋ง, ์ฌ๊ณ ๊ฐ ๋ฌ์ ๋ ์๋ช ์ ๊ตฌํด์ฃผ์์? ์ฝ๋๋ ๋ง์ฐฌ๊ฐ์ง์ผ. ํ ์คํธ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ ์ฒ์์ ๋ฒ๊ฑฐ๋ก์ธ ์ ์์ง๋ง, ๋์ค์ ๋ฆฌํฉํ ๋งํ๊ฑฐ๋ ์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ ๋ ์์ฒญ๋ ์์ ๊ฐ์ ์ค.
๐ก ํ ์คํธ์ ํต์ฌ ๊ฐ์น
๋ฒ๊ทธ ์กฐ๊ธฐ ๋ฐ๊ฒฌ: ๊ฐ๋ฐ ๋จ๊ณ์์ ๋ฌธ์ ๋ฅผ ์ฐพ์๋ด๋ฉด ์์ ๋น์ฉ์ด ํจ์ฌ ์ ์ด์ ธ.
๋ฆฌํฉํ ๋ง ์์ ๊ฐ: ์ฝ๋๋ฅผ ๊ฐ์ ํ ๋ ๊ธฐ์กด ๊ธฐ๋ฅ์ด ๊นจ์ง์ง ์์๋์ง ์ฆ์ ํ์ธ ๊ฐ๋ฅ.
๋ฌธ์ํ ํจ๊ณผ: ํ
์คํธ ์ฝ๋ ์์ฒด๊ฐ ์ฝ๋ ์ฌ์ฉ๋ฒ์ ๋ณด์ฌ์ฃผ๋ ์ด์์๋ ๋ฌธ์๊ฐ ๋ผ.
ํ์
ํจ์จ: ํ์์ด ๋ด ์ฝ๋๋ฅผ ์์ ํด๋ ํ
์คํธ๊ฐ ์์ ๋ง ์ญํ ์ ํด์ค.
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ๊ฐ๋ฐ ๊ด๋ จ ์ง์์ ๊ณต์ ํ๋ค ๋ณด๋ฉด, ๋ง์ ์ด๋ณด ๊ฐ๋ฐ์๋ค์ด ํ ์คํธ๋ฅผ "๋์ค์ ๋ฐฐ์ธ ๊ฒ"์ผ๋ก ๋ฏธ๋ฃจ๋๋ผ๊ณ . ํ์ง๋ง ์์งํ ๋งํ๋ฉด, ํ ์คํธ๋ ์ฒ์๋ถํฐ ์ต๊ด์ผ๋ก ๋ง๋๋ ๊ฒ ํจ์ฌ ์ข์. ๋์ค์ ๋ฐฐ์ฐ๋ ค๋ฉด ๊ธฐ์กด ์ฝ๋๋ฅผ ๋ค ๋ฏ์ด๊ณ ์ณ์ผ ํ๊ฑฐ๋ ! ๐ง
๐๏ธ ํ ์คํธ์ 3๊ฐ์ง ๋ ๋ฒจ: ํผ๋ผ๋ฏธ๋ ๊ตฌ์กฐ ์ดํดํ๊ธฐ
ํ ์คํธ๋ ํฌ๊ฒ ์ธ ๊ฐ์ง ๋ ๋ฒจ๋ก ๋๋์ด. ์ด๊ฑธ ํ ์คํธ ํผ๋ผ๋ฏธ๋๋ผ๊ณ ๋ถ๋ฅด๋๋ฐ, ํผ๋ผ๋ฏธ๋ ๋ชจ์์ฒ๋ผ ์๋๋ก ๊ฐ์๋ก ํ ์คํธ ์๊ฐ ๋ง์์ ธ์ผ ํด.
๐ฌ ๋จ์ ํ ์คํธ (Unit Test)
๊ฐ์ฅ ์์ ๋จ์์ ์ฝ๋๋ฅผ ํ ์คํธํด. ์ฃผ๋ก ๊ฐ๋ณ ํจ์๋ ๋ฉ์๋ ํ๋ํ๋๋ฅผ ๊ฒ์ฆํ์ง.
ํน์ง: ์คํ ์๋๊ฐ ๋งค์ฐ ๋น ๋ฅด๊ณ , ๋ฌธ์ ๋ฐ์ ์ ์์ธ์ ์ ํํ ํ์ ํ ์ ์์ด.
๋น์จ: ์ ์ฒด ํ ์คํธ์ 70% ์ ๋๋ฅผ ์ฐจ์งํด์ผ ํด.
๐ ํตํฉ ํ ์คํธ (Integration Test)
์ฌ๋ฌ ๋ชจ๋์ด ํจ๊ป ๋์ํ๋ ๊ฑธ ํ ์คํธํด. ์๋ฅผ ๋ค์ด ๋คํธ์ํฌ ๋ ์ด์ด์ ๋ฐ์ดํฐ ํ์ฑ์ด ์ ์ฐ๋๋๋์ง ํ์ธํ๋ ๊ฑฐ์ง.
ํน์ง: ๋จ์ ํ ์คํธ๋ณด๋ค ๋๋ฆฌ์ง๋ง, ์ค์ ์์คํ ์ ๋์์ ๋ ์ ๋ฐ์ํด.
๋น์จ: ์ ์ฒด ํ ์คํธ์ 20% ์ ๋.
๐ญ UI ํ ์คํธ (UI Test)
์ฌ์ฉ์ ๊ด์ ์์ ์ฑ ์ ์ฒด๋ฅผ ํ ์คํธํด. ๋ฒํผ ํด๋ฆญ, ํ๋ฉด ์ ํ ๋ฑ ์ค์ ์ฌ์ฉ์ ํ๋์ ์๋ฎฌ๋ ์ด์ ํ์ง.
ํน์ง: ๊ฐ์ฅ ๋๋ฆฌ๊ณ ๋ถ์์ ํ์ง๋ง, ์ค์ ์ฌ์ฉ์ ๊ฒฝํ์ ๊ฐ์ฅ ์ ๊ฒ์ฆํด.
๋น์จ: ์ ์ฒด ํ ์คํธ์ 10% ์ ๋๋ฉด ์ถฉ๋ถํด.
๐ฏ ์ค์ ํ: ํผ๋ผ๋ฏธ๋๋ฅผ ๊ฑฐ๊พธ๋ก ๋ง๋ค์ง ๋ง!
๋ง์ ํ๋ค์ด ์ค์ํ๋ ๊ฒ UI ํ ์คํธ๋ง ์๋ฉ ๋ง๋๋ ๊ฑฐ์ผ. UI ํ ์คํธ๋ ์คํ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๊ณ ๊นจ์ง๊ธฐ ์ฌ์์, ๋๋ฌด ๋ง์ผ๋ฉด ์คํ๋ ค ์์ฐ์ฑ์ด ๋จ์ด์ ธ. ๋จ์ ํ ์คํธ๋ฅผ ํํํ๊ฒ ๋ง๋ค๊ณ , ํตํฉ ํ ์คํธ๋ก ์ฐ๊ฒฐ ๋ถ๋ถ์ ๊ฒ์ฆํ๊ณ , UI ํ ์คํธ๋ ํต์ฌ ์๋๋ฆฌ์ค๋ง ์ปค๋ฒํ๋ ๊ฒ ๋ฒ ์คํธ์ผ! ๐ฏ
๐ ๏ธ XCTest ํ๋ ์์ํฌ: ์ ํ์ด ์ ๊ณตํ๋ ๊ธฐ๋ณธ ๋ฌด๊ธฐ
iOS ๊ฐ๋ฐ์ ํ๋ฉด Xcode๋ฅผ ์ฐ์์? Xcode์๋ XCTest๋ผ๋ ํ ์คํ ํ๋ ์์ํฌ๊ฐ ๊ธฐ๋ณธ์ผ๋ก ๋ด์ฅ๋์ด ์์ด. ๋ณ๋๋ก ์ค์นํ ํ์ ์์ด ๋ฐ๋ก ์ฌ์ฉํ ์ ์๋ค๋ ๊ฒ ํฐ ์ฅ์ ์ด์ง! ๐
๐ฆ XCTest์ ๊ธฐ๋ณธ ๊ตฌ์กฐ
XCTest๋ XCTestCase๋ผ๋ ํด๋์ค๋ฅผ ์์๋ฐ์์ ํ
์คํธ๋ฅผ ์์ฑํด. ๊ฐ ํ
์คํธ ๋ฉ์๋๋ test๋ก ์์ํ๋ ์ด๋ฆ์ ๊ฐ์ ธ์ผ ํ๊ณ , Xcode๊ฐ ์๋์ผ๋ก ์ด๋ฐ ๋ฉ์๋๋ค์ ์ฐพ์์ ์คํํด์ค.
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() {
let result = calculator.add(2, 3)
XCTAssertEqual(result, 5, "2 + 3์ 5์ฌ์ผ ํด!")
}
// ๋๋์
ํ
์คํธ
func testDivision() {
let result = calculator.divide(10, 2)
XCTAssertEqual(result, 5)
}
// 0์ผ๋ก ๋๋๊ธฐ ํ
์คํธ
func testDivisionByZero() {
XCTAssertThrowsError(try calculator.divide(10, 0)) {
error in
XCTAssertEqual(error as? CalculatorError,
CalculatorError.divisionByZero)
}
}
}
์ ์ฝ๋๋ฅผ ๋ณด๋ฉด ๋ช ๊ฐ์ง ํจํด์ด ๋ณด์ด์ง? ํ๋์ฉ ๋ฏ์ด๋ณผ๊ฒ! ๐
๐ฌ ํ ์คํธ ๋ผ์ดํ์ฌ์ดํด
setUp(): ๊ฐ ํ ์คํธ ๋ฉ์๋๊ฐ ์คํ๋๊ธฐ ์ ์ ํธ์ถ๋ผ. ์ฌ๊ธฐ์ ํ ์คํธ์ ํ์ํ ๊ฐ์ฒด๋ค์ ์ด๊ธฐํํ์ง. ๋ง์น ๋ฌด๋๋ฅผ ์ค๋นํ๋ ๊ฒ์ฒ๋ผ!
test๋ฉ์๋(): ์ค์ ํ ์คํธ๊ฐ ์คํ๋๋ ๋ถ๋ถ. ์ฌ๊ธฐ์ ์ฝ๋๋ฅผ ์คํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๊ฒ์ฆํด.
tearDown(): ๊ฐ ํ ์คํธ ๋ฉ์๋๊ฐ ์คํ๋ ํ์ ํธ์ถ๋ผ. ์ฌ๊ธฐ์ ์ ๋ฆฌ ์์ ์ ํด์ค. ๋ฌด๋๋ฅผ ์น์ฐ๋ ๊ฑฐ์ง!
โ ์ฃผ์ Assertion ๋ฉ์๋๋ค
XCTest๋ ๋ค์ํ ๊ฒ์ฆ ๋ฉ์๋๋ฅผ ์ ๊ณตํด. ์ด๊ฑธ Assertion์ด๋ผ๊ณ ๋ถ๋ฅด๋๋ฐ, ํ ์คํธ์ ํต์ฌ์ด์ผ!
XCTAssertEqual
๋ ๊ฐ์ด ๊ฐ์์ง ํ์ธํด.
XCTAssertEqual(actual, expected)
XCTAssertNotEqual
๋ ๊ฐ์ด ๋ค๋ฅธ์ง ํ์ธํด.
XCTAssertNotEqual(value1, value2)
XCTAssertTrue / False
๋ถ๋ฆฐ ๊ฐ์ ํ์ธํด.
XCTAssertTrue(condition)
XCTAssertNil / NotNil
nil ์ฌ๋ถ๋ฅผ ํ์ธํด.
XCTAssertNil(optionalValue)
XCTAssertThrowsError
์๋ฌ๊ฐ ๋ฐ์ํ๋์ง ํ์ธํด.
XCTAssertThrowsError(try func())
XCTAssertNoThrow
์๋ฌ๊ฐ ๋ฐ์ํ์ง ์๋์ง ํ์ธํด.
XCTAssertNoThrow(try func())
๐ฌ ์ค์ ์กฐ์ธ: ์คํจ ๋ฉ์์ง๋ฅผ ๊ผญ ์์ฑํด!
๋ชจ๋ Assertion ๋ฉ์๋๋ ๋ง์ง๋ง ํ๋ผ๋ฏธํฐ๋ก ์คํจ ๋ฉ์์ง๋ฅผ ๋ฐ์ ์ ์์ด. ์๋ฅผ ๋ค์ด:
XCTAssertEqual(result, 5, "๊ณ์ฐ ๊ฒฐ๊ณผ๊ฐ ์์๊ณผ ๋ค๋ฆ
๋๋ค")
์ด๋ ๊ฒ ๋ฉ์์ง๋ฅผ ๋ฃ์ด๋๋ฉด ํ
์คํธ๊ฐ ์คํจํ์ ๋ ๋ฌด์์ด ์๋ชป๋๋์ง ๋ฐ๋ก ์ ์ ์์ด. ๋ฏธ๋์ ๋(๋๋ ํ์)์๊ฒ ์น์ ํ ๊ฐ๋ฐ์๊ฐ ๋์! ๐
๐งฉ ๋จ์ ํ ์คํธ ์ค์ : ์์ ๊ฒ๋ถํฐ ํํํ๊ฒ
์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ๋จ์ ํ ์คํธ๋ฅผ ์์ฑํด๋ณผ๊น? ๋จ์ ํ ์คํธ๋ ํ๋์ ๊ธฐ๋ฅ, ํ๋์ ์ฑ ์๋ง ํ ์คํธํ๋ ๊ฒ ์์น์ด์ผ. ๋๋ฌด ๋ง์ ๊ฑธ ํ ๋ฒ์ ํ ์คํธํ๋ ค๊ณ ํ๋ฉด ๋์ค์ ๋ญ๊ฐ ๋ฌธ์ ์ธ์ง ์ฐพ๊ธฐ ์ด๋ ค์์ ธ.
๐ฏ ์ข์ ๋จ์ ํ ์คํธ์ ํน์ง: FIRST ์์น
โก Fast (๋น ๋ฆ)
ํ ์คํธ๋ ๋น ๋ฅด๊ฒ ์คํ๋์ด์ผ ํด. ๋๋ฆฐ ํ ์คํธ๋ ๊ฐ๋ฐ์๊ฐ ์์ฃผ ์คํํ์ง ์๊ฒ ๋๊ฑฐ๋ .
๐ Independent (๋ ๋ฆฝ์ )
๊ฐ ํ ์คํธ๋ ๋ค๋ฅธ ํ ์คํธ์ ์์กดํ์ง ์์์ผ ํด. ์์๊ฐ ๋ฐ๋์ด๋ ๊ฒฐ๊ณผ๊ฐ ๊ฐ์์ผ ํ์ง.
๐ Repeatable (๋ฐ๋ณต ๊ฐ๋ฅ)
๊ฐ์ ํ ์คํธ๋ฅผ ์ฌ๋ฌ ๋ฒ ์คํํด๋ ํญ์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์์ผ ํด.
โ๏ธ Self-Validating (์๊ฐ ๊ฒ์ฆ)
ํ ์คํธ๋ ์๋์ผ๋ก ์ฑ๊ณต/์คํจ๋ฅผ ํ๋จํด์ผ ํด. ์ฌ๋์ด ๋ก๊ทธ๋ฅผ ๋ณด๊ณ ํ๋จํ๋ฉด ์ ๋ผ!
โฐ Timely (์ ์์)
ํ ์คํธ๋ ํ๋ก๋์ ์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ์ ์ด๋ ์งํ์ ์์ฑํด์ผ ํด.
๐ ์ค์ ์์ : ์ฌ์ฉ์ ๊ฒ์ฆ ๋ก์ง ํ ์คํธ
์ค์ ๋ก ๋ง์ด ์ฐ์ด๋ ์ฌ์ฉ์ ๊ฒ์ฆ ๋ก์ง์ ํ ์คํธํด๋ณด์. ์ด๋ฉ์ผ ํ์์ด ์ฌ๋ฐ๋ฅธ์ง, ๋น๋ฐ๋ฒํธ๊ฐ ์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ํ์ธํ๋ ์ฝ๋์ผ.
// ํ๋ก๋์
์ฝ๋
struct UserValidator {
func isValidEmail(_ email: String) -> Bool {
let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
let emailPredicate = NSPredicate(format: "SELF MATCHES %@", emailRegex)
return emailPredicate.evaluate(with: email)
}
func isValidPassword(_ password: String) -> Bool {
// ์ต์ 8์, ๋๋ฌธ์ 1๊ฐ, ์๋ฌธ์ 1๊ฐ, ์ซ์ 1๊ฐ ํฌํจ
guard password.count >= 8 else { return false }
let hasUppercase = password.range(of: "[A-Z]", options: .regularExpression) != nil
let hasLowercase = password.range(of: "[a-z]", options: .regularExpression) != nil
let hasNumber = password.range(of: "[0-9]", options: .regularExpression) != nil
return hasUppercase && hasLowercase && hasNumber
}
func isValidUsername(_ username: String) -> Bool {
return username.count >= 3 && username.count <= 20
}
}
์ด์ ์ด ์ฝ๋๋ฅผ ํ ์คํธํด๋ณด์! ๐งช
import XCTest
@testable import MyApp
class UserValidatorTests: XCTestCase {
var validator: UserValidator!
override func setUp() {
super.setUp()
validator = UserValidator()
}
override func tearDown() {
validator = nil
super.tearDown()
}
// MARK: - ์ด๋ฉ์ผ ํ
์คํธ
func testValidEmail() {
// Given (์ค๋น)
let validEmails = [
"test@example.com",
"user.name@domain.co.kr",
"hello+world@test.org"
]
// When & Then (์คํ & ๊ฒ์ฆ)
for email in validEmails {
XCTAssertTrue(validator.isValidEmail(email),
"\(email)์ ์ ํจํ ์ด๋ฉ์ผ์ด์ด์ผ ํฉ๋๋ค")
}
}
func testInvalidEmail() {
let invalidEmails = [
"notanemail",
"@example.com",
"user@",
"user name@example.com",
""
]
for email in invalidEmails {
XCTAssertFalse(validator.isValidEmail(email),
"\(email)์ ์ ํจํ์ง ์์ ์ด๋ฉ์ผ์ด์ด์ผ ํฉ๋๋ค")
}
}
// MARK: - ๋น๋ฐ๋ฒํธ ํ
์คํธ
func testValidPassword() {
let validPasswords = [
"Password1",
"MyP@ssw0rd",
"Secure123"
]
for password in validPasswords {
XCTAssertTrue(validator.isValidPassword(password),
"\(password)๋ ์ ํจํ ๋น๋ฐ๋ฒํธ์ฌ์ผ ํฉ๋๋ค")
}
}
func testPasswordTooShort() {
let shortPassword = "Pass1"
XCTAssertFalse(validator.isValidPassword(shortPassword),
"7์ ์ดํ ๋น๋ฐ๋ฒํธ๋ ๊ฑฐ๋ถ๋์ด์ผ ํฉ๋๋ค")
}
func testPasswordWithoutUppercase() {
let password = "password123"
XCTAssertFalse(validator.isValidPassword(password),
"๋๋ฌธ์๊ฐ ์๋ ๋น๋ฐ๋ฒํธ๋ ๊ฑฐ๋ถ๋์ด์ผ ํฉ๋๋ค")
}
func testPasswordWithoutLowercase() {
let password = "PASSWORD123"
XCTAssertFalse(validator.isValidPassword(password),
"์๋ฌธ์๊ฐ ์๋ ๋น๋ฐ๋ฒํธ๋ ๊ฑฐ๋ถ๋์ด์ผ ํฉ๋๋ค")
}
func testPasswordWithoutNumber() {
let password = "PasswordOnly"
XCTAssertFalse(validator.isValidPassword(password),
"์ซ์๊ฐ ์๋ ๋น๋ฐ๋ฒํธ๋ ๊ฑฐ๋ถ๋์ด์ผ ํฉ๋๋ค")
}
// MARK: - ์ฌ์ฉ์๋ช
ํ
์คํธ
func testValidUsername() {
let validUsernames = ["abc", "user123", "twentycharacterslong"]
for username in validUsernames {
XCTAssertTrue(validator.isValidUsername(username),
"\(username)์ ์ ํจํ ์ฌ์ฉ์๋ช
์ด์ด์ผ ํฉ๋๋ค")
}
}
func testUsernameTooShort() {
let shortUsername = "ab"
XCTAssertFalse(validator.isValidUsername(shortUsername),
"2์ ์ดํ ์ฌ์ฉ์๋ช
์ ๊ฑฐ๋ถ๋์ด์ผ ํฉ๋๋ค")
}
func testUsernameTooLong() {
let longUsername = "thisusernameiswaytoolongtobevalid"
XCTAssertFalse(validator.isValidUsername(longUsername),
"20์ ์ด๊ณผ ์ฌ์ฉ์๋ช
์ ๊ฑฐ๋ถ๋์ด์ผ ํฉ๋๋ค")
}
}
๐จ Given-When-Then ํจํด
์ ์ฝ๋์์ ์ฃผ์์ผ๋ก ํ์ํ Given-When-Then ํจํด์ ๋์ฌ๊ฒจ๋ด! ์ด๊ฑด ํ ์คํธ๋ฅผ ๊ตฌ์กฐํํ๋ ์์ฃผ ์ ์ฉํ ๋ฐฉ๋ฒ์ด์ผ:
Given (์ค๋น): ํ
์คํธ์ ํ์ํ ๋ฐ์ดํฐ๋ ์ํ๋ฅผ ์ค๋นํด.
When (์คํ): ํ
์คํธํ๋ ค๋ ๋์์ ์คํํด.
Then (๊ฒ์ฆ): ๊ฒฐ๊ณผ๊ฐ ์์๊ณผ ์ผ์นํ๋์ง ํ์ธํด.
์ด ํจํด์ ๋ฐ๋ฅด๋ฉด ํ ์คํธ ์ฝ๋๊ฐ ํจ์ฌ ์ฝ๊ธฐ ์ฌ์์ ธ! ๐
๐ญ Mock๊ณผ Stub: ์์กด์ฑ ๋ค๋ฃจ๊ธฐ
์ค์ ์ฑ์์๋ ๋คํธ์ํฌ ์์ฒญ, ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ๊ทผ ๊ฐ์ ์ธ๋ถ ์์กด์ฑ์ด ๋ง์. ์ด๋ฐ ๊ฑธ ํ ์คํธํ ๋๋ง๋ค ์ค์ ๋ก ์๋ฒ์ ์์ฒญ์ ๋ณด๋ด๋ฉด ์ด๋ป๊ฒ ๋ ๊น? ํ ์คํธ๊ฐ ์์ฒญ ๋๋ ค์ง๊ณ , ๋คํธ์ํฌ ์ํ์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง ๊ฑฐ์ผ. ๐ฑ
์ด๋ด ๋ ์ฌ์ฉํ๋ ๊ฒ Mock๊ณผ Stub์ด์ผ. ์ค์ ๊ฐ์ฒด๋ฅผ ํ๋ด ๋ด๋ ๊ฐ์ง ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ ํ ์คํธํ๋ ๊ฑฐ์ง!
// ํ๋กํ ์ฝ ์ ์
protocol NetworkService {
func fetchUser(id: Int, completion: @escaping (Result<User, Error>) -> Void)
}
// ์ค์ ๊ตฌํ
class RealNetworkService: NetworkService {
func fetchUser(id: Int, completion: @escaping (Result<User, Error>) -> Void) {
// ์ค์ ๋คํธ์ํฌ ์์ฒญ ์ฝ๋
URLSession.shared.dataTask(with: URL(string: "api.example.com/users/\(id)")!) {
data, response, error in
// ... ์ค์ ๊ตฌํ
}.resume()
}
}
// Mock ๊ตฌํ (ํ
์คํธ์ฉ)
class MockNetworkService: NetworkService {
var shouldReturnError = false
var mockUser: User?
var fetchUserCallCount = 0
func fetchUser(id: Int, completion: @escaping (Result<User, Error>) -> Void) {
fetchUserCallCount += 1
if shouldReturnError {
completion(.failure(NSError(domain: "Test", code: -1)))
} else if let user = mockUser {
completion(.success(user))
}
}
}
// ํ
์คํธํ ํด๋์ค
class UserViewModel {
private let networkService: NetworkService
var user: User?
var errorMessage: String?
init(networkService: NetworkService) {
self.networkService = networkService
}
func loadUser(id: Int) {
networkService.fetchUser(id: id) { [weak self] result in
switch result {
case .success(let user):
self?.user = user
case .failure(let error):
self?.errorMessage = error.localizedDescription
}
}
}
}
์ด์ ํ ์คํธ๋ฅผ ์์ฑํด๋ณด์:
class UserViewModelTests: XCTestCase {
var viewModel: UserViewModel!
var mockNetworkService: MockNetworkService!
override func setUp() {
super.setUp()
mockNetworkService = MockNetworkService()
viewModel = UserViewModel(networkService: mockNetworkService)
}
func testLoadUserSuccess() {
// Given
let expectedUser = User(id: 1, name: "ํ๊ธธ๋", email: "hong@test.com")
mockNetworkService.mockUser = expectedUser
// When
viewModel.loadUser(id: 1)
// Then
XCTAssertEqual(viewModel.user?.name, "ํ๊ธธ๋")
XCTAssertNil(viewModel.errorMessage)
XCTAssertEqual(mockNetworkService.fetchUserCallCount, 1,
"๋คํธ์ํฌ ์์ฒญ์ด ์ ํํ 1๋ฒ ํธ์ถ๋์ด์ผ ํฉ๋๋ค")
}
func testLoadUserFailure() {
// Given
mockNetworkService.shouldReturnError = true
// When
viewModel.loadUser(id: 1)
// Then
XCTAssertNil(viewModel.user)
XCTAssertNotNil(viewModel.errorMessage)
}
}
โจ Mock vs Stub ์ฐจ์ด์
Stub: ๋ฏธ๋ฆฌ ์ ํด์ง ๋ต๋ณ์ ๋ฐํํ๋ ๊ฐ์ฒด. "์ด ๋ฉ์๋๊ฐ ํธ์ถ๋๋ฉด ์ด ๊ฐ์ ๋๋ ค์ค"๋ผ๊ณ ์ค์ ํด๋๋ ๊ฑฐ์ผ.
Mock: Stub์ ๊ธฐ๋ฅ + ํธ์ถ ์ฌ๋ถ์ ํ์๊น์ง ๊ฒ์ฆํ๋ ๊ฐ์ฒด. "์ด ๋ฉ์๋๊ฐ ์ ํํ 2๋ฒ ํธ์ถ๋๋์ง ํ์ธํด์ค"์ฒ๋ผ ๋ ์์ธํ ๊ฒ์ฆ์ด ๊ฐ๋ฅํด.
์ค๋ฌด์์๋ ๋์ ์๊ฒฉํ๊ฒ ๊ตฌ๋ถํ์ง ์๊ณ ์์ด์ ์ฐ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์. ์ค์ํ ๊ฑด ์ธ๋ถ ์์กด์ฑ์ ์ ๊ฑฐํด์ ํ ์คํธ๋ฅผ ๋น ๋ฅด๊ณ ์์ ์ ์ผ๋ก ๋ง๋๋ ๊ฒ์ด์ผ! ๐ฏ
๐ ํตํฉ ํ ์คํธ: ๋ชจ๋๋ค์ด ํจ๊ป ์ถค์ถ๋์ง ํ์ธํ๊ธฐ
๋จ์ ํ ์คํธ๋ก ๊ฐ๋ณ ๋ถํ๋ค์ด ์ ์๋ํ๋ ๊ฑธ ํ์ธํ๋ค๋ฉด, ์ด์ ์ด ๋ถํ๋ค์ ์กฐ๋ฆฝํ์ ๋๋ ์ ๋์๊ฐ๋์ง ํ์ธํด์ผ ํด. ์ด๊ฒ ๋ฐ๋ก ํตํฉ ํ ์คํธ์ผ! ๐ง
์๋ฅผ ๋ค์ด๋ณผ๊ฒ. ์๋์ฐจ์ ์์ง, ๋ฐํด, ํธ๋ค์ด ๊ฐ๊ฐ ์ ๋ง๋ค์ด์ก๋ค๊ณ ํด์ ์กฐ๋ฆฝํ ์๋์ฐจ๊ฐ ์ ๋ฌ๋ฆฐ๋ค๋ ๋ณด์ฅ์ ์์์? ๋ถํ๋ค์ด ์ ๋๋ก ์ฐ๊ฒฐ๋์ด์ผ ํ๊ณ , ์๋ก ํธํ๋์ด์ผ ํ๋๊น. ์ฝ๋๋ ๋ง์ฐฌ๊ฐ์ง์ผ!
๐ฏ ํตํฉ ํ ์คํธ๊ฐ ํ์ํ ์๋๋ฆฌ์ค
๐ ๋คํธ์ํฌ + ํ์ฑ
API์์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์์์ JSON์ ํ์ฑํ๊ณ ๋ชจ๋ธ๋ก ๋ณํํ๋ ์ ์ฒด ํ๋ฆ
๐พ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๋
Core Data๋ Realm ๊ฐ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํ๊ณ ๋ถ๋ฌ์ค๋ ๊ณผ์
๐ ๋น์ฆ๋์ค ๋ก์ง ํ๋ฆ
์ฌ๋ฌ ์๋น์ค ๊ฐ์ฒด๋ค์ด ํ๋ ฅํด์ ๋ณต์กํ ๋น์ฆ๋์ค ๋ก์ง์ ์ฒ๋ฆฌํ๋ ๊ณผ์
๐ก ์ค์ ์์ : API ํตํฉ ํ ์คํธ
์ค์ ์๋ฒ์ ํต์ ํ๋ ํตํฉ ํ ์คํธ๋ฅผ ๋ง๋ค์ด๋ณด์. ๋ฌผ๋ก ์ค์ ํ๋ก๋์ ์๋ฒ๋ฅผ ์ฐ๋ฉด ์ ๋๊ณ , ํ ์คํธ ์๋ฒ๋ Mock ์๋ฒ๋ฅผ ์ฌ์ฉํด์ผ ํด!
// ๋ชจ๋ธ
struct Post: Codable, Equatable {
let id: Int
let title: String
let body: String
let userId: Int
}
// ๋คํธ์ํฌ ๋ ์ด์ด
class APIClient {
let baseURL: URL
let session: URLSession
init(baseURL: URL, session: URLSession = .shared) {
self.baseURL = baseURL
self.session = session
}
func fetchPosts(completion: @escaping (Result<[Post], Error>) -> Void) {
let url = baseURL.appendingPathComponent("posts")
session.dataTask(with: url) { data, response, error in
if let error = error {
completion(.failure(error))
return
}
guard let data = data else {
completion(.failure(APIError.noData))
return
}
do {
let posts = try JSONDecoder().decode([Post].self, from: data)
completion(.success(posts))
} catch {
completion(.failure(error))
}
}.resume()
}
}
enum APIError: Error {
case noData
case invalidResponse
}
// ์๋น์ค ๋ ์ด์ด
class PostService {
private let apiClient: APIClient
init(apiClient: APIClient) {
self.apiClient = apiClient
}
func getRecentPosts(limit: Int, completion: @escaping (Result<[Post], Error>) -> Void) {
apiClient.fetchPosts { result in
switch result {
case .success(let posts):
let recentPosts = Array(posts.prefix(limit))
completion(.success(recentPosts))
case .failure(let error):
completion(.failure(error))
}
}
}
}
์ด์ ํตํฉ ํ ์คํธ๋ฅผ ์์ฑํด๋ณด์:
class PostServiceIntegrationTests: XCTestCase {
var apiClient: APIClient!
var postService: PostService!
override func setUp() {
super.setUp()
// ํ
์คํธ์ฉ Mock ์๋ฒ URL ์ฌ์ฉ
let testURL = URL(string: "https://jsonplaceholder.typicode.com")!
apiClient = APIClient(baseURL: testURL)
postService = PostService(apiClient: apiClient)
}
func testFetchPostsIntegration() {
// Given
let expectation = XCTestExpectation(description: "ํฌ์คํธ ๊ฐ์ ธ์ค๊ธฐ")
var fetchedPosts: [Post]?
var fetchError: Error?
// When
apiClient.fetchPosts { result in
switch result {
case .success(let posts):
fetchedPosts = posts
case .failure(let error):
fetchError = error
}
expectation.fulfill()
}
// Then
wait(for: [expectation], timeout: 10.0)
XCTAssertNil(fetchError, "์๋ฌ๊ฐ ๋ฐ์ํ์ง ์์์ผ ํฉ๋๋ค")
XCTAssertNotNil(fetchedPosts, "ํฌ์คํธ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์์์ผ ํฉ๋๋ค")
XCTAssertTrue(fetchedPosts!.count > 0, "์ต์ 1๊ฐ ์ด์์ ํฌ์คํธ๊ฐ ์์ด์ผ ํฉ๋๋ค")
}
func testGetRecentPostsIntegration() {
// Given
let expectation = XCTestExpectation(description: "์ต๊ทผ ํฌ์คํธ ๊ฐ์ ธ์ค๊ธฐ")
let requestedLimit = 5
var recentPosts: [Post]?
// When
postService.getRecentPosts(limit: requestedLimit) { result in
if case .success(let posts) = result {
recentPosts = posts
}
expectation.fulfill()
}
// Then
wait(for: [expectation], timeout: 10.0)
XCTAssertNotNil(recentPosts)
XCTAssertEqual(recentPosts?.count, requestedLimit,
"์์ฒญํ ๊ฐ์๋งํผ์ ํฌ์คํธ๋ฅผ ๋ฐ์์์ผ ํฉ๋๋ค")
}
func testFullDataFlowIntegration() {
// Given
let expectation = XCTestExpectation(description: "์ ์ฒด ๋ฐ์ดํฐ ํ๋ฆ")
// When
postService.getRecentPosts(limit: 3) { result in
// Then
switch result {
case .success(let posts):
XCTAssertEqual(posts.count, 3)
// ๋ฐ์ดํฐ ๊ตฌ์กฐ ๊ฒ์ฆ
for post in posts {
XCTAssertTrue(post.id > 0, "ID๋ ์์์ฌ์ผ ํฉ๋๋ค")
XCTAssertFalse(post.title.isEmpty, "์ ๋ชฉ์ด ๋น์ด์์ผ๋ฉด ์ ๋ฉ๋๋ค")
XCTAssertTrue(post.userId > 0, "์ฌ์ฉ์ ID๋ ์์์ฌ์ผ ํฉ๋๋ค")
}
case .failure(let error):
XCTFail("์์ฒญ์ด ์คํจํ์ต๋๋ค: \(error)")
}
expectation.fulfill()
}
wait(for: [expectation], timeout: 10.0)
}
}
โฐ XCTestExpectation: ๋น๋๊ธฐ ํ ์คํธ์ ํต์ฌ
๋คํธ์ํฌ ์์ฒญ ๊ฐ์ ๋น๋๊ธฐ ์์ ์ ํ ์คํธํ ๋๋ XCTestExpectation์ ์ฌ์ฉํด์ผ ํด. ์๋ ๋ฐฉ์์ ์ด๋:
1๏ธโฃ XCTestExpectation ๊ฐ์ฒด๋ฅผ ์์ฑํด
2๏ธโฃ ๋น๋๊ธฐ ์์
์ด ์๋ฃ๋๋ฉด expectation.fulfill()์ ํธ์ถํด
3๏ธโฃ wait(for:timeout:)์ผ๋ก ์์
์ด ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ ค
timeout์ ์ค์ ํ๋ ๊ฑธ ์์ง ๋ง! ๋คํธ์ํฌ ๋ฌธ์ ๋ก ์๋ต์ด ์ ์ค๋ฉด ํ ์คํธ๊ฐ ์์ํ ๊ธฐ๋ค๋ฆด ์ ์๊ฑฐ๋ . ๋ณดํต 5~10์ด ์ ๋๊ฐ ์ ๋นํด. โฑ๏ธ
๐พ Core Data ํตํฉ ํ ์คํธ
๋ฐ์ดํฐ๋ฒ ์ด์ค ํ ์คํธ๋ ์ค์ํด! Core Data๋ฅผ ์ฌ์ฉํ๋ค๋ฉด ์ด๋ ๊ฒ ํ ์คํธํ ์ ์์ด:
class CoreDataIntegrationTests: XCTestCase {
var persistentContainer: NSPersistentContainer!
var context: NSManagedObjectContext!
override func setUp() {
super.setUp()
// ์ธ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ์ ์ฌ์ฉ (์ค์ DB ํ์ผ์ ๋ง๋ค์ง ์์)
persistentContainer = NSPersistentContainer(name: "MyApp")
let description = NSPersistentStoreDescription()
description.type = NSInMemoryStoreType
persistentContainer.persistentStoreDescriptions = [description]
persistentContainer.loadPersistentStores { description, error in
XCTAssertNil(error)
}
context = persistentContainer.viewContext
}
override func tearDown() {
persistentContainer = nil
context = nil
super.tearDown()
}
func testSaveAndFetchUser() {
// Given
let user = User(context: context)
user.id = 1
user.name = "ํ
์คํธ ์ ์ "
user.email = "test@example.com"
// When - ์ ์ฅ
do {
try context.save()
} catch {
XCTFail("์ ์ฅ ์คํจ: \(error)")
}
// Then - ๋ถ๋ฌ์ค๊ธฐ
let fetchRequest: NSFetchRequest<User> = User.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "id == %d", 1)
do {
let results = try context.fetch(fetchRequest)
XCTAssertEqual(results.count, 1, "์ ํํ 1๊ฐ์ ์ ์ ๊ฐ ์กฐํ๋์ด์ผ ํฉ๋๋ค")
XCTAssertEqual(results.first?.name, "ํ
์คํธ ์ ์ ")
XCTAssertEqual(results.first?.email, "test@example.com")
} catch {
XCTFail("์กฐํ ์คํจ: \(error)")
}
}
func testUpdateUser() {
// Given - ์ ์ ์์ฑ ๋ฐ ์ ์ฅ
let user = User(context: context)
user.id = 1
user.name = "์๋ ์ด๋ฆ"
try? context.save()
// When - ์
๋ฐ์ดํธ
user.name = "๋ณ๊ฒฝ๋ ์ด๋ฆ"
try? context.save()
// Then - ๋ณ๊ฒฝ์ฌํญ ํ์ธ
context.refreshAllObjects()
let fetchRequest: NSFetchRequest<User> = User.fetchRequest()
let results = try? context.fetch(fetchRequest)
XCTAssertEqual(results?.first?.name, "๋ณ๊ฒฝ๋ ์ด๋ฆ")
}
func testDeleteUser() {
// Given
let user = User(context: context)
user.id = 1
user.name = "์ญ์ ๋ ์ ์ "
try? context.save()
// When
context.delete(user)
try? context.save()
// Then
let fetchRequest: NSFetchRequest<User> = User.fetchRequest()
let results = try? context.fetch(fetchRequest)
XCTAssertEqual(results?.count, 0, "์ ์ ๊ฐ ์ญ์ ๋์ด์ผ ํฉ๋๋ค")
}
}
๐ฏ ์ธ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ์๋ฅผ ์ฌ์ฉํ๋ ์ด์
ํ
์คํธ์์ NSInMemoryStoreType์ ์ฌ์ฉํ๋ ๊ฑด ์ ๋ง ์ค์ํด! ์ค์ ๋์คํฌ์ ํ์ผ์ ๋ง๋ค๋ฉด:
โ ํ
์คํธ๊ฐ ๋๋ ค์ ธ
โ ์ด์ ํ
์คํธ์ ๋ฐ์ดํฐ๊ฐ ๋จ์์ ํ
์คํธ๊ฐ ์ค์ผ๋ ์ ์์ด
โ ํ
์คํธ ํ ์ ๋ฆฌ ์์
์ด ๋ณต์กํด์ ธ
์ธ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ์๋ ๋ฉ๋ชจ๋ฆฌ์๋ง ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ , ํ ์คํธ๊ฐ ๋๋๋ฉด ์๋์ผ๋ก ์ฌ๋ผ์ ธ. ์๋ฒฝํ์ง? ๐
๐ญ UI ํ ์คํธ: ์ฌ์ฉ์์ ๋์ผ๋ก ๋ณด๊ธฐ
๋๋์ด UI ํ ์คํธ๊น์ง ์๋ค! UI ํ ์คํธ๋ ์ค์ ์ฌ์ฉ์๊ฐ ์ฑ์ ์ฌ์ฉํ๋ ๊ฒ์ฒ๋ผ ํ๋ฉด์ ํฐ์นํ๊ณ , ํ ์คํธ๋ฅผ ์ ๋ ฅํ๊ณ , ์คํฌ๋กคํ๋ ๊ฑธ ์๋ํํ๋ ๊ฑฐ์ผ. ๋ง์น ๋ก๋ด์ด ๋ด ์ฑ์ ํ ์คํธํด์ฃผ๋ ๋๋! ๐ค
๐ UI ํ ์คํธ ์์ํ๊ธฐ
Xcode์์ UI ํ
์คํธ ํ๊ฒ์ ๋ง๋ค๋ฉด ์๋์ผ๋ก XCUIApplication์ ์ฌ์ฉํ๋ ํ
ํ๋ฆฟ์ด ์์ฑ๋ผ. UI ํ
์คํธ๋ ๋ณ๋์ ํ๋ก์ธ์ค์์ ์คํ๋๊ธฐ ๋๋ฌธ์ ์ฑ์ ๋ด๋ถ ์ฝ๋์ ์ง์ ์ ๊ทผํ ์ ์์ด. ๋์ ์ ๊ทผ์ฑ ์๋ณ์(Accessibility Identifier)๋ฅผ ์ฌ์ฉํด์ UI ์์๋ฅผ ์ฐพ์์ผ ํด.
import XCTest
class LoginUITests: XCTestCase {
var app: XCUIApplication!
override func setUp() {
super.setUp()
continueAfterFailure = false
app = XCUIApplication()
app.launch()
}
override func tearDown() {
app = nil
super.tearDown()
}
func testSuccessfulLogin() {
// Given - ๋ก๊ทธ์ธ ํ๋ฉด์ด ํ์๋์ด ์์
let emailTextField = app.textFields["emailTextField"]
let passwordSecureField = app.secureTextFields["passwordTextField"]
let loginButton = app.buttons["loginButton"]
// When - ์ ํจํ ์ ๋ณด๋ก ๋ก๊ทธ์ธ ์๋
XCTAssertTrue(emailTextField.exists, "์ด๋ฉ์ผ ์
๋ ฅ ํ๋๊ฐ ์กด์ฌํด์ผ ํฉ๋๋ค")
emailTextField.tap()
emailTextField.typeText("test@example.com")
passwordSecureField.tap()
passwordSecureField.typeText("Password123")
loginButton.tap()
// Then - ํ ํ๋ฉด์ผ๋ก ์ด๋
let homeTitle = app.staticTexts["homeTitle"]
XCTAssertTrue(homeTitle.waitForExistence(timeout: 5),
"๋ก๊ทธ์ธ ํ ํ ํ๋ฉด์ด ํ์๋์ด์ผ ํฉ๋๋ค")
}
func testLoginWithInvalidEmail() {
// Given
let emailTextField = app.textFields["emailTextField"]
let loginButton = app.buttons["loginButton"]
// When
emailTextField.tap()
emailTextField.typeText("invalidemail")
loginButton.tap()
// Then
let errorAlert = app.alerts["์ค๋ฅ"]
XCTAssertTrue(errorAlert.waitForExistence(timeout: 2),
"์๋ชป๋ ์ด๋ฉ์ผ ํ์์ ๋ํ ์ค๋ฅ ์๋ฆผ์ด ํ์๋์ด์ผ ํฉ๋๋ค")
let errorMessage = errorAlert.staticTexts["์ฌ๋ฐ๋ฅธ ์ด๋ฉ์ผ ํ์์ด ์๋๋๋ค"]
XCTAssertTrue(errorMessage.exists)
errorAlert.buttons["ํ์ธ"].tap()
}
func testLoginWithEmptyFields() {
// Given
let loginButton = app.buttons["loginButton"]
// When - ์๋ฌด๊ฒ๋ ์
๋ ฅํ์ง ์๊ณ ๋ก๊ทธ์ธ ์๋
loginButton.tap()
// Then
let emailTextField = app.textFields["emailTextField"]
XCTAssertTrue(emailTextField.exists,
"๋น ํ๋๋ก ๋ก๊ทธ์ธ ์๋ ์ ํ๋ฉด์ด ์ ์ง๋์ด์ผ ํฉ๋๋ค")
}
func testPasswordVisibilityToggle() {
// Given
let passwordField = app.secureTextFields["passwordTextField"]
let toggleButton = app.buttons["passwordVisibilityToggle"]
// When
passwordField.tap()
passwordField.typeText("MyPassword")
// Then - ์ฒ์์ secure field
XCTAssertTrue(passwordField.exists)
// When - ํ ๊ธ ๋ฒํผ ํญ
toggleButton.tap()
// Then - ์ผ๋ฐ text field๋ก ๋ณ๊ฒฝ
let visiblePasswordField = app.textFields["passwordTextField"]
XCTAssertTrue(visiblePasswordField.exists,
"๋น๋ฐ๋ฒํธ๊ฐ ๋ณด์ด๋ ์ํ๋ก ๋ณ๊ฒฝ๋์ด์ผ ํฉ๋๋ค")
}
}
๐ท๏ธ Accessibility Identifier ์ค์ ํ๊ธฐ
UI ํ ์คํธ๊ฐ ์ ๋๋ก ์๋ํ๋ ค๋ฉด ๊ฐ UI ์์์ ์๋ณ์๋ฅผ ์ค์ ํด์ผ ํด. SwiftUI์ UIKit์์ ๊ฐ๊ฐ ์ด๋ ๊ฒ ํด:
SwiftUI:
TextField("์ด๋ฉ์ผ", text: $email)
.accessibilityIdentifier("emailTextField")
UIKit:
emailTextField.accessibilityIdentifier = "emailTextField"
์๋ณ์๋ ๋ช ํํ๊ณ ์ผ๊ด์ฑ ์๊ฒ ์ง์ด์ผ ํด. ๋์ค์ ํ ์คํธ ์ฝ๋๋ฅผ ์ฝ์ ๋ ๋ฌด์จ ์์์ธ์ง ๋ฐ๋ก ์ ์ ์๋๋ก! ๐
๐ฌ UI ํ ์คํธ ๋ ์ฝ๋ฉ ๊ธฐ๋ฅ
Xcode์ ์จ๊ฒจ์ง ๋ณด์ ๊ฐ์ ๊ธฐ๋ฅ์ด ์์ด! ๋ฐ๋ก UI ํ ์คํธ ๋ ์ฝ๋ฉ์ด์ผ. ์ง์ ์ฑ์ ์กฐ์ํ๋ฉด Xcode๊ฐ ์๋์ผ๋ก ํ ์คํธ ์ฝ๋๋ฅผ ์์ฑํด์ค. ๐ฅ
๐ฌ ๋ ์ฝ๋ฉ ์ฌ์ฉ ๋ฐฉ๋ฒ
1๏ธโฃ UI ํ
์คํธ ๋ฉ์๋ ์์ ์ปค์๋ฅผ ๋์
2๏ธโฃ Xcode ํ๋จ์ ๋นจ๊ฐ ๋
นํ ๋ฒํผ์ ํด๋ฆญํด
3๏ธโฃ ์๋ฎฌ๋ ์ดํฐ์์ ์ฑ์ ์กฐ์ํด
4๏ธโฃ ๋ค์ ๋
นํ ๋ฒํผ์ ๋๋ฌ์ ์ค์งํด
5๏ธโฃ ์์ฑ๋ ์ฝ๋๋ฅผ ํ์ธํ๊ณ ํ์ํ assertion์ ์ถ๊ฐํด
๋ ์ฝ๋ฉ์ ์์์ ์ผ๋ก๋ ์ข์ง๋ง, ์์ฑ๋ ์ฝ๋๋ฅผ ๊ทธ๋๋ก ์ฐ๋ฉด ์ ๋ผ! ๋ถํ์ํ ๋ถ๋ถ์ ์ ๋ฆฌํ๊ณ , ์๋ฏธ ์๋ assertion์ ์ถ๊ฐํด์ผ ํด. ๐จ
๐ฑ ๋ค์ํ UI ์์ ๋ค๋ฃจ๊ธฐ
UI ํ ์คํธ์์ ์ฌ์ฉํ ์ ์๋ ๋ค์ํ ์ฟผ๋ฆฌ ๋ฐฉ๋ฒ๋ค์ ์์๋ณด์:
class UIElementsTests: XCTestCase {
var app: XCUIApplication!
override func setUp() {
super.setUp()
app = XCUIApplication()
app.launch()
}
func testVariousUIElements() {
// ๋ฒํผ
let button = app.buttons["submitButton"]
button.tap()
// ํ
์คํธ ํ๋
let textField = app.textFields["nameField"]
textField.tap()
textField.typeText("ํ๊ธธ๋")
// ๋ณด์ ํ
์คํธ ํ๋ (๋น๋ฐ๋ฒํธ)
let secureField = app.secureTextFields["passwordField"]
secureField.tap()
secureField.typeText("secret123")
// ์ค์์น
let toggle = app.switches["notificationSwitch"]
if toggle.value as? String == "0" {
toggle.tap() // OFF -> ON
}
// ์ฌ๋ผ์ด๋
let slider = app.sliders["volumeSlider"]
slider.adjust(toNormalizedSliderPosition: 0.7) // 70% ์์น๋ก
// ํผ์ปค
let picker = app.pickers["datePicker"]
picker.pickerWheels.element(boundBy: 0).adjust(toPickerWheelValue: "2024")
// ํ
์ด๋ธ๋ทฐ ์
let tableView = app.tables["userList"]
let firstCell = tableView.cells.element(boundBy: 0)
firstCell.tap()
// ์ปฌ๋ ์
๋ทฐ ์
let collectionView = app.collectionViews["photoGrid"]
let thirdItem = collectionView.cells.element(boundBy: 2)
thirdItem.tap()
// ์๋ฆผ์ฐฝ
let alert = app.alerts["๊ฒฝ๊ณ "]
if alert.exists {
alert.buttons["ํ์ธ"].tap()
}
// ์คํฌ๋กค
let scrollView = app.scrollViews.firstMatch
scrollView.swipeUp()
scrollView.swipeDown()
// ํน์ ํ
์คํธ๊ฐ ์๋ ์์ ์ฐพ๊ธฐ
let label = app.staticTexts["ํ์ํฉ๋๋ค"]
XCTAssertTrue(label.exists)
// ์ฌ๋ฌ ๊ฐ ์ค ํน์ ์์
let secondButton = app.buttons.element(boundBy: 1)
secondButton.tap()
}
func testWaitingForElements() {
// ์์๊ฐ ๋ํ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๊ธฐ
let loadingIndicator = app.activityIndicators["loadingSpinner"]
let disappearPredicate = NSPredicate(format: "exists == false")
let expectation = XCTNSPredicateExpectation(
predicate: disappearPredicate,
object: loadingIndicator
)
let result = XCTWaiter.wait(for: [expectation], timeout: 10)
XCTAssertEqual(result, .completed, "๋ก๋ฉ์ด 10์ด ๋ด์ ์๋ฃ๋์ด์ผ ํฉ๋๋ค")
// ๊ฐ๋จํ ๋ฐฉ๋ฒ
let resultLabel = app.staticTexts["resultLabel"]
XCTAssertTrue(resultLabel.waitForExistence(timeout: 5))
}
}
๐ฏ UI ํ ์คํธ ๋ฒ ์คํธ ํ๋ํฐ์ค
โ ํต์ฌ ์๋๋ฆฌ์ค๋ง
๋ชจ๋ ํ๋ฉด์ ํ ์คํธํ๋ ค๊ณ ํ์ง ๋ง. ์ฌ์ฉ์๊ฐ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ํต์ฌ ํ๋ฆ๋ง ํ ์คํธํด.
๐ญ Page Object ํจํด
ํ๋ฉด๋ณ๋ก ํด๋์ค๋ฅผ ๋ง๋ค์ด์ UI ์์์ ๋์์ ์บก์ํํ๋ฉด ์ ์ง๋ณด์๊ฐ ์ฌ์์ ธ.
โฑ๏ธ ์ ์ ํ ๋๊ธฐ ์๊ฐ
๋คํธ์ํฌ ์์ฒญ์ด๋ ์ ๋๋ฉ์ด์ ์ ๊ณ ๋ คํด์ ์ถฉ๋ถํ ๋๊ธฐ ์๊ฐ์ ์ค์ ํด.
๐ ์ฌ์๋ ๋ก์ง
UI ํ ์คํธ๋ ๋ถ์์ ํ ์ ์์ด. ์ค์ํ ํ ์คํธ๋ ์คํจ ์ ์ฌ์๋ํ๋ ๋ก์ง์ ์ถ๊ฐํด.
// Page Object ํจํด ์์
class LoginScreen {
let app: XCUIApplication
init(app: XCUIApplication) {
self.app = app
}
// UI ์์๋ค
var emailField: XCUIElement {
app.textFields["emailTextField"]
}
var passwordField: XCUIElement {
app.secureTextFields["passwordTextField"]
}
var loginButton: XCUIElement {
app.buttons["loginButton"]
}
// ๋์๋ค
func enterEmail(_ email: String) {
emailField.tap()
emailField.typeText(email)
}
func enterPassword(_ password: String) {
passwordField.tap()
passwordField.typeText(password)
}
func tapLoginButton() {
loginButton.tap()
}
func login(email: String, password: String) {
enterEmail(email)
enterPassword(password)
tapLoginButton()
}
// ๊ฒ์ฆ
func isDisplayed() -> Bool {
return emailField.exists && passwordField.exists && loginButton.exists
}
}
// ์ฌ์ฉ ์
class LoginFlowTests: XCTestCase {
var app: XCUIApplication!
var loginScreen: LoginScreen!
override func setUp() {
super.setUp()
app = XCUIApplication()
app.launch()
loginScreen = LoginScreen(app: app)
}
func testLoginFlow() {
XCTAssertTrue(loginScreen.isDisplayed())
loginScreen.login(email: "test@example.com", password: "Password123")
// ๋ค์ ํ๋ฉด ๊ฒ์ฆ
let homeScreen = HomeScreen(app: app)
XCTAssertTrue(homeScreen.isDisplayed())
}
}
๐ก UI ํ ์คํธ๊ฐ ๋๋ฆฐ ์ด์ ์ ํด๊ฒฐ์ฑ
UI ํ ์คํธ๋ ์ค์ ์ฑ์ ์คํํ๊ณ ํ๋ฉด์ ๋ ๋๋งํ๊ธฐ ๋๋ฌธ์ ๋๋ฆด ์๋ฐ์ ์์ด. ํ์ง๋ง ๋ช ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ์๋๋ฅผ ๊ฐ์ ํ ์ ์์ด:
๐ ์ ๋๋ฉ์ด์
๋นํ์ฑํ: ํ
์คํธ ํ๊ฒฝ์์๋ ์ ๋๋ฉ์ด์
์ ๋๋ฉด ํจ์ฌ ๋นจ๋ผ์ ธ
๐ ๋ณ๋ ฌ ์คํ: Xcode์์ ์ฌ๋ฌ ์๋ฎฌ๋ ์ดํฐ์์ ๋์์ ํ
์คํธ ์คํ ๊ฐ๋ฅ
๐ ์ ํ์ ์คํ: ๋ณ๊ฒฝ๋ ๋ถ๋ถ๊ณผ ๊ด๋ จ๋ ํ
์คํธ๋ง ์คํ
๐ CI/CD ํ์ฉ: ๊ฐ๋ฐ ์ค์๋ ๋จ์ ํ
์คํธ๋ง, ๋ฐฐํฌ ์ ์ UI ํ
์คํธ ์คํ
๐ Swift Testing: ์๋ก์ด ํ ์คํ ํ๋ ์์ํฌ
2024๋ , ์ ํ์ด WWDC์์ ์์ ํ ์๋ก์ด ํ ์คํ ํ๋ ์์ํฌ๋ฅผ ๋ฐํํ์ด! ๋ฐ๋ก Swift Testing์ด์ผ. XCTest๋ฅผ ๋์ฒดํ๋ ๊ฑด ์๋๊ณ , ๋ ํ๋์ ์ด๊ณ Swift์ค๋ฌ์ด ๋ฐฉ์์ผ๋ก ํ ์คํธ๋ฅผ ์์ฑํ ์ ์๊ฒ ํด์ฃผ๋ ๊ฑฐ์ง. ๐
โจ Swift Testing์ ์ฃผ์ ํน์ง
๐ฏ ๊ฐ๊ฒฐํ ๋ฌธ๋ฒ
XCTest๋ณด๋ค ํจ์ฌ ๊ฐ๊ฒฐํ๊ณ ์ฝ๊ธฐ ์ฌ์ด ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ด.
โก ๋ณ๋ ฌ ์คํ
๊ธฐ๋ณธ์ ์ผ๋ก ํ ์คํธ๋ค์ด ๋ณ๋ ฌ๋ก ์คํ๋์ด ์ ์ฒด ํ ์คํธ ์๊ฐ์ด ๋จ์ถ๋ผ.
๐ท๏ธ ํ๊ทธ ์์คํ
ํ ์คํธ์ ํ๊ทธ๋ฅผ ๋ถ์ฌ์ ํน์ ๊ทธ๋ฃน๋ง ์คํํ ์ ์์ด.
๐ ํ๋ผ๋ฏธํฐํ
๊ฐ์ ํ ์คํธ๋ฅผ ์ฌ๋ฌ ์ ๋ ฅ๊ฐ์ผ๋ก ์ฝ๊ฒ ๋ฐ๋ณต ์คํํ ์ ์์ด.
๐ XCTest vs Swift Testing ๋น๊ต
๊ฐ์ ํ ์คํธ๋ฅผ ๋ ํ๋ ์์ํฌ๋ก ์์ฑํด๋ณด๋ฉด ์ฐจ์ด๊ฐ ํ ๋๊ปด์ ธ:
// XCTest ๋ฐฉ์
import XCTest
class CalculatorTests: XCTestCase {
var calculator: Calculator!
override func setUp() {
super.setUp()
calculator = Calculator()
}
override func tearDown() {
calculator = nil
super.tearDown()
}
func testAddition() {
let result = calculator.add(2, 3)
XCTAssertEqual(result, 5)
}
func testSubtraction() {
let result = calculator.subtract(5, 3)
XCTAssertEqual(result, 2)
}
}
// Swift Testing ๋ฐฉ์
import Testing
@Suite("๊ณ์ฐ๊ธฐ ํ
์คํธ")
struct CalculatorTests {
let calculator = Calculator()
@Test("๋ง์
ํ
์คํธ")
func addition() {
let result = calculator.add(2, 3)
#expect(result == 5)
}
@Test("๋บ์
ํ
์คํธ")
func subtraction() {
let result = calculator.subtract(5, 3)
#expect(result == 2)
}
}
์ฐจ์ด์ ์ด ๋ณด์ด์ง? Swift Testing์:
โ
struct๋ฅผ ์ฌ์ฉํ ์ ์์ด (ํด๋์ค ์์ ๋ถํ์)
โ
setUp/tearDown ๋์ ์ผ๋ฐ ์ด๊ธฐํ ์ฌ์ฉ
โ
@Test ์ดํธ๋ฆฌ๋ทฐํธ๋ก ํ
์คํธ ํ์
โ
#expect ๋งคํฌ๋ก๋ก ๋ ์์ฐ์ค๋ฌ์ด ๊ฒ์ฆ
โ
ํ
์คํธ์ ์ค๋ช
์ ์ง์ ๋ถ์ผ ์ ์์ด
๐จ Swift Testing์ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ๋ค
1๏ธโฃ ํ๋ผ๋ฏธํฐํ๋ ํ ์คํธ
๊ฐ์ ๋ก์ง์ ์ฌ๋ฌ ์ ๋ ฅ๊ฐ์ผ๋ก ํ ์คํธํ๊ณ ์ถ์ ๋ ์์ฒญ ์ ์ฉํด:
import Testing
@Suite("์ด๋ฉ์ผ ๊ฒ์ฆ ํ
์คํธ")
struct EmailValidationTests {
@Test("์ ํจํ ์ด๋ฉ์ผ๋ค", arguments: [
"test@example.com",
"user.name@domain.co.kr",
"hello+world@test.org"
])
func validEmails(email: String) {
let validator = EmailValidator()
#expect(validator.isValid(email))
}
@Test("์ ํจํ์ง ์์ ์ด๋ฉ์ผ๋ค", arguments: [
"notanemail",
"@example.com",
"user@",
"user name@example.com"
])
func invalidEmails(email: String) {
let validator = EmailValidator()
#expect(!validator.isValid(email))
}
// ์ฌ๋ฌ ํ๋ผ๋ฏธํฐ ์กฐํฉ ํ
์คํธ
@Test("๋น๋ฐ๋ฒํธ ๊ฐ๋", arguments: [
("weak", false),
("Weak123", true),
("VeryStrong123!", true),
("short", false)
])
func passwordStrength(password: String, shouldBeStrong: Bool) {
let validator = PasswordValidator()
#expect(validator.isStrong(password) == shouldBeStrong)
}
}
XCTest์์ ์ด๊ฑธ ํ๋ ค๋ฉด ๋ฐ๋ณต๋ฌธ์ ๋๋ฆฌ๊ฑฐ๋ ํ ์คํธ ๋ฉ์๋๋ฅผ ์ฌ๋ฌ ๊ฐ ๋ง๋ค์ด์ผ ํ๋๋ฐ, Swift Testing์ ํจ์ฌ ๊น๋ํ์ง? ๐
2๏ธโฃ ํ๊ทธ๋ฅผ ํ์ฉํ ํ ์คํธ ๊ทธ๋ฃนํ
import Testing
extension Tag {
@Tag static var network: Self
@Tag static var database: Self
@Tag static var ui: Self
@Tag static var critical: Self
}
@Suite("์ฌ์ฉ์ ๊ด๋ฆฌ")
struct UserManagementTests {
@Test("์ฌ์ฉ์ ์์ฑ", .tags(.database, .critical))
func createUser() {
// ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฌ์ฉ์ ์์ฑ ํ
์คํธ
}
@Test("์ฌ์ฉ์ ์ ๋ณด ๊ฐ์ ธ์ค๊ธฐ", .tags(.network))
func fetchUserInfo() {
// API์์ ์ฌ์ฉ์ ์ ๋ณด ๊ฐ์ ธ์ค๊ธฐ ํ
์คํธ
}
@Test("ํ๋กํ ํ๋ฉด ํ์", .tags(.ui))
func displayProfile() {
// UI ํ
์คํธ
}
}
// ์คํ ์ ํน์ ํ๊ทธ๋ง ์ ํ ๊ฐ๋ฅ
// swift test --filter tag:critical // ์ค์ํ ํ
์คํธ๋ง
// swift test --filter tag:network // ๋คํธ์ํฌ ํ
์คํธ๋ง
๐ฏ ํ๊ทธ ํ์ฉ ์๋๋ฆฌ์ค
๋น ๋ฅธ ํผ๋๋ฐฑ: ๊ฐ๋ฐ ์ค์๋ .critical ํ๊ทธ๋ง ์คํ
CI/CD ์ต์ ํ: PR ๋จ๊ณ์์๋ ๋น ๋ฅธ ํ
์คํธ๋ง, ๋ฐฐํฌ ์ ์๋ ์ ์ฒด ์คํ
ํ๋ซํผ๋ณ ํ
์คํธ: iOS, macOS ๋ฑ ํ๋ซํผ๋ณ๋ก ํ๊ทธ ๋ถ๋ฆฌ
๊ธฐ๋ฅ๋ณ ๊ทธ๋ฃนํ: ์ธ์ฆ, ๊ฒฐ์ , ์๋ฆผ ๋ฑ ๊ธฐ๋ฅ๋ณ๋ก ํ๊ทธ ๊ด๋ฆฌ
3๏ธโฃ ๋ ๋์ ์๋ฌ ๋ฉ์์ง
Swift Testing์ #expect ๋งคํฌ๋ก๋ ์คํจ ์ ํจ์ฌ ์์ธํ ์ ๋ณด๋ฅผ ์ ๊ณตํด:
@Test("์ฌ์ฉ์ ๋์ด ๊ฒ์ฆ")
func userAge() {
let user = User(name: "ํ๊ธธ๋", age: 25)
// XCTest ๋ฐฉ์
// XCTAssertEqual(user.age, 30)
// ์คํจ ๋ฉ์์ง: XCTAssertEqual failed: ("25") is not equal to ("30")
// Swift Testing ๋ฐฉ์
#expect(user.age == 30)
// ์คํจ ๋ฉ์์ง: Expectation failed: (user.age โ 25) == 30
// ์ค์ ๊ฐ๊ณผ ์์ ๊ฐ์ ๋ ๋ช
ํํ๊ฒ ๋ณด์ฌ์ค!
// ๋ณต์กํ ์กฐ๊ฑด๋ ๊ฐ๋ฅ
#expect(user.age >= 18 && user.age <= 65)
// ์ต์
๋ ๊ฒ์ฆ
#expect(user.email != nil)
// ์ปฌ๋ ์
๊ฒ์ฆ
let numbers = [1, 2, 3, 4, 5]
#expect(numbers.contains(3))
#expect(numbers.count == 5)
}
4๏ธโฃ ๋น๋๊ธฐ ํ ์คํธ๊ฐ ๋ ์ฌ์์ก์ด
@Suite("๋น๋๊ธฐ ์์
ํ
์คํธ")
struct AsyncTests {
@Test("์ฌ์ฉ์ ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ")
func fetchUserData() async throws {
let service = UserService()
// async/await๋ฅผ ์์ฐ์ค๋ฝ๊ฒ ์ฌ์ฉ
let user = try await service.fetchUser(id: 1)
#expect(user.name == "ํ๊ธธ๋")
#expect(user.email != nil)
}
@Test("์ฌ๋ฌ ์์ฒญ ๋์ ์ฒ๋ฆฌ")
func concurrentRequests() async throws {
let service = UserService()
// ์ฌ๋ฌ ๋น๋๊ธฐ ์์
์ ๋์์
async let user1 = service.fetchUser(id: 1)
async let user2 = service.fetchUser(id: 2)
async let user3 = service.fetchUser(id: 3)
let users = try await [user1, user2, user3]
#expect(users.count == 3)
}
@Test("ํ์์์ ํ
์คํธ")
func timeout() async {
await #expect(throws: TimeoutError.self) {
try await withTimeout(seconds: 2) {
// 3์ด ๊ฑธ๋ฆฌ๋ ์์
try await Task.sleep(nanoseconds: 3_000_000_000)
}
}
}
}
๐ XCTest์์ Swift Testing์ผ๋ก ๋ง์ด๊ทธ๋ ์ด์
๊ธฐ์กด XCTest ์ฝ๋๋ฅผ Swift Testing์ผ๋ก ์ฎ๊ธฐ๊ณ ์ถ๋ค๋ฉด:
1๏ธโฃ ํ ๋ฒ์ ๋ค ๋ฐ๊พธ์ง ๋ง๊ณ ์ ์ง์ ์ผ๋ก ์งํํด
2๏ธโฃ ์๋ก์ด ํ
์คํธ๋ Swift Testing์ผ๋ก ์์ฑํด
3๏ธโฃ ๋ ํ๋ ์์ํฌ๋ ๊ฐ์ ํ๋ก์ ํธ์์ ๊ณต์กด ๊ฐ๋ฅํด
4๏ธโฃ CI/CD ํ์ดํ๋ผ์ธ๋ ํจ๊ป ์
๋ฐ์ดํธํด์ผ ํด
Swift Testing์ iOS 18, macOS 15๋ถํฐ ์ฌ์ฉ ๊ฐ๋ฅํ๋๊น, ๋ฐฐํฌ ํ๊ฒ์ ๊ณ ๋ คํด์ ๋์ ํด์ผ ํด! ๐ฑ
๐ฏ ํ ์คํธ ์ปค๋ฒ๋ฆฌ์ง: ์ผ๋ง๋ ํ ์คํธํ์๊น?
์ฝ๋ ์ปค๋ฒ๋ฆฌ์ง๋ ์ ์ฒด ์ฝ๋ ์ค ํ ์คํธ๋ก ์คํ๋ ๋ถ๋ถ์ ๋น์จ์ ๋ํ๋ด. "๋ด ํ ์คํธ๊ฐ ์ฝ๋์ 80%๋ฅผ ์ปค๋ฒํ๋ค"๋ ์์ผ๋ก ํํํ์ง. ํ์ง๋ง ์กฐ์ฌํด์ผ ํ ๊ฒ ์์ด! ๐จ
โ ๏ธ ์ปค๋ฒ๋ฆฌ์ง์ ํจ์
100% ์ปค๋ฒ๋ฆฌ์ง = ๋ฒ๊ทธ ์์์ด ์๋์ผ! ์ฝ๋๋ฅผ ์คํํ๋ค๊ณ ํด์ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ํ ์คํธํ ๊ฑด ์๋๊ฑฐ๋ . ์๋ฅผ ๋ค์ด:
func divide(_ a: Int, _ b: Int) -> Int {
return a / b // ์ด ์ค์ด ์คํ๋๋ฉด ์ปค๋ฒ๋ฆฌ์ง 100%
}
์ ์ฝ๋๋ divide(10, 2) ํ
์คํธ ํ๋๋ง ์์ด๋ ์ปค๋ฒ๋ฆฌ์ง 100%์ผ. ํ์ง๋ง divide(10, 0)์ ํ
์คํธํ์ง ์์์ง! ๐ฅ
์ปค๋ฒ๋ฆฌ์ง๋ ์ฐธ๊ณ ์งํ์ผ ๋ฟ, ์ ๋์ ์ธ ๊ธฐ์ค์ด ์๋์ผ. ์ค์ํ ๊ฑด ์๋ฏธ ์๋ ํ ์คํธ๋ฅผ ์์ฑํ๋ ๊ฑฐ์ผ!
๐ Xcode์์ ์ปค๋ฒ๋ฆฌ์ง ํ์ธํ๊ธฐ
Xcode๋ ์ฝ๋ ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ์๊ฐ์ ์ผ๋ก ๋ณด์ฌ์ค:
๐ ์ปค๋ฒ๋ฆฌ์ง ํ์ฑํ ๋ฐฉ๋ฒ
1๏ธโฃ Product โ Scheme โ Edit Scheme ์ ํ
2๏ธโฃ Test ํญ ์ ํ
3๏ธโฃ Options ํญ์์ "Code Coverage" ์ฒดํฌ
4๏ธโฃ ํ
์คํธ ์คํ ํ Report Navigator์์ Coverage ํ์ธ
์ฝ๋ ์๋ํฐ์์ ๊ฐ ์ค ์์ ์ด๋ก์(์คํ๋จ) ๋๋ ๋นจ๊ฐ์(์คํ ์ ๋จ) ํ์๊ฐ ๋ํ๋. ์ด๊ฑธ ๋ณด๋ฉด ์ด๋ ๋ถ๋ถ์ ๋ ํ ์คํธํด์ผ ํ ์ง ํ๋์ ์ ์ ์์ด! ๐
๐ฏ ์ ์ ํ ์ปค๋ฒ๋ฆฌ์ง ๋ชฉํ
๐ข 70-80%
ํ์ค์ ์ธ ๋ชฉํ
๋๋ถ๋ถ์ ํ๋ก์ ํธ์์ ๋ฌ์ฑ ๊ฐ๋ฅํ๊ณ ํจ๊ณผ์ ์ธ ์์ค
๐ก 80-90%
๋์ ํ์ง
๊ธ์ต, ์๋ฃ ๋ฑ ์์ ์ฑ์ด ์ค์ํ ์ฑ์ ์ ํฉ
๐ด 90-100%
๊ณผ๋ํ ํฌ์
๋น์ฉ ๋๋น ํจ๊ณผ๊ฐ ๋จ์ด์ง ์ ์์ด. ํต์ฌ ๋ก์ง์๋ง ์ง์คํ๋ ๊ฒ ๋์
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ๋ค์ํ ๊ฐ๋ฐ์๋ค๊ณผ ์ด์ผ๊ธฐํด๋ณด๋ฉด, ๋๋ถ๋ถ 70-80% ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ๋ชฉํ๋ก ํ๋ค๊ณ ํด. ์ค์ํ ๊ฑด ์ซ์๊ฐ ์๋๋ผ ์ด๋ค ์ฝ๋๋ฅผ ํ ์คํธํ๋๋์ผ!
๐ฏ ์ฐ์ ์์๋ฅผ ์ ํ์
๋ชจ๋ ์ฝ๋๋ฅผ ๋๊ฐ์ด ํ ์คํธํ ํ์๋ ์์ด. ์ด๋ฐ ์์๋ก ์ฐ์ ์์๋ฅผ ์ ํด๋ด:
// 1์์: ๋น์ฆ๋์ค ๋ก์ง (๋ฐ๋์ ํ
์คํธ!)
class PaymentProcessor {
func processPayment(amount: Decimal, card: CreditCard) -> Result<Receipt, PaymentError> {
// ๊ฒฐ์ ๋ก์ง - 100% ํ
์คํธ ํ์!
}
}
// 2์์: ๋ฐ์ดํฐ ๋ณํ ๋ฐ ๊ฒ์ฆ
class UserValidator {
func validate(email: String) -> Bool {
// ๊ฒ์ฆ ๋ก์ง - ์ฃ์ง ์ผ์ด์ค๊น์ง ํ
์คํธ
}
}
// 3์์: ๋คํธ์ํฌ ๋ฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ ์ด์ด
class APIClient {
func fetchData() async throws -> Data {
// ํตํฉ ํ
์คํธ๋ก ์ปค๋ฒ
}
}
// ๋ฎ์ ์ฐ์ ์์: UI ๋ ์ด์์, ๊ฐ๋จํ getter/setter
class ProfileView: UIView {
var nameLabel: UILabel!
// UI ์ฝ๋๋ UI ํ
์คํธ๋ก ํต์ฌ๋ง ์ปค๋ฒ
}
๐ ์ค์ ํ: ํ ์คํธ๋ฅผ ์ต๊ด์ผ๋ก ๋ง๋ค๊ธฐ
์ด๋ก ์ ์ถฉ๋ถํ ๋ฐฐ์ ์ผ๋, ์ด์ ์ค์ ๋ก ํ ์คํธ๋ฅผ ์ผ์ํํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์! ๋ง์ ๊ฐ๋ฐ์๋ค์ด ํ ์คํธ์ ์ค์์ฑ์ ์์ง๋ง ์ค์ฒํ๊ธฐ ์ด๋ ค์ํ๊ฑฐ๋ . ๐
๐ฏ TDD (Test-Driven Development)
ํ ์คํธ ์ฃผ๋ ๊ฐ๋ฐ์ ์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ์ ์ ํ ์คํธ๋ฅผ ๋จผ์ ์์ฑํ๋ ๋ฐฉ๋ฒ๋ก ์ด์ผ. ์ฒ์์ ์ด์ํ๊ฒ ๋๊ปด์ง ์ ์์ง๋ง, ์ต์ํด์ง๋ฉด ์์ฒญ๋ ํจ๊ณผ๋ฅผ ๋ณผ ์ ์์ด!
๐ด Red: ์คํจํ๋ ํ ์คํธ ์์ฑ
// 1๋จ๊ณ: ํ
์คํธ๋ถํฐ ์์ฑ (์์ง ๊ตฌํ ์ ๋จ)
@Test("ํ ์ธ ๊ฐ๊ฒฉ ๊ณ์ฐ")
func discountCalculation() {
let calculator = PriceCalculator()
let originalPrice: Decimal = 10000
let discountRate: Decimal = 0.2 // 20% ํ ์ธ
let result = calculator.calculateDiscount(
originalPrice: originalPrice,
discountRate: discountRate
)
#expect(result == 8000) // ์คํจ! PriceCalculator๊ฐ ์์
}
๐ข Green: ํ ์คํธ๋ฅผ ํต๊ณผ์ํค๊ธฐ
// 2๋จ๊ณ: ํ
์คํธ๋ฅผ ํต๊ณผ์ํฌ ์ต์ํ์ ์ฝ๋ ์์ฑ
struct PriceCalculator {
func calculateDiscount(originalPrice: Decimal, discountRate: Decimal) -> Decimal {
return originalPrice * (1 - discountRate)
}
}
// ํ
์คํธ ํต๊ณผ! โ
๐ต Refactor: ์ฝ๋ ๊ฐ์ ํ๊ธฐ
// 3๋จ๊ณ: ์ฝ๋๋ฅผ ๋ ๊น๋ํ๊ฒ ๋ฆฌํฉํ ๋ง
struct PriceCalculator {
func calculateDiscount(originalPrice: Decimal, discountRate: Decimal) -> Decimal {
guard discountRate >= 0 && discountRate <= 1 else {
fatalError("ํ ์ธ์จ์ 0๊ณผ 1 ์ฌ์ด์ฌ์ผ ํฉ๋๋ค")
}
let discountAmount = originalPrice * discountRate
return originalPrice - discountAmount
}
func calculateFinalPrice(originalPrice: Decimal,
discountRate: Decimal,
taxRate: Decimal = 0.1) -> Decimal {
let discountedPrice = calculateDiscount(
originalPrice: originalPrice,
discountRate: discountRate
)
return discountedPrice * (1 + taxRate)
}
}
// ์ถ๊ฐ ํ
์คํธ ์์ฑ
@Test("์๋ชป๋ ํ ์ธ์จ ์ฒ๋ฆฌ")
func invalidDiscountRate() {
let calculator = PriceCalculator()
#expect(throws: Error.self) {
calculator.calculateDiscount(originalPrice: 10000, discountRate: 1.5)
}
}
๐ก TDD์ ์ฅ์
๋ช
ํํ ์๊ตฌ์ฌํญ: ํ
์คํธ๋ฅผ ๋จผ์ ์์ฑํ๋ฉด ๋ฌด์์ ๋ง๋ค์ด์ผ ํ๋์ง ๋ช
ํํด์ ธ.
๊ณผ๋ํ ์ค๊ณ ๋ฐฉ์ง: ํ์ํ ๋งํผ๋ง ์ฝ๋๋ฅผ ์์ฑํ๊ฒ ๋ผ.
๋ฆฌํฉํ ๋ง ์์ ๊ฐ: ํ
์คํธ๊ฐ ์์ผ๋ ์ฝ๋๋ฅผ ๋ง์๊ป ๊ฐ์ ํ ์ ์์ด.
๋ฌธ์ํ ํจ๊ณผ: ํ
์คํธ ์์ฒด๊ฐ ์ฝ๋ ์ฌ์ฉ๋ฒ์ ๋ณด์ฌ์ฃผ๋ ์์ ๊ฐ ๋ผ.
๐ CI/CD์ ํ ์คํธ ํตํฉํ๊ธฐ
ํ ์คํธ๋ฅผ ์๋ํํ๋ฉด ํ ์ ์ฒด์ ์์ฐ์ฑ์ด ์ฌ๋ผ๊ฐ! GitHub Actions๋ฅผ ์ฌ์ฉํ ์์ ๋ฅผ ๋ณผ๊ฒ:
# .github/workflows/test.yml
name: iOS Tests
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main, develop ]
jobs:
test:
runs-on: macos-latest
steps:
- uses: actions/checkout@v3
- name: Select Xcode
run: sudo xcode-select -s /Applications/Xcode_15.0.app
- name: Run Unit Tests
run: |
xcodebuild test \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 15,OS=17.0' \
-only-testing:MyAppTests \
-enableCodeCoverage YES
- name: Run Integration Tests
run: |
xcodebuild test \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 15,OS=17.0' \
-only-testing:MyAppIntegrationTests
- name: Upload Coverage
uses: codecov/codecov-action@v3
with:
files: ./coverage.xml
fail_ci_if_error: true
๐ ํ ์คํธ ์์ฑ ์ฒดํฌ๋ฆฌ์คํธ
์๋ก์ด ๊ธฐ๋ฅ์ ๋ง๋ค ๋๋ง๋ค ์ด ์ฒดํฌ๋ฆฌ์คํธ๋ฅผ ํ์ธํด๋ด:
โ ๋จ์ ํ ์คํธ
โก ์ ์ ์ผ์ด์ค ํ
์คํธ
โก ์ฃ์ง ์ผ์ด์ค ํ
์คํธ
โก ์๋ฌ ์ผ์ด์ค ํ
์คํธ
โก nil/empty ์
๋ ฅ ํ
์คํธ
โ ํตํฉ ํ ์คํธ
โก ๋ชจ๋ ๊ฐ ์ฐ๋ ํ
์คํธ
โก ๋ฐ์ดํฐ ํ๋ฆ ํ
์คํธ
โก ๋น๋๊ธฐ ์ฒ๋ฆฌ ํ
์คํธ
โก ์๋ฌ ์ ํ ํ
์คํธ
โ UI ํ ์คํธ
โก ํต์ฌ ์ฌ์ฉ์ ์๋๋ฆฌ์ค
โก ํ๋ฉด ์ ํ ํ
์คํธ
โก ์
๋ ฅ ๊ฒ์ฆ ํ
์คํธ
โก ์๋ฌ ๋ฉ์์ง ํ์
โ ์ฝ๋ ํ์ง
โก ํ
์คํธ ์ด๋ฆ์ด ๋ช
ํํ๊ฐ?
โก Given-When-Then ๊ตฌ์กฐ
โก ํ๋์ ํ
์คํธ, ํ๋์ ๊ฒ์ฆ
โก ํ
์คํธ ๊ฐ ๋
๋ฆฝ์ฑ ๋ณด์ฅ
๐จ ํ ์คํธ ๊ฐ๋ฅํ ์ฝ๋ ์์ฑํ๊ธฐ
ํ ์คํธํ๊ธฐ ์ฌ์ด ์ฝ๋๋ ์์ฐ์ค๋ฝ๊ฒ ์ข์ ์ฝ๋๊ฐ ๋ผ. ๋ช ๊ฐ์ง ์์น์ ์๊ฐํ ๊ฒ:
// โ ํ
์คํธํ๊ธฐ ์ด๋ ค์ด ์ฝ๋
class UserViewController: UIViewController {
func loadUser() {
// ์ง์ ๋คํธ์ํฌ ์์ฒญ
URLSession.shared.dataTask(with: URL(string: "api.com/user")!) { data, _, _ in
guard let data = data else { return }
let user = try? JSONDecoder().decode(User.self, from: data)
// ์ง์ UI ์
๋ฐ์ดํธ
DispatchQueue.main.async {
self.nameLabel.text = user?.name
}
}.resume()
}
}
// โ
ํ
์คํธํ๊ธฐ ์ฌ์ด ์ฝ๋
protocol UserServiceProtocol {
func fetchUser() async throws -> User
}
class UserViewModel {
private let userService: UserServiceProtocol
@Published var userName: String = ""
@Published var errorMessage: String?
init(userService: UserServiceProtocol) {
self.userService = userService
}
func loadUser() async {
do {
let user = try await userService.fetchUser()
userName = user.name
} catch {
errorMessage = "์ฌ์ฉ์ ์ ๋ณด๋ฅผ ๋ถ๋ฌ์ฌ ์ ์์ต๋๋ค"
}
}
}
// ํ
์คํธ ์ฝ๋
class MockUserService: UserServiceProtocol {
var mockUser: User?
var shouldThrowError = false
func fetchUser() async throws -> User {
if shouldThrowError {
throw NSError(domain: "Test", code: -1)
}
return mockUser ?? User(name: "ํ
์คํธ")
}
}
@Test("์ฌ์ฉ์ ๋ก๋ ์ฑ๊ณต")
func loadUserSuccess() async {
// Given
let mockService = MockUserService()
mockService.mockUser = User(name: "ํ๊ธธ๋")
let viewModel = UserViewModel(userService: mockService)
// When
await viewModel.loadUser()
// Then
#expect(viewModel.userName == "ํ๊ธธ๋")
#expect(viewModel.errorMessage == nil)
}
๐๏ธ SOLID ์์น๊ณผ ํ ์คํธ
ํ ์คํธ ๊ฐ๋ฅํ ์ฝ๋๋ SOLID ์์น์ ๋ฐ๋ฅด๋ ๊ฒฝ์ฐ๊ฐ ๋ง์:
S - ๋จ์ผ ์ฑ
์: ํ๋์ ํด๋์ค๋ ํ๋์ ์ฑ
์๋ง โ ํ
์คํธํ๊ธฐ ์ฌ์
O - ๊ฐ๋ฐฉ-ํ์: ํ์ฅ์๋ ์ด๋ ค์๊ณ ์์ ์๋ ๋ซํ์์ โ Mock ๊ฐ์ฒด ์ฃผ์
๊ฐ๋ฅ
L - ๋ฆฌ์ค์ฝํ ์นํ: ํ์ ํ์
์ ์์ ํ์
์ ๋์ฒด ๊ฐ๋ฅ โ Mock์ด ์ค์ ๊ฐ์ฒด๋ฅผ ๋์ฒด
I - ์ธํฐํ์ด์ค ๋ถ๋ฆฌ: ํด๋ผ์ด์ธํธ๋ณ ์ธํฐํ์ด์ค ๋ถ๋ฆฌ โ ํ์ํ ๋ถ๋ถ๋ง Mock
D - ์์กด์ฑ ์ญ์ : ์ถ์ํ์ ์์กด โ ์์กด์ฑ ์ฃผ์
์ผ๋ก ํ
์คํธ ์ฉ์ด
๐ ๋ง๋ฌด๋ฆฌ: ํ ์คํธ๋ ํฌ์๋ค
์ฌ๊ธฐ๊น์ง ๊ธด ์ฌ์ ์ ํจ๊ปํด์ค์ ๊ณ ๋ง์! ๐ ๋จ์ ํ ์คํธ๋ถํฐ ํตํฉ ํ ์คํธ, UI ํ ์คํธ, ๊ทธ๋ฆฌ๊ณ ์ต์ Swift Testing๊น์ง ์ ๋ง ๋ง์ ๋ด์ฉ์ ๋ค๋ค์ง?
ํ ์คํธ ์์ฑ์ ์ฒ์์ ์๊ฐ์ด ๋ ๊ฑธ๋ฆฌ๋ ๊ฒ์ฒ๋ผ ๋๊ปด์ง ์ ์์ด. "์ด ์๊ฐ์ ๊ธฐ๋ฅ ํ๋ ๋ ๋ง๋ค์ง"๋ผ๋ ์๊ฐ์ด ๋ค ์๋ ์๊ณ . ํ์ง๋ง ์ฅ๊ธฐ์ ์ผ๋ก ๋ณด๋ฉด ํ ์คํธ๋ ์๊ฐ์ ์ ์ฝํด์ค. ๋ฒ๊ทธ๋ฅผ ์ผ์ฐ ๋ฐ๊ฒฌํ๊ณ , ๋ฆฌํฉํ ๋ง์ ์์ ์๊ฒ ํ๊ณ , ์๋ก์ด ํ์์ด ์๋ ์์ ํ๊ฒ ์ฝ๋๋ฅผ ์์ ํ ์ ์๊ฑฐ๋ .
๐ ํต์ฌ ์์ฝ
ํ
์คํธ ํผ๋ผ๋ฏธ๋: ๋จ์ ํ
์คํธ 70%, ํตํฉ ํ
์คํธ 20%, UI ํ
์คํธ 10%
XCTest: iOS์ ๊ธฐ๋ณธ ํ
์คํ
ํ๋ ์์ํฌ, ์์ ์ ์ด๊ณ ์ฑ์ํจ
Swift Testing: ํ๋์ ์ด๊ณ ๊ฐ๊ฒฐํ ์๋ก์ด ํ๋ ์์ํฌ
TDD: Red-Green-Refactor ์ฌ์ดํด๋ก ํ์ง ๋์ ์ฝ๋ ์์ฑ
์ปค๋ฒ๋ฆฌ์ง: ์ซ์๋ณด๋ค ์๋ฏธ ์๋ ํ
์คํธ๊ฐ ์ค์
CI/CD: ํ
์คํธ ์๋ํ๋ก ํ ์์ฐ์ฑ ํฅ์
์ฌ๋ฅ๋ท์์ ๋ง์ ๊ฐ๋ฐ์๋ค๊ณผ ์ด์ผ๊ธฐํ๋ค ๋ณด๋ฉด, ํ ์คํธ๋ฅผ ์ ํ์ฉํ๋ ๊ฐ๋ฐ์๋ค์ด ๋ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ๋ ๊ฑธ ๋ณผ ์ ์์ด. ์ฒ์์ ์ด๋ ต๊ณ ๊ท์ฐฎ์ ์ ์์ง๋ง, ํ ๋ฒ ์ต๊ด์ด ๋๋ฉด ํ ์คํธ ์์ด๋ ์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ๋ถ์ํด์ง ๊ฑฐ์ผ! ๐
๐ ๋ค์ ๋จ๊ณ
์ด์ ๋น์ฅ ์ค์ฒํด๋ณผ ์ ์๋ ๊ฒ๋ค:
1๏ธโฃ ์๊ฒ ์์ํ๊ธฐ
์๋ก์ด ํจ์๋ฅผ ๋ง๋ค ๋๋ง๋ค ๊ฐ๋จํ ํ ์คํธ ํ๋์ฉ ์ถ๊ฐํด๋ด.
2๏ธโฃ ๋ ๊ฑฐ์ ์ฝ๋
๋ฒ๊ทธ๋ฅผ ๊ณ ์น ๋๋ง๋ค ๊ทธ ๋ฒ๊ทธ๋ฅผ ์ฌํํ๋ ํ ์คํธ๋ฅผ ๋จผ์ ์์ฑํด.
3๏ธโฃ ํ๊ณผ ๊ณต์
ํ ์คํธ ์์ฑ ๊ฐ์ด๋๋ฅผ ๋ง๋ค๊ณ ํ์๋ค๊ณผ ๋ฒ ์คํธ ํ๋ํฐ์ค๋ฅผ ๊ณต์ ํด.
4๏ธโฃ ์ง์์ ํ์ต
๋ค๋ฅธ ๊ฐ๋ฐ์๋ค์ ํ ์คํธ ์ฝ๋๋ฅผ ์ฝ์ด๋ณด๊ณ ์ข์ ํจํด์ ๋ฐฐ์.
ํ ์คํธ๋ ์๋ฒฝํ ํ์ ์์ด. ์กฐ๊ธ์ฉ, ๊พธ์คํ ๊ฐ์ ํด๋๊ฐ๋ฉด ๋ผ. ์ค๋ ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก ๋น์ฅ ๋ด์ผ๋ถํฐ ์์ ํ ์คํธ ํ๋์ฉ ์ถ๊ฐํด๋ณด์! ๐ช
๊ถ๊ธํ ์ ์ด ์๊ฑฐ๋ ๋ ๊น์ด ์๋ ๋ด์ฉ์ด ํ์ํ๋ค๋ฉด, ์ฌ๋ฅ๋ท์ ์ง์์ธ์ ์ฒ์์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ์ํตํด๋ด. ํจ๊ป ์ฑ์ฅํ๋ ๊ฒ ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ์ด๋๊น! ๐ณ
ํ๋ณตํ ์ฝ๋ฉ, ๊ทธ๋ฆฌ๊ณ ์ฆ๊ฑฐ์ด ํ ์คํ ๋๊ธธ ๋ฐ๋๊ฒ! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.