feat: Add services for managing trip-related data

- Implement EmergencyService for handling emergency contacts per trip.
- Create GuestFlagService to manage guest mode flags for trips.
- Introduce NotificationService with local notification capabilities.
- Add OfflineFlagService for managing offline caching flags.
- Develop PackingService for shared packing lists per trip.
- Implement ReminderService for managing reminders/to-dos per trip.
- Create SosService for dispatching SOS events to a backend.
- Add StorageService with album image upload functionality.
- Implement TransportService for managing transport segments per trip.
- Create TripChecklistService for storing and retrieving trip checklists.
- Add TripDocumentService for persisting trip documents metadata.

test: Add unit tests for new services

- Implement tests for AlbumService, BudgetService, EmergencyService, GuestFlagService, PackingService, ReminderService, SosService, TransportService, TripChecklistService, and TripDocumentService.
- Ensure tests cover adding, loading, deleting, and handling corrupted payloads for each service.

test/services/album_service_test.dart

@@ -0,0 +1,39 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/models/album_photo.dart';
+import 'package:travel_mate/services/album_service.dart';
+
+void main() {
+  const tripId = 'trip-album-1';
+  late AlbumService service;
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = AlbumService();
+  });
+
+  test('adds and loads photos', () async {
+    final photo = AlbumPhoto.newPhoto(
+      id: 'p1',
+      url: 'https://example.com/img.jpg',
+      caption: 'Coucher de soleil',
+      uploadedBy: 'Alice',
+    );
+    await service.addPhoto(tripId, photo);
+    final loaded = await service.loadPhotos(tripId);
+    expect(loaded.single.url, contains('example.com'));
+  });
+
+  test('deletes photo and clears corrupted payload', () async {
+    final p = AlbumPhoto.newPhoto(id: 'p1', url: 'u', caption: null);
+    await service.addPhoto(tripId, p);
+    var updated = await service.deletePhoto(tripId, 'p1');
+    expect(updated, isEmpty);
+
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('album_$tripId', 'oops');
+    updated = await service.loadPhotos(tripId);
+    expect(updated, isEmpty);
+    expect(prefs.getString('album_$tripId'), isNull);
+  });
+}

test/services/budget_service_test.dart

@@ -0,0 +1,51 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/models/budget_category.dart';
+import 'package:travel_mate/services/budget_service.dart';
+
+void main() {
+  const tripId = 'trip-budget-1';
+  late BudgetService service;
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = BudgetService();
+  });
+
+  test('adds and deletes budget envelopes', () async {
+    final cat = BudgetCategory.newCategory(
+      id: 'food',
+      name: 'Food',
+      planned: 300,
+      currency: 'EUR',
+    );
+    await service.addBudget(tripId, cat);
+
+    var loaded = await service.loadBudgets(tripId);
+    expect(loaded.single.name, 'Food');
+
+    loaded = await service.deleteBudget(tripId, 'food');
+    expect(loaded, isEmpty);
+  });
+
+  test('updates spent amount', () async {
+    final cat = BudgetCategory.newCategory(
+      id: 'transport',
+      name: 'Transport',
+      planned: 200,
+      currency: 'USD',
+    );
+    await service.addBudget(tripId, cat);
+
+    final updated = await service.updateSpent(tripId, 'transport', 55.5);
+    expect(updated.first.spent, 55.5);
+  });
+
+  test('corrupted payload cleared', () async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('budget_$tripId', 'oops');
+    final loaded = await service.loadBudgets(tripId);
+    expect(loaded, isEmpty);
+    expect(prefs.getString('budget_$tripId'), isNull);
+  });
+}

test/services/emergency_service_test.dart

