Flutter 튜토리얼 42편: 의존성 주입과 레이어 테스팅

1
void main() {
2
  runApp(
3
    MultiProvider(
4
      providers: [
5
        // Service 등록
6
        Provider(create: (context) => AuthApiClient()),
7
        Provider(create: (context) => ApiClient()),
8
        Provider(create: (context) => SharedPreferencesService()),
9

10
        // Repository 등록 (Service를 주입받음)
11
        ChangeNotifierProvider(
12
          create: (context) => AuthRepository(
13
            authApiClient: context.read(),
14
            apiClient: context.read(),
15
            sharedPreferencesService: context.read(),
16
          ) as AuthRepository,
17
        ),
18
        Provider(
19
          create: (context) => BookingRepository(
20
            apiClient: context.read(),
21
          ) as BookingRepository,
22
        ),
23
      ],
24
      child: const MainApp(),
25
    ),
26
  );
27
}

1
GoRouter router(AuthRepository authRepository) => GoRouter(
2
  routes: [
3
    GoRoute(
4
      path: '/login',
5
      builder: (context, state) {
6
        return LoginScreen(
7
          viewModel: LoginViewModel(
8
            authRepository: context.read(),
9
          ),
10
        );
11
      },
12
    ),
13
    GoRoute(
14
      path: '/home',
15
      builder: (context, state) {
16
        return HomeScreen(
17
          viewModel: HomeViewModel(
18
            bookingRepository: context.read(),
19
            userRepository: context.read(),
20
          ),
21
        );
22
      },
23
    ),
24
  ],
25
);

1
class HomeScreen extends StatelessWidget {
2
  final HomeViewModel viewModel;
3

4
  const HomeScreen({required this.viewModel, super.key});
5

6
  @override
7
  Widget build(BuildContext context) {
8
    return ListenableBuilder(
9
      listenable: viewModel,
10
      builder: (context, _) {
11
        return ListView.builder(
12
          itemCount: viewModel.bookings.length,
13
          itemBuilder: (context, index) {
14
            final booking = viewModel.bookings[index];
15
            return ListTile(title: Text(booking.destination));
16
          },
17
        );
18
      },
19
    );
20
  }
21
}

1
class FakeBookingRepository implements BookingRepository {
2
  List<Booking> bookings = [];
3

4
  @override
5
  Future<Result<void>> createBooking(Booking booking) async {
6
    bookings.add(booking);
7
    return Result.ok(null);
8
  }
9

10
  @override
11
  Future<Result<List<Booking>>> getBookings() async {
12
    return Result.ok(bookings);
13
  }
14
}
15

16
// home_viewmodel_test.dart
17
void main() {
18
  group('HomeViewModel 테스트', () {
19
    late FakeBookingRepository fakeRepository;
20
    late HomeViewModel viewModel;
21

22
    setUp(() {
23
      fakeRepository = FakeBookingRepository();
24
      viewModel = HomeViewModel(bookingRepository: fakeRepository);
25
    });
26

27
    test('예약 목록을 불러온다', () async {
28
      // Given: 예약 데이터가 있을 때
29
      final booking = Booking(id: '1', destination: '서울');
30
      await fakeRepository.createBooking(booking);
31

32
      // When: 예약 목록을 로드하면
33
      await viewModel.loadBookings();
34

35
      // Then: 예약이 표시된다
36
      expect(viewModel.bookings, isNotEmpty);
37
      expect(viewModel.bookings.first.destination, equals('서울'));
38
    });
39

40
    test('예약 생성 시 목록이 업데이트된다', () async {
41
      // Given: 빈 예약 목록
42
      expect(viewModel.bookings, isEmpty);
43

44
      // When: 새 예약을 생성하면
45
      await viewModel.createBooking(
46
        Booking(id: '2', destination: '부산'),
47
      );
48

49
      // Then: 목록에 추가된다
50
      expect(viewModel.bookings.length, equals(1));
51
    });
52
  });
53
}

1
void main() {
2
  group('HomeScreen 테스트', () {
3
    late HomeViewModel viewModel;
4
    late MockGoRouter goRouter;
5
    late FakeBookingRepository bookingRepository;
6

7
    setUp(() {
8
      bookingRepository = FakeBookingRepository()
9
        ..createBooking(Booking(id: '1', destination: '서울'));
10

11
      viewModel = HomeViewModel(bookingRepository: bookingRepository);
12

13
      goRouter = MockGoRouter();
14
      when(() => goRouter.push(any())).thenAnswer((_) => Future.value(null));
15
    });
16

17
    testWidgets('예약 목록을 표시한다', (tester) async {
18
      // Given: 예약 데이터가 로드된 ViewModel
19
      await viewModel.loadBookings();
20

21
      // When: 화면을 렌더링하면
22
      await tester.pumpWidget(
23
        MaterialApp(
24
          home: HomeScreen(viewModel: viewModel),
25
        ),
26
      );
27

28
      // Then: 예약 정보가 표시된다
29
      expect(find.text('서울'), findsOneWidget);
30
    });
31

32
    testWidgets('예약 탭 시 상세 화면으로 이동한다', (tester) async {
33
      await viewModel.loadBookings();
34

35
      await tester.pumpWidget(
36
        MaterialApp(
37
          home: InheritedGoRouter(
38
            goRouter: goRouter,
39
            child: HomeScreen(viewModel: viewModel),
40
          ),
41
        ),
42
      );
43

44
      // When: 예약 아이템을 탭하면
45
      await tester.tap(find.text('서울'));
46
      await tester.pumpAndSettle();
47

48
      // Then: 상세 화면으로 이동한다
49
      verify(() => goRouter.push('/booking/1')).called(1);
50
    });
51
  });
52
}

