Files
meshcore-open/test/connector/node_discover_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

207 lines
7.0 KiB
Dart

import 'dart:typed_data';
import 'package:flutter_test/flutter_test.dart';
import 'package:meshcore_open/connector/meshcore_connector.dart';
import 'package:meshcore_open/connector/meshcore_protocol.dart';
import 'package:meshcore_open/review_mode/review_radio.dart';
import 'package:meshcore_open/services/message_retry_service.dart';
import 'package:meshcore_open/services/path_history_service.dart';
import 'package:meshcore_open/services/storage_service.dart';
import 'package:meshcore_open/storage/prefs_manager.dart';
import 'package:shared_preferences/shared_preferences.dart';
Future<void> _waitFor(bool Function() condition, {int seconds = 8}) async {
final end = DateTime.now().add(Duration(seconds: seconds));
while (!condition()) {
if (DateTime.now().isAfter(end)) fail('Timed out waiting for condition');
await Future<void>.delayed(const Duration(milliseconds: 25));
}
}
Uint8List _discoverResp({
required int type,
required int tag,
required List<int> key,
int snrQuarterDb = 20,
int remoteSnrQuarterDb = -8,
}) {
final tagBytes = ByteData(4)..setUint32(0, tag, Endian.little);
return Uint8List.fromList([
pushCodeControlData,
snrQuarterDb & 0xFF,
(-70) & 0xFF,
0,
(controlSubtypeDiscoverResp << 4) | type,
remoteSnrQuarterDb & 0xFF,
...tagBytes.buffer.asUint8List(),
...key,
]);
}
/// Review radio that records sent frames and can inject extra responses.
class _ScanRadio extends ReviewRadio {
_ScanRadio({required super.firmwareVerCode})
: super(
scheduledMessageInterval: const Duration(hours: 1),
ackDelay: const Duration(milliseconds: 50),
replyDelay: const Duration(hours: 1),
);
final List<Uint8List> sent = [];
void Function(int tag)? onDiscoverRequest;
@override
void handle(Uint8List frame) {
sent.add(Uint8List.fromList(frame));
super.handle(frame);
if (frame.isNotEmpty && frame[0] == cmdSendControlData) {
final tag = ByteData.sublistView(frame, 3, 7).getUint32(0, Endian.little);
onDiscoverRequest?.call(tag);
}
}
}
late MeshCoreConnector _connector;
Future<(MeshCoreConnector, _ScanRadio)> _connect(int verCode) async {
final radio = _ScanRadio(firmwareVerCode: verCode);
_connector.reviewRadioFactoryForTest = () => radio;
await _connector.connectReview();
addTearDown(_connector.disconnect);
await _waitFor(
() =>
_connector.firmwareVerCode == verCode && _connector.channels.isNotEmpty,
);
return (_connector, radio);
}
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
setUpAll(() async {
SharedPreferences.setMockInitialValues({});
PrefsManager.reset();
await PrefsManager.initialize();
_connector = MeshCoreConnector();
final retryService = MessageRetryService();
_connector.initialize(
retryService: retryService,
pathHistoryService: PathHistoryService(StorageService()),
);
addTearDown(() {
_connector.dispose();
retryService.dispose();
});
});
group('frames', () {
test('scan request asks repeaters, rooms and sensors for full keys', () {
final payload = buildDiscoveryRequestPayload(
0x11223344,
typeMask: nodeDiscoverScanTypeMask,
);
expect(payload[0], 0x80); // DISCOVER_REQ, full keys
expect(payload[1], (1 << 2) | (1 << 3) | (1 << 4));
expect(
ByteData.sublistView(payload, 2, 6).getUint32(0, Endian.little),
0x11223344,
);
expect(payload.length, 10); // + since
expect(buildSendControlDataFrame(payload)[0], cmdSendControlData);
});
test('parses a full-key DISCOVER_RESP', () {
final key = List<int>.generate(32, (i) => i + 1);
final parsed = parseNodeDiscoverResponse(
_discoverResp(type: advTypeRepeater, tag: 0xDEADBEEF, key: key),
)!;
expect(parsed.nodeType, advTypeRepeater);
expect(parsed.tag, 0xDEADBEEF);
expect(parsed.snr, 5.0);
expect(parsed.remoteSnr, -2.0);
expect(parsed.rssi, -70);
expect(parsed.hasFullKey, isTrue);
expect(parsed.publicKey, key);
});
test('parses a prefix-only DISCOVER_RESP', () {
final parsed = parseNodeDiscoverResponse(
_discoverResp(type: advTypeSensor, tag: 1, key: List.filled(8, 0xAB)),
)!;
expect(parsed.hasFullKey, isFalse);
expect(parsed.publicKeyHex, 'ab' * 8);
});
test('rejects other control data and short frames', () {
final notResp = _discoverResp(
type: advTypeRepeater,
tag: 1,
key: List.filled(32, 1),
)..[4] = (controlSubtypeDiscoverReq << 4);
expect(parseNodeDiscoverResponse(notResp), isNull);
expect(
parseNodeDiscoverResponse(
_discoverResp(type: advTypeRepeater, tag: 1, key: [1, 2, 3]),
),
isNull,
);
expect(parseNodeDiscoverResponse(Uint8List.fromList([0x80])), isNull);
});
});
group('connector', () {
test(
'collects tagged responses, ignoring other tags and duplicates',
() async {
final (connector, radio) = await _connect(14);
expect(connector.supportsNodeDiscover, isTrue);
final stranger = List<int>.generate(32, (i) => 0xF0 ^ i);
radio.onDiscoverRequest = (tag) {
// A reply to someone else's scan, then a stranger answering twice.
radio.emitForTest(
_discoverResp(type: advTypeRepeater, tag: tag ^ 1, key: stranger),
);
radio.emitForTest(
_discoverResp(type: advTypeSensor, tag: tag, key: stranger),
);
radio.emitForTest(
_discoverResp(type: advTypeSensor, tag: tag, key: stranger),
);
};
final results = await connector
.discoverNearbyNodes(timeout: const Duration(milliseconds: 600))
.toList();
final keys = results.map((r) => r.publicKeyHex).toList();
expect(keys.toSet().length, keys.length, reason: 'no duplicates');
expect(keys, contains(pubKeyToHex(Uint8List.fromList(stranger))));
// The scripted Hilltop Repeater answers too, and is a known contact.
final repeater = results.firstWhere(
(r) => r.nodeType == advTypeRepeater,
);
expect(
connector.contactForDiscoverResponse(repeater).name,
'Hilltop Repeater',
);
// An unknown node gets a direct-path placeholder named by its key.
final unknown = connector.contactForDiscoverResponse(
results.firstWhere((r) => r.nodeType == advTypeSensor),
);
expect(unknown.pathLength, 0);
expect(unknown.name, 'F0F1F2F3');
},
);
test('older firmware gets no scan request', () async {
final (connector, radio) = await _connect(7);
expect(connector.supportsNodeDiscover, isFalse);
final results = await connector
.discoverNearbyNodes(timeout: const Duration(milliseconds: 200))
.toList();
expect(results, isEmpty);
expect(radio.sent.where((f) => f[0] == cmdSendControlData), isEmpty);
});
});
}