단위 테스트

소프트웨어 개발에서 테스트는 코드의 정확성을 검증하고 결함을 조기에 발견하는 데 핵심적인 역할을 합니다. 이 장에서는 Flutter 애플리케이션의 단위 테스트에 대해 다루겠습니다. 단위 테스트는 코드의 가장 작은 단위(일반적으로 함수나 메서드)가 예상대로 작동하는지 확인하는 테스트입니다.

단위 테스트의 중요성

단위 테스트는 다음과 같은 여러 이유로 중요합니다:

버그 조기 발견: 코드 변경이 기존 기능을 손상시키지 않는지 확인할 수 있습니다.
리팩토링 신뢰성: 코드를 변경하더라도 동작이 여전히 올바른지 확인할 수 있습니다.
문서화: 테스트는 코드가 어떻게 동작해야 하는지 보여주는 생생한 문서 역할을 합니다.
설계 개선: 테스트를 작성하면 종종 더 나은 코드 설계로 이어집니다.
개발 속도 향상: 장기적으로 디버깅 시간이 줄어들어 개발 속도가 빨라집니다.

Flutter에서 단위 테스트 설정하기

1. 의존성 추가

Flutter 프로젝트에서 단위 테스트를 시작하려면 pubspec.yaml 파일에 필요한 패키지를 추가해야 합니다:

1
dev_dependencies:
2
  flutter_test:
3
    sdk: flutter
4
  test: ^1.24.1

flutter_test는 Flutter SDK의 일부로, Flutter 위젯을 테스트하는 데 필요한 도구를 제공합니다. test 패키지는 일반 Dart 코드를 테스트하는 데 사용됩니다.

2. 테스트 파일 구성

테스트 파일은 일반적으로 프로젝트의 test 디렉토리에 위치합니다. 테스트 파일 이름은 관례적으로 {파일명}_test.dart 형식을 따릅니다:

1
my_app/
2
  ├── lib/
3
  │    ├── models/
4
  │    │    └── user.dart
5
  │    └── utils/
6
  │         └── validator.dart
7
  └── test/
8
       ├── models/
9
       │    └── user_test.dart
10
       └── utils/
11
            └── validator_test.dart

기본 단위 테스트 작성하기

1. 간단한 유틸리티 함수 테스트

먼저 테스트할 간단한 유틸리티 함수를 살펴보겠습니다:

1
class Calculator {
2
  int add(int a, int b) => a + b;
3
  int subtract(int a, int b) => a - b;
4
  int multiply(int a, int b) => a * b;
5
  double divide(int a, int b) {
6
    if (b == 0) {
7
      throw ArgumentError('Cannot divide by zero');
8
    }
9
    return a / b;
10
  }
11
}

이제 이 Calculator 클래스의 단위 테스트를 작성해 보겠습니다:

1
import 'package:flutter_test/flutter_test.dart';
2
import 'package:my_app/utils/calculator.dart';
3

4
void main() {
5
  late Calculator calculator;
6

7
  setUp(() {
8
    calculator = Calculator();
9
  });
10

11
  group('Calculator', () {
12
    test('add returns the sum of two numbers', () {
13
      // Arrange & Act
14
      final result = calculator.add(2, 3);
15

16
      // Assert
17
      expect(result, 5);
18
    });
19

20
    test('subtract returns the difference of two numbers', () {
21
      expect(calculator.subtract(5, 2), 3);
22
    });
23

24
    test('multiply returns the product of two numbers', () {
25
      expect(calculator.multiply(3, 4), 12);
26
    });
27

28
    test('divide returns the quotient of two numbers', () {
29
      expect(calculator.divide(10, 2), 5.0);
30
    });
31

32
    test('divide throws ArgumentError when dividing by zero', () {
33
      expect(
34
        () => calculator.divide(10, 0),
35
        throwsA(isA<ArgumentError>()),
36
      );
37
    });
38
  });
39
}

