mirror of
https://github.com/logos-messaging/nim-sds.git
synced 2026-05-18 16:09:30 +00:00
1634 lines
56 KiB
Nim
1634 lines
56 KiB
Nim
import unittest, results, chronos, std/[times, options, tables]
|
|
import sds
|
|
|
|
const testChannel = "testChannel"
|
|
|
|
# Core functionality tests
|
|
suite "Core Operations":
|
|
var rm: ReliabilityManager
|
|
|
|
setup:
|
|
let rmResult = newReliabilityManager()
|
|
check rmResult.isOk()
|
|
rm = rmResult.get()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
teardown:
|
|
if not rm.isNil:
|
|
rm.cleanup()
|
|
|
|
test "can create with default config":
|
|
let config = defaultConfig()
|
|
check:
|
|
config.bloomFilterCapacity == DefaultBloomFilterCapacity
|
|
config.bloomFilterErrorRate == DefaultBloomFilterErrorRate
|
|
config.maxMessageHistory == DefaultMaxMessageHistory
|
|
|
|
test "basic message wrapping and unwrapping":
|
|
let msg = @[byte(1), 2, 3]
|
|
let msgId = "test-msg-1"
|
|
|
|
let wrappedResult = rm.wrapOutgoingMessage(msg, msgId, testChannel)
|
|
check wrappedResult.isOk()
|
|
let wrapped = wrappedResult.get()
|
|
check wrapped.len > 0
|
|
|
|
let unwrapResult = rm.unwrapReceivedMessage(wrapped)
|
|
check unwrapResult.isOk()
|
|
let (unwrapped, missingDeps, channelId) = unwrapResult.get()
|
|
check:
|
|
unwrapped == msg
|
|
missingDeps.len == 0
|
|
channelId == testChannel
|
|
|
|
test "message ordering":
|
|
# Create messages with different timestamps
|
|
let msg1 = SdsMessage(
|
|
messageId: "msg1",
|
|
lamportTimestamp: 1,
|
|
causalHistory: @[],
|
|
channelId: testChannel,
|
|
content: @[byte(1)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let msg2 = SdsMessage(
|
|
messageId: "msg2",
|
|
lamportTimestamp: 5,
|
|
causalHistory: @[],
|
|
channelId: testChannel,
|
|
content: @[byte(2)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let serialized1 = serializeMessage(msg1)
|
|
let serialized2 = serializeMessage(msg2)
|
|
check:
|
|
serialized1.isOk()
|
|
serialized2.isOk()
|
|
|
|
# Process out of order
|
|
discard rm.unwrapReceivedMessage(serialized2.get())
|
|
let timestamp1 = rm.channels[testChannel].lamportTimestamp
|
|
discard rm.unwrapReceivedMessage(serialized1.get())
|
|
let timestamp2 = rm.channels[testChannel].lamportTimestamp
|
|
|
|
check timestamp2 > timestamp1
|
|
|
|
# Reliability mechanism tests
|
|
suite "Reliability Mechanisms":
|
|
var rm: ReliabilityManager
|
|
|
|
setup:
|
|
let rmResult = newReliabilityManager()
|
|
check rmResult.isOk()
|
|
rm = rmResult.get()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
teardown:
|
|
if not rm.isNil:
|
|
rm.cleanup()
|
|
|
|
test "dependency detection and resolution":
|
|
var messageReadyCount = 0
|
|
var messageSentCount = 0
|
|
var missingDepsCount = 0
|
|
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageReadyCount += 1,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageSentCount += 1,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
missingDepsCount += 1,
|
|
)
|
|
|
|
# Create dependency chain: msg3 -> msg2 -> msg1
|
|
let id1 = "msg1"
|
|
let id2 = "msg2"
|
|
let id3 = "msg3"
|
|
|
|
# Create messages with dependencies
|
|
let msg2 = SdsMessage(
|
|
messageId: id2,
|
|
lamportTimestamp: 2,
|
|
causalHistory: toCausalHistory(@[id1]), # msg2 depends on msg1
|
|
channelId: testChannel,
|
|
content: @[byte(2)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let msg3 = SdsMessage(
|
|
messageId: id3,
|
|
lamportTimestamp: 3,
|
|
causalHistory: toCausalHistory(@[id1, id2]), # msg3 depends on both msg1 and msg2
|
|
channelId: testChannel,
|
|
content: @[byte(3)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let serialized2 = serializeMessage(msg2)
|
|
let serialized3 = serializeMessage(msg3)
|
|
check:
|
|
serialized2.isOk()
|
|
serialized3.isOk()
|
|
|
|
# First try processing msg3 (which depends on msg2 which depends on msg1)
|
|
let unwrapResult3 = rm.unwrapReceivedMessage(serialized3.get())
|
|
check unwrapResult3.isOk()
|
|
let (_, missingDeps3, _) = unwrapResult3.get()
|
|
|
|
check:
|
|
missingDepsCount == 1 # Should trigger missing deps callback
|
|
missingDeps3.len == 2 # Should be missing both msg1 and msg2
|
|
id1 in missingDeps3.getMessageIds()
|
|
id2 in missingDeps3.getMessageIds()
|
|
|
|
# Then try processing msg2 (which only depends on msg1)
|
|
let unwrapResult2 = rm.unwrapReceivedMessage(serialized2.get())
|
|
check unwrapResult2.isOk()
|
|
let (_, missingDeps2, _) = unwrapResult2.get()
|
|
|
|
check:
|
|
missingDepsCount == 2 # Should have triggered another missing deps callback
|
|
missingDeps2.len == 1 # Should only be missing msg1
|
|
id1 in missingDeps2.getMessageIds()
|
|
messageReadyCount == 0 # No messages should be ready yet
|
|
|
|
# Mark first dependency (msg1) as met
|
|
let markResult1 = rm.markDependenciesMet(@[id1], testChannel)
|
|
check markResult1.isOk()
|
|
|
|
let incomingBuffer = rm.getIncomingBuffer(testChannel)
|
|
|
|
check:
|
|
incomingBuffer.len == 0
|
|
messageReadyCount == 2 # Both msg2 and msg3 should be ready
|
|
missingDepsCount == 2 # Should still be 2 from the initial missing deps
|
|
|
|
test "acknowledgment via causal history":
|
|
var messageReadyCount = 0
|
|
var messageSentCount = 0
|
|
var missingDepsCount = 0
|
|
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageReadyCount += 1,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageSentCount += 1,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
missingDepsCount += 1,
|
|
)
|
|
|
|
# Send our message
|
|
let msg1 = @[byte(1)]
|
|
let id1 = "msg1"
|
|
let wrap1 = rm.wrapOutgoingMessage(msg1, id1, testChannel)
|
|
check wrap1.isOk()
|
|
|
|
# Create a message that has our message in causal history
|
|
let msg2 = SdsMessage(
|
|
messageId: "msg2",
|
|
lamportTimestamp: rm.channels[testChannel].lamportTimestamp + 1,
|
|
causalHistory: toCausalHistory(@[id1]), # Include our message in causal history
|
|
channelId: testChannel,
|
|
content: @[byte(2)],
|
|
bloomFilter: @[] # Test with an empty bloom filter
|
|
,
|
|
)
|
|
|
|
let serializedMsg2 = serializeMessage(msg2)
|
|
check serializedMsg2.isOk()
|
|
|
|
# Process the "received" message - should trigger callbacks
|
|
let unwrapResult = rm.unwrapReceivedMessage(serializedMsg2.get())
|
|
check unwrapResult.isOk()
|
|
|
|
check:
|
|
messageReadyCount == 1 # For msg2 which we "received"
|
|
messageSentCount == 1 # For msg1 which was acknowledged via causal history
|
|
|
|
test "acknowledgment via bloom filter":
|
|
var messageSentCount = 0
|
|
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageSentCount += 1,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
)
|
|
|
|
# Send our message
|
|
let msg1 = @[byte(1)]
|
|
let id1 = "msg1"
|
|
let wrap1 = rm.wrapOutgoingMessage(msg1, id1, testChannel)
|
|
check wrap1.isOk()
|
|
|
|
# Create a message with bloom filter containing our message
|
|
var otherPartyBloomFilter =
|
|
RollingBloomFilter.init(DefaultBloomFilterCapacity, DefaultBloomFilterErrorRate)
|
|
otherPartyBloomFilter.add(id1)
|
|
|
|
let bfResult = serializeBloomFilter(otherPartyBloomFilter.filter)
|
|
check bfResult.isOk()
|
|
|
|
let msg2 = SdsMessage(
|
|
messageId: "msg2",
|
|
lamportTimestamp: rm.channels[testChannel].lamportTimestamp + 1,
|
|
causalHistory: @[], # Empty causal history as we're using bloom filter
|
|
channelId: testChannel,
|
|
content: @[byte(2)],
|
|
bloomFilter: bfResult.get(),
|
|
)
|
|
|
|
let serializedMsg2 = serializeMessage(msg2)
|
|
check serializedMsg2.isOk()
|
|
|
|
let unwrapResult = rm.unwrapReceivedMessage(serializedMsg2.get())
|
|
check unwrapResult.isOk()
|
|
|
|
check messageSentCount == 1 # Our message should be acknowledged via bloom filter
|
|
|
|
test "retrieval hints":
|
|
var messageReadyCount = 0
|
|
var messageSentCount = 0
|
|
var missingDepsCount = 0
|
|
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageReadyCount += 1,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageSentCount += 1,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
missingDepsCount += 1,
|
|
nil,
|
|
proc(messageId: SdsMessageID): seq[byte] =
|
|
return cast[seq[byte]]("hint:" & messageId)
|
|
)
|
|
|
|
# Send a first message to populate history
|
|
let msg1 = @[byte(1)]
|
|
let id1 = "msg1"
|
|
let wrap1 = rm.wrapOutgoingMessage(msg1, id1, testChannel)
|
|
check wrap1.isOk()
|
|
|
|
# Send a second message, which should have the first in its causal history
|
|
let msg2 = @[byte(2)]
|
|
let id2 = "msg2"
|
|
let wrap2 = rm.wrapOutgoingMessage(msg2, id2, testChannel)
|
|
check wrap2.isOk()
|
|
|
|
# Check that the wrapped message contains the hint
|
|
let unwrappedMsg2 = deserializeMessage(wrap2.get()).get()
|
|
check unwrappedMsg2.causalHistory.len > 0
|
|
check unwrappedMsg2.causalHistory[0].messageId == id1
|
|
check unwrappedMsg2.causalHistory[0].retrievalHint == cast[seq[byte]]("hint:" & id1)
|
|
|
|
# Create a message with a missing dependency (no retrieval hint)
|
|
let msg3 = SdsMessage(
|
|
messageId: "msg3",
|
|
lamportTimestamp: 3,
|
|
causalHistory: toCausalHistory(@["missing-dep"]),
|
|
channelId: testChannel,
|
|
content: @[byte(3)],
|
|
bloomFilter: @[],
|
|
)
|
|
let serialized3 = serializeMessage(msg3).get()
|
|
let unwrapResult3 = rm.unwrapReceivedMessage(serialized3)
|
|
check unwrapResult3.isOk()
|
|
let (_, missingDeps3, _) = unwrapResult3.get()
|
|
check missingDeps3.len == 1
|
|
check missingDeps3[0].messageId == "missing-dep"
|
|
# The hint is empty because it was not provided by the remote sender
|
|
check missingDeps3[0].retrievalHint.len == 0
|
|
|
|
# Test with a message that HAS a retrieval hint from remote
|
|
let msg4 = SdsMessage(
|
|
messageId: "msg4",
|
|
lamportTimestamp: 4,
|
|
causalHistory: @[newHistoryEntry("another-missing", cast[seq[byte]]("remote-hint"))],
|
|
channelId: testChannel,
|
|
content: @[byte(4)],
|
|
bloomFilter: @[],
|
|
)
|
|
let serialized4 = serializeMessage(msg4).get()
|
|
let unwrapResult4 = rm.unwrapReceivedMessage(serialized4)
|
|
check unwrapResult4.isOk()
|
|
let (_, missingDeps4, _) = unwrapResult4.get()
|
|
check missingDeps4.len == 1
|
|
check missingDeps4[0].messageId == "another-missing"
|
|
# The hint should be preserved from the remote sender
|
|
check missingDeps4[0].retrievalHint == cast[seq[byte]]("remote-hint")
|
|
|
|
# Periodic task & Buffer management tests
|
|
suite "Periodic Tasks & Buffer Management":
|
|
var rm: ReliabilityManager
|
|
|
|
setup:
|
|
let rmResult = newReliabilityManager()
|
|
check rmResult.isOk()
|
|
rm = rmResult.get()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
teardown:
|
|
if not rm.isNil:
|
|
rm.cleanup()
|
|
|
|
test "outgoing buffer management":
|
|
var messageSentCount = 0
|
|
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageSentCount += 1,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
)
|
|
|
|
# Add multiple messages
|
|
for i in 0 .. 5:
|
|
let msg = @[byte(i)]
|
|
let id = "msg" & $i
|
|
let wrap = rm.wrapOutgoingMessage(msg, id, testChannel)
|
|
check wrap.isOk()
|
|
|
|
let outBuffer = rm.getOutgoingBuffer(testChannel)
|
|
check outBuffer.len == 6
|
|
|
|
# Create message that acknowledges some messages
|
|
let ackMsg = SdsMessage(
|
|
messageId: "ack1",
|
|
lamportTimestamp: rm.channels[testChannel].lamportTimestamp + 1,
|
|
causalHistory: toCausalHistory(@["msg0", "msg2", "msg4"]),
|
|
channelId: testChannel,
|
|
content: @[byte(100)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let serializedAck = serializeMessage(ackMsg)
|
|
check serializedAck.isOk()
|
|
|
|
# Process the acknowledgment
|
|
discard rm.unwrapReceivedMessage(serializedAck.get())
|
|
|
|
let finalBuffer = rm.getOutgoingBuffer(testChannel)
|
|
check:
|
|
finalBuffer.len == 3 # Should have removed acknowledged messages
|
|
messageSentCount == 3
|
|
# Should have triggered sent callback for acknowledged messages
|
|
|
|
test "periodic buffer sweep and bloom clean":
|
|
var messageSentCount = 0
|
|
|
|
var config = defaultConfig()
|
|
config.resendInterval = initDuration(milliseconds = 100) # Short for testing
|
|
config.bufferSweepInterval = initDuration(milliseconds = 50) # Frequent sweeps
|
|
config.bloomFilterCapacity = 2 # Small capacity for testing
|
|
config.maxResendAttempts = 3 # Set a low number of max attempts
|
|
|
|
let rmResultP = newReliabilityManager(config)
|
|
check rmResultP.isOk()
|
|
let rm = rmResultP.get()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageSentCount += 1,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
)
|
|
|
|
# First message - should be cleaned from bloom filter later
|
|
let msg1 = @[byte(1)]
|
|
let id1 = "msg1"
|
|
let wrap1 = rm.wrapOutgoingMessage(msg1, id1, testChannel)
|
|
check wrap1.isOk()
|
|
|
|
let initialBuffer = rm.getOutgoingBuffer(testChannel)
|
|
check:
|
|
initialBuffer[0].resendAttempts == 0
|
|
rm.channels[testChannel].bloomFilter.contains(id1)
|
|
|
|
rm.startPeriodicTasks()
|
|
|
|
# Wait long enough for bloom filter
|
|
waitFor sleepAsync(chronos.milliseconds(500))
|
|
|
|
# Add new messages
|
|
let msg2 = @[byte(2)]
|
|
let id2 = "msg2"
|
|
let wrap2 = rm.wrapOutgoingMessage(msg2, id2, testChannel)
|
|
check wrap2.isOk()
|
|
|
|
let msg3 = @[byte(3)]
|
|
let id3 = "msg3"
|
|
let wrap3 = rm.wrapOutgoingMessage(msg3, id3, testChannel)
|
|
check wrap3.isOk()
|
|
|
|
let finalBuffer = rm.getOutgoingBuffer(testChannel)
|
|
check:
|
|
finalBuffer.len == 2
|
|
# Only msg2 and msg3 should be in buffer, msg1 should be removed after max retries
|
|
finalBuffer[0].message.messageId == id2 # Verify it's the second message
|
|
finalBuffer[0].resendAttempts == 0 # New message should have 0 attempts
|
|
not rm.channels[testChannel].bloomFilter.contains(id1) # Bloom filter cleaning check
|
|
rm.channels[testChannel].bloomFilter.contains(id3) # New message still in filter
|
|
|
|
rm.cleanup()
|
|
|
|
test "periodic sync callback":
|
|
var syncCallCount = 0
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
proc() {.gcsafe.} =
|
|
syncCallCount += 1,
|
|
)
|
|
|
|
rm.startPeriodicTasks()
|
|
waitFor sleepAsync(chronos.seconds(1))
|
|
rm.cleanup()
|
|
|
|
check syncCallCount > 0
|
|
|
|
# Special cases handling
|
|
suite "Special Cases Handling":
|
|
var rm: ReliabilityManager
|
|
|
|
setup:
|
|
let rmResult = newReliabilityManager()
|
|
check rmResult.isOk()
|
|
rm = rmResult.get()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
teardown:
|
|
if not rm.isNil:
|
|
rm.cleanup()
|
|
|
|
test "message history limits":
|
|
# Add messages up to max history size
|
|
for i in 0 .. rm.config.maxMessageHistory + 5:
|
|
let msg = @[byte(i)]
|
|
let id = "msg" & $i
|
|
let wrap = rm.wrapOutgoingMessage(msg, id, testChannel)
|
|
check wrap.isOk()
|
|
|
|
let history = rm.getMessageHistory(testChannel)
|
|
check:
|
|
history.len <= rm.config.maxMessageHistory
|
|
history[^1] == "msg" & $(rm.config.maxMessageHistory + 5)
|
|
|
|
test "invalid bloom filter handling":
|
|
let msgInvalid = SdsMessage(
|
|
messageId: "invalid-bf",
|
|
lamportTimestamp: 1,
|
|
causalHistory: toCausalHistory(@[]),
|
|
channelId: testChannel,
|
|
content: @[byte(1)],
|
|
bloomFilter: @[1.byte, 2.byte, 3.byte] # Invalid filter data
|
|
,
|
|
)
|
|
|
|
let serializedInvalid = serializeMessage(msgInvalid)
|
|
check serializedInvalid.isOk()
|
|
|
|
# Should handle invalid bloom filter gracefully
|
|
let result = rm.unwrapReceivedMessage(serializedInvalid.get())
|
|
check:
|
|
result.isOk()
|
|
result.get()[1].len == 0 # No missing dependencies
|
|
|
|
test "duplicate message handling":
|
|
var messageReadyCount = 0
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
messageReadyCount += 1,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
discard,
|
|
)
|
|
|
|
# Create and process a message
|
|
let msg = SdsMessage(
|
|
messageId: "dup-msg",
|
|
lamportTimestamp: 1,
|
|
causalHistory: toCausalHistory(@[]),
|
|
channelId: testChannel,
|
|
content: @[byte(1)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let serialized = serializeMessage(msg)
|
|
check serialized.isOk()
|
|
|
|
# Process same message twice
|
|
let result1 = rm.unwrapReceivedMessage(serialized.get())
|
|
check result1.isOk()
|
|
let result2 = rm.unwrapReceivedMessage(serialized.get())
|
|
check:
|
|
result2.isOk()
|
|
result2.get()[1].len == 0 # No missing deps on second process
|
|
messageReadyCount == 1 # Message should only be processed once
|
|
|
|
test "error handling":
|
|
# Empty message
|
|
let emptyMsg: seq[byte] = @[]
|
|
let emptyResult = rm.wrapOutgoingMessage(emptyMsg, "empty", testChannel)
|
|
check:
|
|
not emptyResult.isOk()
|
|
emptyResult.error == reInvalidArgument
|
|
|
|
# Oversized message
|
|
let largeMsg = newSeq[byte](MaxMessageSize + 1)
|
|
let largeResult = rm.wrapOutgoingMessage(largeMsg, "large", testChannel)
|
|
check:
|
|
not largeResult.isOk()
|
|
largeResult.error == reMessageTooLarge
|
|
|
|
suite "cleanup":
|
|
test "cleanup works correctly":
|
|
let rmResult = newReliabilityManager()
|
|
check rmResult.isOk()
|
|
let rm = rmResult.get()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
# Add some messages
|
|
let msg = @[byte(1), 2, 3]
|
|
let msgId = "test-msg-1"
|
|
discard rm.wrapOutgoingMessage(msg, msgId, testChannel)
|
|
|
|
rm.cleanup()
|
|
|
|
let outBuffer = rm.getOutgoingBuffer(testChannel)
|
|
let history = rm.getMessageHistory(testChannel)
|
|
check:
|
|
outBuffer.len == 0
|
|
history.len == 0
|
|
|
|
suite "Multi-Channel ReliabilityManager Tests":
|
|
var rm: ReliabilityManager
|
|
|
|
setup:
|
|
let rmResult = newReliabilityManager()
|
|
check rmResult.isOk()
|
|
rm = rmResult.get()
|
|
|
|
teardown:
|
|
if not rm.isNil:
|
|
rm.cleanup()
|
|
|
|
test "can create multi-channel manager without channel ID":
|
|
check rm.channels.len == 0
|
|
|
|
test "channel management":
|
|
let channel1 = "channel1"
|
|
let channel2 = "channel2"
|
|
|
|
# Ensure channels
|
|
check rm.ensureChannel(channel1).isOk()
|
|
check rm.ensureChannel(channel2).isOk()
|
|
check rm.channels.len == 2
|
|
|
|
# Remove channel
|
|
check rm.removeChannel(channel1).isOk()
|
|
check rm.channels.len == 1
|
|
check channel1 notin rm.channels
|
|
check channel2 in rm.channels
|
|
|
|
test "stateless message unwrapping with channel extraction":
|
|
let channel1 = "test-channel-1"
|
|
let channel2 = "test-channel-2"
|
|
|
|
# Create and wrap messages for different channels
|
|
let msg1 = @[byte(1), 2, 3]
|
|
let msgId1 = "msg1"
|
|
let wrapped1 = rm.wrapOutgoingMessage(msg1, msgId1, channel1)
|
|
check wrapped1.isOk()
|
|
|
|
let msg2 = @[byte(4), 5, 6]
|
|
let msgId2 = "msg2"
|
|
let wrapped2 = rm.wrapOutgoingMessage(msg2, msgId2, channel2)
|
|
check wrapped2.isOk()
|
|
|
|
# Unwrap messages - should extract channel ID and route correctly
|
|
let unwrap1 = rm.unwrapReceivedMessage(wrapped1.get())
|
|
check unwrap1.isOk()
|
|
let (content1, deps1, extractedChannel1) = unwrap1.get()
|
|
check:
|
|
content1 == msg1
|
|
deps1.len == 0
|
|
extractedChannel1 == channel1
|
|
|
|
let unwrap2 = rm.unwrapReceivedMessage(wrapped2.get())
|
|
check unwrap2.isOk()
|
|
let (content2, deps2, extractedChannel2) = unwrap2.get()
|
|
check:
|
|
content2 == msg2
|
|
deps2.len == 0
|
|
extractedChannel2 == channel2
|
|
|
|
test "channel isolation":
|
|
let channel1 = "isolated-channel-1"
|
|
let channel2 = "isolated-channel-2"
|
|
|
|
# Add messages to different channels
|
|
let msg1 = @[byte(1)]
|
|
let msgId1 = "isolated-msg1"
|
|
discard rm.wrapOutgoingMessage(msg1, msgId1, channel1)
|
|
|
|
let msg2 = @[byte(2)]
|
|
let msgId2 = "isolated-msg2"
|
|
discard rm.wrapOutgoingMessage(msg2, msgId2, channel2)
|
|
|
|
# Check channel-specific data is isolated
|
|
let history1 = rm.getMessageHistory(channel1)
|
|
let history2 = rm.getMessageHistory(channel2)
|
|
|
|
check:
|
|
history1.len == 1
|
|
history2.len == 1
|
|
msgId1 in history1
|
|
msgId2 in history2
|
|
msgId1 notin history2
|
|
msgId2 notin history1
|
|
|
|
test "multi-channel callbacks":
|
|
var readyMessageCount = 0
|
|
var sentMessageCount = 0
|
|
var missingDepsCount = 0
|
|
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
readyMessageCount += 1,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} =
|
|
sentMessageCount += 1,
|
|
proc(messageId: SdsMessageID, deps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
missingDepsCount += 1
|
|
)
|
|
|
|
let channel1 = "callback-channel-1"
|
|
let channel2 = "callback-channel-2"
|
|
|
|
# Send messages from both channels
|
|
let msg1 = @[byte(1)]
|
|
let msgId1 = "callback-msg1"
|
|
let wrapped1 = rm.wrapOutgoingMessage(msg1, msgId1, channel1)
|
|
check wrapped1.isOk()
|
|
|
|
let msg2 = @[byte(2)]
|
|
let msgId2 = "callback-msg2"
|
|
let wrapped2 = rm.wrapOutgoingMessage(msg2, msgId2, channel2)
|
|
check wrapped2.isOk()
|
|
|
|
# Create acknowledgment messages that include our message IDs in causal history
|
|
# to trigger sent callbacks
|
|
let ackMsg1 = SdsMessage(
|
|
messageId: "ack1",
|
|
lamportTimestamp: rm.channels[channel1].lamportTimestamp + 1,
|
|
causalHistory: toCausalHistory(@[msgId1]), # Acknowledge msg1
|
|
channelId: channel1,
|
|
content: @[byte(100)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let ackMsg2 = SdsMessage(
|
|
messageId: "ack2",
|
|
lamportTimestamp: rm.channels[channel2].lamportTimestamp + 1,
|
|
causalHistory: toCausalHistory(@[msgId2]), # Acknowledge msg2
|
|
channelId: channel2,
|
|
content: @[byte(101)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let serializedAck1 = serializeMessage(ackMsg1)
|
|
let serializedAck2 = serializeMessage(ackMsg2)
|
|
check:
|
|
serializedAck1.isOk()
|
|
serializedAck2.isOk()
|
|
|
|
# Process acknowledgment messages - should trigger callbacks
|
|
discard rm.unwrapReceivedMessage(serializedAck1.get())
|
|
discard rm.unwrapReceivedMessage(serializedAck2.get())
|
|
|
|
check:
|
|
readyMessageCount == 2 # Both ack messages should trigger ready callbacks
|
|
sentMessageCount == 2 # Both original messages should be marked as sent
|
|
missingDepsCount == 0 # No missing dependencies
|
|
|
|
test "channel-specific dependency management":
|
|
let channel1 = "dep-channel-1"
|
|
let channel2 = "dep-channel-2"
|
|
let depIds = @["dep1", "dep2", "dep3"]
|
|
|
|
# Ensure both channels exist first
|
|
check rm.ensureChannel(channel1).isOk()
|
|
check rm.ensureChannel(channel2).isOk()
|
|
|
|
# Mark dependencies as met for specific channel
|
|
check rm.markDependenciesMet(depIds, channel1).isOk()
|
|
|
|
# Dependencies should only affect the specified channel
|
|
# Dependencies in channel1 should not affect channel2
|
|
check rm.channels[channel1].bloomFilter.contains("dep1")
|
|
check not rm.channels[channel2].bloomFilter.contains("dep1")
|
|
|
|
# SDS-R Repair tests
|
|
suite "SDS-R: Computation Functions":
|
|
test "computeTReq returns duration in [tMin, tMax)":
|
|
let tMin = initDuration(seconds = 30)
|
|
let tMax = initDuration(seconds = 300)
|
|
let d = computeTReq("participant1", "msg1", tMin, tMax)
|
|
check:
|
|
d.inMilliseconds >= tMin.inMilliseconds
|
|
d.inMilliseconds < tMax.inMilliseconds
|
|
|
|
test "computeTReq is deterministic for same inputs":
|
|
let tMin = initDuration(seconds = 30)
|
|
let tMax = initDuration(seconds = 300)
|
|
let d1 = computeTReq("p1", "m1", tMin, tMax)
|
|
let d2 = computeTReq("p1", "m1", tMin, tMax)
|
|
check d1 == d2
|
|
|
|
test "computeTReq varies with different participants":
|
|
let tMin = initDuration(seconds = 30)
|
|
let tMax = initDuration(seconds = 300)
|
|
let d1 = computeTReq("participant-A", "msg1", tMin, tMax)
|
|
let d2 = computeTReq("participant-B", "msg1", tMin, tMax)
|
|
# Different participants should generally get different backoff (not guaranteed but highly likely)
|
|
# Just check both are in valid range
|
|
check:
|
|
d1.inMilliseconds >= tMin.inMilliseconds
|
|
d2.inMilliseconds >= tMin.inMilliseconds
|
|
|
|
test "computeTResp original sender has zero distance":
|
|
let d = computeTResp("sender1", "sender1", "msg1", initDuration(seconds = 300))
|
|
check d.inMilliseconds == 0
|
|
|
|
test "computeTResp non-sender has positive backoff":
|
|
let d = computeTResp("other-node", "sender1", "msg1", initDuration(seconds = 300))
|
|
check d.inMilliseconds >= 0
|
|
|
|
test "isInResponseGroup all in same group when numGroups=1":
|
|
check isInResponseGroup("p1", "sender1", "msg1", 1) == true
|
|
check isInResponseGroup("p2", "sender1", "msg1", 1) == true
|
|
|
|
test "isInResponseGroup sender always in own group":
|
|
# Original sender must always be in their own response group
|
|
for groups in 1 .. 10:
|
|
check isInResponseGroup("sender1", "sender1", "msg1", groups) == true
|
|
|
|
suite "SDS-R: Repair Buffer Management":
|
|
var rm: ReliabilityManager
|
|
|
|
setup:
|
|
let rmResult = newReliabilityManager(
|
|
participantId = "test-participant"
|
|
)
|
|
check rmResult.isOk()
|
|
rm = rmResult.get()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
teardown:
|
|
if not rm.isNil:
|
|
rm.cleanup()
|
|
|
|
test "missing deps added to outgoing repair buffer":
|
|
var missingDepsCount = 0
|
|
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} =
|
|
missingDepsCount += 1,
|
|
)
|
|
|
|
# Create a message with a missing dependency
|
|
let msg = SdsMessage(
|
|
messageId: "msg2",
|
|
lamportTimestamp: 2,
|
|
causalHistory: @[HistoryEntry(messageId: "msg1", senderId: "sender-A")],
|
|
channelId: testChannel,
|
|
content: @[byte(2)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let serialized = serializeMessage(msg).get()
|
|
let result = rm.unwrapReceivedMessage(serialized)
|
|
check result.isOk()
|
|
|
|
# msg1 should be in the outgoing repair buffer
|
|
let channel = rm.channels[testChannel]
|
|
check:
|
|
missingDepsCount == 1
|
|
"msg1" in channel.outgoingRepairBuffer
|
|
|
|
test "receiving message clears it from repair buffers":
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
# First, create the missing dep scenario
|
|
let msg2 = SdsMessage(
|
|
messageId: "msg2",
|
|
lamportTimestamp: 2,
|
|
causalHistory: @[HistoryEntry(messageId: "msg1", senderId: "sender-A")],
|
|
channelId: testChannel,
|
|
content: @[byte(2)],
|
|
bloomFilter: @[],
|
|
)
|
|
discard rm.unwrapReceivedMessage(serializeMessage(msg2).get())
|
|
check "msg1" in rm.channels[testChannel].outgoingRepairBuffer
|
|
|
|
# Now receive msg1 — should clear from repair buffer
|
|
let msg1 = SdsMessage(
|
|
messageId: "msg1",
|
|
lamportTimestamp: 1,
|
|
causalHistory: @[],
|
|
channelId: testChannel,
|
|
content: @[byte(1)],
|
|
bloomFilter: @[],
|
|
)
|
|
discard rm.unwrapReceivedMessage(serializeMessage(msg1).get())
|
|
check "msg1" notin rm.channels[testChannel].outgoingRepairBuffer
|
|
|
|
test "markDependenciesMet clears repair buffers":
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
let msg2 = SdsMessage(
|
|
messageId: "msg2",
|
|
lamportTimestamp: 2,
|
|
causalHistory: @[HistoryEntry(messageId: "msg1", senderId: "sender-A")],
|
|
channelId: testChannel,
|
|
content: @[byte(2)],
|
|
bloomFilter: @[],
|
|
)
|
|
discard rm.unwrapReceivedMessage(serializeMessage(msg2).get())
|
|
check "msg1" in rm.channels[testChannel].outgoingRepairBuffer
|
|
|
|
# Mark as met via store retrieval
|
|
check rm.markDependenciesMet(@["msg1"], testChannel).isOk()
|
|
check "msg1" notin rm.channels[testChannel].outgoingRepairBuffer
|
|
|
|
test "expired repair requests attached to outgoing messages":
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
# Manually add an expired repair entry
|
|
let channel = rm.channels[testChannel]
|
|
channel.outgoingRepairBuffer["missing-msg"] = OutgoingRepairEntry(
|
|
entry: HistoryEntry(messageId: "missing-msg", senderId: "orig-sender"),
|
|
tReq: getTime() - initDuration(seconds = 10), # Already expired
|
|
)
|
|
|
|
# Send a message — should pick up the expired repair request
|
|
let wrapped = rm.wrapOutgoingMessage(@[byte(1)], "new-msg", testChannel)
|
|
check wrapped.isOk()
|
|
|
|
let unwrapped = deserializeMessage(wrapped.get()).get()
|
|
check:
|
|
unwrapped.repairRequest.len == 1
|
|
unwrapped.repairRequest[0].messageId == "missing-msg"
|
|
# Should be removed from buffer after attaching
|
|
"missing-msg" notin channel.outgoingRepairBuffer
|
|
|
|
test "incoming repair request adds to incoming repair buffer when eligible":
|
|
rm.setCallbacks(
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(messageId: SdsMessageID, missingDeps: seq[HistoryEntry], channelId: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
let channel = rm.channels[testChannel]
|
|
|
|
# First, cache a message so we can respond to a repair request for it
|
|
let cachedMsg = SdsMessage(
|
|
messageId: "cached-msg",
|
|
lamportTimestamp: 1,
|
|
causalHistory: @[],
|
|
channelId: testChannel,
|
|
content: @[byte(99)],
|
|
bloomFilter: @[],
|
|
)
|
|
let cachedBytes = serializeMessage(cachedMsg).get()
|
|
channel.messageCache["cached-msg"] = cachedBytes
|
|
|
|
# Receive a message with a repair request for "cached-msg"
|
|
let msgWithRepair = SdsMessage(
|
|
messageId: "requester-msg",
|
|
lamportTimestamp: 5,
|
|
causalHistory: @[],
|
|
channelId: testChannel,
|
|
content: @[byte(3)],
|
|
bloomFilter: @[],
|
|
repairRequest: @[HistoryEntry(
|
|
messageId: "cached-msg",
|
|
senderId: "test-participant", # Same as our participantId so we're in response group
|
|
)],
|
|
)
|
|
discard rm.unwrapReceivedMessage(serializeMessage(msgWithRepair).get())
|
|
|
|
# We should have added it to the incoming repair buffer (we have the message and are in response group)
|
|
check "cached-msg" in channel.incomingRepairBuffer
|
|
|
|
suite "SDS-R: Protobuf Roundtrip":
|
|
test "senderId in HistoryEntry roundtrips through protobuf":
|
|
let msg = SdsMessage(
|
|
messageId: "msg1",
|
|
lamportTimestamp: 100,
|
|
causalHistory: @[
|
|
HistoryEntry(messageId: "dep1", retrievalHint: @[byte(1), 2], senderId: "sender-A"),
|
|
HistoryEntry(messageId: "dep2", senderId: "sender-B"),
|
|
],
|
|
channelId: "ch1",
|
|
content: @[byte(42)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let serialized = serializeMessage(msg).get()
|
|
let decoded = deserializeMessage(serialized).get()
|
|
|
|
check:
|
|
decoded.causalHistory.len == 2
|
|
decoded.causalHistory[0].messageId == "dep1"
|
|
decoded.causalHistory[0].senderId == "sender-A"
|
|
decoded.causalHistory[0].retrievalHint == @[byte(1), 2]
|
|
decoded.causalHistory[1].messageId == "dep2"
|
|
decoded.causalHistory[1].senderId == "sender-B"
|
|
|
|
test "repairRequest field roundtrips through protobuf":
|
|
let msg = SdsMessage(
|
|
messageId: "msg1",
|
|
lamportTimestamp: 100,
|
|
causalHistory: @[],
|
|
channelId: "ch1",
|
|
content: @[byte(42)],
|
|
bloomFilter: @[],
|
|
repairRequest: @[
|
|
HistoryEntry(messageId: "missing1", senderId: "sender-X"),
|
|
HistoryEntry(messageId: "missing2", senderId: "sender-Y", retrievalHint: @[byte(5)]),
|
|
],
|
|
)
|
|
|
|
let serialized = serializeMessage(msg).get()
|
|
let decoded = deserializeMessage(serialized).get()
|
|
|
|
check:
|
|
decoded.repairRequest.len == 2
|
|
decoded.repairRequest[0].messageId == "missing1"
|
|
decoded.repairRequest[0].senderId == "sender-X"
|
|
decoded.repairRequest[1].messageId == "missing2"
|
|
decoded.repairRequest[1].senderId == "sender-Y"
|
|
decoded.repairRequest[1].retrievalHint == @[byte(5)]
|
|
|
|
test "backward compat: message without repairRequest decodes fine":
|
|
let msg = SdsMessage(
|
|
messageId: "msg1",
|
|
lamportTimestamp: 100,
|
|
causalHistory: @[HistoryEntry(messageId: "dep1")],
|
|
channelId: "ch1",
|
|
content: @[byte(42)],
|
|
bloomFilter: @[],
|
|
)
|
|
|
|
let serialized = serializeMessage(msg).get()
|
|
let decoded = deserializeMessage(serialized).get()
|
|
|
|
check:
|
|
decoded.repairRequest.len == 0
|
|
decoded.causalHistory[0].senderId == ""
|
|
|
|
test "SdsMessage.senderId roundtrips through protobuf":
|
|
let msg = SdsMessage(
|
|
messageId: "m1",
|
|
lamportTimestamp: 1,
|
|
causalHistory: @[],
|
|
channelId: "ch1",
|
|
content: @[byte(1)],
|
|
bloomFilter: @[],
|
|
senderId: "alice",
|
|
)
|
|
let decoded = deserializeMessage(serializeMessage(msg).get()).get()
|
|
check decoded.senderId == "alice"
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# SDS-R Phase 2 tests: edge cases, lifecycle, sweep, and multi-participant flows
|
|
# ---------------------------------------------------------------------------
|
|
|
|
suite "SDS-R: Edge Cases and Defensive Branches":
|
|
test "computeTReq returns tMin when range is degenerate":
|
|
let tMin = initDuration(seconds = 30)
|
|
# tMax == tMin
|
|
let d1 = computeTReq("p", "m", tMin, tMin)
|
|
check d1 == tMin
|
|
# tMax < tMin (rangeMs < 0)
|
|
let d2 = computeTReq("p", "m", tMin, initDuration(seconds = 10))
|
|
check d2 == tMin
|
|
|
|
test "computeTResp returns 0 when tMax is 0":
|
|
let d = computeTResp("p", "other", "m", initDuration(milliseconds = 0))
|
|
check d.inMilliseconds == 0
|
|
|
|
test "computeTResp always stays within [0, tMax)":
|
|
# Adversarial sweep — result must never wrap negative nor exceed tMax
|
|
let tMax = initDuration(seconds = 300)
|
|
for i in 0 ..< 500:
|
|
let d = computeTResp(
|
|
"participant-" & $i, "sender-" & $(i * 13), "msg-" & $(i * 31), tMax
|
|
)
|
|
check:
|
|
d.inMilliseconds >= 0
|
|
d.inMilliseconds < tMax.inMilliseconds
|
|
|
|
test "isInResponseGroup returns true for non-positive numGroups":
|
|
check isInResponseGroup("p", "sender", "m", 0) == true
|
|
check isInResponseGroup("p", "sender", "m", -1) == true
|
|
|
|
test "computeTReq bounds across many random inputs":
|
|
let tMin = initDuration(seconds = 30)
|
|
let tMax = initDuration(seconds = 300)
|
|
for i in 0 ..< 200:
|
|
let d = computeTReq("p-" & $i, "m-" & $i, tMin, tMax)
|
|
check:
|
|
d.inMilliseconds >= tMin.inMilliseconds
|
|
d.inMilliseconds < tMax.inMilliseconds
|
|
|
|
test "response group distribution is roughly uniform":
|
|
# With numGroups=10, ~10% of random participants should share sender's group.
|
|
const numGroups = 10
|
|
const totalParticipants = 1000
|
|
let senderId = "alice"
|
|
let msgId = "msg-xyz"
|
|
var sameGroup = 0
|
|
for i in 0 ..< totalParticipants:
|
|
if isInResponseGroup("participant-" & $i, senderId, msgId, numGroups):
|
|
sameGroup += 1
|
|
# Expected ~100 (1/N), allow [50, 200] band for hash quirks
|
|
check:
|
|
sameGroup >= 50
|
|
sameGroup <= 200
|
|
|
|
test "computeTResp monotonicity: self always fastest":
|
|
# The original sender (distance=0) must always be first to respond.
|
|
let tMax = initDuration(seconds = 300)
|
|
let selfD = computeTResp("alice", "alice", "msg-xyz", tMax)
|
|
check selfD.inMilliseconds == 0
|
|
for i in 0 ..< 50:
|
|
let other = computeTResp("other-" & $i, "alice", "msg-xyz", tMax)
|
|
check other.inMilliseconds >= selfD.inMilliseconds
|
|
|
|
suite "SDS-R: Lifecycle and State":
|
|
test "empty participantId disables outgoing repair creation":
|
|
let rm = newReliabilityManager().get() # empty participantId
|
|
defer: rm.cleanup()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
rm.setCallbacks(
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, deps: seq[HistoryEntry], ch: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
let msg = SdsMessage(
|
|
messageId: "m2",
|
|
lamportTimestamp: 2,
|
|
causalHistory: @[HistoryEntry(messageId: "m1-missing", senderId: "alice")],
|
|
channelId: testChannel,
|
|
content: @[byte(2)],
|
|
bloomFilter: @[],
|
|
)
|
|
discard rm.unwrapReceivedMessage(serializeMessage(msg).get())
|
|
check rm.channels[testChannel].outgoingRepairBuffer.len == 0
|
|
|
|
test "empty senderId in incoming repair request is ignored":
|
|
let rm = newReliabilityManager(participantId = "bob").get()
|
|
defer: rm.cleanup()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
let channel = rm.channels[testChannel]
|
|
channel.messageCache["m-wanted"] = @[byte(99), 99, 99]
|
|
|
|
rm.setCallbacks(
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, deps: seq[HistoryEntry], ch: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
let msg = SdsMessage(
|
|
messageId: "req-msg",
|
|
lamportTimestamp: 5,
|
|
causalHistory: @[],
|
|
channelId: testChannel,
|
|
content: @[byte(1)],
|
|
bloomFilter: @[],
|
|
repairRequest: @[HistoryEntry(messageId: "m-wanted", senderId: "")],
|
|
)
|
|
discard rm.unwrapReceivedMessage(serializeMessage(msg).get())
|
|
check "m-wanted" notin channel.incomingRepairBuffer
|
|
|
|
test "wrapOutgoingMessage caches bytes and records sender":
|
|
# Proves Bug 1 is fixed — the original sender can serve her own message.
|
|
let rm = newReliabilityManager(participantId = "alice").get()
|
|
defer: rm.cleanup()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
discard rm.wrapOutgoingMessage(@[byte(1), 2, 3], "m1", testChannel)
|
|
let channel = rm.channels[testChannel]
|
|
check:
|
|
"m1" in channel.messageCache
|
|
channel.messageCache["m1"].len > 0
|
|
"m1" in channel.messageSenders
|
|
channel.messageSenders["m1"] == "alice"
|
|
|
|
test "getRecentHistoryEntries carries senderId for own messages":
|
|
let rm = newReliabilityManager(participantId = "alice").get()
|
|
defer: rm.cleanup()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
discard rm.wrapOutgoingMessage(@[byte(1)], "m1", testChannel)
|
|
discard rm.wrapOutgoingMessage(@[byte(2)], "m2", testChannel)
|
|
let entries = rm.getRecentHistoryEntries(10, testChannel)
|
|
check:
|
|
entries.len == 2
|
|
entries[0].senderId == "alice"
|
|
entries[1].senderId == "alice"
|
|
|
|
test "resetReliabilityManager clears all SDS-R state":
|
|
let rm = newReliabilityManager(participantId = "alice").get()
|
|
defer: rm.cleanup()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
let channel = rm.channels[testChannel]
|
|
|
|
channel.outgoingRepairBuffer["a"] = OutgoingRepairEntry(
|
|
entry: HistoryEntry(messageId: "a", senderId: "x"),
|
|
tReq: getTime(),
|
|
)
|
|
channel.incomingRepairBuffer["b"] = IncomingRepairEntry(
|
|
entry: HistoryEntry(messageId: "b", senderId: "y"),
|
|
cachedMessage: @[byte(1)],
|
|
tResp: getTime(),
|
|
)
|
|
channel.messageCache["c"] = @[byte(2)]
|
|
channel.messageSenders["c"] = "someone"
|
|
|
|
check rm.resetReliabilityManager().isOk()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
let ch2 = rm.channels[testChannel]
|
|
check:
|
|
ch2.outgoingRepairBuffer.len == 0
|
|
ch2.incomingRepairBuffer.len == 0
|
|
ch2.messageCache.len == 0
|
|
ch2.messageSenders.len == 0
|
|
|
|
test "SDS-R state is isolated per channel":
|
|
let rm = newReliabilityManager(participantId = "alice").get()
|
|
defer: rm.cleanup()
|
|
check rm.ensureChannel("ch-A").isOk()
|
|
check rm.ensureChannel("ch-B").isOk()
|
|
|
|
rm.setCallbacks(
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, deps: seq[HistoryEntry], ch: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
let msg = SdsMessage(
|
|
messageId: "m2",
|
|
lamportTimestamp: 2,
|
|
causalHistory: @[HistoryEntry(messageId: "m1-missing", senderId: "bob")],
|
|
channelId: "ch-A",
|
|
content: @[byte(2)],
|
|
bloomFilter: @[],
|
|
)
|
|
discard rm.unwrapReceivedMessage(serializeMessage(msg).get())
|
|
check:
|
|
rm.channels["ch-A"].outgoingRepairBuffer.len == 1
|
|
rm.channels["ch-B"].outgoingRepairBuffer.len == 0
|
|
|
|
test "duplicate message arrival cancels pending incoming repair entry":
|
|
# Covers the dedup-before-cleanup fix: a rebroadcast arriving at a peer who
|
|
# already has the message must clear that peer's incomingRepairBuffer entry.
|
|
let rm = newReliabilityManager(participantId = "carol").get()
|
|
defer: rm.cleanup()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
let channel = rm.channels[testChannel]
|
|
|
|
rm.setCallbacks(
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, deps: seq[HistoryEntry], ch: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
# Carol already has M1 in history and has a pending incomingRepairBuffer entry
|
|
channel.messageHistory.add("m1")
|
|
channel.incomingRepairBuffer["m1"] = IncomingRepairEntry(
|
|
entry: HistoryEntry(messageId: "m1", senderId: "alice"),
|
|
cachedMessage: @[byte(1)],
|
|
tResp: getTime() + initDuration(seconds = 10),
|
|
)
|
|
|
|
# A rebroadcast of M1 arrives
|
|
let msg = SdsMessage(
|
|
messageId: "m1",
|
|
lamportTimestamp: 1,
|
|
causalHistory: @[],
|
|
channelId: testChannel,
|
|
content: @[byte(1)],
|
|
bloomFilter: @[],
|
|
senderId: "alice",
|
|
)
|
|
discard rm.unwrapReceivedMessage(serializeMessage(msg).get())
|
|
check "m1" notin channel.incomingRepairBuffer
|
|
|
|
suite "SDS-R: Repair Sweep":
|
|
var rm: ReliabilityManager
|
|
|
|
setup:
|
|
rm = newReliabilityManager(participantId = "bob").get()
|
|
check rm.ensureChannel(testChannel).isOk()
|
|
|
|
teardown:
|
|
if not rm.isNil:
|
|
rm.cleanup()
|
|
|
|
test "runRepairSweep fires onRepairReady for expired tResp":
|
|
var fireCount = 0
|
|
var firstBytes: seq[byte] = @[]
|
|
rm.setCallbacks(
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, deps: seq[HistoryEntry], ch: SdsChannelID) {.gcsafe.} = discard,
|
|
onRepairReady = proc(bytes: seq[byte], ch: SdsChannelID) {.gcsafe.} =
|
|
{.cast(gcsafe).}:
|
|
fireCount += 1
|
|
if fireCount == 1:
|
|
firstBytes = bytes,
|
|
)
|
|
|
|
let channel = rm.channels[testChannel]
|
|
channel.incomingRepairBuffer["m-ready"] = IncomingRepairEntry(
|
|
entry: HistoryEntry(messageId: "m-ready", senderId: "alice"),
|
|
cachedMessage: @[byte(1), 2, 3],
|
|
tResp: getTime() - initDuration(seconds = 1), # expired
|
|
)
|
|
channel.incomingRepairBuffer["m-not-ready"] = IncomingRepairEntry(
|
|
entry: HistoryEntry(messageId: "m-not-ready", senderId: "alice"),
|
|
cachedMessage: @[byte(9), 9, 9],
|
|
tResp: getTime() + initDuration(minutes = 10), # far future
|
|
)
|
|
|
|
rm.runRepairSweep()
|
|
|
|
check:
|
|
fireCount == 1
|
|
firstBytes == @[byte(1), 2, 3]
|
|
"m-ready" notin channel.incomingRepairBuffer
|
|
"m-not-ready" in channel.incomingRepairBuffer
|
|
|
|
test "runRepairSweep drops outgoing entries past T_max window":
|
|
rm.setCallbacks(
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, deps: seq[HistoryEntry], ch: SdsChannelID) {.gcsafe.} = discard,
|
|
)
|
|
|
|
let channel = rm.channels[testChannel]
|
|
let tMax = rm.config.repairTMax
|
|
channel.outgoingRepairBuffer["m-stale"] = OutgoingRepairEntry(
|
|
entry: HistoryEntry(messageId: "m-stale", senderId: "alice"),
|
|
tReq: getTime() - (tMax + tMax), # now - 2*T_max, past drop window
|
|
)
|
|
channel.outgoingRepairBuffer["m-fresh"] = OutgoingRepairEntry(
|
|
entry: HistoryEntry(messageId: "m-fresh", senderId: "alice"),
|
|
tReq: getTime(),
|
|
)
|
|
|
|
rm.runRepairSweep()
|
|
|
|
check:
|
|
"m-stale" notin channel.outgoingRepairBuffer
|
|
"m-fresh" in channel.outgoingRepairBuffer
|
|
|
|
test "runRepairSweep no-op when buffers are empty":
|
|
var fireCount = 0
|
|
rm.setCallbacks(
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, deps: seq[HistoryEntry], ch: SdsChannelID) {.gcsafe.} = discard,
|
|
onRepairReady = proc(bytes: seq[byte], ch: SdsChannelID) {.gcsafe.} =
|
|
fireCount += 1,
|
|
)
|
|
rm.runRepairSweep()
|
|
check fireCount == 0
|
|
|
|
# --- Multi-participant in-process bus for integration tests ---------------
|
|
|
|
type
|
|
TestBus = ref object
|
|
peers: OrderedTable[SdsParticipantID, ReliabilityManager]
|
|
delivered: Table[SdsParticipantID, seq[SdsMessageID]]
|
|
# Log of raw message-ids placed on the wire, tagged with the source peer.
|
|
wireLog: seq[tuple[senderId: SdsParticipantID, messageId: SdsMessageID]]
|
|
|
|
proc newTestBus(): TestBus =
|
|
TestBus(
|
|
peers: initOrderedTable[SdsParticipantID, ReliabilityManager](),
|
|
delivered: initTable[SdsParticipantID, seq[SdsMessageID]](),
|
|
wireLog: @[],
|
|
)
|
|
|
|
proc recordWire(bus: TestBus, senderId: SdsParticipantID, bytes: seq[byte]) {.gcsafe.} =
|
|
let decoded = deserializeMessage(bytes)
|
|
if decoded.isOk():
|
|
bus.wireLog.add((senderId, decoded.get().messageId))
|
|
|
|
proc deliverExcept(
|
|
bus: TestBus,
|
|
senderId: SdsParticipantID,
|
|
bytes: seq[byte],
|
|
exclude: seq[SdsParticipantID],
|
|
) {.gcsafe.} =
|
|
for pid, peer in bus.peers:
|
|
if pid == senderId or pid in exclude:
|
|
continue
|
|
discard peer.unwrapReceivedMessage(bytes)
|
|
|
|
proc addPeer(
|
|
bus: TestBus,
|
|
participantId: SdsParticipantID,
|
|
config: ReliabilityConfig = defaultConfig(),
|
|
): ReliabilityManager =
|
|
let rm = newReliabilityManager(config, participantId).get()
|
|
doAssert rm.ensureChannel(testChannel).isOk()
|
|
bus.peers[participantId] = rm
|
|
bus.delivered[participantId] = @[]
|
|
|
|
let pid = participantId
|
|
let busRef = bus
|
|
rm.setCallbacks(
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} =
|
|
{.cast(gcsafe).}:
|
|
busRef.delivered[pid].add(msgId),
|
|
proc(msgId: SdsMessageID, ch: SdsChannelID) {.gcsafe.} = discard,
|
|
proc(msgId: SdsMessageID, deps: seq[HistoryEntry], ch: SdsChannelID) {.gcsafe.} = discard,
|
|
onRepairReady = proc(bytes: seq[byte], ch: SdsChannelID) {.gcsafe.} =
|
|
{.cast(gcsafe).}:
|
|
busRef.recordWire(pid, bytes)
|
|
busRef.deliverExcept(pid, bytes, @[]),
|
|
)
|
|
rm
|
|
|
|
proc broadcast(
|
|
bus: TestBus,
|
|
senderId: SdsParticipantID,
|
|
content: seq[byte],
|
|
messageId: SdsMessageID,
|
|
dropAt: seq[SdsParticipantID] = @[],
|
|
) =
|
|
let rm = bus.peers[senderId]
|
|
let wrapped = rm.wrapOutgoingMessage(content, messageId, testChannel)
|
|
doAssert wrapped.isOk()
|
|
bus.recordWire(senderId, wrapped.get())
|
|
bus.deliverExcept(senderId, wrapped.get(), dropAt)
|
|
|
|
proc forceOutgoingExpired(
|
|
rm: ReliabilityManager, messageId: SdsMessageID
|
|
) =
|
|
## Push a specific outgoingRepairBuffer entry's tReq into the past so the
|
|
## next wrapOutgoingMessage will pick it up.
|
|
let channel = rm.channels[testChannel]
|
|
if messageId in channel.outgoingRepairBuffer:
|
|
channel.outgoingRepairBuffer[messageId].tReq =
|
|
getTime() - initDuration(seconds = 1)
|
|
|
|
proc forceIncomingExpired(
|
|
rm: ReliabilityManager, messageId: SdsMessageID
|
|
) =
|
|
## Push an incomingRepairBuffer entry's tResp into the past so runRepairSweep fires it.
|
|
let channel = rm.channels[testChannel]
|
|
if messageId in channel.incomingRepairBuffer:
|
|
channel.incomingRepairBuffer[messageId].tResp =
|
|
getTime() - initDuration(seconds = 1)
|
|
|
|
suite "SDS-R: Multi-Participant Integration":
|
|
|
|
test "basic single-gap repair (Alice -> Bob misses -> Carol's message triggers repair)":
|
|
let bus = newTestBus()
|
|
let alice = bus.addPeer("alice")
|
|
let bob = bus.addPeer("bob")
|
|
let carol = bus.addPeer("carol")
|
|
|
|
# Alice sends M1, but Bob is offline for this one.
|
|
bus.broadcast("alice", @[byte(1)], "m1", dropAt = @["bob".SdsParticipantID])
|
|
# Carol now has M1; Bob does not.
|
|
check "m1" in carol.channels[testChannel].messageHistory
|
|
check "m1" notin bob.channels[testChannel].messageHistory
|
|
|
|
# Carol sends M2 with causal history referencing M1.
|
|
bus.broadcast("carol", @[byte(2)], "m2")
|
|
# Bob detects M1 missing and populates his outgoingRepairBuffer.
|
|
check "m1" in bob.channels[testChannel].outgoingRepairBuffer
|
|
# Bob should have buffered M2.
|
|
check "m2" in bob.channels[testChannel].incomingBuffer
|
|
check "m2" notin bus.delivered["bob"]
|
|
|
|
# Force Bob's T_req so the next wrap attaches the repair request.
|
|
bob.forceOutgoingExpired("m1")
|
|
|
|
# Bob sends M3 — it must carry repair_request=[M1, sender=alice].
|
|
bus.broadcast("bob", @[byte(3)], "m3")
|
|
|
|
# Alice received M3, saw the repair_request, cached-bypass and response-group
|
|
# checks pass, so she has an incomingRepairBuffer entry for M1 with tResp=0.
|
|
check "m1" in alice.channels[testChannel].incomingRepairBuffer
|
|
|
|
# Force alice's tResp to past just to be safe (it's already 0 for self),
|
|
# then run her sweep. She rebroadcasts M1.
|
|
alice.forceIncomingExpired("m1")
|
|
alice.runRepairSweep()
|
|
|
|
# Bob now has M1 and M2 delivered.
|
|
check:
|
|
"m1" in bus.delivered["bob"]
|
|
"m2" in bus.delivered["bob"]
|
|
|
|
test "response cancellation: only one rebroadcast on the wire":
|
|
let bus = newTestBus()
|
|
let alice = bus.addPeer("alice")
|
|
let bob = bus.addPeer("bob")
|
|
let carol = bus.addPeer("carol")
|
|
|
|
# Alice sends M1, Bob offline.
|
|
bus.broadcast("alice", @[byte(1)], "m1", dropAt = @["bob".SdsParticipantID])
|
|
# Carol sends M2; Bob sees M1 missing.
|
|
bus.broadcast("carol", @[byte(2)], "m2")
|
|
check "m1" in bob.channels[testChannel].outgoingRepairBuffer
|
|
|
|
# Bob requests repair.
|
|
bob.forceOutgoingExpired("m1")
|
|
bus.broadcast("bob", @[byte(3)], "m3")
|
|
|
|
# Both Alice and Carol now have an incomingRepairBuffer entry for M1.
|
|
check:
|
|
"m1" in alice.channels[testChannel].incomingRepairBuffer
|
|
"m1" in carol.channels[testChannel].incomingRepairBuffer
|
|
|
|
# Alice fires first (T_resp=0 for self). Her rebroadcast should cancel Carol's
|
|
# pending entry when Carol receives the rebroadcast.
|
|
alice.forceIncomingExpired("m1")
|
|
alice.runRepairSweep()
|
|
|
|
# Carol's pending response must have been cleared by the dedup-path cleanup.
|
|
check "m1" notin carol.channels[testChannel].incomingRepairBuffer
|
|
|
|
# Even if we now force-run Carol's sweep, nothing should fire.
|
|
let wireCountBefore = bus.wireLog.len
|
|
carol.runRepairSweep()
|
|
check bus.wireLog.len == wireCountBefore
|
|
|
|
# Bob received exactly one rebroadcast of M1.
|
|
var m1RebroadcastCount = 0
|
|
for entry in bus.wireLog:
|
|
if entry.messageId == "m1" and entry.senderId != "alice":
|
|
discard # only the original Alice->all broadcast had senderId="alice"
|
|
if entry.messageId == "m1":
|
|
m1RebroadcastCount += 1
|
|
# Two "m1" entries total on wire: (1) Alice's original broadcast, (2) Alice's rebroadcast.
|
|
check m1RebroadcastCount == 2
|
|
|
|
test "cancellation on incoming repair request: peer drops its own pending request":
|
|
let bus = newTestBus()
|
|
let alice = bus.addPeer("alice")
|
|
let bob = bus.addPeer("bob")
|
|
let carol = bus.addPeer("carol")
|
|
|
|
# Alice sends M1 — drop at both Bob and Carol, so both miss it.
|
|
bus.broadcast(
|
|
"alice", @[byte(1)], "m1",
|
|
dropAt = @["bob".SdsParticipantID, "carol".SdsParticipantID],
|
|
)
|
|
# Alice sends M2 referencing M1 — both Bob and Carol see M1 missing.
|
|
bus.broadcast("alice", @[byte(2)], "m2")
|
|
check:
|
|
"m1" in bob.channels[testChannel].outgoingRepairBuffer
|
|
"m1" in carol.channels[testChannel].outgoingRepairBuffer
|
|
|
|
# Bob's T_req fires first. He sends a repair request for M1.
|
|
bob.forceOutgoingExpired("m1")
|
|
bus.broadcast("bob", @[byte(3)], "m3")
|
|
|
|
# Carol, on receiving Bob's repair request, must have dropped her own
|
|
# pending outgoingRepairBuffer entry for M1 (cancellation).
|
|
check "m1" notin carol.channels[testChannel].outgoingRepairBuffer
|
|
|
|
test "response group filtering: only group members respond":
|
|
# With numGroups=10, roughly 1/10 of receivers will be in the group.
|
|
# Construct a sender+message where a specific non-sender is NOT in the group.
|
|
var cfg = defaultConfig()
|
|
cfg.numResponseGroups = 10
|
|
|
|
# Pick a msgId where carol is not in the group and bob is
|
|
# We probe deterministically because computeTReq/isInResponseGroup are pure.
|
|
var chosenMsg = ""
|
|
for i in 0 ..< 1000:
|
|
let candidate = "probe-" & $i
|
|
let bobIn = isInResponseGroup("bob", "alice", candidate, 10)
|
|
let carolIn = isInResponseGroup("carol", "alice", candidate, 10)
|
|
if bobIn and not carolIn:
|
|
chosenMsg = candidate
|
|
break
|
|
check chosenMsg.len > 0
|
|
|
|
let bus = newTestBus()
|
|
discard bus.addPeer("alice", cfg)
|
|
let bob = bus.addPeer("bob", cfg)
|
|
let carol = bus.addPeer("carol", cfg)
|
|
|
|
# Both Bob and Carol receive the original M1 (so both have it in messageCache).
|
|
bus.broadcast("alice", @[byte(1)], chosenMsg)
|
|
|
|
# Now Dave arrives: build a fake requester message manually so its repair_request
|
|
# names Alice as senderId for chosenMsg.
|
|
# We inject directly by calling unwrapReceivedMessage on bob/carol.
|
|
let dave = bus.addPeer("dave", cfg)
|
|
# Dave has no messages, but we can hand-craft a repair request he would send.
|
|
let reqMsg = SdsMessage(
|
|
messageId: "req-from-dave",
|
|
lamportTimestamp: 10,
|
|
causalHistory: @[],
|
|
channelId: testChannel,
|
|
content: @[byte(9)],
|
|
bloomFilter: @[],
|
|
senderId: "dave",
|
|
repairRequest: @[HistoryEntry(messageId: chosenMsg, senderId: "alice")],
|
|
)
|
|
let bytes = serializeMessage(reqMsg).get()
|
|
discard bob.unwrapReceivedMessage(bytes)
|
|
discard carol.unwrapReceivedMessage(bytes)
|
|
|
|
check:
|
|
chosenMsg in bob.channels[testChannel].incomingRepairBuffer
|
|
chosenMsg notin carol.channels[testChannel].incomingRepairBuffer
|
|
|
|
test "multi-gap batch repair: many missing deps split across requests":
|
|
let bus = newTestBus()
|
|
discard bus.addPeer("alice")
|
|
let bob = bus.addPeer("bob")
|
|
|
|
# Alice sends 5 messages while Bob is offline.
|
|
let drops = @["bob".SdsParticipantID]
|
|
bus.broadcast("alice", @[byte(1)], "m1", dropAt = drops)
|
|
bus.broadcast("alice", @[byte(2)], "m2", dropAt = drops)
|
|
bus.broadcast("alice", @[byte(3)], "m3", dropAt = drops)
|
|
bus.broadcast("alice", @[byte(4)], "m4", dropAt = drops)
|
|
bus.broadcast("alice", @[byte(5)], "m5", dropAt = drops)
|
|
|
|
# Bob comes online and receives M6 which depends on m1..m5.
|
|
bus.broadcast("alice", @[byte(6)], "m6")
|
|
|
|
# Bob should have 5 outgoing repair entries.
|
|
let channel = bob.channels[testChannel]
|
|
check channel.outgoingRepairBuffer.len == 5
|
|
|
|
# Force all to expired and wrap one message — only maxRepairRequests
|
|
# (default 3) should attach to a single outgoing message.
|
|
for id in ["m1", "m2", "m3", "m4", "m5"]:
|
|
bob.forceOutgoingExpired(id)
|
|
|
|
let wrapped = bob.wrapOutgoingMessage(@[byte(99)], "bob-msg-1", testChannel).get()
|
|
let decoded = deserializeMessage(wrapped).get()
|
|
check decoded.repairRequest.len <= bob.config.maxRepairRequests
|
|
|
|
# The attached entries should be removed from the outgoing buffer.
|
|
check channel.outgoingRepairBuffer.len == 5 - decoded.repairRequest.len
|
|
|
|
test "markDependenciesMet externally clears pending repair entry":
|
|
let bus = newTestBus()
|
|
discard bus.addPeer("alice")
|
|
let bob = bus.addPeer("bob")
|
|
|
|
bus.broadcast("alice", @[byte(1)], "m1", dropAt = @["bob".SdsParticipantID])
|
|
bus.broadcast("alice", @[byte(2)], "m2")
|
|
check "m1" in bob.channels[testChannel].outgoingRepairBuffer
|
|
|
|
# Simulate Bob fetching M1 via an out-of-band store query.
|
|
check bob.markDependenciesMet(@["m1"], testChannel).isOk()
|
|
check "m1" notin bob.channels[testChannel].outgoingRepairBuffer
|