test/
├── domain/
│   └── usecase/
│       └── get_user_usecase_test.dart
├── data/
│   └── repository/
│       └── user_repository_test.dart
├── presentation/
│   ├── bloc/
│   │   └── user_bloc_test.dart
│   └── widget/
│       └── user_card_test.dart
├── fixtures/
│   └── test_data.dart
├── helpers/
│   └── pump_app.dart
└── goldens/
    └── user_card_golden_test.dart

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

class MockIUserRepository extends Mock implements IUserRepository {}

void main() {
  late GetUserUseCase useCase;
  late MockIUserRepository mockRepository;

  setUp(() {
    mockRepository = MockIUserRepository();
    useCase = GetUserUseCase(mockRepository);
  });

  setUpAll(() {
    registerFallbackValue(const GetUserParams(id: 0));
  });

  group('GetUserUseCase', () {
    final testUser = User(id: 1, name: 'Test', email: 'test@test.com');

    test('should return User when repository succeeds', () async {
      // Arrange
      when(() => mockRepository.getUser(any()))
          .thenAnswer((_) async => right(testUser));

      // Act
      final result = await useCase(const GetUserParams(id: 1));

      // Assert
      expect(result, right(testUser));
      verify(() => mockRepository.getUser(1)).called(1);
    });

    test('should return Failure when repository fails', () async {
      // Arrange
      final failure = ServerFailure('Server error');
      when(() => mockRepository.getUser(any()))
          .thenAnswer((_) async => left(failure));

      // Act
      final result = await useCase(const GetUserParams(id: 1));

      // Assert
      expect(result, left(failure));
    });
  });
}

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

class MockGetUserUseCase extends Mock implements GetUserUseCase {}

void main() {
  late UserBloc bloc;
  late MockGetUserUseCase mockGetUserUseCase;

  final testUser = User(id: 1, name: 'Test', email: 'test@test.com');

  setUp(() {
    mockGetUserUseCase = MockGetUserUseCase();
    bloc = UserBloc(mockGetUserUseCase);
  });

  setUpAll(() {
    registerFallbackValue(const GetUserParams(id: 0));
  });

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

  group('UserBloc', () {
    test('initial state is UserState.initial()', () {
      expect(bloc.stateValue, const UserState.initial());
    });

    blocSignalTest<UserBloc, UserState>(
      'emits [loading, loaded] when load succeeds',
      setUp: () {
        when(() => mockGetUserUseCase(any()))
            .thenAnswer((_) async => right(testUser));
      },
      build: () => bloc,
      act: (bloc) => bloc.add(const UserEvent.load(userId: 1)),
      expect: () => [
        const UserState.loading(),
        UserState.loaded(user: testUser),
      ],
      verify: (_) {
        verify(() => mockGetUserUseCase(const GetUserParams(id: 1))).called(1);
      },
    );

    blocSignalTest<UserBloc, UserState>(
      'emits [loading, error] when load fails',
      setUp: () {
        when(() => mockGetUserUseCase(any()))
            .thenAnswer((_) async => left(ServerFailure('Error')));
      },
      build: () => bloc,
      act: (bloc) => bloc.add(const UserEvent.load(userId: 1)),
      expect: () => [
        const UserState.loading(),
        isA<UserState>(),
      ],
    );
  });
}

// test/helpers/pump_app.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:flutter/material.dart';

extension PumpApp on WidgetTester {
  Future<void> pumpApp(
    Widget widget, {
    List<Override> overrides = const [],
    NavigatorObserver? navigatorObserver,
  }) async {
    await pumpWidget(
      MaterialApp(
        home: widget,
        navigatorObservers: [
          if (navigatorObserver != null) navigatorObserver,
        ],
      ),
    );
  }

  Future<void> pumpAppWithBloc<B extends BlocSignalBase<S>, S>(
    Widget widget, {
    required B bloc,
  }) async {
    await pumpWidget(
      MaterialApp(
        home: BlocSignalProvider.value(
          value: bloc,
          child: widget,
        ),
      ),
    );
  }
}

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