2. 테스트 실행하기

테스트를 실행하는 방법은 여러 가지가 있습니다:

명령줄에서 실행:

1
flutter test

특정 테스트 파일만 실행:

1
flutter test test/utils/calculator_test.dart

IDE에서 실행:

대부분의 IDE(예: VS Code, Android Studio)는 테스트 파일 옆에 실행 버튼을 제공하여 쉽게 테스트를 실행할 수 있습니다.

모델 클래스 테스트

모델 클래스의 테스트는 특히 JSON 변환과 관련된 코드를 검증하는 데 유용합니다:

1
class User {
2
  final int id;
3
  final String name;
4
  final String email;
5

6
  User({
7
    required this.id,
8
    required this.name,
9
    required this.email,
10
  });
11

12
  factory User.fromJson(Map<String, dynamic> json) {
13
    return User(
14
      id: json['id'] as int,
15
      name: json['name'] as String,
16
      email: json['email'] as String,
17
    );
18
  }
19

20
  Map<String, dynamic> toJson() {
21
    return {
22
      'id': id,
23
      'name': name,
24
      'email': email,
25
    };
26
  }
27

28
  @override
29
  bool operator ==(Object other) {
30
    if (identical(this, other)) return true;
31
    return other is User &&
32
        other.id == id &&
33
        other.name == name &&
34
        other.email == email;
35
  }
36

37
  @override
38
  int get hashCode => id.hashCode ^ name.hashCode ^ email.hashCode;
39
}

이 User 클래스에 대한 테스트:

1
import 'package:flutter_test/flutter_test.dart';
2
import 'package:my_app/models/user.dart';
3

4
void main() {
5
  group('User', () {
6
    test('fromJson creates a User instance correctly', () {
7
      // Arrange
8
      final json = {
9
        'id': 1,
10
        'name': '홍길동',
11
        'email': 'hong@example.com',
12
      };
13

14
      // Act
15
      final user = User.fromJson(json);
16

17
      // Assert
18
      expect(user.id, 1);
19
      expect(user.name, '홍길동');
20
      expect(user.email, 'hong@example.com');
21
    });
22

23
    test('toJson returns correct map', () {
24
      // Arrange
25
      final user = User(
26
        id: 1,
27
        name: '홍길동',
28
        email: 'hong@example.com',
29
      );
30

31
      // Act
32
      final json = user.toJson();
33

34
      // Assert
35
      expect(json, {
36
        'id': 1,
37
        'name': '홍길동',
38
        'email': 'hong@example.com',
39
      });
40
    });
41

42
    test('equality works correctly', () {
43
      // Arrange
44
      final user1 = User(id: 1, name: '홍길동', email: 'hong@example.com');
45
      final user2 = User(id: 1, name: '홍길동', email: 'hong@example.com');
46
      final user3 = User(id: 2, name: '김철수', email: 'kim@example.com');
47

48
      // Assert
49
      expect(user1, equals(user2));
50
      expect(user1, isNot(equals(user3)));
51
    });
52

53
    test('fromJson throws when fields are missing', () {
54
      // Arrange
55
      final incompleteJson = {
56
        'id': 1,
57
        'name': '홍길동',
58
        // email이 누락됨
59
      };
60

61
      // Act & Assert
62
      expect(
63
        () => User.fromJson(incompleteJson),
64
        throwsA(isA<TypeError>()),
65
      );
66
    });
67
  });
68
}

비동기 코드 테스트

Flutter 앱에서는 네트워크 요청, 파일 입출력 등 비동기 코드가 흔합니다. 이러한 코드를 테스트하는 방법을 살펴보겠습니다:

1
import 'dart:convert';
2
import 'package:http/http.dart' as http;
3
import '../models/user.dart';
4

