Test RPC latency refresh state

Author: piatoss3612

lib/src/core/config/rpc_endpoint_config.dart

@@ -62,8 +62,8 @@ class RpcEndpointPreset {
   String get hostPort => rpcEndpointHostPort(url);
 }
 
-// Mirrors the current zodl-android lightwalletd candidate list while keeping
-// this app's existing zec.rocks default unchanged.
+// Additional regional lightwalletd presets while keeping this app's existing
+// zec.rocks default unchanged.
 final kMainnetRpcEndpointPresets = List<RpcEndpointPreset>.unmodifiable([
   RpcEndpointPreset(
     id: kDefaultRpcEndpointPresetId,

lib/src/providers/rpc_endpoint_latency_provider.dart

@@ -120,16 +120,17 @@ class RpcEndpointLatencyNotifier extends Notifier<RpcEndpointLatencyState> {
     required RpcEndpointChainNameGetter getChainName,
     required int generation,
   }) async {
+    final normalizedUrl = normalizeRpcEndpointUrl(
+      preset.url,
+      allowDefaultPort: true,
+    );
     final sample = await measureRpcEndpointLatency(
-      lightwalletdUrl: normalizeRpcEndpointUrl(
-        preset.url,
-        allowDefaultPort: true,
-      ),
+      lightwalletdUrl: normalizedUrl,
       expectedNetworkName: networkName,
       getChainName: getChainName,
     );
     if (generation != _generation) return;
-    state = state.copyWithSample(preset.url, sample);
+    state = state.copyWithSample(normalizedUrl, sample);
   }
 }
 

test/core/config/rpc_endpoint_config_test.dart

@@ -57,7 +57,7 @@ void main() {
   });
 
   group('preset lookup', () {
-    test('mainnet presets include the zodl endpoint list', () {
+    test('mainnet presets include the regional endpoint list', () {
       final urls = kMainnetRpcEndpointPresets
           .map((preset) => preset.url)
           .map((url) => normalizeRpcEndpointUrl(url, allowDefaultPort: true))

test/providers/rpc_endpoint_latency_provider_test.dart

@@ -1,4 +1,7 @@
+import 'dart:async';
+
 import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:zcash_wallet/src/providers/rpc_endpoint_latency_provider.dart';
 
 void main() {
@@ -47,4 +50,95 @@ void main() {
       expect(sample.label, 'Unavailable');
     });
   });
+
+  group('RpcEndpointLatencyNotifier', () {
+    test('marks presets checking before resolving measured latency', () async {
+      final completer = Completer<String>();
+      final container = ProviderContainer(
+        overrides: [
+          rpcEndpointChainNameGetterProvider.overrideWithValue(
+            (_) => completer.future,
+          ),
+        ],
+      );
+      addTearDown(container.dispose);
+
+      final refresh = container
+          .read(rpcEndpointLatencyProvider.notifier)
+          .refresh('main');
+
+      await Future<void>.delayed(Duration.zero);
+
+      final checkingState = container.read(rpcEndpointLatencyProvider);
+      expect(
+        checkingState.samples.values.every(
+          (sample) => sample.status == RpcEndpointLatencyStatus.checking,
+        ),
+        isTrue,
+      );
+
+      completer.complete('main');
+      await refresh;
+
+      final finalState = container.read(rpcEndpointLatencyProvider);
+      expect(
+        finalState.samples.values.every(
+          (sample) => sample.status == RpcEndpointLatencyStatus.available,
+        ),
+        isTrue,
+      );
+    });
+
+    test('discard stale samples when a newer refresh starts', () async {
+      final completers = <Completer<String>>[];
+      final container = ProviderContainer(
+        overrides: [
+          rpcEndpointChainNameGetterProvider.overrideWithValue((_) {
+            final completer = Completer<String>();
+            completers.add(completer);
+            return completer.future;
+          }),
+        ],
+      );
+      addTearDown(container.dispose);
+
+      final firstRefresh = container
+          .read(rpcEndpointLatencyProvider.notifier)
+          .refresh('main');
+      await Future<void>.delayed(Duration.zero);
+      final firstCompleters = List<Completer<String>>.of(completers);
+
+      final secondRefresh = container
+          .read(rpcEndpointLatencyProvider.notifier)
+          .refresh('main');
+      await Future<void>.delayed(Duration.zero);
+      final secondCompleters = completers
+          .where((completer) => !firstCompleters.contains(completer))
+          .toList();
+
+      for (final completer in firstCompleters) {
+        completer.complete('test');
+      }
+      await firstRefresh;
+      final afterStale = container.read(rpcEndpointLatencyProvider);
+      expect(
+        afterStale.samples.values.every(
+          (sample) => sample.status == RpcEndpointLatencyStatus.checking,
+        ),
+        isTrue,
+      );
+
+      for (final completer in secondCompleters) {
+        completer.complete('main');
+      }
+      await secondRefresh;
+      final finalState = container.read(rpcEndpointLatencyProvider);
+      expect(
+        finalState.samples.values.every(
+          (sample) => sample.status == RpcEndpointLatencyStatus.available,
+        ),
+        isTrue,
+      );
+    });
+  });
 }