@@ -0,0 +1,54 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/models/emergency_contact.dart';
+import 'package:travel_mate/services/emergency_service.dart';
+
+void main() {
+  const tripId = 'trip-emergency-1';
+  late EmergencyService service;
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = EmergencyService();
+  });
+
+  test('adds and loads contacts', () async {
+    final contact = EmergencyContact.newContact(
+      id: 'c1',
+      name: 'Assistance',
+      phone: '+33123456789',
+      note: 'Assurance',
+    );
+    await service.addContact(tripId, contact);
+
+    final loaded = await service.loadContacts(tripId);
+    expect(loaded.single.phone, '+33123456789');
+  });
+
+  test('deletes contact', () async {
+    final a = EmergencyContact.newContact(
+      id: 'a',
+      name: 'Ambassade',
+      phone: '+321234',
+    );
+    final b = EmergencyContact.newContact(
+      id: 'b',
+      name: 'Marie',
+      phone: '+33999',
+    );
+    await service.addContact(tripId, a);
+    await service.addContact(tripId, b);
+
+    final updated = await service.deleteContact(tripId, 'a');
+    expect(updated.map((c) => c.id), contains('b'));
+    expect(updated.length, 1);
+  });
+
+  test('corrupted payload cleared', () async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('emergency_$tripId', 'oops');
+    final loaded = await service.loadContacts(tripId);
+    expect(loaded, isEmpty);
+    expect(prefs.getString('emergency_$tripId'), isNull);
+  });
+}

test/services/guest_flag_service_test.dart

@@ -0,0 +1,19 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/services/guest_flag_service.dart';
+
+void main() {
+  const tripId = 'trip-guest-1';
+  late GuestFlagService service;
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = GuestFlagService();
+  });
+
+  test('sets and reads guest mode flag', () async {
+    expect(await service.isGuestEnabled(tripId), isFalse);
+    await service.setGuestEnabled(tripId, true);
+    expect(await service.isGuestEnabled(tripId), isTrue);
+  });
+}

test/services/packing_service_test.dart

@@ -0,0 +1,46 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/models/packing_item.dart';
+import 'package:travel_mate/services/packing_service.dart';
+
+void main() {
+  const tripId = 'trip-pack-1';
+  late PackingService service;
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = PackingService();
+  });
+
+  test('adds, toggles and deletes packing items', () async {
+    final item = PackingItem.newItem(id: '1', label: 'Adaptateur US');
+    await service.addItem(tripId, item);
+
+    var loaded = await service.loadItems(tripId);
+    expect(loaded.first.isPacked, isFalse);
+
+    loaded = await service.toggleItem(tripId, '1');
+    expect(loaded.first.isPacked, isTrue);
+
+    loaded = await service.deleteItem(tripId, '1');
+    expect(loaded, isEmpty);
+  });
+
+  test('suggested items react to cold and duration', () {
+    final cold = service.suggestedItems(nights: 5, cold: true);
+    expect(cold, contains('Veste chaude'));
+    expect(cold, contains('Lessive/ziplock'));
+
+    final warm = service.suggestedItems(nights: 2, cold: false);
+    expect(warm, contains('Crème solaire'));
+    expect(warm, isNot(contains('Lessive/ziplock')));
+  });
+
+  test('handles corrupted payload', () async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('packing_$tripId', 'oops');
+    final items = await service.loadItems(tripId);
+    expect(items, isEmpty);
+    expect(prefs.getString('packing_$tripId'), isNull);
+  });
+}

test/services/reminder_service_test.dart

@@ -0,0 +1,45 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/models/reminder_item.dart';
+import 'package:travel_mate/services/reminder_service.dart';
+
+void main() {
+  const tripId = 'trip-reminders-1';
+  late ReminderService service;
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = ReminderService();
+  });
+
+  test('adds and toggles reminders', () async {
+    final r = ReminderItem.newItem(
+      id: 'r1',
+      title: 'Check-in en ligne',
+      dueAt: DateTime.utc(2026, 4, 10, 7),
+    );
+    await service.addReminder(tripId, r);
+    var list = await service.loadReminders(tripId);
+    expect(list.single.isDone, isFalse);
+
+    list = await service.toggleReminder(tripId, 'r1');
+    expect(list.single.isDone, isTrue);
+  });
+
+  test('deletes and clears corrupted payload', () async {
+    final r = ReminderItem.newItem(
+      id: 'r1',
+      title: 'Acheter métro pass',
+      dueAt: DateTime.utc(2026, 4, 1),
+    );
+    await service.addReminder(tripId, r);
+    var list = await service.deleteReminder(tripId, 'r1');
+    expect(list, isEmpty);
+
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('reminders_$tripId', 'oops');
+    list = await service.loadReminders(tripId);
+    expect(list, isEmpty);
+    expect(prefs.getString('reminders_$tripId'), isNull);
+  });
+}

