/test {type} {target} [--options]

feature/{location}/{feature_name}/test/
├── src/
│   ├── domain/
│   │   └── usecase/           # UseCase 단위 테스트
│   ├── data/
│   │   └── repository/        # Repository 테스트 (mocked)
│   └── presentation/
│       ├── bloc/              # BLoC 테스트
│       └── widget/            # Widget 테스트
└── feature/                   # BDD 테스트
    ├── {feature}.feature
    └── step/

import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
import 'package:dependencies/dependencies.dart';

class MockI{Feature}Repository extends Mock implements I{Feature}Repository {}

void main() {
  late Get{Entity}UseCase useCase;
  late MockI{Feature}Repository mockRepository;

  setUp(() {
    mockRepository = MockI{Feature}Repository();
    useCase = Get{Entity}UseCase(mockRepository);
  });

  group('Get{Entity}UseCase', () {
    final tEntity = {Entity}(id: 1, name: 'Test');
    final tParams = Get{Entity}Params(id: 1);

    test('should return entity when repository succeeds', () async {
      // Arrange
      when(() => mockRepository.get{Entity}(any()))
          .thenAnswer((_) async => Right(tEntity));

      // Act
      final result = await useCase(tParams);

      // Assert
      expect(result, Right(tEntity));
      verify(() => mockRepository.get{Entity}(1)).called(1);
      verifyNoMoreInteractions(mockRepository);
    });

    test('should return failure when repository fails', () async {
      // Arrange
      final tFailure = ServerFailure('Error');
      when(() => mockRepository.get{Entity}(any()))
          .thenAnswer((_) async => Left(tFailure));

      // Act
      final result = await useCase(tParams);

      // Assert
      expect(result, Left(tFailure));
    });
  });
}

import 'package:bloc_test/bloc_test.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';

class MockGet{Entity}UseCase extends Mock implements Get{Entity}UseCase {}

void main() {
  late {Feature}Bloc bloc;
  late MockGet{Entity}UseCase mockUseCase;

  setUp(() {
    mockUseCase = MockGet{Entity}UseCase();
    bloc = {Feature}Bloc();
  });

  tearDown(() {
    bloc.close();
  });

  group('{Feature}Bloc', () {
    test('initial state is Initial', () {
      expect(bloc.state, const {Feature}State.initial());
    });

    blocTest<{Feature}Bloc, {Feature}State>(
      'emits [Loading, Loaded] when load succeeds',
      build: () => bloc,
      act: (bloc) => bloc.load(),
      expect: () => [
        const {Feature}State.loading(),
        isA<{Feature}State>().having(
          (s) => s.maybeMap(loaded: (l) => l.items, orElse: () => null),
          'items',
          isNotEmpty,
        ),
      ],
    );

    blocTest<{Feature}Bloc, {Feature}State>(
      'emits [Loading, Error] when load fails',
      build: () => bloc,
      act: (bloc) => bloc.load(),
      expect: () => [
        const {Feature}State.loading(),
        isA<{Feature}State>().having(
          (s) => s.maybeMap(error: (e) => e.failure, orElse: () => null),
          'failure',
          isNotNull,
        ),
      ],
    );
  });
}

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:mocktail/mocktail.dart';

class Mock{Feature}Bloc extends MockBloc<{Feature}Event, {Feature}State>
    implements {Feature}Bloc {}

void main() {
  late Mock{Feature}Bloc mockBloc;

  setUp(() {
    mockBloc = Mock{Feature}Bloc();
  });

  Widget buildTestWidget() {
    return MaterialApp(
      home: BlocProvider<{Feature}Bloc>.value(
        value: mockBloc,
        child: const {Feature}Page(),
      ),
    );
  }

  group('{Feature}Page', () {
    testWidgets('renders loading indicator when loading', (tester) async {
      // Arrange
      when(() => mockBloc.state).thenReturn(const {Feature}State.loading());

      // Act
      await tester.pumpWidget(buildTestWidget());

      // Assert
      expect(find.byType(CircularProgressIndicator), findsOneWidget);
    });

    testWidgets('renders list when loaded', (tester) async {
      // Arrange
      final items = [
        {Entity}(id: 1, name: 'Item 1'),
        {Entity}(id: 2, name: 'Item 2'),
      ];
      when(() => mockBloc.state).thenReturn(
        {Feature}State.loaded(items: items),
      );

      // Act
      await tester.pumpWidget(buildTestWidget());

      // Assert
      expect(find.text('Item 1'), findsOneWidget);
      expect(find.text('Item 2'), findsOneWidget);
    });

    testWidgets('shows error message when error', (tester) async {
      // Arrange
      when(() => mockBloc.state).thenReturn(
        {Feature}State.error(ServerFailure('Network error')),
      );

      // Act
      await tester.pumpWidget(buildTestWidget());

      // Assert
      expect(find.text('Network error'), findsOneWidget);
    });
  });
}

@smoke
@auth
Feature: Login Page # 로그인 페이지

  Background:
    Given I am on the login page # 로그인 페이지

  @validation
  Scenario: Email field validation # 이메일 유효성 검사
    When I enter { ' invalid-email ' } in the email field # 잘못된 이메일
    Then the email error should be displayed # 에러 표시

  @patrol-only
  Scenario: Native back button # 네이티브 백 버튼
    When I press the back button # 백 버튼
    Then the app should navigate back # 이전 화면 복귀

import 'package:test_driver/test_driver.dart';

/// Usage: I enter {string} in the email field # 이메일 입력
Future<void> iEnterInTheEmailField(TestDriver driver, String param1) async {
  await driver.enterText(K.emailField, param1);
}

targets:
  $default:
    builders:
      bdd_test_gen|dual_test_gen:
        enabled: true
        generate_for:
          - test/src/bdd/*.feature
        options:
          stepFolder: step

Feature: {Feature} List View # {Feature} 목록 조회
  User can view {Feature} list.

  Background:
    Given the app is running # 앱이 실행되어 있다

  Scenario: List loads successfully # 목록 조회 성공
    When user navigates to {feature} screen
    Then {entity} list is displayed

import 'package:patrol/patrol.dart';
import 'package:test_driver/test_driver.dart';

void main() {
  patrolTest(
    'Given logged in, When store, Then book list',
    config: const PatrolTesterConfig(settleTimeout: Duration(seconds: 15)),
    ($) async {
      final driver = PatrolTestDriver($);
      await driver.tap(K.navStore);
      await driver.expectVisible(K.bookList);
    },
  );
}

# 전체 테스트
melos run test

# Feature별 테스트
melos run test --scope=feature_{feature_name}

# 커버리지 포함
melos run test:with-html-coverage

# BDD tests
melos run test:bdd
melos run test:bdd:select

# Code generation (BDD → _test.dart)
melos run build

# Patrol E2E
patrol test --target integration_test/scenarios/smoke_test.dart

# Tag filtering
flutter test --tags smoke
flutter test --exclude-tags patrol-only

/test unit GetUserUseCase --feature auth

/test bloc HomeBloc --feature home

/test widget LoginPage --feature auth

/test bdd community

/test patrol auth_flow --feature auth