Flutter 튜토리얼 45편: 위젯 테스트

1
// pumpWidget: 위젯을 처음 빌드
2
await tester.pumpWidget(MyWidget());
3

4
// pump: 프레임 하나 진행 (상태 변경 후 리빌드)
5
await tester.pump();
6

7
// pump(duration): 지정된 시간만큼 진행
8
await tester.pump(const Duration(milliseconds: 100));
9

10
// pumpAndSettle: 모든 애니메이션이 완료될 때까지 대기
11
await tester.pumpAndSettle();

1
testWidgets('버튼 클릭 시 카운터가 증가한다', (tester) async {
2
  await tester.pumpWidget(const CounterApp());
3

4
  // 초기 상태 확인
5
  expect(find.text('0'), findsOneWidget);
6

7
  // 버튼 탭
8
  await tester.tap(find.byIcon(Icons.add));
9

10
  // 상태 변경 전에는 아직 0
11
  expect(find.text('0'), findsOneWidget);
12

13
  // pump로 리빌드 트리거
14
  await tester.pump();
15

16
  // 이제 1로 업데이트됨
17
  expect(find.text('1'), findsOneWidget);
18
});

1
testWidgets('애니메이션이 완료되면 결과가 표시된다', (tester) async {
2
  await tester.pumpWidget(const AnimatedWidget());
3

4
  // 애니메이션 트리거
5
  await tester.tap(find.byType(ElevatedButton));
6

7
  // 애니메이션이 완료될 때까지 대기
8
  await tester.pumpAndSettle();
9

10
  // 최종 상태 확인
11
  expect(find.text('완료'), findsOneWidget);
12
});

1
testWidgets('환영 메시지가 표시된다', (tester) async {
2
  await tester.pumpWidget(const MaterialApp(
3
    home: Scaffold(body: Text('환영합니다')),
4
  ));
5

6
  expect(find.text('환영합니다'), findsOneWidget);
7
});

1
testWidgets('특정 아이템을 Key로 찾는다', (tester) async {
2
  await tester.pumpWidget(MaterialApp(
3
    home: ListView(
4
      children: [
5
        ListTile(key: const Key('item_1'), title: const Text('아이템')),
6
        ListTile(key: const Key('item_2'), title: const Text('아이템')),
7
        ListTile(key: const Key('item_3'), title: const Text('아이템')),
8
      ],
9
    ),
10
  ));
11

12
  // 텍스트로 찾으면 3개가 나옴
13
  expect(find.text('아이템'), findsNWidgets(3));
14

15
  // Key로 특정 아이템을 찾음
16
  expect(find.byKey(const Key('item_2')), findsOneWidget);
17
});

1
testWidgets('AppBar가 존재한다', (tester) async {
2
  await tester.pumpWidget(const MaterialApp(
3
    home: Scaffold(
4
      appBar: AppBar(title: Text('제목')),
5
    ),
6
  ));
7

8
  expect(find.byType(AppBar), findsOneWidget);
9
  expect(find.byType(FloatingActionButton), findsNothing);
10
});

1
testWidgets('child 위젯이 렌더링된다', (tester) async {
2
  const childWidget = Padding(
3
    padding: EdgeInsets.all(16),
4
    child: Text('자식 위젯'),
5
  );
6

7
  await tester.pumpWidget(const MaterialApp(
8
    home: Scaffold(body: childWidget),
9
  ));
10

11
  expect(find.byWidget(childWidget), findsOneWidget);
12
});

1
testWidgets('특정 위젯 내부의 텍스트를 찾는다', (tester) async {
2
  await tester.pumpWidget(MaterialApp(
3
    home: Column(
4
      children: [
5
        Card(
6
          key: const Key('card_1'),
7
          child: const Text('카드 1 내용'),
8
        ),
9
        Card(
10
          key: const Key('card_2'),
11
          child: const Text('카드 2 내용'),
12
        ),
13
      ],
14
    ),
15
  ));
16

17
  // descendant: 특정 위젯의 자손 중에서 찾기
18
  expect(
19
    find.descendant(
20
      of: find.byKey(const Key('card_1')),
21
      matching: find.text('카드 1 내용'),
22
    ),
23
    findsOneWidget,
24
  );
25

26
  // ancestor: 특정 위젯의 조상 중에서 찾기
27
  expect(
28
    find.ancestor(
29
      of: find.text('카드 2 내용'),
30
      matching: find.byType(Card),
31
    ),
32
    findsOneWidget,
33
  );
34
});

