edde746
8624c37041
ActiveProfileProvider diffed connections on toConfigJson alone, but createdAt is a real column and now decides which connection lends a profile its picture. A creation-time correction was therefore invisible to the guard and left a stale avatar until the next launch. Compare createdAt alongside the config. ConnectionRegistry pins creation order across re-authentication, so this adds no notifications in normal operation — it only stops an out-of-band correction, such as a restore or a backfill, from being swallowed.
540 lines
22 KiB
Dart
540 lines
22 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:drift/drift.dart' show Value;
|
|
import 'package:drift/native.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:plezy/connection/connection.dart';
|
|
import 'package:plezy/connection/connection_registry.dart';
|
|
import 'package:plezy/database/app_database.dart';
|
|
import 'package:plezy/models/plex/plex_home_user.dart';
|
|
import 'package:plezy/profiles/active_profile_provider.dart';
|
|
import 'package:plezy/profiles/plex_home_service.dart';
|
|
import 'package:plezy/profiles/profile.dart';
|
|
import 'package:plezy/profiles/profile_connection.dart';
|
|
import 'package:plezy/profiles/profile_connection_registry.dart';
|
|
import 'package:plezy/profiles/profile_registry.dart';
|
|
import 'package:plezy/services/storage_service.dart';
|
|
import 'package:shared_preferences_platform_interface/shared_preferences_async_platform_interface.dart';
|
|
import 'package:shared_preferences_platform_interface/types.dart';
|
|
|
|
import '../test_helpers/prefs.dart';
|
|
|
|
final class _RecordingPreferencesPlatform extends SharedPreferencesAsyncPlatform {
|
|
_RecordingPreferencesPlatform(this.delegate);
|
|
|
|
final SharedPreferencesAsyncPlatform delegate;
|
|
final List<String> writes = [];
|
|
String? failIntKey;
|
|
|
|
@override
|
|
Future<void> setString(String key, String value, SharedPreferencesOptions options) async {
|
|
writes.add('string:$key');
|
|
await delegate.setString(key, value, options);
|
|
}
|
|
|
|
@override
|
|
Future<void> setInt(String key, int value, SharedPreferencesOptions options) async {
|
|
writes.add('int:$key');
|
|
if (key == failIntKey) throw StateError('injected recency failure');
|
|
await delegate.setInt(key, value, options);
|
|
}
|
|
|
|
@override
|
|
Future<void> setBool(String key, bool value, SharedPreferencesOptions options) =>
|
|
delegate.setBool(key, value, options);
|
|
|
|
@override
|
|
Future<void> setDouble(String key, double value, SharedPreferencesOptions options) =>
|
|
delegate.setDouble(key, value, options);
|
|
|
|
@override
|
|
Future<void> setStringList(String key, List<String> value, SharedPreferencesOptions options) =>
|
|
delegate.setStringList(key, value, options);
|
|
|
|
@override
|
|
Future<String?> getString(String key, SharedPreferencesOptions options) => delegate.getString(key, options);
|
|
|
|
@override
|
|
Future<bool?> getBool(String key, SharedPreferencesOptions options) => delegate.getBool(key, options);
|
|
|
|
@override
|
|
Future<double?> getDouble(String key, SharedPreferencesOptions options) => delegate.getDouble(key, options);
|
|
|
|
@override
|
|
Future<int?> getInt(String key, SharedPreferencesOptions options) => delegate.getInt(key, options);
|
|
|
|
@override
|
|
Future<List<String>?> getStringList(String key, SharedPreferencesOptions options) =>
|
|
delegate.getStringList(key, options);
|
|
|
|
@override
|
|
Future<void> clear(ClearPreferencesParameters parameters, SharedPreferencesOptions options) =>
|
|
delegate.clear(parameters, options);
|
|
|
|
@override
|
|
Future<Map<String, Object>> getPreferences(GetPreferencesParameters parameters, SharedPreferencesOptions options) =>
|
|
delegate.getPreferences(parameters, options);
|
|
|
|
@override
|
|
Future<Set<String>> getKeys(GetPreferencesParameters parameters, SharedPreferencesOptions options) =>
|
|
delegate.getKeys(parameters, options);
|
|
}
|
|
|
|
PlexHomeUser _homeUser(String uuid, {int id = 1, String name = 'Home User', String thumb = ''}) {
|
|
return PlexHomeUser(
|
|
id: id,
|
|
uuid: uuid,
|
|
title: name,
|
|
thumb: thumb,
|
|
hasPassword: false,
|
|
restricted: false,
|
|
updatedAt: null,
|
|
admin: true,
|
|
guest: false,
|
|
protected: false,
|
|
);
|
|
}
|
|
|
|
PlexAccountConnection _account(String id) {
|
|
return PlexAccountConnection(
|
|
id: id,
|
|
accountToken: 'token-$id',
|
|
clientIdentifier: 'client-$id',
|
|
accountLabel: 'Plex',
|
|
createdAt: DateTime(2026, 1, 1),
|
|
);
|
|
}
|
|
|
|
JellyfinConnection _jellyfin(String id, {required DateTime createdAt, required String primaryImageTag}) {
|
|
return JellyfinConnection(
|
|
id: id,
|
|
baseUrl: 'https://jellyfin.example',
|
|
serverName: 'Jellyfin',
|
|
serverMachineId: 'machine-$id',
|
|
userId: 'user-$id',
|
|
userName: 'User $id',
|
|
accessToken: 'token-$id',
|
|
deviceId: 'device-$id',
|
|
primaryImageTag: primaryImageTag,
|
|
createdAt: createdAt,
|
|
);
|
|
}
|
|
|
|
void main() {
|
|
late AppDatabase db;
|
|
late ProfileRegistry registry;
|
|
late ConnectionRegistry connections;
|
|
late ProfileConnectionRegistry profileConnections;
|
|
late PlexHomeService plexHome;
|
|
late ActiveProfileProvider provider;
|
|
late StorageService storage;
|
|
late _RecordingPreferencesPlatform preferencesPlatform;
|
|
late List<PlexHomeUser> fetchedHomeUsers;
|
|
|
|
setUp(() async {
|
|
resetSharedPreferencesForTest();
|
|
preferencesPlatform = _RecordingPreferencesPlatform(SharedPreferencesAsyncPlatform.instance!);
|
|
SharedPreferencesAsyncPlatform.instance = preferencesPlatform;
|
|
db = AppDatabase.forTesting(NativeDatabase.memory());
|
|
registry = ProfileRegistry(db);
|
|
connections = ConnectionRegistry(db);
|
|
storage = await StorageService.getInstance();
|
|
fetchedHomeUsers = const [];
|
|
profileConnections = ProfileConnectionRegistry(db);
|
|
plexHome = PlexHomeService(
|
|
connections: connections,
|
|
profileConnections: profileConnections,
|
|
storage: storage,
|
|
plexHomeUserFetcher: (_) async => fetchedHomeUsers,
|
|
);
|
|
provider = ActiveProfileProvider(
|
|
registry: registry,
|
|
plexHome: plexHome,
|
|
connections: connections,
|
|
profileConnections: profileConnections,
|
|
storage: storage,
|
|
);
|
|
});
|
|
|
|
tearDown(() async {
|
|
await provider.resetForTesting();
|
|
provider.dispose();
|
|
await plexHome.dispose();
|
|
await db.close();
|
|
});
|
|
|
|
group('ActiveProfileProvider', () {
|
|
test('initialize with no profiles leaves active null', () async {
|
|
await provider.initialize();
|
|
expect(provider.profiles, isEmpty);
|
|
expect(provider.active, isNull);
|
|
});
|
|
|
|
test('concurrent initialize calls await the same in-flight load', () async {
|
|
final first = provider.initialize();
|
|
final second = provider.initialize();
|
|
expect(identical(first, second), isTrue);
|
|
|
|
await second;
|
|
expect(provider.isInitialized, isTrue);
|
|
});
|
|
|
|
test('initialize leaves active null when no active id stored', () async {
|
|
// Fresh state: no auto-fallback to the first profile so the UI can
|
|
// force the picker. The binder skips its rebind while active is null,
|
|
// which is what avoids the surprise PIN prompt at first sign-in.
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await provider.initialize();
|
|
expect(provider.profiles, hasLength(1));
|
|
expect(provider.activeId, isNull);
|
|
});
|
|
|
|
test('reloadFromStorage resolves Plex Home profile added after early initialize', () async {
|
|
await provider.initialize();
|
|
expect(provider.profiles, isEmpty);
|
|
|
|
final account = _account('plex.migrated');
|
|
final user = _homeUser('home-user-1', name: 'Migrated User');
|
|
fetchedHomeUsers = [user];
|
|
await connections.upsert(account);
|
|
await storage.savePlexHomeUsersCache(account.id, [user.toJson()]);
|
|
final profileId = plexHomeProfileId(accountConnectionId: account.id, homeUserUuid: user.uuid);
|
|
await storage.setActiveProfileId(profileId);
|
|
|
|
await provider.reloadFromStorage();
|
|
|
|
expect(provider.profiles.map((p) => p.id), contains(profileId));
|
|
expect(provider.activeId, profileId);
|
|
expect(provider.active?.displayName, 'Migrated User');
|
|
});
|
|
|
|
test('initialize keeps a stored id it cannot resolve (transient snapshots must not wipe it)', () async {
|
|
// Early snapshots can legitimately miss state (boot before migration,
|
|
// Plex Home cache not hydrated yet) — resolution goes inactive but the
|
|
// persisted selection survives for a later snapshot to resolve.
|
|
// Genuinely unresolvable ids are cleared by the boot guard and the
|
|
// post-removal settle flow, not here.
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await storage.setActiveProfileId('ghost-id-no-longer-exists');
|
|
await provider.initialize();
|
|
await Future<void>.delayed(Duration.zero);
|
|
expect(provider.activeId, isNull);
|
|
expect(storage.getActiveProfileId(), 'ghost-id-no-longer-exists');
|
|
});
|
|
|
|
test('re-upserting an identical connection does not notify listeners', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
final account = _account('plex.acct');
|
|
await connections.upsert(account);
|
|
await provider.initialize();
|
|
await Future<void>.delayed(const Duration(milliseconds: 20));
|
|
|
|
var notifications = 0;
|
|
provider.addListener(() => notifications++);
|
|
// Same row content — the binder does this on every successful bind
|
|
// (persisting refreshed-but-identical server metadata).
|
|
await connections.upsert(account);
|
|
await Future<void>.delayed(const Duration(milliseconds: 20));
|
|
|
|
expect(notifications, 0);
|
|
});
|
|
|
|
group('avatarUrlFor', () {
|
|
test('returns the linked Jellyfin user picture after initialize', () async {
|
|
final profile = Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1));
|
|
final connection = _jellyfin('first', createdAt: DateTime(2025, 1, 1), primaryImageTag: 'avatar-tag');
|
|
await registry.upsert(profile);
|
|
await connections.upsert(connection);
|
|
await profileConnections.upsert(
|
|
const ProfileConnection(profileId: 'p1', connectionId: 'first', userIdentifier: 'user-first'),
|
|
);
|
|
|
|
await provider.initialize();
|
|
|
|
expect(
|
|
provider.avatarUrlFor(profile.id),
|
|
'https://jellyfin.example/Users/user-first/Images/Primary'
|
|
'?tag=avatar-tag&maxWidth=240&maxHeight=240',
|
|
);
|
|
});
|
|
|
|
test('returns null for profiles without links and unknown profile ids', () async {
|
|
await registry.upsert(Profile.local(id: 'unlinked', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
|
|
await provider.initialize();
|
|
|
|
expect(provider.avatarUrlFor('unlinked'), isNull);
|
|
expect(provider.avatarUrlFor('unknown'), isNull);
|
|
});
|
|
|
|
test('linking an older connection updates the selected picture', () async {
|
|
final profile = Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1));
|
|
final newer = _jellyfin('newer', createdAt: DateTime(2026, 1, 2), primaryImageTag: 'newer-tag');
|
|
final older = _jellyfin('older', createdAt: DateTime(2025, 12, 31), primaryImageTag: 'older-tag');
|
|
await registry.upsert(profile);
|
|
await connections.upsert(newer);
|
|
await connections.upsert(older);
|
|
await profileConnections.upsert(
|
|
const ProfileConnection(profileId: 'p1', connectionId: 'newer', userIdentifier: 'user-newer'),
|
|
);
|
|
await provider.initialize();
|
|
expect(
|
|
provider.avatarUrlFor(profile.id),
|
|
'https://jellyfin.example/Users/user-newer/Images/Primary'
|
|
'?tag=newer-tag&maxWidth=240&maxHeight=240',
|
|
);
|
|
|
|
final changed = Completer<void>();
|
|
void listener() {
|
|
if (provider.avatarUrlFor(profile.id)?.contains('older-tag') ?? false) {
|
|
if (!changed.isCompleted) changed.complete();
|
|
}
|
|
}
|
|
|
|
provider.addListener(listener);
|
|
addTearDown(() => provider.removeListener(listener));
|
|
|
|
await profileConnections.upsert(
|
|
const ProfileConnection(profileId: 'p1', connectionId: 'older', userIdentifier: 'user-older'),
|
|
);
|
|
await changed.future.timeout(const Duration(seconds: 2));
|
|
|
|
expect(
|
|
provider.avatarUrlFor(profile.id),
|
|
'https://jellyfin.example/Users/user-older/Images/Primary'
|
|
'?tag=older-tag&maxWidth=240&maxHeight=240',
|
|
);
|
|
});
|
|
|
|
test('a corrected connection creation time re-picks the avatar without a restart', () async {
|
|
// createdAt is a real column, not part of toConfigJson, so the
|
|
// connection diff guard has to compare it explicitly. Nothing in
|
|
// normal operation rewrites it — ConnectionRegistry pins creation
|
|
// order across re-auth — but a restore or a backfill can, and
|
|
// swallowing that would leave a stale avatar until the next launch.
|
|
final profile = Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1));
|
|
await registry.upsert(profile);
|
|
await connections.upsert(_jellyfin('a', createdAt: DateTime(2025, 1, 1), primaryImageTag: 'a-tag'));
|
|
await connections.upsert(_jellyfin('b', createdAt: DateTime(2026, 1, 1), primaryImageTag: 'b-tag'));
|
|
await profileConnections.upsert(
|
|
const ProfileConnection(profileId: 'p1', connectionId: 'a', userIdentifier: 'user-a'),
|
|
);
|
|
await profileConnections.upsert(
|
|
const ProfileConnection(profileId: 'p1', connectionId: 'b', userIdentifier: 'user-b'),
|
|
);
|
|
await provider.initialize();
|
|
expect(provider.avatarUrlFor(profile.id), contains('tag=a-tag'));
|
|
|
|
final changed = Completer<void>();
|
|
void listener() {
|
|
if ((provider.avatarUrlFor(profile.id)?.contains('b-tag') ?? false) && !changed.isCompleted) {
|
|
changed.complete();
|
|
}
|
|
}
|
|
|
|
provider.addListener(listener);
|
|
addTearDown(() => provider.removeListener(listener));
|
|
|
|
// Straight to the table: the registry deliberately refuses to restamp
|
|
// an existing row, so this stands in for an out-of-band correction.
|
|
await (db.update(db.connections)..where((t) => t.id.equals('a'))).write(
|
|
ConnectionsCompanion(createdAt: Value(DateTime(2027, 1, 1).millisecondsSinceEpoch)),
|
|
);
|
|
await changed.future.timeout(const Duration(seconds: 2));
|
|
|
|
expect(provider.avatarUrlFor(profile.id), contains('tag=b-tag'));
|
|
});
|
|
|
|
test('token and timestamp churn on a link does not notify listeners', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await connections.upsert(_jellyfin('jellyfin', createdAt: DateTime(2025, 1, 1), primaryImageTag: 'avatar-tag'));
|
|
await profileConnections.upsert(
|
|
const ProfileConnection(
|
|
profileId: 'p1',
|
|
connectionId: 'jellyfin',
|
|
userToken: 'initial-token',
|
|
userIdentifier: 'user-jellyfin',
|
|
),
|
|
);
|
|
await provider.initialize();
|
|
|
|
var notifications = 0;
|
|
void listener() => notifications++;
|
|
provider.addListener(listener);
|
|
addTearDown(() => provider.removeListener(listener));
|
|
|
|
final churnObserved = Completer<void>();
|
|
final rowSubscription = profileConnections.watchAll().listen((rows) {
|
|
final row = rows.single;
|
|
if (row.userToken == 'refreshed-token' && row.tokenAcquiredAt != null && !churnObserved.isCompleted) {
|
|
churnObserved.complete();
|
|
}
|
|
});
|
|
addTearDown(rowSubscription.cancel);
|
|
|
|
await profileConnections.recordToken('p1', 'jellyfin', 'refreshed-token');
|
|
await churnObserved.future.timeout(const Duration(seconds: 2));
|
|
await Future<void>(() {});
|
|
|
|
expect(notifications, 0);
|
|
});
|
|
|
|
test('changing a Plex link user changes the picture and notifies listeners', () async {
|
|
final profile = Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1));
|
|
final account = _account('plex.acct');
|
|
final firstUser = _homeUser('home-1', thumb: 'https://images.example/first.jpg');
|
|
final secondUser = _homeUser('home-2', id: 2, thumb: 'https://images.example/second.jpg');
|
|
fetchedHomeUsers = [firstUser, secondUser];
|
|
await registry.upsert(profile);
|
|
await connections.upsert(account);
|
|
await profileConnections.upsert(
|
|
const ProfileConnection(profileId: 'p1', connectionId: 'plex.acct', userIdentifier: 'home-1'),
|
|
);
|
|
expect(await plexHome.refresh(account), isTrue);
|
|
await provider.initialize();
|
|
expect(provider.avatarUrlFor(profile.id), firstUser.thumb);
|
|
|
|
var notifications = 0;
|
|
final changed = Completer<void>();
|
|
void listener() {
|
|
notifications++;
|
|
if (provider.avatarUrlFor(profile.id) == secondUser.thumb && !changed.isCompleted) {
|
|
changed.complete();
|
|
}
|
|
}
|
|
|
|
provider.addListener(listener);
|
|
addTearDown(() => provider.removeListener(listener));
|
|
|
|
await profileConnections.upsert(
|
|
const ProfileConnection(profileId: 'p1', connectionId: 'plex.acct', userIdentifier: 'home-2'),
|
|
);
|
|
await changed.future.timeout(const Duration(seconds: 2));
|
|
|
|
expect(provider.avatarUrlFor(profile.id), secondUser.thumb);
|
|
expect(notifications, greaterThan(0));
|
|
});
|
|
});
|
|
|
|
test('initialize resolves the stored active profile id', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await registry.upsert(Profile.local(id: 'p2', displayName: 'Kids', createdAt: DateTime(2026, 1, 2)));
|
|
await storage.setActiveProfileId('p2');
|
|
await provider.initialize();
|
|
expect(provider.activeId, 'p2');
|
|
});
|
|
|
|
test('activate without PIN switches a non-protected profile', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await registry.upsert(Profile.local(id: 'p2', displayName: 'Kids', createdAt: DateTime(2026, 1, 2)));
|
|
await provider.initialize();
|
|
final p2 = provider.profiles.firstWhere((p) => p.id == 'p2');
|
|
final ok = await provider.activate(p2);
|
|
expect(ok, isTrue);
|
|
expect(provider.activeId, 'p2');
|
|
});
|
|
|
|
test('recency failure leaves stored and in-memory active identity unchanged', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await registry.upsert(Profile.local(id: 'p2', displayName: 'Kids', createdAt: DateTime(2026, 1, 2)));
|
|
await storage.setActiveProfileId('p1');
|
|
await provider.initialize();
|
|
preferencesPlatform.writes.clear();
|
|
preferencesPlatform.failIntKey = 'profile_last_used_p2';
|
|
|
|
final p2 = provider.profiles.firstWhere((profile) => profile.id == 'p2');
|
|
await expectLater(provider.activate(p2), throwsA(isA<StateError>()));
|
|
await storage.prefs.reloadCache();
|
|
|
|
expect(preferencesPlatform.writes, ['int:profile_last_used_p2']);
|
|
expect(storage.getProfileLastUsed('p2'), isNull);
|
|
expect(storage.getActiveProfileId(), 'p1');
|
|
expect(provider.activeId, 'p1');
|
|
});
|
|
|
|
test('activation persists recency then marker before notifying listeners', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await registry.upsert(Profile.local(id: 'p2', displayName: 'Kids', createdAt: DateTime(2026, 1, 2)));
|
|
await storage.setActiveProfileId('p1');
|
|
await provider.initialize();
|
|
preferencesPlatform.writes.clear();
|
|
var notifiedAfterCommit = false;
|
|
void listener() {
|
|
if (provider.activeId != 'p2') return;
|
|
notifiedAfterCommit =
|
|
storage.getProfileLastUsed('p2') != null &&
|
|
storage.getActiveProfileId() == 'p2' &&
|
|
preferencesPlatform.writes.length >= 2 &&
|
|
preferencesPlatform.writes[0] == 'int:profile_last_used_p2' &&
|
|
preferencesPlatform.writes[1] == 'string:active_app_profile_id';
|
|
}
|
|
|
|
provider.addListener(listener);
|
|
addTearDown(() => provider.removeListener(listener));
|
|
final p2 = provider.profiles.firstWhere((profile) => profile.id == 'p2');
|
|
|
|
expect(await provider.activate(p2), isTrue);
|
|
|
|
expect(preferencesPlatform.writes.take(2), ['int:profile_last_used_p2', 'string:active_app_profile_id']);
|
|
expect(notifiedAfterCommit, isTrue);
|
|
});
|
|
|
|
test('activate moves the selected profile to the front by recent usage', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await registry.upsert(Profile.local(id: 'p2', displayName: 'Kids', createdAt: DateTime(2026, 1, 2)));
|
|
await provider.initialize();
|
|
expect(provider.profiles.map((p) => p.id).toList(), ['p1', 'p2']);
|
|
|
|
final p2 = provider.profiles.firstWhere((p) => p.id == 'p2');
|
|
final ok = await provider.activate(p2);
|
|
|
|
expect(ok, isTrue);
|
|
expect(provider.profiles.map((p) => p.id).toList(), ['p2', 'p1']);
|
|
expect(storage.getProfileLastUsed('p2'), isNotNull);
|
|
});
|
|
|
|
test('clearActiveProfile clears storage and in-memory active profile', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await provider.initialize();
|
|
await provider.activate(provider.profiles.single);
|
|
|
|
await provider.clearActiveProfile();
|
|
|
|
expect(storage.getActiveProfileId(), isNull);
|
|
expect(provider.active, isNull);
|
|
});
|
|
|
|
test('activate rejects wrong PIN for a protected local profile', () async {
|
|
await registry.upsert(
|
|
Profile.local(id: 'p1', displayName: 'Kids', pinHash: computePinHash('1234'), createdAt: DateTime(2026, 1, 1)),
|
|
);
|
|
await provider.initialize();
|
|
final p1 = provider.profiles.first;
|
|
expect(await provider.activate(p1, pin: 'wrong'), isFalse);
|
|
expect(await provider.activate(p1, pin: '1234'), isTrue);
|
|
});
|
|
|
|
test('hasMultipleProfiles reflects the registry size', () async {
|
|
await registry.upsert(Profile.local(id: 'p1', displayName: 'Owner', createdAt: DateTime(2026, 1, 1)));
|
|
await provider.initialize();
|
|
expect(provider.hasMultipleProfiles, isFalse);
|
|
// Latch onto the next provider notification that flips the flag,
|
|
// instead of sleeping a fixed duration. The provider is a ChangeNotifier
|
|
// (not a Stream), so we use addListener + Completer here rather than
|
|
// expectLater(stream, ...) like the other profile tests.
|
|
final flipped = Completer<void>();
|
|
void listener() {
|
|
if (provider.hasMultipleProfiles && !flipped.isCompleted) {
|
|
flipped.complete();
|
|
}
|
|
}
|
|
|
|
provider.addListener(listener);
|
|
addTearDown(() => provider.removeListener(listener));
|
|
await registry.upsert(Profile.local(id: 'p2', displayName: 'Kids', createdAt: DateTime(2026, 1, 2)));
|
|
await flipped.future.timeout(const Duration(seconds: 2));
|
|
expect(provider.hasMultipleProfiles, isTrue);
|
|
});
|
|
});
|
|
}
|