5
class UserService {
6
  final String baseUrl;
7
  final http.Client client;
8

9
  UserService({
10
    required this.baseUrl,
11
    required this.client,
12
  });
13

14
  Future<User> fetchUser(int id) async {
15
    final response = await client.get(Uri.parse('$baseUrl/users/$id'));
16

17
    if (response.statusCode == 200) {
18
      return User.fromJson(json.decode(response.body));
19
    } else {
20
      throw Exception('Failed to load user');
21
    }
22
  }
23

24
  Future<List<User>> fetchUsers() async {
25
    final response = await client.get(Uri.parse('$baseUrl/users'));
26

27
    if (response.statusCode == 200) {
28
      final List<dynamic> userJsonList = json.decode(response.body);
29
      return userJsonList.map((json) => User.fromJson(json)).toList();
30
    } else {
31
      throw Exception('Failed to load users');
32
    }
33
  }
34
}

이 UserService 클래스의 단위 테스트:

1
import 'dart:convert';
2
import 'package:flutter_test/flutter_test.dart';
3
import 'package:http/http.dart' as http;
4
import 'package:mockito/annotations.dart';
5
import 'package:mockito/mockito.dart';
6
import 'package:my_app/models/user.dart';
7
import 'package:my_app/services/user_service.dart';
8

9
import 'user_service_test.mocks.dart';
10

11
// Mockito를 사용하여 http.Client 클래스를 모방하는 Mock 클래스 생성
12
@GenerateMocks([http.Client])
13
void main() {
14
  late MockClient mockClient;
15
  late UserService userService;
16

17
  setUp(() {
18
    mockClient = MockClient();
19
    userService = UserService(
20
      baseUrl: 'https://api.example.com',
21
      client: mockClient,
22
    );
23
  });
24

25
  group('UserService', () {
26
    test('fetchUser returns a User if the http call completes successfully', () async {
27
      // Arrange
28
      final userData = {
29
        'id': 1,
30
        'name': '홍길동',
31
        'email': 'hong@example.com',
32
      };
33

34
      // mock 클라이언트가 GET 요청을 받으면 가짜 응답을 반환하도록 설정
35
      when(mockClient.get(Uri.parse('https://api.example.com/users/1')))
36
          .thenAnswer((_) async => http.Response(json.encode(userData), 200));
37

38
      // Act
39
      final user = await userService.fetchUser(1);
40

41
      // Assert
42
      expect(user.id, 1);
43
      expect(user.name, '홍길동');
44
      expect(user.email, 'hong@example.com');
45
    });
46

47
    test('fetchUser throws an exception if the http call fails', () async {
48
      // Arrange
49
      when(mockClient.get(Uri.parse('https://api.example.com/users/1')))
50
          .thenAnswer((_) async => http.Response('Not Found', 404));
51

52
      // Act & Assert
53
      expect(userService.fetchUser(1), throwsException);
54
    });
55

56
    test('fetchUsers returns a list of Users if the http call completes successfully', () async {
57
      // Arrange
58
      final usersData = [
59
        {
60
          'id': 1,
61
          'name': '홍길동',
62
          'email': 'hong@example.com',
63
        },
64
        {
65
          'id': 2,
66
          'name': '김철수',
67
          'email': 'kim@example.com',
68
        },
69
      ];
70

71
      when(mockClient.get(Uri.parse('https://api.example.com/users')))
72
          .thenAnswer((_) async => http.Response(json.encode(usersData), 200));
73

74
      // Act
75
      final users = await userService.fetchUsers();
76

77
      // Assert
78
      expect(users.length, 2);
79
      expect(users[0].id, 1);
80
      expect(users[0].name, '홍길동');
81
      expect(users[1].id, 2);
82
      expect(users[1].name, '김철수');
83
    });
84
  });
85
}

이 테스트를 실행하기 전에 Mockito 패키지를 설치하고 코드를 생성해야 합니다:

1
dev_dependencies:
2
  flutter_test:
3
    sdk: flutter
4
  mockito: ^5.4.2