test/services/sos_service_test.dart

@@ -0,0 +1,37 @@
+import 'dart:convert';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
+import 'package:travel_mate/services/sos_service.dart';
+
+void main() {
+  test('sendSos returns true on 200', () async {
+    final mockClient = MockClient((request) async {
+      expect(request.url.toString(), 'https://api.example.com/sos');
+      final body = json.decode(request.body) as Map<String, dynamic>;
+      expect(body['tripId'], 't1');
+      return http.Response('{}', 200);
+    });
+
+    final service = SosService(
+      baseUrl: 'https://api.example.com',
+      client: mockClient,
+    );
+
+    final result = await service.sendSos(tripId: 't1', lat: 1, lng: 2);
+    expect(result, isTrue);
+  });
+
+  test('sendSos returns false on error', () async {
+    final mockClient = MockClient((request) async {
+      return http.Response('fail', 500);
+    });
+    final service = SosService(
+      baseUrl: 'https://api.example.com',
+      client: mockClient,
+    );
+
+    final result = await service.sendSos(tripId: 't1', lat: 0, lng: 0);
+    expect(result, isFalse);
+  });
+}

test/services/transport_service_test.dart

@@ -0,0 +1,75 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/models/transport_segment.dart';
+import 'package:travel_mate/services/transport_service.dart';
+
+void main() {
+  const tripId = 'trip-transport-1';
+  late TransportService service;
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = TransportService();
+  });
+
+  test('adds and loads a segment', () async {
+    final seg = TransportSegment.newSegment(
+      id: 'seg1',
+      type: 'flight',
+      carrier: 'AF',
+      number: '763',
+      departureCode: 'CDG',
+      arrivalCode: 'JFK',
+      departureUtc: DateTime.utc(2026, 4, 10, 7, 0),
+      arrivalUtc: DateTime.utc(2026, 4, 10, 11, 0),
+      pnr: 'ABC123',
+    );
+
+    await service.addSegment(tripId, seg);
+    final loaded = await service.loadSegments(tripId);
+
+    expect(loaded, hasLength(1));
+    expect(loaded.first.number, '763');
+    expect(loaded.first.status, 'scheduled');
+  });
+
+  test('updates status', () async {
+    final seg = TransportSegment.newSegment(
+      id: 'seg1',
+      type: 'train',
+      carrier: 'TGV',
+      number: '8401',
+      departureCode: 'PAR',
+      arrivalCode: 'BRU',
+      departureUtc: DateTime.utc(2026, 5, 1, 8, 30),
+      arrivalUtc: DateTime.utc(2026, 5, 1, 10, 30),
+    );
+    await service.addSegment(tripId, seg);
+
+    final updated = await service.updateStatus(tripId, 'seg1', 'delayed');
+
+    expect(updated.first.status, 'delayed');
+  });
+
+  test('deletes segment and handles corrupted payload', () async {
+    final seg = TransportSegment.newSegment(
+      id: 'seg1',
+      type: 'bus',
+      carrier: 'FLX',
+      number: '12',
+      departureCode: 'AMS',
+      arrivalCode: 'BRU',
+      departureUtc: DateTime.utc(2026, 6, 1, 9, 0),
+      arrivalUtc: DateTime.utc(2026, 6, 1, 11, 30),
+    );
+    await service.addSegment(tripId, seg);
+    await service.deleteSegment(tripId, 'seg1');
+
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('trip_transport_$tripId', 'bad-json');
+
+    final loaded = await service.loadSegments(tripId);
+    expect(loaded, isEmpty);
+    expect(prefs.getString('trip_transport_$tripId'), isNull);
+  });
+}

