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.
203 lines
5.9 KiB
Dart
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');
|
|
});
|
|
});
|
|
}
|