5
  build_runner: ^2.4.6

그리고 다음 명령어를 실행하여 Mock 클래스를 생성합니다:

1
flutter pub run build_runner build

비즈니스 로직 레이어(Provider, Riverpod, Bloc 등) 테스트

상태 관리 라이브러리를 사용하는 비즈니스 로직 레이어 테스트를 살펴보겠습니다. 여기서는 Riverpod를 예시로 들겠습니다:

1
import 'package:riverpod_annotation/riverpod_annotation.dart';
2

3
part 'counter_provider.g.dart';
4

5
@riverpod
6
class Counter extends _$Counter {
7
  @override
8
  int build() => 0;
9

10
  void increment() {
11
    state = state + 1;
12
  }
13

14
  void decrement() {
15
    if (state > 0) {
16
      state = state - 1;
17
    }
18
  }
19

20
  void reset() {
21
    state = 0;
22
  }
23
}

이 Riverpod 프로바이더의 단위 테스트:

1
import 'package:flutter_riverpod/flutter_riverpod.dart';
2
import 'package:flutter_test/flutter_test.dart';
3
import 'package:my_app/providers/counter_provider.dart';
4

5
void main() {
6
  late ProviderContainer container;
7

8
  setUp(() {
9
    container = ProviderContainer();
10
  });
11

12
  tearDown(() {
13
    container.dispose();
14
  });
15

16
  group('CounterProvider', () {
17
    test('initial value is 0', () {
18
      final value = container.read(counterProvider);
19
      expect(value, 0);
20
    });
21

22
    test('increment increases state by 1', () {
23
      final notifier = container.read(counterProvider.notifier);
24

25
      // 초기값 확인
26
      expect(container.read(counterProvider), 0);
27

28
      // 증가 실행
29
      notifier.increment();
30

31
      // 변경된 값 확인
32
      expect(container.read(counterProvider), 1);
33
    });
34

35
    test('decrement decreases state by 1', () {
36
      final notifier = container.read(counterProvider.notifier);
37

38
      // 초기값을 1로 변경
39
      notifier.increment();
40
      expect(container.read(counterProvider), 1);
41

42
      // 감소 실행
43
      notifier.decrement();
44

45
      // 변경된 값 확인
46
      expect(container.read(counterProvider), 0);
47
    });
48

49
    test('decrement does not go below 0', () {
50
      final notifier = container.read(counterProvider.notifier);
51

52
      // 초기값 확인
53
      expect(container.read(counterProvider), 0);
54

55
      // 감소 실행
56
      notifier.decrement();
57

58
      // 여전히 0이어야 함
59
      expect(container.read(counterProvider), 0);
60
    });
61

62
    test('reset sets state back to 0', () {
63
      final notifier = container.read(counterProvider.notifier);
64

65
      // 증가 실행
66
      notifier.increment();
67
      notifier.increment();
68
      expect(container.read(counterProvider), 2);
69

70
      // 리셋 실행
71
      notifier.reset();
72

73
      // 0으로 리셋됨
74
      expect(container.read(counterProvider), 0);
75
    });
76

77
    test('confirms state changes correctly with multiple operations', () {
78
      final notifier = container.read(counterProvider.notifier);
79

80
      notifier.increment(); // 1
81
      notifier.increment(); // 2
82
      notifier.decrement(); // 1
83
      notifier.increment(); // 2
84
      notifier.increment(); // 3
85

86
      expect(container.read(counterProvider), 3);
87
    });
88
  });
89
}

Freezed 또는 json_serializable 모델 테스트

Freezed나 json_serializable을 사용하는 모델의 테스트 예시입니다:

1
import 'package:freezed_annotation/freezed_annotation.dart';
2
import 'package:json_annotation/json_annotation.dart';
3

4
part 'product.freezed.dart';
5
part 'product.g.dart';
6

