/cc-flutter:test {type} {target} [--options]

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

app/{app}/integration_test/
├── features/{feature}.feature
├── step/
└── scenarios/
    ├── {feature}_{screen}_batch_test.dart   # 기본: 같은 Background 시나리오 3건+ 를 한 세션에
    └── {feature}_{scenario}_test.dart       # @isolated 또는 2건 이하일 때만

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_signals_test/bloc_signals_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.stateValue, const {Feature}State.initial());
    });

    blocSignalTest<{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,
        ),
      ],
    );

    blocSignalTest<{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:bloc_signals_flutter/bloc_signals_flutter.dart';
import 'package:mocktail/mocktail.dart';

// bloc_signals 에는 MockBloc/whenListen 이 없다. state 는 ReadonlySignal 이라
// 목으로 값을 돌려줘도 리빌드가 일어나지 않는다 → 실제 컨테이너를 시드해서 쓴다.
void main() {
  late MockGet{Entity}UseCase mockUseCase;

  setUp(() {
    mockUseCase = MockGet{Entity}UseCase();
  });

  Widget buildTestWidget({Feature}State initialState) {
    final bloc = {Feature}Bloc(mockUseCase, initialState: initialState);
    addTearDown(bloc.close);

    return MaterialApp(
      home: BlocSignalProvider<{Feature}Bloc>.value(
        value: bloc,
        child: const {Feature}Page(),
      ),
    );
  }

  group('{Feature}Page', () {
    testWidgets('renders loading indicator when loading', (tester) async {
      // Arrange
      // Act
      await tester.pumpWidget(buildTestWidget(const {Feature}State.loading()));

      // 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'),
      ];
      // Act
      await tester.pumpWidget(
        buildTestWidget({Feature}State.loaded(items: items)),
      );

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

    testWidgets('shows error message when error', (tester) async {
      // Arrange
      // Act
      await tester.pumpWidget(
        buildTestWidget({Feature}State.error(ServerFailure('Network error'))),
      );

      // 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 # 에러 표시

  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);
}

import 'package:test_driver/shared_steps.dart';

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

# ⛔ melos run test:bdd / test:bdd:select / melos run build (BDD → _test.dart) are retired —
# there is no BDD codegen pipeline. Patrol E2E is the only way to run a BDD scenario:
patrol test --target integration_test/scenarios/smoke_test.dart

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

/cc-flutter:test unit GetUserUseCase --feature auth

/cc-flutter:test bloc HomeBloc --feature home

/cc-flutter:test widget LoginPage --feature auth

/cc-flutter:test bdd community

/cc-flutter:test patrol auth_flow --feature auth