mirror of https://github.com/immich-app/immich.git
feat: user sync stream (#16862)
* refactor: user entity * chore: rebase fixes * refactor: remove int user Id * refactor: migrate store userId from int to string * refactor: rename uid to id * feat: drift * pr feedback * refactor: move common overrides to mixin * refactor: remove int user Id * refactor: migrate store userId from int to string * refactor: rename uid to id * feat: user & partner sync stream * pr changes * refactor: sync service and add tests * chore: remove generated change * chore: move sync model * rebase: convert string ids to byte uuids * rebase * add processing logs * batch db calls * rewrite isolate manager * rewrite with worker_manager * misc fixes * add sync order test --------- Co-authored-by: shenlong-tanwen <139912620+shalong-tanwen@users.noreply.github.com> Co-authored-by: Alex <alex.tran1502@gmail.com>pull/17675/head^2
shenlong
GitHub
parent
067338b0ed
commit
81ed54aa61
@ -1,3 +1,4 @@
|
||||
description: This file stores settings for Dart & Flutter DevTools.
|
||||
documentation: https://docs.flutter.dev/tools/devtools/extensions#configure-extension-enablement-states
|
||||
extensions:
|
||||
- drift: true
|
||||
@ -1,7 +1,8 @@
|
||||
import 'package:immich_mobile/domain/models/sync/sync_event.model.dart';
|
||||
import 'package:immich_mobile/domain/models/sync_event.model.dart';
|
||||
import 'package:openapi/api.dart';
|
||||
|
||||
abstract interface class ISyncApiRepository {
|
||||
Future<void> ack(String data);
|
||||
Future<void> ack(List<String> data);
|
||||
|
||||
Stream<List<SyncEvent>> watchUserSyncEvent();
|
||||
Stream<List<SyncEvent>> getSyncEvents(List<SyncRequestType> type);
|
||||
}
|
||||
|
||||
@ -0,0 +1,10 @@
|
||||
import 'package:immich_mobile/domain/interfaces/db.interface.dart';
|
||||
import 'package:openapi/api.dart';
|
||||
|
||||
abstract interface class ISyncStreamRepository implements IDatabaseRepository {
|
||||
Future<bool> updateUsersV1(Iterable<SyncUserV1> data);
|
||||
Future<bool> deleteUsersV1(Iterable<SyncUserDeleteV1> data);
|
||||
|
||||
Future<bool> updatePartnerV1(Iterable<SyncPartnerV1> data);
|
||||
Future<bool> deletePartnerV1(Iterable<SyncPartnerDeleteV1> data);
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
class SyncEvent {
|
||||
// dynamic
|
||||
final dynamic data;
|
||||
|
||||
final String ack;
|
||||
|
||||
SyncEvent({
|
||||
required this.data,
|
||||
required this.ack,
|
||||
});
|
||||
|
||||
@override
|
||||
String toString() => 'SyncEvent(data: $data, ack: $ack)';
|
||||
}
|
||||
@ -0,0 +1,13 @@
|
||||
import 'package:openapi/api.dart';
|
||||
|
||||
class SyncEvent {
|
||||
final SyncEntityType type;
|
||||
// ignore: avoid-dynamic
|
||||
final dynamic data;
|
||||
final String ack;
|
||||
|
||||
const SyncEvent({required this.type, required this.data, required this.ack});
|
||||
|
||||
@override
|
||||
String toString() => 'SyncEvent(type: $type, data: $data, ack: $ack)';
|
||||
}
|
||||
@ -1,49 +1,200 @@
|
||||
// ignore_for_file: avoid-passing-async-when-sync-expected
|
||||
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:collection/collection.dart';
|
||||
import 'package:immich_mobile/domain/interfaces/sync_api.interface.dart';
|
||||
import 'package:immich_mobile/domain/interfaces/sync_stream.interface.dart';
|
||||
import 'package:logging/logging.dart';
|
||||
import 'package:openapi/api.dart';
|
||||
import 'package:worker_manager/worker_manager.dart';
|
||||
|
||||
const _kSyncTypeOrder = [
|
||||
SyncEntityType.userDeleteV1,
|
||||
SyncEntityType.userV1,
|
||||
SyncEntityType.partnerDeleteV1,
|
||||
SyncEntityType.partnerV1,
|
||||
SyncEntityType.assetDeleteV1,
|
||||
SyncEntityType.assetV1,
|
||||
SyncEntityType.assetExifV1,
|
||||
SyncEntityType.partnerAssetDeleteV1,
|
||||
SyncEntityType.partnerAssetV1,
|
||||
SyncEntityType.partnerAssetExifV1,
|
||||
];
|
||||
|
||||
class SyncStreamService {
|
||||
final Logger _logger = Logger('SyncStreamService');
|
||||
|
||||
final ISyncApiRepository _syncApiRepository;
|
||||
final ISyncStreamRepository _syncStreamRepository;
|
||||
final bool Function()? _cancelChecker;
|
||||
|
||||
SyncStreamService({
|
||||
required ISyncApiRepository syncApiRepository,
|
||||
required ISyncStreamRepository syncStreamRepository,
|
||||
bool Function()? cancelChecker,
|
||||
}) : _syncApiRepository = syncApiRepository,
|
||||
_syncStreamRepository = syncStreamRepository,
|
||||
_cancelChecker = cancelChecker;
|
||||
|
||||
Future<bool> _handleSyncData(
|
||||
SyncEntityType type,
|
||||
// ignore: avoid-dynamic
|
||||
Iterable<dynamic> data,
|
||||
) async {
|
||||
if (data.isEmpty) {
|
||||
_logger.warning("Received empty sync data for $type");
|
||||
return false;
|
||||
}
|
||||
|
||||
_logger.fine("Processing sync data for $type of length ${data.length}");
|
||||
|
||||
try {
|
||||
if (type == SyncEntityType.partnerV1) {
|
||||
return await _syncStreamRepository.updatePartnerV1(data.cast());
|
||||
}
|
||||
|
||||
if (type == SyncEntityType.partnerDeleteV1) {
|
||||
return await _syncStreamRepository.deletePartnerV1(data.cast());
|
||||
}
|
||||
|
||||
SyncStreamService(this._syncApiRepository);
|
||||
if (type == SyncEntityType.userV1) {
|
||||
return await _syncStreamRepository.updateUsersV1(data.cast());
|
||||
}
|
||||
|
||||
if (type == SyncEntityType.userDeleteV1) {
|
||||
return await _syncStreamRepository.deleteUsersV1(data.cast());
|
||||
}
|
||||
} catch (error, stack) {
|
||||
_logger.severe("Error processing sync data for $type", error, stack);
|
||||
return false;
|
||||
}
|
||||
|
||||
_logger.warning("Unknown sync data type: $type");
|
||||
return false;
|
||||
}
|
||||
|
||||
StreamSubscription? _userSyncSubscription;
|
||||
Future<void> _syncEvent(List<SyncRequestType> types) {
|
||||
_logger.info("Syncing Events: $types");
|
||||
final streamCompleter = Completer();
|
||||
bool shouldComplete = false;
|
||||
// the onDone callback might fire before the events are processed
|
||||
// the following flag ensures that the onDone callback is not called
|
||||
// before the events are processed and also that events are processed sequentially
|
||||
Completer? mutex;
|
||||
StreamSubscription? subscription;
|
||||
try {
|
||||
subscription = _syncApiRepository.getSyncEvents(types).listen(
|
||||
(events) async {
|
||||
if (events.isEmpty) {
|
||||
_logger.warning("Received empty sync events");
|
||||
return;
|
||||
}
|
||||
|
||||
void syncUsers() {
|
||||
_userSyncSubscription =
|
||||
_syncApiRepository.watchUserSyncEvent().listen((events) async {
|
||||
for (final event in events) {
|
||||
if (event.data is SyncUserV1) {
|
||||
final data = event.data as SyncUserV1;
|
||||
debugPrint("User Update: $data");
|
||||
// If previous events are still being processed, wait for them to finish
|
||||
if (mutex != null) {
|
||||
await mutex!.future;
|
||||
}
|
||||
|
||||
// final user = await _userRepository.get(data.id);
|
||||
if (_cancelChecker?.call() ?? false) {
|
||||
_logger.info("Sync cancelled, stopping stream");
|
||||
subscription?.cancel();
|
||||
if (!streamCompleter.isCompleted) {
|
||||
streamCompleter.completeError(
|
||||
CanceledError(),
|
||||
StackTrace.current,
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// if (user == null) {
|
||||
// continue;
|
||||
// }
|
||||
// Take control of the mutex and process the events
|
||||
mutex = Completer();
|
||||
|
||||
// user.name = data.name;
|
||||
// user.email = data.email;
|
||||
// user.updatedAt = DateTime.now();
|
||||
try {
|
||||
final eventsMap = events.groupListsBy((event) => event.type);
|
||||
final Map<SyncEntityType, String> acks = {};
|
||||
|
||||
// await _userRepository.update(user);
|
||||
// await _syncApiRepository.ack(event.ack);
|
||||
}
|
||||
for (final type in _kSyncTypeOrder) {
|
||||
final data = eventsMap[type];
|
||||
if (data == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (event.data is SyncUserDeleteV1) {
|
||||
final data = event.data as SyncUserDeleteV1;
|
||||
if (_cancelChecker?.call() ?? false) {
|
||||
_logger.info("Sync cancelled, stopping stream");
|
||||
mutex?.complete();
|
||||
mutex = null;
|
||||
if (!streamCompleter.isCompleted) {
|
||||
streamCompleter.completeError(
|
||||
CanceledError(),
|
||||
StackTrace.current,
|
||||
);
|
||||
}
|
||||
|
||||
debugPrint("User delete: $data");
|
||||
// await _syncApiRepository.ack(event.ack);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (data.isEmpty) {
|
||||
_logger.warning("Received empty sync events for $type");
|
||||
continue;
|
||||
}
|
||||
|
||||
if (await _handleSyncData(type, data.map((e) => e.data))) {
|
||||
// ignore: avoid-unsafe-collection-methods
|
||||
acks[type] = data.last.ack;
|
||||
} else {
|
||||
_logger.warning("Failed to handle sync events for $type");
|
||||
}
|
||||
}
|
||||
|
||||
if (acks.isNotEmpty) {
|
||||
await _syncApiRepository.ack(acks.values.toList());
|
||||
}
|
||||
_logger.info("$types events processed");
|
||||
} catch (error, stack) {
|
||||
_logger.warning("Error handling sync events", error, stack);
|
||||
} finally {
|
||||
mutex?.complete();
|
||||
mutex = null;
|
||||
}
|
||||
|
||||
if (shouldComplete) {
|
||||
_logger.info("Sync done, completing stream");
|
||||
if (!streamCompleter.isCompleted) streamCompleter.complete();
|
||||
}
|
||||
},
|
||||
onError: (error, stack) {
|
||||
_logger.warning("Error in sync stream for $types", error, stack);
|
||||
// Do not proceed if the stream errors
|
||||
if (!streamCompleter.isCompleted) {
|
||||
// ignore: avoid-missing-completer-stack-trace
|
||||
streamCompleter.completeError(error, stack);
|
||||
}
|
||||
},
|
||||
onDone: () {
|
||||
_logger.info("$types stream done");
|
||||
if (mutex == null && !streamCompleter.isCompleted) {
|
||||
streamCompleter.complete();
|
||||
} else {
|
||||
// Marks the stream as done but does not complete the completer
|
||||
// until the events are processed
|
||||
shouldComplete = true;
|
||||
}
|
||||
},
|
||||
);
|
||||
} catch (error, stack) {
|
||||
_logger.severe("Error starting sync stream", error, stack);
|
||||
if (!streamCompleter.isCompleted) {
|
||||
streamCompleter.completeError(error, stack);
|
||||
}
|
||||
}
|
||||
return streamCompleter.future.whenComplete(() {
|
||||
_logger.info("Sync stream completed");
|
||||
return subscription?.cancel();
|
||||
});
|
||||
}
|
||||
|
||||
Future<void> dispose() async {
|
||||
await _userSyncSubscription?.cancel();
|
||||
}
|
||||
Future<void> syncUsers() =>
|
||||
_syncEvent([SyncRequestType.usersV1, SyncRequestType.partnersV1]);
|
||||
}
|
||||
|
||||
@ -0,0 +1,37 @@
|
||||
// ignore_for_file: avoid-passing-async-when-sync-expected
|
||||
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:immich_mobile/providers/infrastructure/sync_stream.provider.dart';
|
||||
import 'package:immich_mobile/utils/isolate.dart';
|
||||
import 'package:worker_manager/worker_manager.dart';
|
||||
|
||||
class BackgroundSyncManager {
|
||||
Cancelable<void>? _userSyncTask;
|
||||
|
||||
BackgroundSyncManager();
|
||||
|
||||
Future<void> cancel() {
|
||||
final futures = <Future>[];
|
||||
if (_userSyncTask != null) {
|
||||
futures.add(_userSyncTask!.future);
|
||||
}
|
||||
_userSyncTask?.cancel();
|
||||
_userSyncTask = null;
|
||||
return Future.wait(futures);
|
||||
}
|
||||
|
||||
Future<void> syncUsers() {
|
||||
if (_userSyncTask != null) {
|
||||
return _userSyncTask!.future;
|
||||
}
|
||||
|
||||
_userSyncTask = runInIsolateGentle(
|
||||
computation: (ref) => ref.read(syncStreamServiceProvider).syncUsers(),
|
||||
);
|
||||
_userSyncTask!.whenComplete(() {
|
||||
_userSyncTask = null;
|
||||
});
|
||||
return _userSyncTask!.future;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,104 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:immich_mobile/domain/interfaces/sync_stream.interface.dart';
|
||||
import 'package:immich_mobile/extensions/string_extensions.dart';
|
||||
import 'package:immich_mobile/infrastructure/entities/partner.entity.drift.dart';
|
||||
import 'package:immich_mobile/infrastructure/entities/user.entity.drift.dart';
|
||||
import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
|
||||
import 'package:logging/logging.dart';
|
||||
import 'package:openapi/api.dart';
|
||||
|
||||
class DriftSyncStreamRepository extends DriftDatabaseRepository
|
||||
implements ISyncStreamRepository {
|
||||
final Logger _logger = Logger('DriftSyncStreamRepository');
|
||||
final Drift _db;
|
||||
|
||||
DriftSyncStreamRepository(super.db) : _db = db;
|
||||
|
||||
@override
|
||||
Future<bool> deleteUsersV1(Iterable<SyncUserDeleteV1> data) async {
|
||||
try {
|
||||
await _db.batch((batch) {
|
||||
for (final user in data) {
|
||||
batch.delete(
|
||||
_db.userEntity,
|
||||
UserEntityCompanion(id: Value(user.userId.toUuidByte())),
|
||||
);
|
||||
}
|
||||
});
|
||||
return true;
|
||||
} catch (e, s) {
|
||||
_logger.severe('Error while processing SyncUserDeleteV1', e, s);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> updateUsersV1(Iterable<SyncUserV1> data) async {
|
||||
try {
|
||||
await _db.batch((batch) {
|
||||
for (final user in data) {
|
||||
final companion = UserEntityCompanion(
|
||||
name: Value(user.name),
|
||||
email: Value(user.email),
|
||||
);
|
||||
|
||||
batch.insert(
|
||||
_db.userEntity,
|
||||
companion.copyWith(id: Value(user.id.toUuidByte())),
|
||||
onConflict: DoUpdate((_) => companion),
|
||||
);
|
||||
}
|
||||
});
|
||||
return true;
|
||||
} catch (e, s) {
|
||||
_logger.severe('Error while processing SyncUserV1', e, s);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> deletePartnerV1(Iterable<SyncPartnerDeleteV1> data) async {
|
||||
try {
|
||||
await _db.batch((batch) {
|
||||
for (final partner in data) {
|
||||
batch.delete(
|
||||
_db.partnerEntity,
|
||||
PartnerEntityCompanion(
|
||||
sharedById: Value(partner.sharedById.toUuidByte()),
|
||||
sharedWithId: Value(partner.sharedWithId.toUuidByte()),
|
||||
),
|
||||
);
|
||||
}
|
||||
});
|
||||
return true;
|
||||
} catch (e, s) {
|
||||
_logger.severe('Error while processing SyncPartnerDeleteV1', e, s);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> updatePartnerV1(Iterable<SyncPartnerV1> data) async {
|
||||
try {
|
||||
await _db.batch((batch) {
|
||||
for (final partner in data) {
|
||||
final companion =
|
||||
PartnerEntityCompanion(inTimeline: Value(partner.inTimeline));
|
||||
|
||||
batch.insert(
|
||||
_db.partnerEntity,
|
||||
companion.copyWith(
|
||||
sharedById: Value(partner.sharedById.toUuidByte()),
|
||||
sharedWithId: Value(partner.sharedWithId.toUuidByte()),
|
||||
),
|
||||
onConflict: DoUpdate((_) => companion),
|
||||
);
|
||||
}
|
||||
});
|
||||
return true;
|
||||
} catch (e, s) {
|
||||
_logger.severe('Error while processing SyncPartnerV1', e, s);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
import 'package:hooks_riverpod/hooks_riverpod.dart';
|
||||
import 'package:immich_mobile/domain/utils/background_sync.dart';
|
||||
|
||||
final backgroundSyncProvider = Provider<BackgroundSyncManager>((ref) {
|
||||
final manager = BackgroundSyncManager();
|
||||
ref.onDispose(manager.cancel);
|
||||
return manager;
|
||||
});
|
||||
@ -0,0 +1,12 @@
|
||||
import 'package:hooks_riverpod/hooks_riverpod.dart';
|
||||
|
||||
/// Provider holding a boolean function that returns true when cancellation is requested.
|
||||
/// A computation running in the isolate uses the function to implement cooperative cancellation.
|
||||
final cancellationProvider = Provider<bool Function()>(
|
||||
// This will be overridden in the isolate's container.
|
||||
// Throwing ensures it's not used without an override.
|
||||
(ref) => throw UnimplementedError(
|
||||
"cancellationProvider must be overridden in the isolate's ProviderContainer and not to be used in the root isolate",
|
||||
),
|
||||
name: 'cancellationProvider',
|
||||
);
|
||||
@ -1,24 +1,23 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:hooks_riverpod/hooks_riverpod.dart';
|
||||
import 'package:immich_mobile/domain/services/sync_stream.service.dart';
|
||||
import 'package:immich_mobile/infrastructure/repositories/sync_api.repository.dart';
|
||||
import 'package:immich_mobile/infrastructure/repositories/sync_stream.repository.dart';
|
||||
import 'package:immich_mobile/providers/api.provider.dart';
|
||||
import 'package:immich_mobile/providers/infrastructure/cancel.provider.dart';
|
||||
import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
|
||||
|
||||
final syncStreamServiceProvider = Provider(
|
||||
(ref) {
|
||||
final instance = SyncStreamService(
|
||||
ref.watch(syncApiRepositoryProvider),
|
||||
);
|
||||
|
||||
ref.onDispose(() => unawaited(instance.dispose()));
|
||||
|
||||
return instance;
|
||||
},
|
||||
(ref) => SyncStreamService(
|
||||
syncApiRepository: ref.watch(syncApiRepositoryProvider),
|
||||
syncStreamRepository: ref.watch(syncStreamRepositoryProvider),
|
||||
cancelChecker: ref.watch(cancellationProvider),
|
||||
),
|
||||
);
|
||||
|
||||
final syncApiRepositoryProvider = Provider(
|
||||
(ref) => SyncApiRepository(
|
||||
ref.watch(apiServiceProvider),
|
||||
),
|
||||
(ref) => SyncApiRepository(ref.watch(apiServiceProvider)),
|
||||
);
|
||||
|
||||
final syncStreamRepositoryProvider = Provider(
|
||||
(ref) => DriftSyncStreamRepository(ref.watch(driftProvider)),
|
||||
);
|
||||
|
||||
@ -0,0 +1,69 @@
|
||||
import 'dart:async';
|
||||
import 'dart:ui';
|
||||
|
||||
import 'package:flutter/services.dart';
|
||||
import 'package:hooks_riverpod/hooks_riverpod.dart';
|
||||
import 'package:immich_mobile/providers/db.provider.dart';
|
||||
import 'package:immich_mobile/providers/infrastructure/cancel.provider.dart';
|
||||
import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
|
||||
import 'package:immich_mobile/utils/bootstrap.dart';
|
||||
import 'package:logging/logging.dart';
|
||||
import 'package:worker_manager/worker_manager.dart';
|
||||
|
||||
class InvalidIsolateUsageException implements Exception {
|
||||
const InvalidIsolateUsageException();
|
||||
|
||||
@override
|
||||
String toString() =>
|
||||
"IsolateHelper should only be used from the root isolate";
|
||||
}
|
||||
|
||||
// !! Should be used only from the root isolate
|
||||
Cancelable<T?> runInIsolateGentle<T>({
|
||||
required Future<T> Function(ProviderContainer ref) computation,
|
||||
String? debugLabel,
|
||||
}) {
|
||||
final token = RootIsolateToken.instance;
|
||||
if (token == null) {
|
||||
throw const InvalidIsolateUsageException();
|
||||
}
|
||||
|
||||
return workerManager.executeGentle((cancelledChecker) async {
|
||||
BackgroundIsolateBinaryMessenger.ensureInitialized(token);
|
||||
DartPluginRegistrant.ensureInitialized();
|
||||
|
||||
final db = await Bootstrap.initIsar();
|
||||
await Bootstrap.initDomain(db, shouldBufferLogs: false);
|
||||
final ref = ProviderContainer(
|
||||
overrides: [
|
||||
// TODO: Remove once isar is removed
|
||||
dbProvider.overrideWithValue(db),
|
||||
isarProvider.overrideWithValue(db),
|
||||
cancellationProvider.overrideWithValue(cancelledChecker),
|
||||
],
|
||||
);
|
||||
|
||||
Logger log = Logger("IsolateLogger");
|
||||
|
||||
try {
|
||||
return await computation(ref);
|
||||
} on CanceledError {
|
||||
log.warning(
|
||||
"Computation cancelled ${debugLabel == null ? '' : ' for $debugLabel'}",
|
||||
);
|
||||
} catch (error, stack) {
|
||||
log.severe(
|
||||
"Error in runInIsolateGentle ${debugLabel == null ? '' : ' for $debugLabel'}",
|
||||
error,
|
||||
stack,
|
||||
);
|
||||
} finally {
|
||||
// Wait for the logs to flush
|
||||
await Future.delayed(const Duration(seconds: 2));
|
||||
// Always close the new db connection on Isolate end
|
||||
ref.read(driftProvider).close();
|
||||
ref.read(isarProvider).close();
|
||||
}
|
||||
return null;
|
||||
});
|
||||
}
|
||||
@ -1,7 +1,10 @@
|
||||
import 'package:immich_mobile/domain/services/store.service.dart';
|
||||
import 'package:immich_mobile/domain/services/user.service.dart';
|
||||
import 'package:immich_mobile/domain/utils/background_sync.dart';
|
||||
import 'package:mocktail/mocktail.dart';
|
||||
|
||||
class MockStoreService extends Mock implements StoreService {}
|
||||
|
||||
class MockUserService extends Mock implements UserService {}
|
||||
|
||||
class MockBackgroundSyncManager extends Mock implements BackgroundSyncManager {}
|
||||
|
||||
@ -0,0 +1,443 @@
|
||||
// ignore_for_file: avoid-unnecessary-futures, avoid-async-call-in-sync-function
|
||||
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:immich_mobile/domain/interfaces/sync_api.interface.dart';
|
||||
import 'package:immich_mobile/domain/interfaces/sync_stream.interface.dart';
|
||||
import 'package:immich_mobile/domain/models/sync_event.model.dart';
|
||||
import 'package:immich_mobile/domain/services/sync_stream.service.dart';
|
||||
import 'package:mocktail/mocktail.dart';
|
||||
import 'package:openapi/api.dart';
|
||||
import 'package:worker_manager/worker_manager.dart';
|
||||
|
||||
import '../../fixtures/sync_stream.stub.dart';
|
||||
import '../../infrastructure/repository.mock.dart';
|
||||
|
||||
class _CancellationWrapper {
|
||||
const _CancellationWrapper();
|
||||
|
||||
bool isCancelled() => false;
|
||||
}
|
||||
|
||||
class _MockCancellationWrapper extends Mock implements _CancellationWrapper {}
|
||||
|
||||
void main() {
|
||||
late SyncStreamService sut;
|
||||
late ISyncStreamRepository mockSyncStreamRepo;
|
||||
late ISyncApiRepository mockSyncApiRepo;
|
||||
late StreamController<List<SyncEvent>> streamController;
|
||||
|
||||
successHandler(Invocation _) async => true;
|
||||
failureHandler(Invocation _) async => false;
|
||||
|
||||
setUp(() {
|
||||
mockSyncStreamRepo = MockSyncStreamRepository();
|
||||
mockSyncApiRepo = MockSyncApiRepository();
|
||||
streamController = StreamController<List<SyncEvent>>.broadcast();
|
||||
|
||||
sut = SyncStreamService(
|
||||
syncApiRepository: mockSyncApiRepo,
|
||||
syncStreamRepository: mockSyncStreamRepo,
|
||||
);
|
||||
|
||||
// Default stream setup - emits one batch and closes
|
||||
when(() => mockSyncApiRepo.getSyncEvents(any()))
|
||||
.thenAnswer((_) => streamController.stream);
|
||||
|
||||
// Default ack setup
|
||||
when(() => mockSyncApiRepo.ack(any())).thenAnswer((_) async => {});
|
||||
|
||||
// Register fallbacks for mocktail verification
|
||||
registerFallbackValue(<SyncUserV1>[]);
|
||||
registerFallbackValue(<SyncPartnerV1>[]);
|
||||
registerFallbackValue(<SyncUserDeleteV1>[]);
|
||||
registerFallbackValue(<SyncPartnerDeleteV1>[]);
|
||||
|
||||
// Default successful repository calls
|
||||
when(() => mockSyncStreamRepo.updateUsersV1(any()))
|
||||
.thenAnswer(successHandler);
|
||||
when(() => mockSyncStreamRepo.deleteUsersV1(any()))
|
||||
.thenAnswer(successHandler);
|
||||
when(() => mockSyncStreamRepo.updatePartnerV1(any()))
|
||||
.thenAnswer(successHandler);
|
||||
when(() => mockSyncStreamRepo.deletePartnerV1(any()))
|
||||
.thenAnswer(successHandler);
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
if (!streamController.isClosed) {
|
||||
await streamController.close();
|
||||
}
|
||||
});
|
||||
|
||||
// Helper to trigger sync and add events to the stream
|
||||
Future<void> triggerSyncAndEmit(List<SyncEvent> events) async {
|
||||
final future = sut.syncUsers(); // Start listening
|
||||
await Future.delayed(Duration.zero); // Allow listener to attach
|
||||
if (!streamController.isClosed) {
|
||||
streamController.add(events);
|
||||
await streamController.close(); // Close after emitting
|
||||
}
|
||||
await future; // Wait for processing to complete
|
||||
}
|
||||
|
||||
group("SyncStreamService", () {
|
||||
test(
|
||||
"completes successfully when stream emits data and handlers succeed",
|
||||
() async {
|
||||
final events = [
|
||||
...SyncStreamStub.userEvents,
|
||||
...SyncStreamStub.partnerEvents,
|
||||
];
|
||||
final future = triggerSyncAndEmit(events);
|
||||
await expectLater(future, completes);
|
||||
// Verify ack includes last ack from each successfully handled type
|
||||
verify(
|
||||
() =>
|
||||
mockSyncApiRepo.ack(any(that: containsAll(["5", "2", "4", "3"]))),
|
||||
).called(1);
|
||||
},
|
||||
);
|
||||
|
||||
test("completes successfully when stream emits an error", () async {
|
||||
when(() => mockSyncApiRepo.getSyncEvents(any()))
|
||||
.thenAnswer((_) => Stream.error(Exception("Stream Error")));
|
||||
// Should complete gracefully without throwing
|
||||
await expectLater(sut.syncUsers(), throwsException);
|
||||
verifyNever(() => mockSyncApiRepo.ack(any())); // No ack on stream error
|
||||
});
|
||||
|
||||
test("throws when initial getSyncEvents call fails", () async {
|
||||
final apiException = Exception("API Error");
|
||||
when(() => mockSyncApiRepo.getSyncEvents(any())).thenThrow(apiException);
|
||||
// Should rethrow the exception from the initial call
|
||||
await expectLater(sut.syncUsers(), throwsA(apiException));
|
||||
verifyNever(() => mockSyncApiRepo.ack(any()));
|
||||
});
|
||||
|
||||
test(
|
||||
"completes successfully when a repository handler throws an exception",
|
||||
() async {
|
||||
when(() => mockSyncStreamRepo.updateUsersV1(any()))
|
||||
.thenThrow(Exception("Repo Error"));
|
||||
final events = [
|
||||
...SyncStreamStub.userEvents,
|
||||
...SyncStreamStub.partnerEvents,
|
||||
];
|
||||
// Should complete, but ack only for the successful types
|
||||
await triggerSyncAndEmit(events);
|
||||
// Only partner delete was successful by default setup
|
||||
verify(() => mockSyncApiRepo.ack(["2", "4", "3"])).called(1);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
"completes successfully but sends no ack when all handlers fail",
|
||||
() async {
|
||||
when(() => mockSyncStreamRepo.updateUsersV1(any()))
|
||||
.thenAnswer(failureHandler);
|
||||
when(() => mockSyncStreamRepo.deleteUsersV1(any()))
|
||||
.thenAnswer(failureHandler);
|
||||
when(() => mockSyncStreamRepo.updatePartnerV1(any()))
|
||||
.thenAnswer(failureHandler);
|
||||
when(() => mockSyncStreamRepo.deletePartnerV1(any()))
|
||||
.thenAnswer(failureHandler);
|
||||
|
||||
final events = [
|
||||
...SyncStreamStub.userEvents,
|
||||
...SyncStreamStub.partnerEvents,
|
||||
];
|
||||
await triggerSyncAndEmit(events);
|
||||
verifyNever(() => mockSyncApiRepo.ack(any()));
|
||||
},
|
||||
);
|
||||
|
||||
test("sends ack only for types where handler returns true", () async {
|
||||
// Mock specific handlers: user update fails, user delete succeeds
|
||||
when(() => mockSyncStreamRepo.updateUsersV1(any()))
|
||||
.thenAnswer(failureHandler);
|
||||
when(() => mockSyncStreamRepo.deleteUsersV1(any()))
|
||||
.thenAnswer(successHandler);
|
||||
// partner update fails, partner delete succeeds
|
||||
when(() => mockSyncStreamRepo.updatePartnerV1(any()))
|
||||
.thenAnswer(failureHandler);
|
||||
|
||||
final events = [
|
||||
...SyncStreamStub.userEvents,
|
||||
...SyncStreamStub.partnerEvents,
|
||||
];
|
||||
await triggerSyncAndEmit(events);
|
||||
|
||||
// Expect ack only for userDeleteV1 (ack: "2") and partnerDeleteV1 (ack: "4")
|
||||
verify(() => mockSyncApiRepo.ack(any(that: containsAll(["2", "4"]))))
|
||||
.called(1);
|
||||
});
|
||||
|
||||
test("does not process or ack when stream emits an empty list", () async {
|
||||
final future = sut.syncUsers();
|
||||
streamController.add([]); // Emit empty list
|
||||
await streamController.close();
|
||||
await future; // Wait for completion
|
||||
|
||||
verifyNever(() => mockSyncStreamRepo.updateUsersV1(any()));
|
||||
verifyNever(() => mockSyncStreamRepo.deleteUsersV1(any()));
|
||||
verifyNever(() => mockSyncStreamRepo.updatePartnerV1(any()));
|
||||
verifyNever(() => mockSyncStreamRepo.deletePartnerV1(any()));
|
||||
verifyNever(() => mockSyncApiRepo.ack(any()));
|
||||
});
|
||||
|
||||
test("processes multiple batches sequentially using mutex", () async {
|
||||
final completer1 = Completer<void>();
|
||||
final completer2 = Completer<void>();
|
||||
int callOrder = 0;
|
||||
int handler1StartOrder = -1;
|
||||
int handler2StartOrder = -1;
|
||||
int handler1Calls = 0;
|
||||
int handler2Calls = 0;
|
||||
|
||||
when(() => mockSyncStreamRepo.updateUsersV1(any())).thenAnswer((_) async {
|
||||
handler1Calls++;
|
||||
handler1StartOrder = ++callOrder;
|
||||
await completer1.future;
|
||||
return true;
|
||||
});
|
||||
when(() => mockSyncStreamRepo.updatePartnerV1(any()))
|
||||
.thenAnswer((_) async {
|
||||
handler2Calls++;
|
||||
handler2StartOrder = ++callOrder;
|
||||
await completer2.future;
|
||||
return true;
|
||||
});
|
||||
|
||||
final batch1 = SyncStreamStub.userEvents;
|
||||
final batch2 = SyncStreamStub.partnerEvents;
|
||||
|
||||
final syncFuture = sut.syncUsers();
|
||||
await pumpEventQueue();
|
||||
|
||||
streamController.add(batch1);
|
||||
await pumpEventQueue();
|
||||
// Small delay to ensure the first handler starts
|
||||
await Future.delayed(const Duration(milliseconds: 20));
|
||||
|
||||
expect(handler1StartOrder, 1, reason: "Handler 1 should start first");
|
||||
expect(handler1Calls, 1);
|
||||
|
||||
streamController.add(batch2);
|
||||
await pumpEventQueue();
|
||||
// Small delay
|
||||
await Future.delayed(const Duration(milliseconds: 20));
|
||||
|
||||
expect(handler2StartOrder, -1, reason: "Handler 2 should wait");
|
||||
expect(handler2Calls, 0);
|
||||
|
||||
completer1.complete();
|
||||
await pumpEventQueue(times: 40);
|
||||
// Small delay to ensure the second handler starts
|
||||
await Future.delayed(const Duration(milliseconds: 20));
|
||||
|
||||
expect(handler2StartOrder, 2, reason: "Handler 2 should start after H1");
|
||||
expect(handler2Calls, 1);
|
||||
|
||||
completer2.complete();
|
||||
await pumpEventQueue(times: 40);
|
||||
// Small delay before closing the stream
|
||||
await Future.delayed(const Duration(milliseconds: 20));
|
||||
|
||||
if (!streamController.isClosed) {
|
||||
await streamController.close();
|
||||
}
|
||||
await pumpEventQueue(times: 40);
|
||||
// Small delay to ensure the sync completes
|
||||
await Future.delayed(const Duration(milliseconds: 20));
|
||||
|
||||
await syncFuture;
|
||||
|
||||
verify(() => mockSyncStreamRepo.updateUsersV1(any())).called(1);
|
||||
verify(() => mockSyncStreamRepo.updatePartnerV1(any())).called(1);
|
||||
verify(() => mockSyncApiRepo.ack(any())).called(2);
|
||||
});
|
||||
|
||||
test(
|
||||
"stops processing and ack when cancel checker is completed",
|
||||
() async {
|
||||
final cancellationChecker = _MockCancellationWrapper();
|
||||
when(() => cancellationChecker.isCancelled()).thenAnswer((_) => false);
|
||||
|
||||
sut = SyncStreamService(
|
||||
syncApiRepository: mockSyncApiRepo,
|
||||
syncStreamRepository: mockSyncStreamRepo,
|
||||
cancelChecker: cancellationChecker.isCancelled,
|
||||
);
|
||||
|
||||
final processingCompleter = Completer<void>();
|
||||
bool handlerStarted = false;
|
||||
|
||||
// Make handler wait so we can cancel it mid-flight
|
||||
when(() => mockSyncStreamRepo.deleteUsersV1(any()))
|
||||
.thenAnswer((_) async {
|
||||
handlerStarted = true;
|
||||
await processingCompleter
|
||||
.future; // Wait indefinitely until test completes it
|
||||
return true;
|
||||
});
|
||||
|
||||
final syncFuture = sut.syncUsers();
|
||||
await pumpEventQueue(times: 30);
|
||||
|
||||
streamController.add(SyncStreamStub.userEvents);
|
||||
// Ensure processing starts
|
||||
await Future.delayed(const Duration(milliseconds: 10));
|
||||
|
||||
expect(handlerStarted, isTrue, reason: "Handler should have started");
|
||||
|
||||
when(() => cancellationChecker.isCancelled()).thenAnswer((_) => true);
|
||||
|
||||
// Allow cancellation logic to propagate
|
||||
await Future.delayed(const Duration(milliseconds: 10));
|
||||
|
||||
// Complete the handler's completer after cancellation signal
|
||||
// to ensure the cancellation logic itself isn't blocked by the handler.
|
||||
processingCompleter.complete();
|
||||
|
||||
await expectLater(syncFuture, throwsA(isA<CanceledError>()));
|
||||
|
||||
// Verify that ack was NOT called because processing was cancelled
|
||||
verifyNever(() => mockSyncApiRepo.ack(any()));
|
||||
},
|
||||
);
|
||||
|
||||
test("completes successfully when ack call throws an exception", () async {
|
||||
when(() => mockSyncApiRepo.ack(any())).thenThrow(Exception("Ack Error"));
|
||||
final events = [
|
||||
...SyncStreamStub.userEvents,
|
||||
...SyncStreamStub.partnerEvents,
|
||||
];
|
||||
|
||||
// Should still complete even if ack fails
|
||||
await triggerSyncAndEmit(events);
|
||||
verify(() => mockSyncApiRepo.ack(any()))
|
||||
.called(1); // Verify ack was attempted
|
||||
});
|
||||
|
||||
test("waits for processing to finish if onDone called early", () async {
|
||||
final processingCompleter = Completer<void>();
|
||||
bool handlerFinished = false;
|
||||
|
||||
when(() => mockSyncStreamRepo.updateUsersV1(any())).thenAnswer((_) async {
|
||||
await processingCompleter.future; // Wait inside handler
|
||||
handlerFinished = true;
|
||||
return true;
|
||||
});
|
||||
|
||||
final syncFuture = sut.syncUsers();
|
||||
// Allow listener to attach
|
||||
// This is necessary to ensure the stream is ready to receive events
|
||||
await Future.delayed(Duration.zero);
|
||||
|
||||
streamController.add(SyncStreamStub.userEvents); // Emit batch
|
||||
await Future.delayed(
|
||||
const Duration(milliseconds: 10),
|
||||
); // Ensure processing starts
|
||||
|
||||
await streamController
|
||||
.close(); // Close stream (triggers onDone internally)
|
||||
await Future.delayed(
|
||||
const Duration(milliseconds: 10),
|
||||
); // Give onDone a chance to fire
|
||||
|
||||
// At this point, onDone was called, but processing is blocked
|
||||
expect(handlerFinished, isFalse);
|
||||
|
||||
processingCompleter.complete(); // Allow processing to finish
|
||||
await syncFuture; // Now the main future should complete
|
||||
|
||||
expect(handlerFinished, isTrue);
|
||||
verify(() => mockSyncApiRepo.ack(any())).called(1);
|
||||
});
|
||||
|
||||
test("processes events in the defined _kSyncTypeOrder", () async {
|
||||
final future = sut.syncUsers();
|
||||
await pumpEventQueue();
|
||||
if (!streamController.isClosed) {
|
||||
final events = [
|
||||
SyncEvent(
|
||||
type: SyncEntityType.partnerV1,
|
||||
data: SyncStreamStub.partnerV1,
|
||||
ack: "1",
|
||||
), // Should be processed last
|
||||
SyncEvent(
|
||||
type: SyncEntityType.userV1,
|
||||
data: SyncStreamStub.userV1Admin,
|
||||
ack: "2",
|
||||
), // Should be processed second
|
||||
SyncEvent(
|
||||
type: SyncEntityType.partnerDeleteV1,
|
||||
data: SyncStreamStub.partnerDeleteV1,
|
||||
ack: "3",
|
||||
), // Should be processed third
|
||||
SyncEvent(
|
||||
type: SyncEntityType.userDeleteV1,
|
||||
data: SyncStreamStub.userDeleteV1,
|
||||
ack: "4",
|
||||
), // Should be processed first
|
||||
];
|
||||
|
||||
streamController.add(events);
|
||||
await streamController.close();
|
||||
}
|
||||
await future;
|
||||
|
||||
verifyInOrder([
|
||||
() => mockSyncStreamRepo.deleteUsersV1(any()),
|
||||
() => mockSyncStreamRepo.updateUsersV1(any()),
|
||||
() => mockSyncStreamRepo.deletePartnerV1(any()),
|
||||
() => mockSyncStreamRepo.updatePartnerV1(any()),
|
||||
// Verify ack happens after all processing
|
||||
() => mockSyncApiRepo.ack(any()),
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
group("syncUsers", () {
|
||||
test("calls getSyncEvents with correct types", () async {
|
||||
// Need to close the stream for the future to complete
|
||||
final future = sut.syncUsers();
|
||||
await streamController.close();
|
||||
await future;
|
||||
|
||||
verify(
|
||||
() => mockSyncApiRepo.getSyncEvents([
|
||||
SyncRequestType.usersV1,
|
||||
SyncRequestType.partnersV1,
|
||||
]),
|
||||
).called(1);
|
||||
});
|
||||
|
||||
test("calls repository methods with correctly grouped data", () async {
|
||||
final events = [
|
||||
...SyncStreamStub.userEvents,
|
||||
...SyncStreamStub.partnerEvents,
|
||||
];
|
||||
await triggerSyncAndEmit(events);
|
||||
|
||||
// Verify each handler was called with the correct list of data payloads
|
||||
verify(
|
||||
() => mockSyncStreamRepo.updateUsersV1(
|
||||
[SyncStreamStub.userV1Admin, SyncStreamStub.userV1User],
|
||||
),
|
||||
).called(1);
|
||||
verify(
|
||||
() => mockSyncStreamRepo.deleteUsersV1([SyncStreamStub.userDeleteV1]),
|
||||
).called(1);
|
||||
verify(
|
||||
() => mockSyncStreamRepo.updatePartnerV1([SyncStreamStub.partnerV1]),
|
||||
).called(1);
|
||||
verify(
|
||||
() => mockSyncStreamRepo
|
||||
.deletePartnerV1([SyncStreamStub.partnerDeleteV1]),
|
||||
).called(1);
|
||||
});
|
||||
});
|
||||
}
|
||||
@ -0,0 +1,45 @@
|
||||
import 'package:immich_mobile/domain/models/sync_event.model.dart';
|
||||
import 'package:openapi/api.dart';
|
||||
|
||||
abstract final class SyncStreamStub {
|
||||
static final userV1Admin = SyncUserV1(
|
||||
deletedAt: DateTime(2020),
|
||||
email: "admin@admin",
|
||||
id: "1",
|
||||
name: "Admin",
|
||||
);
|
||||
static final userV1User = SyncUserV1(
|
||||
deletedAt: DateTime(2021),
|
||||
email: "user@user",
|
||||
id: "2",
|
||||
name: "User",
|
||||
);
|
||||
static final userDeleteV1 = SyncUserDeleteV1(userId: "2");
|
||||
static final userEvents = [
|
||||
SyncEvent(type: SyncEntityType.userV1, data: userV1Admin, ack: "1"),
|
||||
SyncEvent(
|
||||
type: SyncEntityType.userDeleteV1,
|
||||
data: userDeleteV1,
|
||||
ack: "2",
|
||||
),
|
||||
SyncEvent(type: SyncEntityType.userV1, data: userV1User, ack: "5"),
|
||||
];
|
||||
|
||||
static final partnerV1 = SyncPartnerV1(
|
||||
inTimeline: true,
|
||||
sharedById: "1",
|
||||
sharedWithId: "2",
|
||||
);
|
||||
static final partnerDeleteV1 = SyncPartnerDeleteV1(
|
||||
sharedById: "3",
|
||||
sharedWithId: "4",
|
||||
);
|
||||
static final partnerEvents = [
|
||||
SyncEvent(
|
||||
type: SyncEntityType.partnerDeleteV1,
|
||||
data: partnerDeleteV1,
|
||||
ack: "4",
|
||||
),
|
||||
SyncEvent(type: SyncEntityType.partnerV1, data: partnerV1, ack: "3"),
|
||||
];
|
||||
}
|
||||
Loading…
Reference in New Issue