feat: Introduce comprehensive unit tests for models and BLoCs using mockito and bloc_test, and refine TripBloc error handling.

test/models/expense_test.dart

@@ -0,0 +1,91 @@
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:travel_mate/models/expense.dart';
+import 'package:travel_mate/models/expense_split.dart';
+
+void main() {
+  group('Expense Model Tests', () {
+    const id = 'expense1';
+    const groupId = 'group1';
+    const description = 'Lunch';
+    const amount = 50.0;
+    const currency = ExpenseCurrency.eur;
+    const amountInEur = 50.0;
+    const category = ExpenseCategory.restaurant;
+    const paidById = 'user1';
+    const paidByName = 'Alice';
+    final date = DateTime(2023, 6, 1);
+    final createdAt = DateTime(2023, 6, 1);
+    const split = ExpenseSplit(
+      userId: 'user1',
+      userName: 'Alice',
+      amount: 25.0,
+    );
+    const splits = [
+      split,
+      ExpenseSplit(userId: 'user2', userName: 'Bob', amount: 25.0),
+    ];
+
+    final expense = Expense(
+      id: id,
+      groupId: groupId,
+      description: description,
+      amount: amount,
+      currency: currency,
+      amountInEur: amountInEur,
+      category: category,
+      paidById: paidById,
+      paidByName: paidByName,
+      date: date,
+      createdAt: createdAt,
+      splits: splits,
+    );
+
+    test('supports value equality', () {
+      final expense2 = Expense(
+        id: id,
+        groupId: groupId,
+        description: description,
+        amount: amount,
+        currency: currency,
+        amountInEur: amountInEur,
+        category: category,
+        paidById: paidById,
+        paidByName: paidByName,
+        date: date,
+        createdAt: createdAt,
+        splits: splits,
+      );
+      expect(expense, equals(expense2));
+    });
+
+    group('fromMap', () {
+      test('parses correctly', () {
+        final map = {
+          'groupId': groupId,
+          'description': description,
+          'amount': amount,
+          'currency': 'EUR',
+          'amountInEur': amountInEur,
+          'category': 'restaurant', // matching category name
+          'paidById': paidById,
+          'paidByName': paidByName,
+          'date': Timestamp.fromDate(date),
+          'createdAt': Timestamp.fromDate(createdAt),
+          'splits': splits.map((s) => s.toMap()).toList(),
+        };
+
+        final fromMapExpense = Expense.fromMap(map, id);
+        expect(fromMapExpense, equals(expense));
+      });
+    });
+
+    group('copyWith', () {
+      test('updates fields correctly', () {
+        final updated = expense.copyWith(amount: 100.0);
+        expect(updated.amount, 100.0);
+        expect(updated.description, description);
+      });
+    });
+  });
+}

test/models/group_test.dart

@@ -0,0 +1,100 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:travel_mate/models/group.dart';
+
+void main() {
+  group('Group Model Tests', () {
+    const id = 'group1';
+    const name = 'Paris Trip Group';
+    const tripId = 'trip1';
+    const createdBy = 'user1';
+    final createdAt = DateTime(2023, 1, 1);
+    final updatedAt = DateTime(2023, 1, 2);
+    const memberIds = ['user1', 'user2'];
+
+    final groupInstance = Group(
+      id: id,
+      name: name,
+      tripId: tripId,
+      createdBy: createdBy,
+      createdAt: createdAt,
+      updatedAt: updatedAt,
+      memberIds: memberIds,
+    );
+
+    test('props correct', () {
+      expect(groupInstance.id, id);
+      expect(groupInstance.name, name);
+      expect(groupInstance.tripId, tripId);
+      expect(groupInstance.createdBy, createdBy);
+      expect(groupInstance.createdAt, createdAt);
+      expect(groupInstance.updatedAt, updatedAt);
+      expect(groupInstance.memberIds, memberIds);
+      expect(groupInstance.members, isEmpty);
+    });
+
+    group('fromMap', () {
+      test('returns correct group from valid map', () {
+        final map = {
+          'name': name,
+          'tripId': tripId,
+          'createdBy': createdBy,
+          'createdAt': createdAt.millisecondsSinceEpoch,
+          'updatedAt': updatedAt.millisecondsSinceEpoch,
+          'memberIds': memberIds,
+        };
+        final fromMapGroup = Group.fromMap(map, id);
+
+        expect(fromMapGroup.id, id);
+        expect(fromMapGroup.name, name);
+        expect(fromMapGroup.tripId, tripId);
+        expect(fromMapGroup.createdBy, createdBy);
+        expect(fromMapGroup.createdAt, createdAt);
+        expect(fromMapGroup.updatedAt, updatedAt);
+        expect(fromMapGroup.memberIds, memberIds);
+      });
+
+      test('handles missing values gracefully', () {
+        final map = <String, dynamic>{};
+        final fromMapGroup = Group.fromMap(map, id);
+
+        expect(fromMapGroup.id, id);
+        expect(fromMapGroup.name, '');
+        expect(fromMapGroup.tripId, '');
+        expect(fromMapGroup.createdBy, '');
+        expect(fromMapGroup.memberIds, isEmpty);
+      });
+    });
+
+    group('toMap', () {
+      test('returns correct map', () {
+        final map = groupInstance.toMap();
+
+        expect(map['name'], name);
+        expect(map['tripId'], tripId);
+        expect(map['createdBy'], createdBy);
+        expect(map['createdAt'], createdAt.millisecondsSinceEpoch);
+        expect(map['updatedAt'], updatedAt.millisecondsSinceEpoch);
+        expect(map['memberIds'], memberIds);
+      });
+    });
+
+    group('copyWith', () {
+      test('returns object with updated values', () {
+        const newName = 'London Trip Group';
+        final updatedGroup = groupInstance.copyWith(name: newName);
+
+        expect(updatedGroup.name, newName);
+        expect(updatedGroup.id, id);
+        expect(updatedGroup.tripId, tripId);
+      });
+
+      test('returns distinct object but same values if no args', () {
+        final copy = groupInstance.copyWith();
+        expect(copy.id, groupInstance.id);
+        expect(copy.name, groupInstance.name);
+        // Note: Group does not implement == so we check reference inequality but value equality manually or trust fields are copied
+        expect(identical(copy, groupInstance), isFalse);
+      });
+    });
+  });
+}