1
testWidgets('버튼 탭 시 다이얼로그가 표시된다', (tester) async {
2
  await tester.pumpWidget(MaterialApp(
3
    home: Scaffold(
4
      body: Builder(
5
        builder: (context) => ElevatedButton(
6
          onPressed: () {
7
            showDialog(
8
              context: context,
9
              builder: (_) => const AlertDialog(
10
                title: Text('알림'),
11
                content: Text('버튼이 클릭되었습니다'),
12
              ),
13
            );
14
          },
15
          child: const Text('버튼'),
16
        ),
17
      ),
18
    ),
19
  ));
20

21
  // 버튼 탭
22
  await tester.tap(find.text('버튼'));
23
  await tester.pumpAndSettle();
24

25
  // 다이얼로그 확인
26
  expect(find.text('알림'), findsOneWidget);
27
  expect(find.text('버튼이 클릭되었습니다'), findsOneWidget);
28
});

1
testWidgets('텍스트 입력이 동작한다', (tester) async {
2
  await tester.pumpWidget(MaterialApp(
3
    home: Scaffold(
4
      body: TextField(
5
        key: const Key('input_field'),
6
      ),
7
    ),
8
  ));
9

10
  // 텍스트 입력
11
  await tester.enterText(find.byKey(const Key('input_field')), '안녕하세요');
12
  await tester.pump();
13

14
  // 입력된 텍스트 확인
15
  expect(find.text('안녕하세요'), findsOneWidget);
16
});

1
testWidgets('스와이프로 아이템을 삭제한다', (tester) async {
2
  await tester.pumpWidget(MaterialApp(
3
    home: Scaffold(
4
      body: Dismissible(
5
        key: const Key('dismissible_item'),
6
        onDismissed: (_) {},
7
        child: const ListTile(title: Text('삭제할 아이템')),
8
      ),
9
    ),
10
  ));
11

12
  // 아이템 존재 확인
13
  expect(find.text('삭제할 아이템'), findsOneWidget);
14

15
  // 오른쪽으로 스와이프
16
  await tester.drag(
17
    find.byKey(const Key('dismissible_item')),
18
    const Offset(500, 0),
19
  );
20

21
  // 애니메이션 완료 대기
22
  await tester.pumpAndSettle();
23

24
  // 아이템이 삭제됨
25
  expect(find.text('삭제할 아이템'), findsNothing);
26
});

1
testWidgets('Todo 앱: 추가와 삭제', (tester) async {
2
  await tester.pumpWidget(const TodoApp());
3

4
  // 1. 텍스트 입력
5
  await tester.enterText(find.byType(TextField), '우유 사기');
6

7
  // 2. 추가 버튼 탭
8
  await tester.tap(find.byType(FloatingActionButton));
9
  await tester.pump();
10

11
  // 3. 아이템이 추가됨
12
  expect(find.text('우유 사기'), findsOneWidget);
13

14
  // 4. 스와이프로 삭제
15
  await tester.drag(
16
    find.byType(Dismissible),
17
    const Offset(500, 0),
18
  );
19
  await tester.pumpAndSettle();
20

21
  // 5. 아이템이 삭제됨
22
  expect(find.text('우유 사기'), findsNothing);
23
});

1
testWidgets('긴 리스트에서 특정 아이템을 찾는다', (tester) async {
2
  // 10000개의 아이템 생성
3
  await tester.pumpWidget(
4
    LongListApp(
5
      items: List<String>.generate(10000, (i) => 'Item $i'),
6
    ),
7
  );
8

9
  // 스크롤 가능한 위젯 찾기
10
  final listFinder = find.byType(Scrollable);
11

12
  // 찾을 아이템의 Finder
13
  final itemFinder = find.byKey(const Key('item_50_text'));
14

15
  // 아이템이 보일 때까지 스크롤
16
  await tester.scrollUntilVisible(
17
    itemFinder,
18
    500.0, // 스크롤 거리
19
    scrollable: listFinder,
20
  );
21

22
  // 아이템이 화면에 있음을 확인
23
  expect(itemFinder, findsOneWidget);
24
});

1
testWidgets('수동으로 스크롤한다', (tester) async {
2
  await tester.pumpWidget(
3
    LongListApp(items: List.generate(100, (i) => 'Item $i')),
4
  );
5

6
  // fling: 빠른 스와이프
7
  await tester.fling(
8
    find.byType(ListView),
9
    const Offset(0, -500), // 위로 스크롤
10
    1000, // 속도
11
  );
12
  await tester.pumpAndSettle();
13

14
  // drag: 드래그
15
  await tester.drag(
16
    find.byType(ListView),
17
    const Offset(0, -200),
18
  );
19
  await tester.pump();
20
});