1
class FakeApiClient implements ApiClient {
2
  final Map<String, dynamic> _mockResponses = {};
3
  Exception? _nextError;
4

5
  void setResponse(String path, dynamic response) {
6
    _mockResponses[path] = response;
7
  }
8

9
  void setError(Exception error) {
10
    _nextError = error;
11
  }
12

13
  @override
14
  Future<dynamic> get(String path) async {
15
    if (_nextError != null) {
16
      final error = _nextError;
17
      _nextError = null;
18
      throw error!;
19
    }
20
    return _mockResponses[path];
21
  }
22
}
23

24
// booking_repository_test.dart
25
void main() {
26
  group('BookingRepository 테스트', () {
27
    late BookingRepository repository;
28
    late FakeApiClient fakeApiClient;
29

30
    setUp(() {
31
      fakeApiClient = FakeApiClient();
32
      repository = BookingRepository(apiClient: fakeApiClient);
33
    });
34

35
    test('예약을 성공적으로 가져온다', () async {
36
      // Given: API가 예약 데이터를 반환
37
      fakeApiClient.setResponse('/bookings', [
38
        {'id': '1', 'destination': '서울'},
39
        {'id': '2', 'destination': '부산'},
40
      ]);
41

42
      // When: 예약 목록을 요청하면
43
      final result = await repository.getBookings();
44

45
      // Then: 예약 목록을 반환한다
46
      expect(result.isOk, isTrue);
47
      expect(result.value.length, equals(2));
48
    });
49

50
    test('API 오류 시 에러를 반환한다', () async {
51
      // Given: API가 오류를 발생시킴
52
      fakeApiClient.setError(NetworkException('연결 실패'));
53

54
      // When: 예약 목록을 요청하면
55
      final result = await repository.getBookings();
56

57
      // Then: 에러 결과를 반환한다
58
      expect(result.isError, isTrue);
59
      expect(result.error, isA<NetworkException>());
60
    });
61

62
    test('특정 예약을 조회한다', () async {
63
      // Given: 특정 예약 데이터
64
      fakeApiClient.setResponse('/bookings/1', {
65
        'id': '1',
66
        'destination': '서울',
67
        'date': '2025-01-15',
68
      });
69

70
      // When: 예약을 조회하면
71
      final result = await repository.getBooking('1');
72

73
      // Then: 해당 예약을 반환한다
74
      expect(result.isOk, isTrue);
75
      expect(result.value.id, equals('1'));
76
    });
77
  });
78
}

1
Future<void> testApp(
2
  WidgetTester tester,
3
  Widget body, {
4
  GoRouter? goRouter,
5
  ThemeData? theme,
6
}) async {
7
  // 테스트 환경 설정
8
  tester.view.devicePixelRatio = 1.0;
9
  await tester.binding.setSurfaceSize(const Size(1200, 800));
10

11
  // 네트워크 이미지 모킹
12
  await mockNetworkImages(() async {
13
    await tester.pumpWidget(
14
      MaterialApp(
15
        // 로컬라이제이션 설정
16
        localizationsDelegates: const [
17
          GlobalWidgetsLocalizations.delegate,
18
          GlobalMaterialLocalizations.delegate,
19
          AppLocalizationDelegate(),
20
        ],
21
        // 테마 적용
22
        theme: theme ?? AppTheme.lightTheme,
23
        home: InheritedGoRouter(
24
          goRouter: goRouter ?? MockGoRouter(),
25
          child: Scaffold(body: body),
26
        ),
27
      ),
28
    );
29
  });
30
}
31

32
// 사용 예시
33
testWidgets('홈 화면 테스트', (tester) async {
34
  final viewModel = HomeViewModel(
35
    bookingRepository: FakeBookingRepository(),
36
  );
37

38
  await testApp(
39
    tester,
40
    HomeScreen(viewModel: viewModel),
41
    goRouter: MockGoRouter(),
42
  );
43

44
  expect(find.byType(ListView), findsOneWidget);
45
});