mirror of
https://github.com/GopeedLab/gopeed.git
synced 2026-11-04 15:49:49 +00:00
266 lines
11 KiB
Dart
266 lines
11 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:gopeed/api/gopeed_site_api.dart';
|
|
import 'package:gopeed/api/model/extension.dart';
|
|
import 'package:gopeed/api/model/store_extension.dart';
|
|
import 'package:gopeed/api/model/update_check_extension_resp.dart';
|
|
import 'package:gopeed/core/capabilities/app_capabilities.dart';
|
|
import 'package:gopeed/core/capabilities/capability_rpc.dart';
|
|
import 'package:gopeed/core/capabilities/gopeed_capability.dart';
|
|
import 'package:gopeed/features/extensions/application/extensions_controller.dart';
|
|
import 'package:gopeed/features/extensions/application/store_extension_details_provider.dart';
|
|
|
|
void main() {
|
|
TestWidgetsFlutterBinding.ensureInitialized();
|
|
|
|
test('store loads while installed data and update checks are still pending', () async {
|
|
final installed = Completer<List<Extension>>();
|
|
final update = Completer<UpdateCheckExtensionResp>();
|
|
var updateCalls = 0;
|
|
final registry = CapabilityRegistry(createAppCapabilityCodecs())
|
|
..bind(GopeedMethods.getExtensions, (_) => installed.future)
|
|
..bind(GopeedMethods.checkExtensionUpdate, (_) {
|
|
updateCalls++;
|
|
return update.future;
|
|
});
|
|
final site = _SiteApi();
|
|
final container = _container(registry, site);
|
|
final subscription = container.listen(extensionsControllerProvider, (_, _) {});
|
|
addTearDown(subscription.close);
|
|
|
|
await _settle();
|
|
expect(site.listCalls, 1);
|
|
expect(container.read(extensionsControllerProvider).value?.storeExtensions.single.id, 'market');
|
|
expect(container.read(extensionsControllerProvider).value?.loadingStore, isFalse);
|
|
expect(updateCalls, 0);
|
|
|
|
installed.complete([_installed()]);
|
|
await _settle();
|
|
expect(updateCalls, 1);
|
|
expect(container.read(extensionsControllerProvider).value?.loadingInstalled, isFalse);
|
|
expect(container.read(extensionsControllerProvider).value?.storeExtensions.single.id, 'market');
|
|
update.complete(UpdateCheckExtensionResp(newVersion: '2.0.0'));
|
|
await _settle();
|
|
expect(container.read(extensionsControllerProvider).value?.updateFlags, {'gopeed@test': '2.0.0'});
|
|
});
|
|
|
|
test('a stale update scan cannot restore flags after installed data changes', () async {
|
|
var installed = [_installed()];
|
|
final update = Completer<UpdateCheckExtensionResp>();
|
|
var updateCalls = 0;
|
|
final registry = CapabilityRegistry(createAppCapabilityCodecs())
|
|
..bind(GopeedMethods.getExtensions, (_) => installed)
|
|
..bind(GopeedMethods.checkExtensionUpdate, (_) {
|
|
updateCalls++;
|
|
return update.future;
|
|
});
|
|
final container = _container(registry, _SiteApi());
|
|
final controller = container.read(extensionsControllerProvider.notifier);
|
|
await _settle();
|
|
final running = controller.checkUpdate();
|
|
expect(updateCalls, 1);
|
|
installed = [];
|
|
await controller.loadInstalled();
|
|
update.complete(UpdateCheckExtensionResp(newVersion: '2.0.0'));
|
|
await running;
|
|
expect(container.read(extensionsControllerProvider).value?.installedExtensions, isEmpty);
|
|
expect(container.read(extensionsControllerProvider).value?.updateFlags, isEmpty);
|
|
});
|
|
|
|
test('an update scan can finish after the controller is disposed', () async {
|
|
final update = Completer<UpdateCheckExtensionResp>();
|
|
final registry = CapabilityRegistry(createAppCapabilityCodecs())
|
|
..bind(GopeedMethods.getExtensions, (_) => [_installed()])
|
|
..bind(GopeedMethods.checkExtensionUpdate, (_) => update.future);
|
|
final container = _container(registry, _SiteApi());
|
|
final controller = container.read(extensionsControllerProvider.notifier);
|
|
await _settle();
|
|
final running = controller.checkUpdate();
|
|
container.dispose();
|
|
update.complete(UpdateCheckExtensionResp(newVersion: '2.0.0'));
|
|
await running;
|
|
});
|
|
|
|
test('old search results cannot replace a newer search', () async {
|
|
final old = Completer<StoreExtensionPage>();
|
|
final latest = Completer<StoreExtensionPage>();
|
|
final site = _SiteApi()
|
|
..onList = (query) => switch (query) {
|
|
'old' => old.future,
|
|
'new' => latest.future,
|
|
_ => Future.value(_page('market')),
|
|
};
|
|
final registry = CapabilityRegistry(createAppCapabilityCodecs())
|
|
..bind(GopeedMethods.getExtensions, (_) => <Extension>[]);
|
|
final container = _container(registry, site);
|
|
final controller = container.read(extensionsControllerProvider.notifier);
|
|
await _settle();
|
|
final first = controller.searchStore('old');
|
|
final second = controller.searchStore('new');
|
|
latest.complete(_page('new-result'));
|
|
await second;
|
|
old.complete(_page('old-result'));
|
|
await first;
|
|
final state = container.read(extensionsControllerProvider).value!;
|
|
expect(state.storeQuery, 'new');
|
|
expect(state.storeExtensions.single.id, 'new-result');
|
|
expect(state.loadingStore, isFalse);
|
|
});
|
|
|
|
test('overlapping cached pages do not duplicate an extension', () async {
|
|
final site = _SiteApi();
|
|
site.onList = (_) async => StoreExtensionPage.fromJson({
|
|
'data': [
|
|
{'id': 'market', 'version': '1.0.0'},
|
|
if (site.listCalls > 1) {'id': 'second', 'version': '1.0.0'},
|
|
],
|
|
'pagination': {'page': site.listCalls, 'limit': 20, 'hasNext': site.listCalls == 1},
|
|
});
|
|
final registry = CapabilityRegistry(createAppCapabilityCodecs())
|
|
..bind(GopeedMethods.getExtensions, (_) => <Extension>[]);
|
|
final container = _container(registry, site);
|
|
final controller = container.read(extensionsControllerProvider.notifier);
|
|
await _settle();
|
|
await controller.loadMoreStore();
|
|
expect(container.read(extensionsControllerProvider).value?.storeExtensions.map((e) => e.id), ['market', 'second']);
|
|
});
|
|
|
|
test('detail requests are shared, cache empty READMEs, and distinguish versions', () async {
|
|
final detail = Completer<StoreExtension>();
|
|
final site = _SiteApi()..onDetail = (_, _) => detail.future;
|
|
final container = ProviderContainer(overrides: [gopeedSiteApiProvider.overrideWithValue(site)]);
|
|
addTearDown(container.dispose);
|
|
const key = (id: 'market', version: '1.0.0');
|
|
final provider = storeExtensionDetailsProvider(key);
|
|
final subscription = container.listen(provider, (_, _) {});
|
|
final first = container.read(provider.future);
|
|
final second = container.read(provider.future);
|
|
expect(site.detailCalls, 1);
|
|
detail.complete(StoreExtension.fromJson({'id': 'market', 'version': '1.0.0', 'readme': null}));
|
|
expect((await first).hasDetails, isTrue);
|
|
await second;
|
|
subscription.close();
|
|
await _settle();
|
|
await container.read(provider.future);
|
|
expect(site.detailCalls, 1);
|
|
await container.read(storeExtensionDetailsProvider((id: 'market', version: '2.0.0')).future);
|
|
expect(site.detailCalls, 2);
|
|
});
|
|
|
|
test('failed details can be retried', () async {
|
|
final site = _SiteApi()..onDetail = (_, _) => Future.error(StateError('offline'));
|
|
final container = ProviderContainer(overrides: [gopeedSiteApiProvider.overrideWithValue(site)]);
|
|
addTearDown(container.dispose);
|
|
final provider = storeExtensionDetailsProvider((id: 'market', version: '1.0.0'));
|
|
final subscription = container.listen(provider, (_, _) {});
|
|
addTearDown(subscription.close);
|
|
await expectLater(container.read(provider.future), throwsStateError);
|
|
expect(site.detailCalls, 3);
|
|
site.onDetail = (_, _) async => StoreExtension.fromJson({'id': 'market', 'readme': 'loaded'});
|
|
container.invalidate(provider);
|
|
expect((await container.read(provider.future)).readme, 'loaded');
|
|
expect(site.detailCalls, 4);
|
|
});
|
|
|
|
test('details automatically recover on the third attempt and retain the result', () async {
|
|
final site = _SiteApi();
|
|
site.onDetail = (id, _) async {
|
|
if (site.detailCalls < 3) throw StateError('offline');
|
|
return StoreExtension.fromJson({'id': id, 'readme': 'recovered'});
|
|
};
|
|
final container = ProviderContainer(overrides: [gopeedSiteApiProvider.overrideWithValue(site)]);
|
|
addTearDown(container.dispose);
|
|
final provider = storeExtensionDetailsProvider((id: 'market', version: '1.0.0'));
|
|
final subscription = container.listen(provider, (_, _) {});
|
|
expect((await container.read(provider.future)).readme, 'recovered');
|
|
expect(site.detailCalls, 3);
|
|
subscription.close();
|
|
await _settle();
|
|
expect((await container.read(provider.future)).readme, 'recovered');
|
|
expect(site.detailCalls, 3);
|
|
});
|
|
|
|
test('closing details stops pending automatic retries', () async {
|
|
final site = _SiteApi()..onDetail = (_, _) => Future.error(StateError('offline'));
|
|
final container = ProviderContainer(overrides: [gopeedSiteApiProvider.overrideWithValue(site)]);
|
|
final provider = storeExtensionDetailsProvider((id: 'market', version: '1.0.0'));
|
|
container.listen(provider, (_, _) {});
|
|
await _settle();
|
|
expect(site.detailCalls, 1);
|
|
container.dispose();
|
|
await Future<void>.delayed(const Duration(milliseconds: 350));
|
|
expect(site.detailCalls, 1);
|
|
});
|
|
}
|
|
|
|
ProviderContainer _container(CapabilityRegistry registry, _SiteApi site) {
|
|
final container = ProviderContainer(
|
|
overrides: [
|
|
appCapabilitiesProvider.overrideWithValue(AppCapabilities(LocalCapabilityInvoker(registry))),
|
|
gopeedSiteApiProvider.overrideWithValue(site),
|
|
],
|
|
);
|
|
addTearDown(container.dispose);
|
|
return container;
|
|
}
|
|
|
|
Future<void> _settle() async {
|
|
for (var i = 0; i < 5; i++) {
|
|
await Future<void>.delayed(Duration.zero);
|
|
}
|
|
}
|
|
|
|
StoreExtensionPage _page(String id) => StoreExtensionPage.fromJson({
|
|
'data': [
|
|
{'id': id, 'version': '1.0.0'},
|
|
],
|
|
'pagination': {'page': 1, 'limit': 20, 'total': 1, 'totalPages': 1},
|
|
});
|
|
|
|
Extension _installed() => Extension(
|
|
identity: 'gopeed@test',
|
|
name: 'test',
|
|
author: 'gopeed',
|
|
title: 'Test',
|
|
description: '',
|
|
icon: '',
|
|
version: '1.0.0',
|
|
homepage: '',
|
|
repository: null,
|
|
disabled: false,
|
|
devMode: false,
|
|
devPath: '',
|
|
);
|
|
|
|
class _SiteApi implements GopeedSiteApi {
|
|
var listCalls = 0;
|
|
var detailCalls = 0;
|
|
Future<StoreExtensionPage> Function(String?) onList = (_) async => _page('market');
|
|
Future<StoreExtension> Function(String, String?) onDetail = (id, _) async =>
|
|
StoreExtension.fromJson({'id': id, 'readme': null});
|
|
|
|
@override
|
|
Future<StoreExtensionPage> getExtensions({
|
|
int page = 1,
|
|
int limit = 20,
|
|
StoreExtensionSort sort = StoreExtensionSort.stars,
|
|
StoreSortOrder order = StoreSortOrder.desc,
|
|
String? query,
|
|
bool forceRefresh = false,
|
|
}) {
|
|
listCalls++;
|
|
return onList(query);
|
|
}
|
|
|
|
@override
|
|
Future<StoreExtension> getExtension(String id, {String? version}) {
|
|
detailCalls++;
|
|
return onDetail(id, version);
|
|
}
|
|
|
|
@override
|
|
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
|
}
|