891 lines
29 KiB
Dart
891 lines
29 KiB
Dart
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
import 'package:drift/native.dart';
|
|
import 'package:drift/drift.dart' as drift;
|
|
import 'package:motorcycle_dash/database/database.dart';
|
|
import 'package:motorcycle_dash/services/auth/auth_service.dart';
|
|
import 'package:motorcycle_dash/services/auth/auth_state.dart';
|
|
import 'package:motorcycle_dash/services/auth/auth_user.dart';
|
|
import 'package:motorcycle_dash/services/sync/sync_models.dart';
|
|
import 'package:motorcycle_dash/services/sync/sync_provider.dart';
|
|
import 'package:motorcycle_dash/services/sync/sync_outbox.dart';
|
|
import 'package:motorcycle_dash/services/sync/sync_manager.dart';
|
|
|
|
class _TestAuthService implements AuthService {
|
|
AuthUser? _currentUser;
|
|
AuthState _authState = const AuthState.unauthenticated();
|
|
|
|
void setAuthenticatedUser(String uid, String email) {
|
|
_currentUser = AuthUser(
|
|
uid: uid,
|
|
email: email,
|
|
displayName: 'Test Rider',
|
|
isAnonymous: false,
|
|
);
|
|
_authState = AuthState.authenticated(_currentUser!);
|
|
}
|
|
|
|
void setGuestUser() {
|
|
_currentUser = const AuthUser(
|
|
uid: 'guest_uid_123',
|
|
email: null,
|
|
displayName: 'Guest Rider',
|
|
isAnonymous: true,
|
|
);
|
|
_authState = AuthState.anonymous(_currentUser!);
|
|
}
|
|
|
|
void setLoggedOut() {
|
|
_currentUser = null;
|
|
_authState = const AuthState.unauthenticated();
|
|
}
|
|
|
|
@override
|
|
AuthUser? get currentUser => _currentUser;
|
|
|
|
@override
|
|
AuthState get currentState => _authState;
|
|
|
|
@override
|
|
Stream<AuthState> get authStateChanges => Stream.value(_authState);
|
|
|
|
@override
|
|
bool get isConfigured => true;
|
|
|
|
@override
|
|
bool get isEmailVerified => false;
|
|
|
|
@override
|
|
Future<void> createUserWithEmailAndPassword(
|
|
String email,
|
|
String password, {
|
|
String? displayName,
|
|
}) async {}
|
|
|
|
@override
|
|
Future<void> deleteCurrentUser() async {}
|
|
|
|
@override
|
|
void dispose() {}
|
|
|
|
@override
|
|
Future<void> ensureBackendIdentity() async {}
|
|
|
|
@override
|
|
Future<String?> getIdToken([bool forceRefresh = false]) async =>
|
|
'fake_id_token';
|
|
|
|
@override
|
|
Future<void> reauthenticate({String? password}) async {}
|
|
|
|
@override
|
|
Future<void> reloadCurrentUser() async {}
|
|
|
|
@override
|
|
Future<void> sendEmailVerification() async {}
|
|
|
|
@override
|
|
Future<void> sendPasswordResetEmail(String email) async {}
|
|
|
|
@override
|
|
Future<void> signInAnonymously() async => setGuestUser();
|
|
|
|
@override
|
|
Future<void> signInWithEmailAndPassword(
|
|
String email,
|
|
String password,
|
|
) async => setAuthenticatedUser('uid_123', email);
|
|
|
|
@override
|
|
Future<void> signInWithGoogle() async =>
|
|
setAuthenticatedUser('uid_google', 'google@example.com');
|
|
|
|
@override
|
|
Future<void> signOut() async => setLoggedOut();
|
|
}
|
|
|
|
void main() {
|
|
TestWidgetsFlutterBinding.ensureInitialized();
|
|
|
|
group('v1.1 Completed-Ride Sync Outbox Recovery Tests', () {
|
|
late SharedPreferences prefs;
|
|
late AppDatabase db;
|
|
late _TestAuthService authService;
|
|
late FakeSyncProvider fakeProvider;
|
|
|
|
setUp(() async {
|
|
SharedPreferences.setMockInitialValues({});
|
|
prefs = await SharedPreferences.getInstance();
|
|
db = AppDatabase.forTesting(NativeDatabase.memory());
|
|
authService = _TestAuthService();
|
|
fakeProvider = FakeSyncProvider(providerId: 'firebase');
|
|
});
|
|
|
|
tearDown(() async {
|
|
await db.close();
|
|
});
|
|
|
|
test(
|
|
'1. Crash Window Recovery: Completed ride missing from outbox is recovered and uploaded',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
// Simulate a completed ride committed to SQLite during a previous session
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 10, 0, 0),
|
|
motorcycleMake: 'Honda',
|
|
motorcycleModel: 'CBR600RR',
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
|
|
// Confirm outbox starts empty (app terminated before enqueue ran)
|
|
final outbox = SyncOutbox(prefs);
|
|
expect(outbox.count, equals(0));
|
|
|
|
// Startup initialization of SyncManager (testing step-by-step)
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
// Reconcile runs
|
|
final report = await manager.reconcileCompletedRides();
|
|
|
|
expect(report.discoveredCompletedRides, equals(1));
|
|
expect(report.recoveredQueuedCount, equals(1));
|
|
expect(report.alreadyTrackedCount, equals(0));
|
|
expect(outbox.count, equals(1));
|
|
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(item, isNotNull);
|
|
expect(item?.status, equals(SyncStatus.queued));
|
|
|
|
// Verify ride ownership was claimed for authenticated user
|
|
final ownerUid = await db.getCloudOwnerUid(rideId);
|
|
expect(ownerUid, equals('rider_alice'));
|
|
|
|
// Process queue to complete upload
|
|
await manager.processQueue();
|
|
expect(
|
|
outbox.getItem(rideId, 'firebase')?.status,
|
|
equals(SyncStatus.synced),
|
|
);
|
|
expect(fakeProvider.uploadedItems.length, equals(1));
|
|
},
|
|
);
|
|
|
|
test(
|
|
'2. Idempotence: Repeated reconciliation does not create duplicate entries or uploads',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 11, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
// First run reconciles and queues the ride
|
|
final report1 = await manager.reconcileCompletedRides();
|
|
expect(report1.recoveredQueuedCount, equals(1));
|
|
expect(outbox.count, equals(1));
|
|
|
|
// Process upload
|
|
await manager.processQueue();
|
|
expect(
|
|
outbox.getItem(rideId, 'firebase')?.status,
|
|
equals(SyncStatus.synced),
|
|
);
|
|
expect(fakeProvider.uploadedItems.length, equals(1));
|
|
|
|
// Second run reports ride as already tracked, zero duplicates
|
|
final report2 = await manager.reconcileCompletedRides();
|
|
expect(report2.discoveredCompletedRides, equals(1));
|
|
expect(report2.alreadyTrackedCount, equals(1));
|
|
expect(report2.recoveredQueuedCount, equals(0));
|
|
expect(report2.totalRecovered, equals(0));
|
|
expect(outbox.count, equals(1));
|
|
|
|
// Running processQueue again does not re-upload
|
|
await manager.processQueue();
|
|
expect(fakeProvider.uploadedItems.length, equals(1));
|
|
},
|
|
);
|
|
|
|
test(
|
|
'3. Guest State & Auth Transition: Recovers as authRequired then claims and syncs on sign-in',
|
|
() async {
|
|
// User is initially a guest and provider requires auth
|
|
authService.setGuestUser();
|
|
fakeProvider.behavior = FakeSyncBehavior.authRequired;
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 12, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
// Reconcile as guest -> authRequired
|
|
final report = await manager.reconcileCompletedRides();
|
|
expect(report.recoveredAuthRequiredCount, equals(1));
|
|
expect(
|
|
outbox.getItem(rideId, 'firebase')?.status,
|
|
equals(SyncStatus.authRequired),
|
|
);
|
|
|
|
// Ownership remains unclaimed
|
|
expect(await db.getCloudOwnerUid(rideId), isNull);
|
|
|
|
// Guest now signs in with Google / Email
|
|
authService.setAuthenticatedUser('rider_bob', 'bob@example.com');
|
|
fakeProvider.behavior = FakeSyncBehavior.success;
|
|
|
|
// Invoking retryAuthRequired claims the ride and triggers queue upload
|
|
await manager.retryAuthRequired();
|
|
|
|
expect(await db.getCloudOwnerUid(rideId), equals('rider_bob'));
|
|
expect(
|
|
outbox.getItem(rideId, 'firebase')?.status,
|
|
equals(SyncStatus.synced),
|
|
);
|
|
expect(fakeProvider.uploadedItems.length, equals(1));
|
|
},
|
|
);
|
|
|
|
test(
|
|
'4. Cloud Confirmed Skip: Confirmed ride marks synced without re-uploading bundle',
|
|
() async {
|
|
authService.setAuthenticatedUser(
|
|
'rider_charlie',
|
|
'charlie@example.com',
|
|
);
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 13, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
final remoteRideId = await db.ensureCloudRideId(rideId);
|
|
|
|
// Simulate that cloud backend already has this ride bundle uploaded
|
|
fakeProvider.confirmedRemoteRideIds.add(remoteRideId);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
);
|
|
|
|
final report = await manager.reconcileCompletedRides();
|
|
expect(report.recoveredAlreadySyncedCount, equals(1));
|
|
expect(report.recoveredQueuedCount, equals(0));
|
|
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(item?.status, equals(SyncStatus.synced));
|
|
expect(item?.remoteId, equals(remoteRideId));
|
|
|
|
// Zero upload attempts because it was already confirmed
|
|
expect(fakeProvider.uploadedItems.isEmpty, isTrue);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'5. Foreign Account Isolation: Does not claim or upload rides belonging to another user',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
// Create ride explicitly owned by rider_bob
|
|
final rideId = await db
|
|
.into(db.rides)
|
|
.insert(
|
|
RidesCompanion.insert(
|
|
cloudRideId: const drift.Value('ride_bob_123'),
|
|
cloudOwnerUid: const drift.Value('rider_bob'),
|
|
startTime: DateTime.utc(2026, 10, 12, 14, 0, 0),
|
|
endTime: drift.Value(DateTime.utc(2026, 10, 12, 15, 0, 0)),
|
|
),
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
);
|
|
|
|
final report = await manager.reconcileCompletedRides();
|
|
expect(report.foreignOwnerSkippedCount, equals(1));
|
|
expect(report.totalRecovered, equals(0));
|
|
expect(outbox.count, equals(0));
|
|
|
|
// Ownership in db remains unchanged
|
|
expect(await db.getCloudOwnerUid(rideId), equals('rider_bob'));
|
|
},
|
|
);
|
|
|
|
test(
|
|
'6. In-Progress Isolation: Active rides without endTime are never recovered as completed',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
// Start ride but do not end it (endTime is null)
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 16, 0, 0),
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
);
|
|
|
|
final report = await manager.reconcileCompletedRides();
|
|
expect(report.discoveredCompletedRides, equals(0));
|
|
expect(report.totalRecovered, equals(0));
|
|
expect(outbox.getItem(rideId, 'firebase'), isNull);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'7. Inconsistent Cloud Confirmation: Preserves local data and reports inconsistent skipped without overwriting',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 17, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
final remoteRideId = await db.ensureCloudRideId(rideId);
|
|
|
|
fakeProvider.confirmationResults[remoteRideId] =
|
|
CloudConfirmationResult.inconsistent(
|
|
remoteRideId: remoteRideId,
|
|
message: 'SHA-256 mismatch detected in storage',
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
);
|
|
|
|
final report = await manager.reconcileCompletedRides();
|
|
expect(report.inconsistentSkippedCount, equals(1));
|
|
expect(report.recoveredAlreadySyncedCount, equals(0));
|
|
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(item, isNotNull);
|
|
expect(item?.status, equals(SyncStatus.failed));
|
|
expect(item?.lastError, contains('inconsistent'));
|
|
|
|
// Local ride remains safe in SQLite
|
|
final localRide = await (db.select(
|
|
db.rides,
|
|
)..where((r) => r.id.equals(rideId))).getSingle();
|
|
expect(localRide.cloudRideId, equals(remoteRideId));
|
|
},
|
|
);
|
|
|
|
test(
|
|
'8. Temporarily Unverifiable State: Leaves ride in retryWait with backoff without marking permanently missing',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 18, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
final remoteRideId = await db.ensureCloudRideId(rideId);
|
|
|
|
fakeProvider.confirmationResults[remoteRideId] =
|
|
CloudConfirmationResult.temporarilyUnverifiable(
|
|
remoteRideId: remoteRideId,
|
|
message: 'HTTP 503 backend gateway timeout',
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
);
|
|
|
|
final report = await manager.reconcileCompletedRides();
|
|
expect(report.unverifiablePendingCount, equals(1));
|
|
expect(report.recoveredAlreadySyncedCount, equals(0));
|
|
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(item, isNotNull);
|
|
expect(item?.status, equals(SyncStatus.retryWait));
|
|
expect(item?.nextRetryAt, isNotNull);
|
|
expect(item?.lastError, contains('temporarily unverifiable'));
|
|
},
|
|
);
|
|
|
|
test(
|
|
'9. Pre-Upload Ownership Protection: processQueue cancels foreign-owned outbox item before calling provider',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
// Create ride owned by rider_bob
|
|
final rideId = await db
|
|
.into(db.rides)
|
|
.insert(
|
|
RidesCompanion.insert(
|
|
cloudRideId: const drift.Value('ride_bob_456'),
|
|
cloudOwnerUid: const drift.Value('rider_bob'),
|
|
startTime: DateTime.utc(2026, 10, 12, 19, 0, 0),
|
|
endTime: drift.Value(DateTime.utc(2026, 10, 12, 20, 0, 0)),
|
|
),
|
|
);
|
|
|
|
// Force an outbox item into the queue (e.g., from stale shared storage)
|
|
final outbox = SyncOutbox(prefs);
|
|
await outbox.update(
|
|
SyncItem(
|
|
localRideId: rideId,
|
|
providerId: 'firebase',
|
|
status: SyncStatus.queued,
|
|
createdAt: DateTime.now(),
|
|
),
|
|
);
|
|
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
await manager.processQueue();
|
|
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(item?.status, equals(SyncStatus.cancelled));
|
|
expect(item?.lastError, contains('belongs to another account'));
|
|
expect(
|
|
fakeProvider.uploadedItems.isEmpty,
|
|
isTrue,
|
|
reason: 'Must not call provider upload for foreign ride',
|
|
);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'10. Mid-flight Auth Change Protection: Reverts upload to authRequired if user logs out mid-flight',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 21, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
await db.claimRideForCloudOwner(rideId, 'rider_alice');
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
await outbox.update(
|
|
SyncItem(
|
|
localRideId: rideId,
|
|
providerId: 'firebase',
|
|
status: SyncStatus.queued,
|
|
createdAt: DateTime.now(),
|
|
),
|
|
);
|
|
|
|
// Provider simulates delay and during delay user logs out
|
|
fakeProvider.delayMs = 50;
|
|
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
// Start processQueue
|
|
final uploadFuture = manager.processQueue();
|
|
|
|
// Mid-flight logout
|
|
await Future<void>.delayed(const Duration(milliseconds: 10));
|
|
authService.setLoggedOut();
|
|
|
|
await uploadFuture;
|
|
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(item?.status, equals(SyncStatus.authRequired));
|
|
expect(
|
|
item?.lastError,
|
|
contains('User changed or logged out during upload'),
|
|
);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'11. Concurrency Protection: Simultaneous reconcileCompletedRides join the same future',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 22, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
final results = await Future.wait([
|
|
manager.reconcileCompletedRides(),
|
|
manager.reconcileCompletedRides(),
|
|
]);
|
|
|
|
expect(results[0].discoveredCompletedRides, equals(1));
|
|
expect(results[1].discoveredCompletedRides, equals(1));
|
|
expect(outbox.count, equals(1));
|
|
},
|
|
);
|
|
|
|
test(
|
|
'12. Stale Persisted Outbox on retryAllPending: Foreign-owned items are cancelled on retry',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db
|
|
.into(db.rides)
|
|
.insert(
|
|
RidesCompanion.insert(
|
|
cloudRideId: const drift.Value('ride_bob_789'),
|
|
cloudOwnerUid: const drift.Value('rider_bob'),
|
|
startTime: DateTime.utc(2026, 10, 12, 23, 0, 0),
|
|
endTime: drift.Value(DateTime.utc(2026, 10, 13, 0, 0, 0)),
|
|
),
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
await outbox.update(
|
|
SyncItem(
|
|
localRideId: rideId,
|
|
providerId: 'firebase',
|
|
status: SyncStatus.failed,
|
|
lastError: 'Previous failure',
|
|
createdAt: DateTime.now(),
|
|
),
|
|
);
|
|
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
await manager.retryAllPending();
|
|
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(item?.status, equals(SyncStatus.cancelled));
|
|
expect(item?.lastError, contains('belongs to another account'));
|
|
expect(fakeProvider.uploadedItems.isEmpty, isTrue);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'13. In-Flight Cancellation Protection: cancelSync preserves cancelled status even after upload completes',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 10, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
await db.claimRideForCloudOwner(rideId, 'rider_alice');
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
await outbox.update(
|
|
SyncItem(
|
|
localRideId: rideId,
|
|
providerId: 'firebase',
|
|
status: SyncStatus.queued,
|
|
createdAt: DateTime.now(),
|
|
),
|
|
);
|
|
|
|
// Simulate provider with 50ms upload latency
|
|
fakeProvider.delayMs = 50;
|
|
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
// Start processing queue
|
|
final processFuture = manager.processQueue();
|
|
|
|
// While upload is in flight, user cancels sync
|
|
await Future<void>.delayed(const Duration(milliseconds: 10));
|
|
await manager.cancelSync(rideId, 'firebase');
|
|
|
|
await processFuture;
|
|
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(
|
|
item?.status,
|
|
equals(SyncStatus.cancelled),
|
|
reason:
|
|
'Item must remain cancelled and not get overwritten with synced',
|
|
);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'14. Default Active Provider: Selects defaultProviderId or first initial provider, defaulting to fake for bare test manager',
|
|
() async {
|
|
final outbox = SyncOutbox(prefs);
|
|
final managerExplicit = SyncManager(
|
|
outbox,
|
|
defaultProviderId: 'firebase',
|
|
autoStart: false,
|
|
);
|
|
expect(managerExplicit.activeProviderId, equals('firebase'));
|
|
|
|
final customProvider = FakeSyncProvider(providerId: 'custom_gateway');
|
|
final managerWithProviders = SyncManager(
|
|
outbox,
|
|
initialProviders: [customProvider],
|
|
autoStart: false,
|
|
);
|
|
expect(managerWithProviders.activeProviderId, equals('custom_gateway'));
|
|
|
|
final managerNoProviders = SyncManager(outbox, autoStart: false);
|
|
expect(managerNoProviders.activeProviderId, equals('fake'));
|
|
},
|
|
);
|
|
|
|
test(
|
|
'15. Immediate Enqueue Ownership Protection: enqueueRide cancels foreign-owned rides immediately',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db
|
|
.into(db.rides)
|
|
.insert(
|
|
RidesCompanion.insert(
|
|
cloudRideId: const drift.Value('ride_bob_999'),
|
|
cloudOwnerUid: const drift.Value('rider_bob'),
|
|
startTime: DateTime.utc(2026, 10, 12, 11, 0, 0),
|
|
endTime: drift.Value(DateTime.utc(2026, 10, 12, 12, 0, 0)),
|
|
),
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
final item = await manager.enqueueRide(rideId, autoProcess: false);
|
|
expect(item.status, equals(SyncStatus.cancelled));
|
|
expect(item.lastError, contains('belongs to another account'));
|
|
expect(
|
|
outbox.getItem(rideId, 'firebase')?.status,
|
|
equals(SyncStatus.cancelled),
|
|
);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'16. Failed Cloud Verification followed by Successful Retry: Recovers to synced without re-upload',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 13, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
final remoteRideId = await db.ensureCloudRideId(rideId);
|
|
|
|
// Step 1: Initial reconciliation fails with temporary verification error (e.g. HTTP 503)
|
|
fakeProvider.confirmationResults[remoteRideId] =
|
|
CloudConfirmationResult.temporarilyUnverifiable(
|
|
remoteRideId: remoteRideId,
|
|
message: 'HTTP 503 gateway timeout',
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
final report1 = await manager.reconcileCompletedRides();
|
|
expect(report1.unverifiablePendingCount, equals(1));
|
|
expect(
|
|
outbox.getItem(rideId, 'firebase')?.status,
|
|
equals(SyncStatus.retryWait),
|
|
);
|
|
|
|
// Step 2: Backend recovers and verifies the bundle in R2
|
|
fakeProvider.confirmationResults[remoteRideId] =
|
|
CloudConfirmationResult.confirmed(remoteRideId: remoteRideId);
|
|
fakeProvider.confirmedRemoteRideIds.add(remoteRideId);
|
|
|
|
// Process queue on retry
|
|
await manager.retryAllPending();
|
|
|
|
expect(
|
|
outbox.getItem(rideId, 'firebase')?.status,
|
|
equals(SyncStatus.synced),
|
|
);
|
|
expect(
|
|
fakeProvider.uploadedItems.isEmpty,
|
|
isTrue,
|
|
reason:
|
|
'Must confirm and mark synced without re-uploading the bundle',
|
|
);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'17. Legacy Unverified Cloud Confirmation: Recovers as synced without re-upload and tracks count',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_alice', 'alice@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 14, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
final remoteRideId = await db.ensureCloudRideId(rideId);
|
|
|
|
fakeProvider.confirmationResults[remoteRideId] =
|
|
CloudConfirmationResult.legacyUnverified(
|
|
remoteRideId: remoteRideId,
|
|
ownerUid: 'rider_alice',
|
|
message: 'Historical bundle without checksum',
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
final report = await manager.reconcileCompletedRides();
|
|
|
|
expect(report.recoveredLegacyUnverifiedCount, equals(1));
|
|
expect(report.recoveredAlreadySyncedCount, equals(1));
|
|
expect(report.totalRecovered, equals(1));
|
|
final item = outbox.getItem(rideId, 'firebase');
|
|
expect(item?.status, equals(SyncStatus.synced));
|
|
expect(item?.lastError, contains('without modern checksum'));
|
|
expect(
|
|
fakeProvider.uploadedItems.isEmpty,
|
|
isTrue,
|
|
reason: 'Must never re-upload existing legacy unverified bundle',
|
|
);
|
|
},
|
|
);
|
|
|
|
test(
|
|
'18. Reconciliation Never Claims Unauthorized Rides: cloudOwnerUid remains null when verification returns unauthorized',
|
|
() async {
|
|
authService.setAuthenticatedUser('rider_eve', 'eve@example.com');
|
|
|
|
final rideId = await db.startRide(
|
|
startTime: DateTime.utc(2026, 10, 12, 15, 0, 0),
|
|
);
|
|
await db.endRide(rideId, const RidesCompanion());
|
|
final remoteRideId = await db.ensureCloudRideId(rideId);
|
|
|
|
// Verification returns unauthorized (foreign-owned or permission denied)
|
|
fakeProvider.confirmationResults[remoteRideId] =
|
|
CloudConfirmationResult.unauthorized(
|
|
remoteRideId: remoteRideId,
|
|
message: 'Foreign owner in cloud metadata',
|
|
);
|
|
|
|
final outbox = SyncOutbox(prefs);
|
|
final manager = SyncManager(
|
|
outbox,
|
|
initialProviders: [fakeProvider],
|
|
defaultProviderId: 'firebase',
|
|
db: db,
|
|
authService: authService,
|
|
autoStart: false,
|
|
);
|
|
|
|
final report = await manager.reconcileCompletedRides();
|
|
|
|
// Must NOT claim ownership for rider_eve
|
|
final localOwner = await db.getCloudOwnerUid(rideId);
|
|
expect(
|
|
localOwner,
|
|
isNull,
|
|
reason: 'Must NEVER claim an unauthorized ride',
|
|
);
|
|
expect(report.foreignOwnerSkippedCount, equals(1));
|
|
expect(report.errors.isNotEmpty, isTrue);
|
|
},
|
|
);
|
|
});
|
|
}
|