Files
meshcore-open/test/services/repeater_command_service_test.dart
T
zjs81 25f197c979 Fix review findings, add default flood scope, and address recent issues
Review fixes:
- Keep stored message history beyond the 200-message window; stop
  messages leaking between radios; reset link/session state on disconnect
- Accept firmware's 176-byte RX frames over USB/TCP
- Hold APP_START during contact sync; contact-sync watchdog; replay DMs
  from not-yet-known senders; tombstone late command replies; finish
  channel sync on ERR_NOT_FOUND; fail region-scoped sends cleanly
- DM retry watchdog when RESP_CODE_SENT never arrives; late repeater CLI
  replies; ACK hash collisions; UTF-8-safe name truncation
- Image pipeline: delete-during-decode, lifecycle cancels, decoder memory
  release, entry cap, dead worker recovery, atomic model writes
- Storage: deterministic reaction hash across web/native, Smaz
  double-decode, per-entry parsing, per-radio path history and regions,
  review-mode data isolation
- UI: safe channel slot selection, byte-length name limits, double-send
  guard, mounted checks, localized hardcoded strings
- Skip persisted-store reload on repeat SELF_INFO

Features:
- Radio default flood scope (firmware ver 11+) and explicit unscoped
  sends (ver 12+)
- Scan for nearby nodes (#570)
- Optional distinct first-hop repeater counting for channel resend (#589)
- Optional region next to hop count (#580)

Issues:
- Message text follows system font size (#569)
- Repeater/room password field accepts 20 chars (#576)
- TCP auto-reconnect and keepalive (#571)
- Order feeds by local receive time; flag future timestamps (#584)
- Coding rate help text (#568), French "Favoris" (#575)
- iOS/macOS app badge now clears

Translations for all new strings in every locale.
2026-10-11 01:25:31 -07:00

203 lines
5.9 KiB
Dart

import 'dart:async';
import 'dart:typed_data';
import 'package:flutter_test/flutter_test.dart';
import 'package:meshcore_open/connector/meshcore_connector.dart';
import 'package:meshcore_open/models/contact.dart';
import 'package:meshcore_open/models/path_selection.dart';
import 'package:meshcore_open/services/repeater_command_service.dart';
class _FakeConnector extends MeshCoreConnector {
@override
Future<PathSelection> preparePathForContactSend(Contact contact) async =>
const PathSelection(pathBytes: [], hopCount: -1, useFlood: true);
@override
Future<void> sendFrame(
Uint8List data, {
String? channelSendQueueId,
bool expectsGenericAck = false,
bool waitForGenericAck = false,
}) async {}
}
class _ShortTimeoutConnector extends _FakeConnector {
final List<Uint8List> sentFrames = [];
@override
int calculateTimeout({
required int pathLength,
int messageBytes = 100,
String? contactKey,
int? deviceTimeoutMs,
}) => 30;
@override
Future<void> sendFrame(
Uint8List data, {
String? channelSendQueueId,
bool expectsGenericAck = false,
bool waitForGenericAck = false,
}) async {
sentFrames.add(data);
}
}
Contact _repeater(int seed) => Contact(
publicKey: Uint8List.fromList(List<int>.generate(32, (i) => seed + i)),
name: 'R$seed',
type: 2,
pathLength: -1,
path: Uint8List(0),
lastSeen: DateTime.now(),
);
void main() {
group('normalizeRepeaterClockSyncCommand', () {
test('translates "clock sync" to explicit time command', () {
final result = normalizeRepeaterClockSyncCommand(
'clock sync',
nowSeconds: 1787900000,
);
expect(result, 'time 1787900000');
});
test('is case-insensitive and tolerates surrounding whitespace', () {
expect(
normalizeRepeaterClockSyncCommand(' Clock Sync ', nowSeconds: 1),
'time 1',
);
});
test('passes other commands through unchanged', () {
expect(
normalizeRepeaterClockSyncCommand('clock', nowSeconds: 1),
'clock',
);
expect(
normalizeRepeaterClockSyncCommand('get radio', nowSeconds: 1),
'get radio',
);
expect(
normalizeRepeaterClockSyncCommand('time 123', nowSeconds: 1),
'time 123',
);
});
test('uses current time when nowSeconds is omitted', () {
final before = DateTime.now().millisecondsSinceEpoch ~/ 1000;
final result = normalizeRepeaterClockSyncCommand('clock sync');
final after = DateTime.now().millisecondsSinceEpoch ~/ 1000;
expect(result, startsWith('time '));
final epoch = int.parse(result.substring('time '.length));
expect(epoch, inInclusiveRange(before, after));
});
});
group('RepeaterCommandService.handleResponse', () {
late RepeaterCommandService service;
setUp(() => service = RepeaterCommandService(_FakeConnector()));
tearDown(() => service.dispose());
test('unknown prefix does not complete the pending command', () async {
final repeater = _repeater(1);
String? result;
unawaited(
service
.sendCommand(repeater, 'ver', retries: 1)
.then((r) => result = r, onError: (_) {}),
);
await pumpEventQueue();
service.handleResponse(repeater, 'FE|late reply');
await pumpEventQueue();
expect(result, isNull);
service.handleResponse(repeater, '00|v1.0');
await pumpEventQueue();
expect(result, 'v1.0');
});
test('prefix owned by another repeater is ignored', () async {
final a = _repeater(1);
final b = _repeater(100);
String? result;
unawaited(
service
.sendCommand(a, 'ver', retries: 1)
.then((r) => result = r, onError: (_) {}),
);
await pumpEventQueue();
service.handleResponse(b, '00|wrong');
await pumpEventQueue();
expect(result, isNull);
service.handleResponse(a, 'unprefixed');
await pumpEventQueue();
expect(result, 'unprefixed');
});
});
group('RepeaterCommandService retries', () {
test('late reply to an earlier attempt completes the command', () async {
final connector = _ShortTimeoutConnector();
final service = RepeaterCommandService(connector);
addTearDown(service.dispose);
final repeater = _repeater(1);
String? result;
unawaited(
service
.sendCommand(repeater, 'password x', retries: 3)
.then((r) => result = r, onError: (_) {}),
);
// Attempt 1 (00|) times out after 30ms and attempt 2 (01|) is sent.
await Future<void>.delayed(const Duration(milliseconds: 45));
expect(connector.sentFrames, hasLength(2));
service.handleResponse(repeater, '00|OK');
await pumpEventQueue();
expect(result, 'OK');
// No third attempt goes out once the call has completed.
await Future<void>.delayed(const Duration(milliseconds: 60));
expect(connector.sentFrames, hasLength(2));
});
test('prefixes are released once the command finishes', () async {
final connector = _ShortTimeoutConnector();
final service = RepeaterCommandService(connector);
addTearDown(service.dispose);
final repeater = _repeater(1);
Object? error;
await service.sendCommand(repeater, 'ver', retries: 2).catchError((
Object e,
) {
error = e;
return '';
});
expect(error, isNotNull);
String? result;
unawaited(
service
.sendCommand(repeater, 'ver', retries: 1)
.then((r) => result = r, onError: (_) {}),
);
await pumpEventQueue();
// Replies to the finished call's prefixes are ignored.
service.handleResponse(repeater, '00|stale');
service.handleResponse(repeater, '01|stale');
await pumpEventQueue();
expect(result, isNull);
service.handleResponse(repeater, '02|fresh');
await pumpEventQueue();
expect(result, 'fresh');
});
});
}