Flutter 튜토리얼 44편: 유닛 테스트

1
my_app/
2
  lib/
3
    counter.dart
4
  test/
5
    counter_test.dart  // 테스트 파일

1
import 'package:my_app/counter.dart';
2
import 'package:test/test.dart';
3

4
void main() {
5
  group('Counter 테스트', () {
6
    late Counter counter;
7

8
    // 각 테스트 전에 새 Counter 생성
9
    setUp(() {
10
      counter = Counter();
11
    });
12

13
    test('초기값은 0이다', () {
14
      expect(counter.value, 0);
15
    });
16

17
    test('값이 증가한다', () {
18
      counter.increment();
19
      expect(counter.value, 1);
20
    });
21

22
    test('값이 감소한다', () {
23
      counter.decrement();
24
      expect(counter.value, -1);
25
    });
26

27
    test('값이 리셋된다', () {
28
      counter.increment();
29
      counter.increment();
30
      counter.reset();
31
      expect(counter.value, 0);
32
    });
33
  });
34

35
  group('Counter 경계값 테스트', () {
36
    test('음수에서 증가하면 0이 될 수 있다', () {
37
      final counter = Counter()..decrement();
38
      counter.increment();
39
      expect(counter.value, 0);
40
    });
41
  });
42
}

1
void main() {
2
  group('Calculator', () {
3
    group('덧셈', () {
4
      test('양수 + 양수', () {
5
        expect(Calculator.add(2, 3), 5);
6
      });
7

8
      test('음수 + 양수', () {
9
        expect(Calculator.add(-2, 3), 1);
10
      });
11
    });
12

13
    group('뺄셈', () {
14
      test('양수 - 양수', () {
15
        expect(Calculator.subtract(5, 3), 2);
16
      });
17
    });
18
  });
19
}

1
// 기본 Matcher
2
expect(value, equals(expected));     // 동등성 비교
3
expect(value, isNull);               // null 확인
4
expect(value, isNotNull);            // null이 아님 확인
5
expect(value, isTrue);               // true 확인
6
expect(value, isFalse);              // false 확인
7

8
// 숫자 Matcher
9
expect(value, greaterThan(10));      // 10보다 큼
10
expect(value, lessThan(10));         // 10보다 작음
11
expect(value, inInclusiveRange(1, 10)); // 1~10 사이
12

13
// 컬렉션 Matcher
14
expect(list, isEmpty);               // 빈 컬렉션
15
expect(list, isNotEmpty);            // 비어있지 않음
16
expect(list, hasLength(3));          // 길이가 3
17
expect(list, contains(item));        // 항목 포함
18
expect(list, containsAll([1, 2]));   // 모든 항목 포함
19

20
// 문자열 Matcher
21
expect(str, startsWith('Hello'));    // 시작 문자열
22
expect(str, endsWith('World'));      // 끝 문자열
23
expect(str, contains('llo'));        // 부분 문자열 포함
24
expect(str, matches(RegExp(r'\d+'))); // 정규식 매칭
25

26
// 타입 Matcher
27
expect(obj, isA<String>());          // 타입 확인
28
expect(obj, isA<List<int>>());       // 제네릭 타입 확인
29

30
// 예외 Matcher
31
expect(() => throwError(), throwsException);
32
expect(() => throwError(), throwsA(isA<FormatException>()));

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

3
class UserService {
4
  List<String> users = [];
5

6
  void addUser(String name) {
7
    if (name.isEmpty) {
8
      throw ArgumentError('이름은 비어있을 수 없습니다');
9
    }
10
    users.add(name);
11
  }
12

13
  String? findUser(String name) {
14
    return users.firstWhere(
15
      (u) => u == name,
16
      orElse: () => throw StateError('사용자를 찾을 수 없습니다'),
17
    );
18
  }
19
}
20

21
void main() {
22
  group('UserService', () {
23
    late UserService service;
24

25
    setUp(() {
26
      service = UserService();
27
    });
28

29
    test('사용자 추가 후 목록에 포함된다', () {
30
      service.addUser('홍길동');
31

32
      expect(service.users, isNotEmpty);
33
      expect(service.users, contains('홍길동'));
34
      expect(service.users, hasLength(1));
35
    });
36

37
    test('빈 이름으로 추가하면 예외가 발생한다', () {
38
      expect(
39
        () => service.addUser(''),
40
        throwsA(isA<ArgumentError>()),
41
      );
42
    });
43

44
    test('존재하지 않는 사용자 검색 시 예외가 발생한다', () {
45
      expect(
46
        () => service.findUser('없는사람'),
47
        throwsA(isA<StateError>()),
48
      );
49
    });
50
  });
51
}

1
// when - 모의 동작 정의
2
when(mock.someMethod(any)).thenReturn(value);        // 동기 반환
3
when(mock.someMethod(any)).thenAnswer((_) async => value);  // 비동기 반환
4
when(mock.someMethod(any)).thenThrow(Exception());   // 예외 발생
5

6
// verify - 호출 검증
7
verify(mock.someMethod(any)).called(1);              // 1번 호출됨
8
verify(mock.someMethod('specific')).called(1);       // 특정 인자로 호출됨
9
verifyNever(mock.someMethod(any));                   // 호출되지 않음
10

11
// Argument Matcher
12
when(mock.method(any));                              // 모든 인자
13
when(mock.method(argThat(contains('test'))));        // 조건 매칭
14
when(mock.method(captureAny));                       // 인자 캡처

1
// Stream을 반환하는 함수
2
Stream<int> countStream(int max) async* {
3
  for (var i = 1; i <= max; i++) {
4
    await Future.delayed(const Duration(milliseconds: 10));
5
    yield i;
6
  }
7
}
8

9
// Stream 테스트
10
void main() {
11
  test('countStream이 순서대로 숫자를 방출한다', () async {
12
    final stream = countStream(3);
13

14
    // emitsInOrder: 순서대로 방출되는지 확인
15
    await expectLater(
16
      stream,
17
      emitsInOrder([1, 2, 3]),
18
    );
19
  });
20

21
  test('Stream이 올바르게 완료된다', () async {
22
    final stream = countStream(2);
23

24
    await expectLater(
25
      stream,
26
      emitsInOrder([1, 2, emitsDone]),
27
    );
28
  });
29

30
  test('Stream 에러를 테스트한다', () async {
31
    Stream<int> errorStream() async* {
32
      yield 1;
33
      throw Exception('에러 발생');
34
    }
35

36
    await expectLater(
37
      errorStream(),
38
      emitsInOrder([1, emitsError(isA<Exception>())]),
39
    );
40
  });
41
}