// bloc_signals 에는 MockBloc/whenListen 이 없고, 상태는 signal 이므로
// 목으로 대체할 수 없다. 실제 컨테이너를 initialState 로 시드해서 쓴다.
void main() {
  late MockGetUserUseCase mockGetUser;

  setUp(() {
    mockGetUser = MockGetUserUseCase();
  });

  UserBloc seeded(UserState state) {
    final bloc = UserBloc(getUserUseCase: mockGetUser, initialState: state);
    addTearDown(bloc.close);
    return bloc;
  }

  group('UserCard', () {
    final testUser = User(id: 1, name: 'Test User', email: 'test@test.com');

    testWidgets('displays user information', (tester) async {
      // Arrange
      final bloc = seeded(UserState.loaded(user: testUser));

      // Act
      await tester.pumpAppWithBloc(
        const UserCard(),
        bloc: bloc,
      );

      // Assert
      expect(find.text('Test User'), findsOneWidget);
      expect(find.text('test@test.com'), findsOneWidget);
    });

    testWidgets('shows loading indicator when loading', (tester) async {
      // Arrange
      final bloc = seeded(const UserState.loading());

      // Act
      await tester.pumpAppWithBloc(
        const UserCard(),
        bloc: bloc,
      );

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

    testWidgets('triggers refresh on pull', (tester) async {
      // Arrange
      final bloc = seeded(UserState.loaded(user: testUser));

      // Act
      await tester.pumpAppWithBloc(
        const RefreshIndicator(
          onRefresh: () async {},
          child: UserCard(),
        ),
        bloc: bloc,
      );
      await tester.fling(find.byType(UserCard), const Offset(0, 300), 500);
      await tester.pumpAndSettle();

      // Assert
      verify(() => mockBloc.add(const UserEvent.refresh())).called(1);
    });
  });
}

import 'package:flutter_test/flutter_test.dart';
import 'package:golden_toolkit/golden_toolkit.dart';

void main() {
  group('UserCard Golden Tests', () {
    testGoldens('UserCard renders correctly', (tester) async {
      // Arrange
      final widget = GoldenTestScenario(
        name: 'default',
        child: UserCard(
          user: User(id: 1, name: 'Test User', email: 'test@test.com'),
        ),
      );

      // Act & Assert
      await tester.pumpWidgetBuilder(
        widget,
        surfaceSize: const Size(400, 200),
      );
      await screenMatchesGolden(tester, 'user_card_default');
    });

    testGoldens('UserCard states', (tester) async {
      final builder = DeviceBuilder()
        ..overrideDevicesForAllScenarios(devices: [Device.phone])
        ..addScenario(
          name: 'loading',
          widget: const UserCard.loading(),
        )
        ..addScenario(
          name: 'loaded',
          widget: UserCard(user: testUser),
        )
        ..addScenario(
          name: 'error',
          widget: const UserCard.error(message: 'Failed to load'),
        );

      await tester.pumpDeviceBuilder(builder);
      await screenMatchesGolden(tester, 'user_card_states');
    });
  });
}

// test/fixtures/test_data.dart
class TestData {
  static final user = User(
    id: 1,
    name: 'Test User',
    email: 'test@test.com',
    avatarUrl: 'https://example.com/avatar.png',
    createdAt: DateTime(2024, 1, 1),
  );

  static final users = [
    user,
    User(id: 2, name: 'User 2', email: 'user2@test.com'),
    User(id: 3, name: 'User 3', email: 'user3@test.com'),
  ];

  static final post = Post(
    id: 1,
    title: 'Test Post',
    content: 'Test content',
    authorId: 1,
  );
}

// test/helpers/register_fallback_values.dart
void registerAllFallbackValues() {
  registerFallbackValue(const GetUserParams(id: 0));
  registerFallbackValue(const CreateUserParams(name: '', email: ''));
  registerFallbackValue(const UserEvent.load(userId: 0));
  registerFallbackValue(const UserState.initial());
}

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

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:patrol/patrol.dart';
import 'package:test_driver/test_driver.dart';

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

# Run all tests
melos run test

# Test specific package
melos exec --scope=feature_user --  " flutter test " 

 # Generate coverage
melos run test:with-html-coverage

# Update golden tests
flutter test --update-goldens

# ⛔ melos run test:bdd / test:bdd:select / melos run build (BDD → _test.dart) are retired —
# there is no BDD codegen pipeline anymore. BDD (Gherkin) scenarios run only via hand-written
# Patrol E2E tests:
patrol test --target integration_test/scenarios/smoke_test.dart

# Single file test
flutter test test/domain/usecase/get_user_usecase_test.dart