yorickr/plezy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(plex): tolerate transient resource failures

Browse Source
This commit is contained in:
edde746
2026-05-16 22:54:53 +02:00
parent 3798a0c332
commit cfd4aa307d
7 changed files with 342 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/profiles/active_profile_binder_test.dart
+142 -1
View File
@@ -1,17 +1,25 @@
import 'package:drift/native.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.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_binder.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/providers/multi_server_provider.dart';
import 'package:plezy/services/data_aggregation_service.dart';
import 'package:plezy/services/multi_server_manager.dart';
import 'package:plezy/services/plex_auth_service.dart';
import 'package:plezy/services/storage_service.dart';
import 'package:plezy/utils/media_server_http_client.dart';
import 'package:plezy/utils/media_server_timeouts.dart';
import '../test_helpers/prefs.dart';
@@ -27,6 +35,7 @@ void main() {
late ActiveProfileBinder binder;
late StorageService storage;
late bool shouldDeferInitialBind;
late List<PlexHomeUser> fetchedHomeUsers;
setUp(() async {
resetSharedPreferencesForTest();
@@ -35,11 +44,12 @@ void main() {
profileConnections = ProfileConnectionRegistry(db);
profiles = ProfileRegistry(db);
storage = await StorageService.getInstance();
fetchedHomeUsers = const [];
plexHome = PlexHomeService(
connections: connections,
profileConnections: profileConnections,
storage: storage,
plexHomeUserFetcher: (_) async => const [],
plexHomeUserFetcher: (_) async => fetchedHomeUsers,
);
activeProfile = ActiveProfileProvider(
registry: profiles,
@@ -161,4 +171,135 @@ void main() {
expect(binder.consumePlexHomePreVerified('plex-home-a'), isTrue);
});
});
group('Plex Home server refresh fallback', () {
Future<({String profileId, _CapturingMultiServerManager manager})> preparePlexHomeBind({
required bool protected,
required http.Client httpClient,
}) async {
binder.dispose();
multiServerProvider.dispose();
final capturingManager = _CapturingMultiServerManager();
manager = capturingManager;
multiServerProvider = MultiServerProvider(manager, DataAggregationService(manager));
binder = ActiveProfileBinder(
activeProfile: activeProfile,
connections: connections,
profileConnections: profileConnections,
serverManager: manager,
multiServerProvider: multiServerProvider,
pinPrompt: (_, {String? errorMessage}) async => null,
shouldDeferInitialBind: (_) async => false,
plexAuth: PlexAuthService.forTesting(http: MediaServerHttpClient(client: httpClient)),
);
final account = PlexAccountConnection(
id: 'plex.account',
accountToken: 'account-token',
clientIdentifier: 'client-id',
accountLabel: 'Owner',
servers: [_server(accessToken: 'account-server-token')],
createdAt: DateTime(2026, 1, 1),
);
await connections.upsert(account);
final homeUser = PlexHomeUser(
id: 1,
uuid: 'home-user-uuid',
title: 'Home User',
thumb: '',
hasPassword: protected,
restricted: false,
updatedAt: null,
admin: true,
guest: false,
protected: protected,
);
fetchedHomeUsers = [homeUser];
final profileId = plexHomeProfileId(accountConnectionId: account.id, homeUserUuid: homeUser.uuid);
await storage.savePlexHomeUsersCache(account.id, [homeUser.toJson()]);
await profileConnections.upsert(
ProfileConnection(
profileId: profileId,
connectionId: account.id,
userToken: 'home-user-token',
userIdentifier: homeUser.uuid,
tokenAcquiredAt: DateTime(2026, 1, 1),
),
);
await storage.setActiveProfileId(profileId);
await activeProfile.initialize();
return (profileId: profileId, manager: capturingManager);
}
test('uses cached server metadata with the active user token after transient resources failure', () async {
final prepared = await preparePlexHomeBind(
protected: false,
httpClient: MockClient((request) async {
throw http.ClientException('DNS failed', request.url);
}),
);
await binder.rebindActive();
expect(activeProfile.lastBindingSucceeded, isTrue);
expect(binder.debugLastBoundProfileId, prepared.profileId);
expect(prepared.manager.refreshCalls, 1);
expect(prepared.manager.lastConnection?.servers.single.accessToken, 'home-user-token');
expect(prepared.manager.lastConnection?.servers.single.clientIdentifier, 'srv-1');
});
test('does not use cached server metadata after cached token auth failure', () async {
final prepared = await preparePlexHomeBind(
protected: true,
httpClient: MockClient((request) async {
return http.Response('{"errors":[]}', 401, headers: {'content-type': 'application/json'});
}),
);
await binder.rebindActive();
expect(activeProfile.lastBindingSucceeded, isFalse);
expect(prepared.manager.refreshCalls, 0);
final pc = await profileConnections.get(prepared.profileId, 'plex.account');
expect(pc?.userToken, isNull);
});
});
}
PlexServer _server({required String accessToken}) {
return PlexServer(
name: 'Home Server',
clientIdentifier: 'srv-1',
accessToken: accessToken,
connections: [
PlexConnection(
protocol: 'https',
address: '192.168.1.3',
port: 32400,
uri: 'https://192-168-1-3.machine.plex.direct:32400',
local: true,
relay: false,
ipv6: false,
),
],
owned: true,
presence: true,
);
}
class _CapturingMultiServerManager extends MultiServerManager {
int refreshCalls = 0;
PlexAccountConnection? lastConnection;
@override
Future<Set<String>> refreshTokensForProfile(
PlexAccountConnection connection, {
Duration timeout = MediaServerTimeouts.perServerConnect,
}) async {
refreshCalls++;
lastConnection = connection;
return connection.servers.map((server) => server.clientIdentifier).toSet();
}
}
test/services/plex_auth_service_test.dart
+69
View File
@@ -0,0 +1,69 @@
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:plezy/exceptions/media_server_exceptions.dart';
import 'package:plezy/services/plex_auth_service.dart';
import 'package:plezy/utils/media_server_http_client.dart';
void main() {
group('PlexAuthService', () {
test('fetchServers retries resources through plex.tv after clients host transport failure', () async {
final hosts = <String>[];
final client = MediaServerHttpClient(
client: MockClient((request) async {
hosts.add(request.url.host);
if (request.url.host == 'clients.plex.tv') {
throw http.ClientException('DNS failed', request.url);
}
return http.Response(jsonEncode([_serverJson()]), 200, headers: {'content-type': 'application/json'});
}),
);
addTearDown(client.close);
final auth = PlexAuthService.forTesting(http: client);
final servers = await auth.fetchServers('token');
expect(hosts, ['clients.plex.tv', 'plex.tv']);
expect(servers.single.clientIdentifier, 'srv-1');
});
test('fetchServers does not retry canonical host for HTTP auth failures', () async {
final hosts = <String>[];
final client = MediaServerHttpClient(
client: MockClient((request) async {
hosts.add(request.url.host);
return http.Response('{"errors":[]}', 401, headers: {'content-type': 'application/json'});
}),
);
addTearDown(client.close);
final auth = PlexAuthService.forTesting(http: client);
await expectLater(
auth.fetchServers('bad-token'),
throwsA(isA<MediaServerHttpException>().having((e) => e.statusCode, 'statusCode', 401)),
);
expect(hosts, ['clients.plex.tv']);
});
});
}
Map<String, dynamic> _serverJson() => {
'name': 'Home Server',
'clientIdentifier': 'srv-1',
'accessToken': 'server-token',
'owned': true,
'provides': 'server',
'connections': [
{
'protocol': 'https',
'address': '192.168.1.3',
'port': 32400,
'uri': 'https://192-168-1-3.machine.plex.direct:32400',
'local': true,
'relay': false,
'IPv6': false,
},
],
};
test/services/plex_server_connection_candidates_test.dart
+32
View File
@@ -146,5 +146,37 @@ void main() {
expect(urls.first, preferred);
expect(urls, contains(localPlexDirect));
});
test('does not treat Tailscale CGNAT preferred endpoint as remote', () {
const preferred = 'https://100.90.80.70:32400';
const localPlexDirect = 'https://192-168-1-50.abc.plex.direct:32400';
final server = PlexServer.fromJson(
_serverJsonWithConnections([
_connectionJson(protocol: 'https', address: '192.168.1.50', port: 32400, uri: localPlexDirect, local: true),
]),
);
final urls = server.prioritizedEndpointUrls(preferredFirst: preferred);
expect(server.networkClassForUrl(preferred), PlexNetworkClass.unknown);
expect(urls.first, preferred);
expect(urls, contains(localPlexDirect));
});
test('does not treat Tailscale MagicDNS preferred endpoint as remote', () {
const preferred = 'https://plex.tailnet.ts.net:32400';
const localPlexDirect = 'https://192-168-1-50.abc.plex.direct:32400';
final server = PlexServer.fromJson(
_serverJsonWithConnections([
_connectionJson(protocol: 'https', address: '192.168.1.50', port: 32400, uri: localPlexDirect, local: true),
]),
);
final urls = server.prioritizedEndpointUrls(preferredFirst: preferred);
expect(server.networkClassForUrl(preferred), PlexNetworkClass.unknown);
expect(urls.first, preferred);
expect(urls, contains(localPlexDirect));
});
});
}
test/utils/media_server_http_exception_test.dart
+9
View File
@@ -89,6 +89,15 @@ void main() {
final e = MediaServerHttpException(type: MediaServerHttpErrorType.cancelled, message: 'halt');
expect(e.toString(), 'MediaServerHttpException(cancelled: halt)');
});
test('toString includes host and path without query parameters', () {
final e = MediaServerHttpException(
type: MediaServerHttpErrorType.connectionError,
message: 'dns failed',
requestUri: Uri.parse('https://clients.plex.tv/api/v2/resources?X-Plex-Token=secret'),
);
expect(e.toString(), 'MediaServerHttpException(connectionError: dns failed: clients.plex.tv/api/v2/resources)');
});
});
group('MediaServerHttpException.isTransient', () {