mirror of
https://gitlab.com/veilid/veilid.git
synced 2024-12-27 08:19:27 -05:00
385 lines
13 KiB
Dart
385 lines
13 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:veilid/veilid.dart';
|
|
|
|
final bogusKey =
|
|
TypedKey.fromString("VLD0:qD10lHHPD1_Qr23_Qy-1JnxTht12eaWwENVG_m2v7II");
|
|
|
|
Future<void> testGetDHTValueUnopened() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
await expectLater(
|
|
() async => await rc.getDHTValue(bogusKey, 0, forceRefresh: false),
|
|
throwsA(isA<VeilidAPIException>()));
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testOpenDHTRecordNonexistentNoWriter() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
await expectLater(() async => await rc.openDHTRecord(bogusKey),
|
|
throwsA(isA<VeilidAPIException>()));
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testCloseDHTRecordNonexistent() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
await expectLater(() async => await rc.closeDHTRecord(bogusKey),
|
|
throwsA(isA<VeilidAPIException>()));
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testDeleteDHTRecordNonexistent() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
await expectLater(() async => await rc.deleteDHTRecord(bogusKey),
|
|
throwsA(isA<VeilidAPIException>()));
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testCreateDeleteDHTRecordSimple() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
final rec = await rc.createDHTRecord(const DHTSchema.dflt(oCnt: 1));
|
|
await rc.closeDHTRecord(rec.key);
|
|
await rc.deleteDHTRecord(rec.key);
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testCreateDeleteDHTRecordNoClose() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
final rec = await rc.createDHTRecord(const DHTSchema.dflt(oCnt: 1));
|
|
await rc.deleteDHTRecord(rec.key);
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testGetDHTValueNonexistent() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
final rec = await rc.createDHTRecord(const DHTSchema.dflt(oCnt: 1));
|
|
expect(await rc.getDHTValue(rec.key, 0), isNull);
|
|
await rc.deleteDHTRecord(rec.key);
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testSetGetDHTValue() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
final rec = await rc.createDHTRecord(const DHTSchema.dflt(oCnt: 2));
|
|
expect(await rc.setDHTValue(rec.key, 0, utf8.encode("BLAH BLAH BLAH")),
|
|
isNull);
|
|
final vd2 = await rc.getDHTValue(rec.key, 0);
|
|
expect(vd2, isNotNull);
|
|
|
|
final vd3 = await rc.getDHTValue(rec.key, 0, forceRefresh: true);
|
|
expect(vd3, isNotNull);
|
|
|
|
final vd4 = await rc.getDHTValue(rec.key, 1);
|
|
expect(vd4, isNull);
|
|
|
|
expect(vd2, equals(vd3));
|
|
|
|
await rc.deleteDHTRecord(rec.key);
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testOpenWriterDHTValue() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
var rec = await rc.createDHTRecord(const DHTSchema.dflt(oCnt: 2));
|
|
final key = rec.key;
|
|
final owner = rec.owner;
|
|
final secret = rec.ownerSecret!;
|
|
|
|
final cs = await Veilid.instance.getCryptoSystem(rec.key.kind);
|
|
expect(await cs.validateKeyPair(owner, secret), isTrue);
|
|
final otherKeyPair = await cs.generateKeyPair();
|
|
|
|
final va = utf8.encode("Qwertyuiop Asdfghjkl Zxcvbnm");
|
|
final vb = utf8.encode("1234567890");
|
|
final vc = utf8.encode("!@#\$%^&*()");
|
|
|
|
// Test subkey writes
|
|
expect(await rc.setDHTValue(key, 1, va), isNull);
|
|
|
|
var vdtemp = await rc.getDHTValue(key, 1);
|
|
expect(vdtemp, isNotNull);
|
|
expect(vdtemp!.data, equals(va));
|
|
expect(vdtemp.seq, equals(0));
|
|
expect(vdtemp.writer, equals(owner));
|
|
|
|
expect(await rc.getDHTValue(key, 0), isNull);
|
|
|
|
expect(await rc.setDHTValue(key, 0, vb), isNull);
|
|
|
|
expect(
|
|
await rc.getDHTValue(key, 0, forceRefresh: true),
|
|
equals(ValueData(
|
|
data: vb,
|
|
seq: 0,
|
|
writer: owner,
|
|
)));
|
|
|
|
expect(
|
|
await rc.getDHTValue(key, 1, forceRefresh: true),
|
|
equals(ValueData(
|
|
data: va,
|
|
seq: 0,
|
|
writer: owner,
|
|
)));
|
|
|
|
// Equal value should not trigger sequence number update
|
|
expect(await rc.setDHTValue(key, 1, va), isNull);
|
|
|
|
// Different value should trigger sequence number update
|
|
expect(await rc.setDHTValue(key, 1, vb), isNull);
|
|
|
|
// Now that we initialized some subkeys
|
|
// and verified they stored correctly
|
|
// Delete things locally and reopen and see if we can write
|
|
// with the same writer key
|
|
//
|
|
|
|
await rc.closeDHTRecord(key);
|
|
await rc.deleteDHTRecord(key);
|
|
|
|
rec = await rc.openDHTRecord(key,
|
|
writer: KeyPair(key: owner, secret: secret));
|
|
expect(rec, isNotNull);
|
|
expect(rec.key, equals(key));
|
|
expect(rec.owner, equals(owner));
|
|
expect(rec.ownerSecret, equals(secret));
|
|
expect(rec.schema, isA<DHTSchemaDFLT>());
|
|
expect(rec.schema.oCnt, equals(2));
|
|
|
|
// Verify subkey 1 can be set before it is get but newer is available online
|
|
vdtemp = await rc.setDHTValue(key, 1, vc);
|
|
expect(vdtemp, isNotNull);
|
|
expect(vdtemp!.data, equals(vb));
|
|
expect(vdtemp.seq, equals(1));
|
|
expect(vdtemp.writer, equals(owner));
|
|
|
|
// Verify subkey 1 can be set a second time and it updates because seq is newer
|
|
expect(await rc.setDHTValue(key, 1, vc), isNull);
|
|
|
|
// Verify the network got the subkey update with a refresh check
|
|
vdtemp = await rc.getDHTValue(key, 1, forceRefresh: true);
|
|
expect(vdtemp, isNotNull);
|
|
expect(vdtemp!.data, equals(vc));
|
|
expect(vdtemp.seq, equals(2));
|
|
expect(vdtemp.writer, equals(owner));
|
|
|
|
// Delete things locally and reopen and see if we can write
|
|
// with a different writer key (should fail)
|
|
await rc.closeDHTRecord(key);
|
|
await rc.deleteDHTRecord(key);
|
|
|
|
rec = await rc.openDHTRecord(key, writer: otherKeyPair);
|
|
expect(rec, isNotNull);
|
|
expect(rec.key, equals(key));
|
|
expect(rec.owner, equals(owner));
|
|
expect(rec.ownerSecret, isNull);
|
|
expect(rec.schema, isA<DHTSchemaDFLT>());
|
|
expect(rec.schema.oCnt, equals(2));
|
|
|
|
// Verify subkey 1 can NOT be set because we have the wrong writer
|
|
await expectLater(() async => await rc.setDHTValue(key, 1, va),
|
|
throwsA(isA<VeilidAPIException>()));
|
|
|
|
// Verify subkey 0 can NOT be set because we have the wrong writer
|
|
await expectLater(() async => await rc.setDHTValue(key, 0, va),
|
|
throwsA(isA<VeilidAPIException>()));
|
|
|
|
// Verify subkey 0 can be set because override with the right writer
|
|
expect(
|
|
await rc.setDHTValue(key, 0, va,
|
|
writer: KeyPair(key: owner, secret: secret)),
|
|
isNull);
|
|
|
|
// Clean up
|
|
await rc.closeDHTRecord(key);
|
|
await rc.deleteDHTRecord(key);
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|
|
|
|
Future<void> testWatchDHTValues(Stream<VeilidUpdate> updateStream) async {
|
|
final valueChangeQueue = StreamController<VeilidUpdateValueChange>();
|
|
final valueChangeSubscription = updateStream.listen((update) {
|
|
if (update is VeilidUpdateValueChange) {
|
|
// print("valuechange: " + update.toString());
|
|
valueChangeQueue.sink.add(update);
|
|
}
|
|
});
|
|
final valueChangeQueueIterator = StreamIterator(valueChangeQueue.stream);
|
|
|
|
try {
|
|
// Make two routing contexts, one with and one without safety
|
|
// So we can pretend to be a different node and get the watch updates
|
|
// Normally they would not get sent if the set comes from the same target
|
|
// as the watch's target
|
|
|
|
final rcWatch = (await Veilid.instance.routingContext())
|
|
.withSequencing(Sequencing.ensureOrdered, closeSelf: true);
|
|
final rcSet = (await Veilid.instance.routingContext()).withSafety(
|
|
const SafetySelectionUnsafe(sequencing: Sequencing.ensureOrdered),
|
|
closeSelf: true);
|
|
try {
|
|
// Make a DHT record
|
|
var rec = await rcWatch.createDHTRecord(const DHTSchema.dflt(oCnt: 10));
|
|
|
|
// Set some subkey we care about
|
|
expect(
|
|
await rcWatch.setDHTValue(rec.key, 3, utf8.encode("BLAH BLAH BLAH")),
|
|
isNull);
|
|
|
|
// Make a watch on that subkey
|
|
expect(await rcWatch.watchDHTValues(rec.key),
|
|
isNot(equals(Timestamp.zero())));
|
|
|
|
// Reopen without closing to change routing context and not lose watch
|
|
rec = await rcSet.openDHTRecord(rec.key, writer: rec.ownerKeyPair());
|
|
|
|
// Now set the subkey and trigger an update
|
|
expect(await rcSet.setDHTValue(rec.key, 3, utf8.encode("BLAH")), isNull);
|
|
|
|
// Wait for the update
|
|
await valueChangeQueueIterator
|
|
.moveNext()
|
|
.timeout(const Duration(seconds: 5), onTimeout: () {
|
|
fail("should have a change");
|
|
});
|
|
|
|
// Verify the update
|
|
expect(valueChangeQueueIterator.current.key, equals(rec.key));
|
|
expect(valueChangeQueueIterator.current.count, equals(0xFFFFFFFE));
|
|
expect(valueChangeQueueIterator.current.subkeys,
|
|
equals([ValueSubkeyRange.single(3)]));
|
|
expect(valueChangeQueueIterator.current.value.seq, equals(1));
|
|
expect(valueChangeQueueIterator.current.value.data,
|
|
equals(utf8.encode("BLAH")));
|
|
expect(valueChangeQueueIterator.current.value.writer, equals(rec.owner));
|
|
|
|
// Reopen without closing to change routing context and not lose watch
|
|
rec = await rcWatch.openDHTRecord(rec.key, writer: rec.ownerKeyPair());
|
|
|
|
// Cancel some subkeys we don't care about
|
|
expect(
|
|
await rcWatch
|
|
.cancelDHTWatch(rec.key, subkeys: [ValueSubkeyRange.make(0, 2)]),
|
|
isTrue);
|
|
|
|
// Reopen without closing to change routing context and not lose watch
|
|
rec = await rcSet.openDHTRecord(rec.key, writer: rec.ownerKeyPair());
|
|
|
|
// Change our subkey
|
|
expect(await rcSet.setDHTValue(rec.key, 3, utf8.encode("BLAH BLAH BLAH")),
|
|
isNull);
|
|
|
|
// Wait for the update
|
|
await valueChangeQueueIterator
|
|
.moveNext()
|
|
.timeout(const Duration(seconds: 5), onTimeout: () {
|
|
fail("should have a change");
|
|
});
|
|
|
|
// Verify the update
|
|
expect(valueChangeQueueIterator.current.key, equals(rec.key));
|
|
expect(valueChangeQueueIterator.current.count, equals(0xFFFFFFFD));
|
|
expect(valueChangeQueueIterator.current.subkeys,
|
|
equals([ValueSubkeyRange.single(3)]));
|
|
expect(valueChangeQueueIterator.current.value.seq, equals(2));
|
|
expect(valueChangeQueueIterator.current.value.data,
|
|
equals(utf8.encode("BLAH BLAH BLAH")));
|
|
expect(valueChangeQueueIterator.current.value.writer, equals(rec.owner));
|
|
|
|
// Reopen without closing to change routing context and not lose watch
|
|
rec = await rcWatch.openDHTRecord(rec.key, writer: rec.ownerKeyPair());
|
|
|
|
// Now cancel the update
|
|
expect(
|
|
await rcWatch
|
|
.cancelDHTWatch(rec.key, subkeys: [ValueSubkeyRange.make(3, 9)]),
|
|
isFalse);
|
|
|
|
// Reopen without closing to change routing context and not lose watch
|
|
rec = await rcSet.openDHTRecord(rec.key, writer: rec.ownerKeyPair());
|
|
|
|
expect(await rcSet.setDHTValue(rec.key, 3, utf8.encode("BLAH")), isNull);
|
|
|
|
if (await valueChangeQueueIterator
|
|
.moveNext()
|
|
.timeout(const Duration(seconds: 5), onTimeout: () {
|
|
return false;
|
|
})) {
|
|
fail("should not have a change");
|
|
}
|
|
|
|
await rcSet.closeDHTRecord(rec.key);
|
|
await rcSet.deleteDHTRecord(rec.key);
|
|
} finally {
|
|
rcWatch.close();
|
|
rcSet.close();
|
|
}
|
|
} finally {
|
|
await valueChangeSubscription.cancel();
|
|
}
|
|
}
|
|
|
|
Future<void> testInspectDHTRecord() async {
|
|
final rc = await Veilid.instance
|
|
.safeRoutingContext(sequencing: Sequencing.ensureOrdered);
|
|
try {
|
|
var rec = await rc.createDHTRecord(const DHTSchema.dflt(oCnt: 2));
|
|
|
|
expect(await rc.setDHTValue(rec.key, 0, utf8.encode("BLAH BLAH BLAH")),
|
|
isNull);
|
|
|
|
final rr = await rc.inspectDHTRecord(rec.key);
|
|
expect(rr.subkeys, equals([ValueSubkeyRange.make(0, 1)]));
|
|
expect(rr.localSeqs, equals([0, 0xFFFFFFFF]));
|
|
expect(rr.networkSeqs, equals([]));
|
|
|
|
final rr2 =
|
|
await rc.inspectDHTRecord(rec.key, scope: DHTReportScope.syncGet);
|
|
expect(rr2.subkeys, equals([ValueSubkeyRange.make(0, 1)]));
|
|
expect(rr2.localSeqs, equals([0, 0xFFFFFFFF]));
|
|
expect(rr2.networkSeqs, equals([0, 0xFFFFFFFF]));
|
|
|
|
await rc.closeDHTRecord(rec.key);
|
|
await rc.deleteDHTRecord(rec.key);
|
|
} finally {
|
|
rc.close();
|
|
}
|
|
}
|