1
// 위젯 존재 확인
2
expect(finder, findsOneWidget);      // 정확히 1개
3
expect(finder, findsNothing);        // 0개
4
expect(finder, findsWidgets);        // 1개 이상
5
expect(finder, findsNWidgets(3));    // 정확히 3개
6
expect(finder, findsAtLeast(2));     // 최소 2개
7

8
// 위젯 속성 확인
9
expect(
10
  tester.widget<Text>(find.byKey(const Key('title'))),
11
  isA<Text>().having((t) => t.data, 'text', '제목'),
12
);
13

14
// 위젯 상태 확인
15
expect(
16
  tester.widget<Checkbox>(find.byType(Checkbox)),
17
  isA<Checkbox>().having((c) => c.value, 'checked', true),
18
);

1
testWidgets('버튼 상태를 검증한다', (tester) async {
2
  await tester.pumpWidget(MaterialApp(
3
    home: Scaffold(
4
      body: ElevatedButton(
5
        onPressed: null, // 비활성화
6
        child: const Text('비활성 버튼'),
7
      ),
8
    ),
9
  ));
10

11
  // 버튼 위젯 가져오기
12
  final button = tester.widget<ElevatedButton>(
13
    find.byType(ElevatedButton),
14
  );
15

16
  // onPressed가 null인지 확인 (비활성화)
17
  expect(button.onPressed, isNull);
18
});

1
testWidgets('TextField 입력값을 검증한다', (tester) async {
2
  final controller = TextEditingController();
3

4
  await tester.pumpWidget(MaterialApp(
5
    home: Scaffold(
6
      body: TextField(controller: controller),
7
    ),
8
  ));
9

10
  await tester.enterText(find.byType(TextField), '테스트 입력');
11
  await tester.pump();
12

13
  // 컨트롤러 값 확인
14
  expect(controller.text, '테스트 입력');
15
});

1
testWidgets('로그인 폼이 올바르게 동작한다', (tester) async {
2
  bool loginCalled = false;
3
  String? capturedEmail;
4
  String? capturedPassword;
5

6
  await tester.pumpWidget(MaterialApp(
7
    home: LoginForm(
8
      onLogin: (email, password) {
9
        loginCalled = true;
10
        capturedEmail = email;
11
        capturedPassword = password;
12
      },
13
    ),
14
  ));
15

16
  // 이메일 입력
17
  await tester.enterText(
18
    find.byKey(const Key('email_field')),
19
    '[email protected]',
20
  );
21

22
  // 비밀번호 입력
23
  await tester.enterText(
24
    find.byKey(const Key('password_field')),
25
    'password123',
26
  );
27

28
  // 로그인 버튼 탭
29
  await tester.tap(find.byKey(const Key('login_button')));
30
  await tester.pump();
31

32
  // 콜백 호출 확인
33
  expect(loginCalled, isTrue);
34
  expect(capturedEmail, '[email protected]');
35
  expect(capturedPassword, 'password123');
36
});

1
testWidgets('로딩 중에 인디케이터가 표시된다', (tester) async {
2
  await tester.pumpWidget(MaterialApp(
3
    home: LoadingScreen(isLoading: true),
4
  ));
5

6
  // 로딩 인디케이터 확인
7
  expect(find.byType(CircularProgressIndicator), findsOneWidget);
8
  expect(find.text('데이터'), findsNothing);
9
});
10

11
testWidgets('로딩 완료 후 데이터가 표시된다', (tester) async {
12
  await tester.pumpWidget(MaterialApp(
13
    home: LoadingScreen(isLoading: false),
14
  ));
15

16
  // 데이터 표시 확인
17
  expect(find.byType(CircularProgressIndicator), findsNothing);
18
  expect(find.text('데이터'), findsOneWidget);
19
});

1
testWidgets('에러 발생 시 에러 메시지가 표시된다', (tester) async {
2
  await tester.pumpWidget(MaterialApp(
3
    home: DataScreen(
4
      error: '네트워크 오류가 발생했습니다',
5
    ),
6
  ));
7

8
  expect(find.text('네트워크 오류가 발생했습니다'), findsOneWidget);
9
  expect(find.byIcon(Icons.error), findsOneWidget);
10
});