7
@freezed
8
class Product with _$Product {
9
  const factory Product({
10
    required int id,
11
    required String name,
12
    required double price,
13
    @Default(0) int stock,
14
    String? description,
15
    @Default([]) List<String> categories,
16
  }) = _Product;
17

18
  factory Product.fromJson(Map<String, dynamic> json) => _$ProductFromJson(json);
19
}

이 Freezed 모델의 테스트:

1
import 'package:flutter_test/flutter_test.dart';
2
import 'package:my_app/models/product.dart';
3

4
void main() {
5
  group('Product', () {
6
    test('fromJson creates a valid Product instance', () {
7
      // Arrange
8
      final json = {
9
        'id': 1,
10
        'name': '노트북',
11
        'price': 1200000.0,
12
        'stock': 10,
13
        'description': '고성능 노트북',
14
        'categories': ['전자제품', '컴퓨터'],
15
      };
16

17
      // Act
18
      final product = Product.fromJson(json);
19

20
      // Assert
21
      expect(product.id, 1);
22
      expect(product.name, '노트북');
23
      expect(product.price, 1200000.0);
24
      expect(product.stock, 10);
25
      expect(product.description, '고성능 노트북');
26
      expect(product.categories, ['전자제품', '컴퓨터']);
27
    });
28

29
    test('fromJson creates a valid Product with default values', () {
30
      // Arrange
31
      final json = {
32
        'id': 1,
33
        'name': '노트북',
34
        'price': 1200000.0,
35
      };
36

37
      // Act
38
      final product = Product.fromJson(json);
39

40
      // Assert
41
      expect(product.id, 1);
42
      expect(product.name, '노트북');
43
      expect(product.price, 1200000.0);
44
      expect(product.stock, 0); // 기본값
45
      expect(product.description, null); // 기본값(null)
46
      expect(product.categories, isEmpty); // 기본값(빈 배열)
47
    });
48

49
    test('toJson returns valid JSON', () {
50
      // Arrange
51
      final product = Product(
52
        id: 1,
53
        name: '노트북',
54
        price: 1200000.0,
55
        stock: 10,
56
        description: '고성능 노트북',
57
        categories: ['전자제품', '컴퓨터'],
58
      );
59

60
      // Act
61
      final json = product.toJson();
62

63
      // Assert
64
      expect(json['id'], 1);
65
      expect(json['name'], '노트북');
66
      expect(json['price'], 1200000.0);
67
      expect(json['stock'], 10);
68
      expect(json['description'], '고성능 노트북');
69
      expect(json['categories'], ['전자제품', '컴퓨터']);
70
    });
71

72
    test('copyWith works correctly', () {
73
      // Arrange
74
      final product = Product(
75
        id: 1,
76
        name: '노트북',
77
        price: 1200000.0,
78
      );
79

80
      // Act
81
      final updatedProduct = product.copyWith(
82
        name: '고성능 노트북',
83
        price: 1300000.0,
84
        stock: 5,
85
      );
86

87
      // Assert
88
      expect(updatedProduct.id, 1); // 변경되지 않음
89
      expect(updatedProduct.name, '고성능 노트북'); // 변경됨
90
      expect(updatedProduct.price, 1300000.0); // 변경됨
91
      expect(updatedProduct.stock, 5); // 변경됨
92
    });
93

94
    test('두 제품이 같은 값을 가질 때 동등하게 취급된다', () {
95
      // Arrange
96
      final product1 = Product(
97
        id: 1,
98
        name: '노트북',
99
        price: 1200000.0,
100
      );
101

102
      final product2 = Product(
103
        id: 1,
104
        name: '노트북',
105
        price: 1200000.0,
106
      );
107

108
      // Assert
109
      expect(product1, equals(product2));
110
    });
111
  });
112
}

복잡한 비즈니스 로직 테스트

복잡한 비즈니스 로직이 포함된 클래스의 테스트 예시입니다:

1
import '../models/product.dart';
2

