// test/models/user_test.dart
import 'package:flutter_test/flutter_test.dart';

void main() {
  group('User', () {
    test('fromJson creates correct User', () {
      final json = {'id': 1, 'name': 'Ali', 'email': 'ali@example.com'};
      final user = User.fromJson(json);

      expect(user.id, 1);
      expect(user.name, 'Ali');
      expect(user.email, 'ali@example.com');
    });

    test('toJson produces correct map', () {
      final user = User(id: 1, name: 'Ali', email: 'ali@example.com');
      final json = user.toJson();

      expect(json['id'], 1);
      expect(json['name'], 'Ali');
    });
  });
}

group('UserRepository', () {
  late UserRepository repo;
  late MockApiClient mockApi;

  setUp(() {
    mockApi = MockApiClient();
    repo = UserRepository(mockApi);
  });

  test('getAll returns list of users', () async {
    // Arrange
    when(() => mockApi.get('/users')).thenAnswer(
      (_) async => Response(
        data: [{'id': 1, 'name': 'Ali'}],
        statusCode: 200,
        requestOptions: RequestOptions(),
      ),
    );

    // Act
    final users = await repo.getAll();

    // Assert
    expect(users.length, 1);
    expect(users.first.name, 'Ali');
  });

  test('getAll throws on network error', () async {
    when(() => mockApi.get('/users')).thenThrow(DioException(
      type: DioExceptionType.connectionError,
      requestOptions: RequestOptions(),
    ));

    expect(() => repo.getAll(), throwsA(isA<NetworkException>()));
  });
});

testWidgets('CounterPage increments on tap', (tester) async {
  // Arrange: Load the widget
  await tester.pumpWidget(const MaterialApp(home: CounterPage()));

  // Assert: Initial state
  expect(find.text('Count: 0'), findsOneWidget);
  expect(find.text('Count: 1'), findsNothing);

  // Act: Tap the button
  await tester.tap(find.byType(ElevatedButton));
  await tester.pump(); // Rebuild after state change

  // Assert: Updated state
  expect(find.text('Count: 0'), findsNothing);
  expect(find.text('Count: 1'), findsOneWidget);
});

testWidgets('Shows loading indicator', (tester) async {
  await tester.pumpWidget(const MaterialApp(home: UserListPage()));
  expect(find.byType(CircularProgressIndicator), findsOneWidget);
});

// integration_test/app_test.dart
import 'package:integration_test/integration_test.dart';

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  group('App Integration Tests', () {
    testWidgets('Full login flow', (tester) async {
      await tester.pumpWidget(const MyApp());
      await tester.pumpAndSettle();

      // Enter credentials
      await tester.enterText(
        find.byType(TextFormField).first, 'ali@example.com');
      await tester.enterText(
        find.byType(TextFormField).last, 'password123');

      // Tap login
      await tester.tap(find.byType(ElevatedButton));
      await tester.pumpAndSettle();

      // Verify home screen loaded
      expect(find.text('Welcome'), findsOneWidget);
    });
  });
}

import 'package:mocktail/mocktail.dart';

// Create a mock
class MockUserRepository extends Mock implements UserRepository {}
class MockApiClient extends Mock implements ApiClient {}

void main() {
  late MockUserRepository mockRepo;

  setUp(() {
    mockRepo = MockUserRepository();
    // Register fallback values for complex types
    registerFallbackValue(User(id: 0, name: '', email: ''));
  });

  test('Bloc emits loaded state on success', () async {
    // Arrange
    final users = [User(id: 1, name: 'Ali', email: 'ali@example.com')];
    when(() => mockRepo.getAll()).thenAnswer((_) async => users);

    // Act
    final bloc = UserBloc(mockRepo);
    bloc.add(LoadUsers());

    // Assert
    await expectLater(
      bloc.stream,
      emitsInOrder([isA<UserLoading>(), UserLoaded(users)]),
    );
  });
}

// Test a Riverpod provider
void main() {
  test('counterProvider starts at 0 and increments', () async {
    // Create a container with overrides
    final container = ProviderContainer();

    // Read initial state
    expect(container.read(counterProvider), 0);

    // Increment
    container.read(counterProvider.notifier).state++;
    expect(container.read(counterProvider), 1);

    container.dispose();
  });

  test('asyncUsersProvider loads users', () async {
    final container = ProviderContainer(
      overrides: [
        userRepositoryProvider.overrideWithValue(MockUserRepository()
          ..getAllReturns([User(id: 1, name: 'Ali', email: 'a@b.com')])),
      ],
    );

    final asyncValue = await container.read(asyncUsersProvider.future);
    expect(asyncValue.length, 1);
    expect(asyncValue.first.name, 'Ali');

    container.dispose();
  });
}

# .github/workflows/flutter-ci.yml
name: Flutter CI

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: '3.22.0'
      - run: flutter pub get
      - run: flutter analyze
      - run: flutter test --coverage
      - uses: codecov/codecov-action@v3
        with:
          files: coverage/lcov.info

  build-android:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: subosito/flutter-action@v2
      - run: flutter build apk --release --obfuscate
      - uses: actions/upload-artifact@v4
        with:
          name: release-apk
          path: build/app/outputs/flutter-apk/app-release.apk