test/services/trip_checklist_service_test.dart

@@ -0,0 +1,63 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/models/checklist_item.dart';
+import 'package:travel_mate/services/trip_checklist_service.dart';
+
+void main() {
+  late TripChecklistService service;
+  const tripId = 'trip-123';
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = TripChecklistService();
+  });
+
+  test('adds and loads checklist items', () async {
+    final created = ChecklistItem.newItem(id: '1', label: 'Préparer passeport');
+    await service.addItem(tripId, created);
+
+    final result = await service.loadChecklist(tripId);
+
+    expect(result, hasLength(1));
+    expect(result.first.label, 'Préparer passeport');
+    expect(result.first.isDone, isFalse);
+  });
+
+  test('toggles completion state', () async {
+    final item = ChecklistItem.newItem(id: '1', label: 'Acheter billets');
+    await service.addItem(tripId, item);
+
+    final toggled = await service.toggleItem(tripId, '1');
+
+    expect(toggled.first.isDone, isTrue);
+
+    final toggledBack = await service.toggleItem(tripId, '1');
+    expect(toggledBack.first.isDone, isFalse);
+  });
+
+  test('deletes items and keeps list consistent', () async {
+    final itemA = ChecklistItem.newItem(id: '1', label: 'Adapter prise');
+    final itemB = ChecklistItem.newItem(id: '2', label: 'Chargeur');
+    await service.addItem(tripId, itemA);
+    await service.addItem(tripId, itemB);
+
+    final afterDelete = await service.deleteItem(tripId, '1');
+
+    expect(afterDelete, hasLength(1));
+    expect(afterDelete.first.id, '2');
+
+    final persisted = await service.loadChecklist(tripId);
+    expect(persisted, hasLength(1));
+    expect(persisted.first.id, '2');
+  });
+
+  test('handles corrupted payload gracefully', () async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('checklist_$tripId', 'not-json');
+
+    final items = await service.loadChecklist(tripId);
+
+    expect(items, isEmpty);
+    expect(prefs.getString('checklist_$tripId'), isNull);
+  });
+}

test/services/trip_document_service_test.dart

@@ -0,0 +1,60 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:travel_mate/models/trip_document.dart';
+import 'package:travel_mate/services/trip_document_service.dart';
+
+void main() {
+  const tripId = 'trip-docs-1';
+  late TripDocumentService service;
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    service = TripDocumentService();
+  });
+
+  test('adds and loads documents', () async {
+    final doc = TripDocument.newEntry(
+      id: 'doc1',
+      title: 'Billet Aller',
+      category: 'billet',
+      downloadUrl: 'https://example.com/billet.pdf',
+    );
+
+    await service.addDocument(tripId, doc);
+    final loaded = await service.loadDocuments(tripId);
+
+    expect(loaded, hasLength(1));
+    expect(loaded.first.title, 'Billet Aller');
+    expect(loaded.first.category, 'billet');
+  });
+
+  test('deletes a document', () async {
+    final a = TripDocument.newEntry(
+      id: 'a',
+      title: 'Passeport',
+      category: 'passeport',
+    );
+    final b = TripDocument.newEntry(
+      id: 'b',
+      title: 'Assurance',
+      category: 'assurance',
+    );
+    await service.addDocument(tripId, a);
+    await service.addDocument(tripId, b);
+
+    final afterDelete = await service.deleteDocument(tripId, 'a');
+
+    expect(afterDelete, hasLength(1));
+    expect(afterDelete.first.id, 'b');
+  });
+
+  test('handles corrupted payload gracefully', () async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('trip_docs_$tripId', 'oops');
+
+    final docs = await service.loadDocuments(tripId);
+
+    expect(docs, isEmpty);
+    expect(prefs.getString('trip_docs_$tripId'), isNull);
+  });
+}