3
class CartItem {
4
  final Product product;
5
  final int quantity;
6

7
  CartItem({required this.product, required this.quantity});
8

9
  double get totalPrice => product.price * quantity;
10

11
  CartItem copyWith({int? quantity}) {
12
    return CartItem(
13
      product: product,
14
      quantity: quantity ?? this.quantity,
15
    );
16
  }
17
}
18

19
class CartService {
20
  final Map<int, CartItem> _items = {};
21

22
  List<CartItem> get items => _items.values.toList();
23

24
  int get itemCount => _items.values.fold(0, (sum, item) => sum + item.quantity);
25

26
  double get totalAmount => _items.values.fold(
27
        0,
28
        (sum, item) => sum + item.totalPrice,
29
      );
30

31
  void addProduct(Product product, {int quantity = 1}) {
32
    if (product.stock < quantity) {
33
      throw Exception('재고가 부족합니다');
34
    }
35

36
    if (_items.containsKey(product.id)) {
37
      final existingItem = _items[product.id]!;
38
      final newQuantity = existingItem.quantity + quantity;
39

40
      if (product.stock < newQuantity) {
41
        throw Exception('재고가 부족합니다');
42
      }
43

44
      _items[product.id] = existingItem.copyWith(quantity: newQuantity);
45
    } else {
46
      _items[product.id] = CartItem(product: product, quantity: quantity);
47
    }
48
  }
49

50
  void updateQuantity(int productId, int quantity) {
51
    if (!_items.containsKey(productId)) {
52
      throw Exception('장바구니에 해당 상품이 없습니다');
53
    }
54

55
    final item = _items[productId]!;
56

57
    if (quantity <= 0) {
58
      _items.remove(productId);
59
      return;
60
    }
61

62
    if (item.product.stock < quantity) {
63
      throw Exception('재고가 부족합니다');
64
    }
65

66
    _items[productId] = item.copyWith(quantity: quantity);
67
  }
68

69
  void removeProduct(int productId) {
70
    _items.remove(productId);
71
  }
72

73
  void clear() {
74
    _items.clear();
75
  }
76

77
  bool hasProduct(int productId) {
78
    return _items.containsKey(productId);
79
  }
80
}

이 CartService 클래스의 단위 테스트:

1
import 'package:flutter_test/flutter_test.dart';
2
import 'package:my_app/models/product.dart';
3
import 'package:my_app/services/cart_service.dart';
4