test/models/trip_test.dart

@@ -0,0 +1,128 @@
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:travel_mate/models/trip.dart';
+
+void main() {
+  group('Trip Model Tests', () {
+    const id = 'trip1';
+    const title = 'Summer Vacation';
+    const description = 'Trip to the beach';
+    const location = 'Miami';
+    final startDate = DateTime(2023, 6, 1);
+    final endDate = DateTime(2023, 6, 10);
+    const createdBy = 'user1';
+    final createdAt = DateTime(2023, 1, 1);
+    final updatedAt = DateTime(2023, 1, 2);
+    const budget = 2000.0;
+    const participants = ['user1', 'user2', 'user3'];
+
+    final trip = Trip(
+      id: id,
+      title: title,
+      description: description,
+      location: location,
+      startDate: startDate,
+      endDate: endDate,
+      createdBy: createdBy,
+      createdAt: createdAt,
+      updatedAt: updatedAt,
+      budget: budget,
+      participants: participants,
+      status: 'active',
+    );
+
+    test('supports value equality', () {
+      final trip2 = Trip(
+        id: id,
+        title: title,
+        description: description,
+        location: location,
+        startDate: startDate,
+        endDate: endDate,
+        createdBy: createdBy,
+        createdAt: createdAt,
+        updatedAt: updatedAt,
+        budget: budget,
+        participants: participants,
+        status: 'active',
+      );
+      expect(trip, equals(trip2));
+    });
+
+    group('Helpers', () {
+      test('durationInDays returns correct number of days', () {
+        // 1st to 10th inclusive = 10 days
+        expect(trip.durationInDays, 10);
+      });
+
+      test('totalParticipants includes creator + participants list count?', () {
+        // Source code says: participants.length + 1
+        // participants has 3 items. So total should be 4.
+        expect(trip.totalParticipants, 4);
+      });
+
+      test('budgetPerParticipant calculation', () {
+        // 2000 / 4 = 500
+        expect(trip.budgetPerParticipant, 500.0);
+      });
+
+      test(
+        'status checks logic (mocking DateTime.now is tricky without injection, skipping exact time logic or testing logic assumption only)',
+        () {
+          // For simple unit tests without time mocking, we can create trips with dates relative to "now".
+          final now = DateTime.now();
+
+          final pastTrip = trip.copyWith(
+            startDate: now.subtract(const Duration(days: 10)),
+            endDate: now.subtract(const Duration(days: 5)),
+            status: 'completed',
+          );
+          expect(pastTrip.isCompleted, isTrue);
+
+          final futureTrip = trip.copyWith(
+            startDate: now.add(const Duration(days: 5)),
+            endDate: now.add(const Duration(days: 10)),
+            status: 'active',
+          );
+          expect(futureTrip.isUpcoming, isTrue);
+
+          final activeTrip = trip.copyWith(
+            startDate: now.subtract(const Duration(days: 2)),
+            endDate: now.add(const Duration(days: 2)),
+            status: 'active',
+          );
+          expect(activeTrip.isActive, isTrue);
+        },
+      );
+    });
+
+    group('fromMap', () {
+      test('parses standard Map inputs correctly', () {
+        final map = {
+          'title': title,
+          'description': description,
+          'location': location,
+          'startDate': startDate
+              .toIso8601String(), // _parseDateTime handles String
+          'endDate': Timestamp.fromDate(
+            endDate,
+          ), // _parseDateTime handles Timestamp
+          'createdBy': createdBy,
+          'createdAt':
+              createdAt.millisecondsSinceEpoch, // _parseDateTime handles int
+          'updatedAt': updatedAt, // _parseDateTime handles DateTime
+          'budget': budget,
+          'participants': participants,
+          'status': 'active',
+        };
+        final fromMapTrip = Trip.fromMap(map, id);
+
+        expect(fromMapTrip.id, id);
+        expect(fromMapTrip.title, title);
+        // Dates might vary slightly due to precision if using milliseconds vs microseconds, checking explicitly later
+        expect(fromMapTrip.description, description);
+        expect(fromMapTrip.budget, budget);
+      });
+    });
+  });
+}