5
void main() {
6
  late CartService cartService;
7
  late Product laptop;
8
  late Product phone;
9

10
  setUp(() {
11
    cartService = CartService();
12

13
    laptop = Product(
14
      id: 1,
15
      name: '노트북',
16
      price: 1200000.0,
17
      stock: 10,
18
    );
19

20
    phone = Product(
21
      id: 2,
22
      name: '스마트폰',
23
      price: 800000.0,
24
      stock: 5,
25
    );
26
  });
27

28
  group('CartService', () {
29
    test('초기 장바구니는 비어있다', () {
30
      expect(cartService.items, isEmpty);
31
      expect(cartService.itemCount, 0);
32
      expect(cartService.totalAmount, 0);
33
    });
34

35
    test('상품을 장바구니에 추가할 수 있다', () {
36
      // Act
37
      cartService.addProduct(laptop);
38

39
      // Assert
40
      expect(cartService.items.length, 1);
41
      expect(cartService.items[0].product, laptop);
42
      expect(cartService.items[0].quantity, 1);
43
      expect(cartService.itemCount, 1);
44
      expect(cartService.totalAmount, 1200000.0);
45
    });
46

47
    test('같은 상품을 추가하면 수량이 증가한다', () {
48
      // Arrange
49
      cartService.addProduct(laptop);
50

51
      // Act
52
      cartService.addProduct(laptop);
53

54
      // Assert
55
      expect(cartService.items.length, 1);
56
      expect(cartService.items[0].quantity, 2);
57
      expect(cartService.itemCount, 2);
58
      expect(cartService.totalAmount, 2400000.0);
59
    });
60

61
    test('재고보다 많은 수량을 추가하려고 하면 예외가 발생한다', () {
62
      // Act & Assert
63
      expect(
64
        () => cartService.addProduct(laptop, quantity: 11),
65
        throwsException,
66
      );
67
    });
68

69
    test('장바구니에 있는 상품의 수량을 업데이트할 수 있다', () {
70
      // Arrange
71
      cartService.addProduct(laptop);
72

73
      // Act
74
      cartService.updateQuantity(laptop.id, 3);
75

76
      // Assert
77
      expect(cartService.items[0].quantity, 3);
78
      expect(cartService.itemCount, 3);
79
      expect(cartService.totalAmount, 3600000.0);
80
    });
81

82
    test('수량을 0 이하로 설정하면 상품이 장바구니에서 제거된다', () {
83
      // Arrange
84
      cartService.addProduct(laptop);
85

86
      // Act
87
      cartService.updateQuantity(laptop.id, 0);
88

89
      // Assert
90
      expect(cartService.items, isEmpty);
91
    });
92

93
    test('존재하지 않는 상품의 수량을 업데이트하려고 하면 예외가 발생한다', () {
94
      // Act & Assert
95
      expect(
96
        () => cartService.updateQuantity(999, 1),
97
        throwsException,
98
      );
99
    });
100

101
    test('상품을 장바구니에서 제거할 수 있다', () {
102
      // Arrange
103
      cartService.addProduct(laptop);
104
      cartService.addProduct(phone);
105
      expect(cartService.items.length, 2);
106

107
      // Act
108
      cartService.removeProduct(laptop.id);
109

110
      // Assert
111
      expect(cartService.items.length, 1);
112
      expect(cartService.items[0].product, phone);
113
    });
114

115
    test('장바구니를 비울 수 있다', () {
116
      // Arrange
117
      cartService.addProduct(laptop);
118
      cartService.addProduct(phone);
119
      expect(cartService.items.length, 2);
120

121
      // Act
122
      cartService.clear();
123

124
      // Assert
125
      expect(cartService.items, isEmpty);
126
      expect(cartService.itemCount, 0);
127
      expect(cartService.totalAmount, 0);
128
    });
129

130
    test('hasProduct는 상품의 존재 여부를 올바르게 확인한다', () {
131
      // Arrange
132
      cartService.addProduct(laptop);
133

134
      // Assert
135
      expect(cartService.hasProduct(laptop.id), true);
136
      expect(cartService.hasProduct(phone.id), false);
137
    });
138

139
    test('여러 상품을 추가하면 totalAmount가 올바르게 계산된다', () {
140
      // Act
141
      cartService.addProduct(laptop); // 1,200,000
142
      cartService.addProduct(phone, quantity: 2); // 800,000 * 2 = 1,600,000
143

144
      // Assert
145
      expect(cartService.itemCount, 3);
146
      expect(cartService.totalAmount, 2800000.0);
147
    });
148
  });
149
}

테스트 커버리지 측정하기

테스트 커버리지는 코드가 테스트에 의해 얼마나 실행되었는지를 나타내는 지표입니다. Flutter에서는 다음과 같이 커버리지를 측정할 수 있습니다:

1
flutter test --coverage

이 명령어는 테스트를 실행하고 coverage/lcov.info 파일을 생성합니다. 이 파일을 사람이 읽기 쉬운 HTML 리포트로 변환하려면 lcov 도구를 사용합니다:

1
genhtml coverage/lcov.info -o coverage/html

그런 다음 coverage/html/index.html 파일을 브라우저에서 열어 커버리지 리포트를 확인할 수 있습니다.

단위 테스트 모범 사례

1. AAA 패턴 사용하기