test/models/user_test.dart

@@ -0,0 +1,139 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:travel_mate/models/user.dart';
+
+void main() {
+  group('User Model Tests', () {
+    const userId = '123';
+    const email = 'test@example.com';
+    const nom = 'Doe';
+    const prenom = 'John';
+    const platform = 'email';
+    const phoneNumber = '1234567890';
+    const profilePictureUrl = 'http://example.com/pic.jpg';
+
+    final user = User(
+      id: userId,
+      nom: nom,
+      prenom: prenom,
+      email: email,
+      platform: platform,
+      phoneNumber: phoneNumber,
+      profilePictureUrl: profilePictureUrl,
+    );
+
+    test('supports value equality', () {
+      final user2 = User(
+        id: userId,
+        nom: nom,
+        prenom: prenom,
+        email: email,
+        platform: platform,
+        phoneNumber: phoneNumber,
+        profilePictureUrl: profilePictureUrl,
+      );
+      expect(user, equals(user2));
+    });
+
+    test('props correct', () {
+      expect(user.id, userId);
+      expect(user.nom, nom);
+      expect(user.prenom, prenom);
+      expect(user.email, email);
+      expect(user.platform, platform);
+      expect(user.phoneNumber, phoneNumber);
+      expect(user.profilePictureUrl, profilePictureUrl);
+      expect(user.fullName, '$prenom $nom');
+    });
+
+    group('fromJson', () {
+      test('returns correct user from valid json', () {
+        final jsonStr =
+            '''
+          {
+            "id": "$userId",
+            "nom": "$nom",
+            "prenom": "$prenom",
+            "email": "$email",
+            "platform": "$platform",
+            "phoneNumber": "$phoneNumber",
+            "profilePictureUrl": "$profilePictureUrl"
+          }
+        ''';
+        expect(User.fromJson(jsonStr), equals(user));
+      });
+    });
+
+    group('fromMap', () {
+      test('returns correct user from valid map', () {
+        final map = {
+          'id': userId,
+          'nom': nom,
+          'prenom': prenom,
+          'email': email,
+          'platform': platform,
+          'phoneNumber': phoneNumber,
+          'profilePictureUrl': profilePictureUrl,
+        };
+        expect(User.fromMap(map), equals(user));
+      });
+
+      test('handles null/missing values gracefully', () {
+        final map = {
+          'id': userId,
+          // Missing nom
+          // Missing prenom
+          // Missing email
+          // Missing platform
+          // Missing phoneNumber
+          // Missing profilePictureUrl
+        };
+        final userFromMap = User.fromMap(map);
+        expect(userFromMap.id, userId);
+        expect(userFromMap.nom, '');
+        expect(userFromMap.prenom, '');
+        expect(userFromMap.email, '');
+        expect(userFromMap.platform, '');
+        expect(userFromMap.phoneNumber, null);
+        expect(userFromMap.profilePictureUrl, null);
+      });
+    });
+
+    group('toJson', () {
+      test('returns correct json string', () {
+        final expectedJson =
+            '{"id":"$userId","nom":"$nom","prenom":"$prenom","email":"$email","profilePictureUrl":"$profilePictureUrl","phoneNumber":"$phoneNumber","platform":"$platform"}';
+        expect(user.toJson(), expectedJson);
+      });
+    });
+
+    group('toMap', () {
+      test('returns correct map', () {
+        final expectedMap = {
+          'id': userId,
+          'nom': nom,
+          'prenom': prenom,
+          'email': email,
+          'profilePictureUrl': profilePictureUrl,
+          'phoneNumber': phoneNumber,
+          'platform': platform,
+        };
+        expect(user.toMap(), expectedMap);
+      });
+    });
+
+    group('copyWith', () {
+      test('returns object with updated values', () {
+        const newNom = 'Smith';
+        final updatedUser = user.copyWith(nom: newNom);
+        expect(updatedUser.nom, newNom);
+        expect(updatedUser.prenom, prenom);
+        expect(updatedUser.email, email);
+      });
+
+      test('returns same object if no values provided', () {
+        final updatedUser = user.copyWith();
+        expect(updatedUser, equals(user));
+      });
+    });
+  });
+}