AAA(Arrange, Act, Assert) 패턴은 테스트를 구조화하는 명확한 방법을 제공합니다:

Arrange: 테스트에 필요한 데이터와 객체를 설정합니다.
Act: 테스트하려는 동작을 실행합니다.
Assert: 예상 결과를 실제 결과와 비교합니다.

2. 테스트 이름을 명확하게 지정하기

1
// 좋지 않은 예
2
test('add', () {
3
  expect(calculator.add(2, 3), 5);
4
});
5

6
// 좋은 예
7
test('add returns the sum of two numbers', () {
8
  expect(calculator.add(2, 3), 5);
9
});

3. 테스트 그룹화하기

관련 테스트를 group 함수를 사용하여 그룹화하면 테스트 출력을 더 잘 구조화할 수 있습니다:

1
group('Calculator', () {
2
  group('add', () {
3
    test('returns the sum of two positive numbers', () {
4
      // ...
5
    });
6

7
    test('returns the correct sum when one number is negative', () {
8
      // ...
9
    });
10
  });
11

12
  group('divide', () {
13
    test('returns the quotient of two numbers', () {
14
      // ...
15
    });
16

17
    test('throws ArgumentError when dividing by zero', () {
18
      // ...
19
    });
20
  });
21
});

4. 중복 제거하기

setUp과 tearDown 함수를 사용하여 테스트 간에 공통 코드를 추출하면 테스트의 가독성과 유지보수성이 향상됩니다.

5. 의미 있는 어설션 사용하기

테스트가 실패했을 때 무엇이 잘못되었는지 명확하게 나타내는 어설션을 사용하세요:

1
// 좋지 않은 예
2
expect(user.toJson(), json); // 오류 메시지가 모호할 수 있음
3

4
// 좋은 예: 개별 필드 테스트
5
expect(user.toJson()['id'], json['id']);
6
expect(user.toJson()['name'], json['name']);
7
expect(user.toJson()['email'], json['email']);

6. 테스트 분리 유지하기

각 테스트는 독립적이어야 하며 다른 테스트나 외부 상태에 의존해서는 안 됩니다. 테스트의 순서가 결과에 영향을 미치지 않아야 합니다.

7. 경계 조건 테스트하기

함수나 메서드의 동작을 검증할 때는 일반적인 케이스뿐만 아니라 경계 조건도 테스트하세요. 예를 들어:

빈 리스트나 맵
null 값 (nullable 필드인 경우)
음수, 0, 매우 큰 숫자
매우 긴 문자열 또는 빈 문자열

8. 실패 케이스 테스트하기

함수나 메서드가 오류를 올바르게 처리하는지 확인하기 위해 실패 케이스도 테스트하세요:

1
test('fetchUser throws exception for non-existent user', () {
2
  // Act & Assert
3
  expect(userService.fetchUser(-1), throwsException);
4
});

결론

단위 테스트는 코드의 신뢰성을 높이는 데 매우 중요합니다. Flutter에서 단위 테스트를 작성하면 앱의 품질이 향상되고, 버그를 조기에 발견할 수 있으며, 코드의 유지보수성이 개선됩니다. 이 장에서는 Dart 함수, 모델 클래스, 비동기 코드, 비즈니스 로직 등 다양한 코드 유형에 대한 단위 테스트 작성 방법을 살펴보았습니다.

가장 좋은 방법은 처음부터 테스트를 작성하는 것이지만, 기존 프로젝트에서도 점진적으로 테스트를 추가하여 이점을 얻을 수 있습니다. 테스트 주도 개발(TDD) 접근 방식을 사용하면 더 견고하고 유지보수하기 쉬운 코드베이스를 구축하는 데 도움이 됩니다.

다음 장에서는 위젯 테스트에 대해 자세히 알아보겠습니다. 위젯 테스트는 단위 테스트보다 한 단계 더 나아가 Flutter 위젯의 동작과 상호작용을 테스트합니다.