@streamr/trackerless-network 0.0.1-tatum.0

package/test/unit/Handshaker.test.ts

@@ -0,0 +1,63 @@
+import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
+import { ListeningRpcCommunicator, PeerDescriptor, PeerID, Simulator, SimulatorTransport } from '@streamr/dht'
+import { mockConnectionLocker, createMockRemotePeer } from '../utils/utils'
+import { PeerList } from '../../src/logic/PeerList'
+import { range } from 'lodash'
+
+describe('Handshaker', () => {
+
+    let handshaker: Handshaker
+    const peerId = PeerID.fromString('Handshaker')
+    const peerDescriptor: PeerDescriptor = {
+        kademliaId: peerId.value,
+        type: 0
+    }
+
+    const N = 4
+    const stream = 'stream#0'
+
+    let targetNeighbors: PeerList
+    let nearbyContactPool: PeerList
+    let randomContactPool: PeerList
+
+    let simulator: Simulator
+    let simulatorTransport: SimulatorTransport
+    
+    beforeEach(() => {
+        simulator = new Simulator()
+        simulatorTransport = new SimulatorTransport(peerDescriptor, simulator)
+        const rpcCommunicator = new ListeningRpcCommunicator(stream, simulatorTransport)
+
+        targetNeighbors = new PeerList(peerId, 10)
+        nearbyContactPool = new PeerList(peerId, 20)
+        randomContactPool = new PeerList(peerId, 20)
+
+        handshaker = new Handshaker({
+            ownPeerDescriptor: peerDescriptor,
+            randomGraphId: stream,
+            connectionLocker: mockConnectionLocker,
+            targetNeighbors,
+            nearbyContactPool,
+            randomContactPool,
+            rpcCommunicator,
+            N
+        })
+    })
+
+    afterEach(async () => {
+        await simulatorTransport.stop()
+        simulator.stop()
+    })
+
+    it('attemptHandshakesOnContact works with empty structures', async () => {
+        const res = await handshaker.attemptHandshakesOnContacts([])
+        expect(res.length).toEqual(0)
+    })
+
+    it('attemptHandshakesOnContact with known peers that cannot be connected to', async () => {
+        range(2).forEach(() => nearbyContactPool.add(createMockRemotePeer()))
+        const res = await handshaker.attemptHandshakesOnContacts([])
+        expect(res.length).toEqual(2)
+    })
+
+})

package/test/unit/HandshakerServer.test.ts

@@ -0,0 +1,123 @@
+import { PeerID } from '@streamr/dht'
+import { HandshakerServer } from '../../src/logic/neighbor-discovery/HandshakerServer'
+import { PeerList } from '../../src/logic/PeerList'
+import { InterleaveNotice, StreamHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { createMockRemoteHandshaker, createMockRemotePeer, mockConnectionLocker } from '../utils/utils'
+
+describe('HandshakerServer', () => {
+
+    let handshakerServer: HandshakerServer
+
+    const peerId = PeerID.fromString('Handshaker')
+    const ownPeerDescriptor = {
+        kademliaId: peerId.value,
+        type: 0
+    }
+
+    let targetNeighbors: PeerList
+    let ongoingHandshakes: Set<string>
+    let handshakeWithInterleaving: jest.Mock
+
+    beforeEach(() => {
+        targetNeighbors = new PeerList(peerId, 10)
+        ongoingHandshakes = new Set()
+
+        handshakeWithInterleaving = jest.fn()
+
+        handshakerServer = new HandshakerServer({
+            randomGraphId: 'random-graph',
+            ownPeerDescriptor,
+            connectionLocker: mockConnectionLocker,
+            ongoingHandshakes,
+            createRemoteHandshaker: (_p) => createMockRemoteHandshaker(),
+            createRemoteNode: (_p) => createMockRemotePeer(),
+            handshakeWithInterleaving: async (_p, _t) => {
+                handshakeWithInterleaving()
+                return true
+            },
+            targetNeighbors,
+            N: 4
+        })
+    })
+
+    it('handshake', async () => {
+        const req = StreamHandshakeRequest.create({
+            randomGraphId: 'random-graph',
+            senderId: 'senderId',
+            requestId: 'requestId',
+            senderDescriptor: {
+                kademliaId: PeerID.fromString('senderId').value,
+                type: 0
+            }
+        })
+        const res = await handshakerServer.handshake(req, {} as any)
+        expect(res.accepted).toEqual(true)
+        expect(res.interleaveTarget).toBeUndefined()
+        expect(res.requestId).toEqual('requestId')
+    })
+
+    it('handshake interleave', async () => {
+        targetNeighbors.add(createMockRemotePeer())
+        targetNeighbors.add(createMockRemotePeer())
+        targetNeighbors.add(createMockRemotePeer())
+        targetNeighbors.add(createMockRemotePeer())
+        const req = StreamHandshakeRequest.create({
+            randomGraphId: 'random-graph',
+            senderId: 'senderId',
+            requestId: 'requestId',
+            senderDescriptor: {
+                kademliaId: PeerID.fromString('senderId').value,
+                type: 0
+            }
+        })
+        const res = await handshakerServer.handshake(req, {} as any)
+        expect(res.accepted).toEqual(true)
+        expect(res.interleaveTarget).toBeDefined()
+    })
+
+    it('unaccepted handshake', async () => {
+        ongoingHandshakes.add('mock1')
+        ongoingHandshakes.add('mock2')
+        ongoingHandshakes.add('mock3')
+        ongoingHandshakes.add('mock4')
+        const req = StreamHandshakeRequest.create({
+            randomGraphId: 'random-graph',
+            senderId: 'senderId',
+            requestId: 'requestId',
+            senderDescriptor: {
+                kademliaId: PeerID.fromString('senderId').value,
+                type: 0
+            }
+        })
+        const res = await handshakerServer.handshake(req, {} as any)
+        expect(res.accepted).toEqual(false)
+    })
+
+    it('handshakeWithInterleaving success', async () => {
+        const req: InterleaveNotice = {
+            randomGraphId: 'random-graph',
+            senderId: 'senderId',
+            interleaveTarget: {
+                kademliaId: PeerID.fromString('interleaveTarget').value,
+                type: 0
+            }
+
+        }
+        await handshakerServer.interleaveNotice(req, {} as any)
+        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
+    })
+
+    it('handshakeWithInterleaving success', async () => {
+        const req: InterleaveNotice = {
+            randomGraphId: 'wrong-random-graph',
+            senderId: 'senderId',
+            interleaveTarget: {
+                kademliaId: PeerID.fromString('interleaveTarget').value,
+                type: 0
+            }
+        }
+        await handshakerServer.interleaveNotice(req, {} as any)
+        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)
+    })
+
+})

package/test/unit/InspectSession.test.ts

@@ -0,0 +1,78 @@
+import { PeerIDKey, PeerID } from '@streamr/dht'
+import { InspectSession, Events } from '../../src/logic/inspect/InspectSession'
+import { MessageRef } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { waitForEvent3 } from '../../../utils/dist/src/waitForEvent3'
+
+describe('InspectSession', () => {
+
+    let inspectSession: InspectSession
+    let inspectedPeer: PeerIDKey
+    let anotherPeer: PeerIDKey
+
+    const messageRef1: MessageRef = {
+        streamId: 'stream',
+        messageChainId: 'messageChain0',
+        streamPartition: 0,
+        sequenceNumber: 0,
+        timestamp: 12345,
+        publisherId: 'publisher'
+    }
+
+    const messageRef2: MessageRef = {
+        streamId: 'stream',
+        messageChainId: 'messageChain1',
+        streamPartition: 0,
+        sequenceNumber: 0,
+        timestamp: 12345,
+        publisherId: 'publisher'
+    }
+
+    beforeEach(() => {
+        inspectedPeer = PeerID.fromString('inspectedPeer').toKey()
+        anotherPeer = PeerID.fromString('anotherPeer').toKey()
+        inspectSession = new InspectSession({
+            inspectedPeer
+        })
+    })
+
+    afterEach(() => {
+        inspectSession.stop()
+    })
+
+    it('should mark message', () => {
+        inspectSession.markMessage(inspectedPeer, messageRef1)
+        expect(inspectSession.getInspectedMessageCount()).toBe(1)
+        inspectSession.markMessage(inspectedPeer, messageRef2)
+        expect(inspectSession.getInspectedMessageCount()).toBe(2)
+    })
+
+    it('should emit done event when inspected peer sends seen message', async () => {
+        inspectSession.markMessage(anotherPeer, messageRef1)
+        await Promise.all([
+            waitForEvent3<Events>(inspectSession, 'done', 100),
+            inspectSession.markMessage(inspectedPeer, messageRef1)
+        ])
+        expect(inspectSession.getInspectedMessageCount()).toBe(1)
+    })
+
+    it('should emit done event another peer sends message after inspected peer', async () => {
+        inspectSession.markMessage(inspectedPeer, messageRef1)
+        await Promise.all([
+            waitForEvent3<Events>(inspectSession, 'done', 100),
+            inspectSession.markMessage(anotherPeer, messageRef1)
+        ])
+        expect(inspectSession.getInspectedMessageCount()).toBe(1)
+    })
+
+    it('should not emit done if messageRefs do not match', async () => {
+        inspectSession.markMessage(inspectedPeer, messageRef1)
+        await expect(async () => {
+            await Promise.all([
+                waitForEvent3<Events>(inspectSession, 'done', 100),
+                inspectSession.markMessage(anotherPeer, messageRef2)
+            ])
+        }).rejects.toThrow('waitForEvent3')
+        
+        expect(inspectSession.getInspectedMessageCount()).toBe(2)
+    })
+})

package/test/unit/Inspector.test.ts

@@ -0,0 +1,57 @@
+import { ListeningRpcCommunicator, NodeType, PeerDescriptor, PeerID, keyFromPeerDescriptor } from '@streamr/dht'
+import { Inspector } from '../../src/logic/inspect/Inspector'
+import { mockConnectionLocker } from '../utils/utils'
+import { MockTransport } from '../utils/mock/Transport'
+
+describe('Inspector', () => {
+    
+    let inspector: Inspector
+    const inspectorPeerId = PeerID.fromString('inspector')
+    const inspectorDescriptor: PeerDescriptor = {
+        kademliaId: inspectorPeerId.value,
+        type: NodeType.NODEJS
+    }
+
+    const inspectedDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('inspected').value,
+        type: NodeType.NODEJS
+    }
+
+    const otherPeerKey = PeerID.fromString('other').toKey()
+    let mockConnect: jest.Mock
+
+    const messageRef = {
+        streamId: 'stream',
+        messageChainId: 'messageChain0',
+        streamPartition: 0,
+        sequenceNumber: 0,
+        timestamp: 12345,
+        publisherId: 'publisher'
+    }
+
+    beforeEach(() => {
+        mockConnect = jest.fn(() => {})
+        inspector = new Inspector({
+            ownPeerDescriptor: inspectorDescriptor,
+            graphId: 'test',
+            rpcCommunicator: new ListeningRpcCommunicator('inspector', new MockTransport()),
+            connectionLocker: mockConnectionLocker,
+            openInspectConnection: async (_peerDescriptor: PeerDescriptor, _lockId: string) => mockConnect()
+        })
+    })
+
+    afterEach(() => {
+        inspector.stop()
+    })
+
+    it('Opens inspection connection and runs successfully', async () => {
+        setTimeout(() => {
+            inspector.markMessage(keyFromPeerDescriptor(inspectedDescriptor), messageRef)
+            inspector.markMessage(otherPeerKey, messageRef)
+        }, 250)
+        await inspector.inspect(inspectedDescriptor)
+        expect(inspector.isInspected(keyFromPeerDescriptor(inspectedDescriptor))).toBe(false)
+        expect(mockConnect).toBeCalledTimes(1)
+    })
+
+})

package/test/unit/NeighborFinder.test.ts

@@ -0,0 +1,48 @@
+import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
+import { PeerList } from '../../src/logic/PeerList'
+import { keyFromPeerDescriptor, PeerID } from '@streamr/dht'
+import { waitForCondition } from '@streamr/utils'
+import { range } from 'lodash'
+import { expect } from 'expect'
+import { createMockRemotePeer } from '../utils/utils'
+
+describe('NeighborFinder', () => {
+
+    const peerId = PeerID.fromString('NeighborFinder')
+    let targetNeighbors: PeerList
+    let nearbyContactPool: PeerList
+    let neighborFinder: NeighborFinder
+
+    const N = 4
+
+    beforeEach(() => {
+        targetNeighbors = new PeerList(peerId, 15)
+        nearbyContactPool = new PeerList(peerId, 30)
+        range(30).forEach(() => nearbyContactPool.add(createMockRemotePeer()))
+        const mockDoFindNeighbors = async (excluded: string[]) => {
+            const target = nearbyContactPool.getRandom(excluded)
+            if (Math.random() < 0.5) {
+                targetNeighbors.add(target!)
+            } else {
+                excluded.push(keyFromPeerDescriptor(target!.getPeerDescriptor()))
+            }
+            return excluded
+        }
+        neighborFinder = new NeighborFinder({
+            targetNeighbors,
+            nearbyContactPool,
+            doFindNeighbors: (excluded) => mockDoFindNeighbors(excluded),
+            N
+        })
+    })
+
+    afterEach(() => {
+        neighborFinder.stop()
+    })
+
+    it('Finds target number of peers', async () => {
+        neighborFinder.start()
+        await waitForCondition(() => targetNeighbors.size() >= N, 10000)
+        expect(neighborFinder.isRunning()).toEqual(false)
+    })
+})

package/test/unit/NumberPair.test.ts

@@ -0,0 +1,22 @@
+import { NumberPair } from '../../src/logic/DuplicateMessageDetector'
+
+test('equalTo', () => {
+    expect(new NumberPair(5, 2).equalTo(new NumberPair(5, 3))).toEqual(false)
+    expect(new NumberPair(5, 2).equalTo(new NumberPair(5, 2))).toEqual(true)
+})
+
+test('greaterThan', () => {
+    expect(new NumberPair(5, 2).greaterThan(new NumberPair(6, 2))).toEqual(false)
+    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 3))).toEqual(false)
+    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 2))).toEqual(false)
+    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 1))).toEqual(true)
+    expect(new NumberPair(5, 2).greaterThan(new NumberPair(3, 2))).toEqual(true)
+})
+
+test('greaterThanOrEqual', () => {
+    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(6, 2))).toEqual(false)
+    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 3))).toEqual(false)
+    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 2))).toEqual(true)
+    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 1))).toEqual(true)
+    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(3, 2))).toEqual(true)
+})

package/test/unit/PeerList.test.ts

@@ -0,0 +1,150 @@
+import { PeerList } from '../../src/logic/PeerList'
+import { RemoteRandomGraphNode } from '../../src/logic/RemoteRandomGraphNode'
+import {
+    PeerDescriptor,
+    ListeningRpcCommunicator,
+    Simulator,
+    PeerID,
+    SimulatorTransport,
+    keyFromPeerDescriptor
+} from '@streamr/dht'
+import { NetworkRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { expect } from 'expect'
+
+describe('PeerList', () => {
+
+    const ids = [
+        new Uint8Array([1, 1, 1]),
+        new Uint8Array([1, 1, 2]),
+        new Uint8Array([1, 1, 3]),
+        new Uint8Array([1, 1, 4]),
+        new Uint8Array([1, 1, 5])
+    ]
+    const ownId = PeerID.fromString('test')
+    const graphId = 'test'
+    let peerList: PeerList
+    let simulator: Simulator
+    let mockTransports: SimulatorTransport[]
+
+    const createRemoteGraphNode = (peerDescriptor: PeerDescriptor) => {
+        const mockTransport = new SimulatorTransport(peerDescriptor, simulator)
+        const mockCommunicator = new ListeningRpcCommunicator(`layer2-${ graphId }`, mockTransport)
+        const mockClient = mockCommunicator.getRpcClientTransport()
+        
+        mockTransports.push(mockTransport)
+        return new RemoteRandomGraphNode(peerDescriptor, graphId, toProtoRpcClient(new NetworkRpcClient(mockClient)))
+    }
+
+    beforeEach(() => {
+        simulator = new Simulator()
+        mockTransports = []
+        peerList = new PeerList(ownId, 6)
+        ids.forEach((peerId) => {
+            const peerDescriptor: PeerDescriptor = {
+                kademliaId: peerId,
+                type: 0
+            }
+            peerList.add(createRemoteGraphNode(peerDescriptor))
+        })
+    })
+
+    afterEach(async ()=> {
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let i = 0; i < mockTransports.length; i++) {
+            await mockTransports[i].stop()
+        }
+        simulator.stop()
+    })
+
+    it('add', () => {
+        const newDescriptor = {
+            kademliaId: new Uint8Array([1, 2, 3]),
+            type: 0
+        }
+        const newNode = createRemoteGraphNode(newDescriptor)
+        peerList.add(newNode)
+        expect(peerList.hasPeer(newDescriptor)).toEqual(true)
+
+        const newDescriptor2 = {
+            kademliaId: new Uint8Array([1, 2, 4]),
+            type: 0
+        }
+        const newNode2 = createRemoteGraphNode(newDescriptor2)
+        peerList.add(newNode2)
+        expect(peerList.hasPeer(newDescriptor2)).toEqual(false)
+    })
+
+    it('remove', () => {
+        const toRemove = peerList.getClosest([])
+        peerList.remove(toRemove!.getPeerDescriptor())
+        expect(peerList.hasPeer(toRemove!.getPeerDescriptor())).toEqual(false)
+    })
+
+    it('removeById', () => {
+        const toRemove = peerList.getClosest([])
+        const stringId = keyFromPeerDescriptor(toRemove!.getPeerDescriptor())
+        peerList.removeById(stringId)
+        expect(peerList.hasPeer(toRemove!.getPeerDescriptor())).toEqual(false)
+    })
+
+    it('getClosest', () => {
+        const closest = peerList.getClosest([])
+        expect(keyFromPeerDescriptor(closest!.getPeerDescriptor()))
+            .toEqual(PeerID.fromValue(new Uint8Array([1, 1, 1])).toKey())
+    })
+
+    it('getClosest with exclude', () => {
+        const closest = peerList.getClosest([PeerID.fromValue(new Uint8Array([1, 1, 1])).toKey()])
+        expect(keyFromPeerDescriptor(closest!.getPeerDescriptor()))
+            .toEqual(PeerID.fromValue(new Uint8Array([1, 1, 2])).toKey())
+    })
+
+    it('getFurthest', () => {
+        const closest = peerList.getFurthest([])
+        expect(keyFromPeerDescriptor(closest!.getPeerDescriptor()))
+            .toEqual(PeerID.fromValue(new Uint8Array([1, 1, 5])).toKey())
+    })
+
+    it('getFurthest with exclude', () => {
+        const closest = peerList.getFurthest([PeerID.fromValue(new Uint8Array([1, 1, 5])).toKey()])
+        expect(keyFromPeerDescriptor(closest!.getPeerDescriptor()))
+            .toEqual(PeerID.fromValue(new Uint8Array([1, 1, 4])).toKey())
+    })
+
+    it('getClosestAndFurthest', () => {
+        const results = peerList.getClosestAndFurthest([])
+        expect(results).toEqual([peerList.getClosest([]), peerList.getFurthest([])])
+    })
+
+    it('getClosest empty', () => {
+        const emptyPeerList = new PeerList(ownId, 2)
+        expect(emptyPeerList.getClosest([])).toBeUndefined()
+    })
+
+    it('getFurthest empty', () => {
+        const emptyPeerList = new PeerList(ownId, 2)
+        expect(emptyPeerList.getFurthest([])).toBeUndefined()
+    })
+
+    it('getRandom empty', () => {
+        const emptyPeerList = new PeerList(ownId, 2)
+        expect(emptyPeerList.getRandom([])).toBeUndefined()
+    })
+
+    it('getClosestAndFurthest empty', () => {
+        const emptyPeerList = new PeerList(ownId, 2)
+        expect(emptyPeerList.getClosestAndFurthest([])).toEqual([])
+    })
+
+    it('getClosestAndFurthest with exclude', () => {
+        const results = peerList.getClosestAndFurthest([
+            PeerID.fromValue(new Uint8Array([1, 1, 1])).toKey(),
+            PeerID.fromValue(new Uint8Array([1, 1, 5])).toKey()
+        ])
+        expect(results).toEqual([
+            peerList.getClosest([PeerID.fromValue(new Uint8Array([1, 1, 1])).toKey()]),
+            peerList.getFurthest([PeerID.fromValue(new Uint8Array([1, 1, 5])).toKey()])
+        ])
+    })
+})

package/test/unit/Propagation.test.ts

@@ -0,0 +1,134 @@
+import {
+    MessageRef,
+    StreamMessage,
+    StreamMessageType,
+} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { Propagation } from '../../src/logic/propagation/Propagation'
+import { toEthereumAddress, wait } from '@streamr/utils'
+
+const PUBLISHER_ID = toEthereumAddress('0x1111111111111111111111111111111111111111')
+
+function makeMsg(streamId: string, partition: number, ts: number, msgNo: number): StreamMessage {
+    const ref: MessageRef = {
+        streamId,
+        streamPartition: partition,
+        timestamp: ts,
+        sequenceNumber: msgNo,
+        messageChainId: 'msgChain',
+        publisherId: PUBLISHER_ID
+    }
+    return {
+        messageRef: ref,
+        content: new Uint8Array([1]),
+        signature: 'signature',
+        messageType: StreamMessageType.MESSAGE
+    }
+}
+
+const TTL = 100
+
+describe(Propagation, () => {
+    let getNeighbors: jest.Mock<ReadonlyArray<string>, [string]>
+    let sendToNeighbor: jest.Mock<Promise<void>, [string, StreamMessage]>
+    let propagation: Propagation
+
+    beforeEach(() => {
+        getNeighbors = jest.fn()
+        sendToNeighbor = jest.fn()
+        propagation = new Propagation({
+            sendToNeighbor,
+            minPropagationTargets: 3,
+            ttl: TTL,
+            maxMessages: 5
+        })
+    })
+
+    describe('#feedUnseenMessage', () => {
+        it('message is propagated to nodes returned by getNeighbors', () => {
+            getNeighbors.mockReturnValueOnce(['n1', 'n2', 'n3'])
+            const msg = makeMsg('s1', 0, 1000, 1)
+            propagation.feedUnseenMessage(msg, [...getNeighbors('s1#0')], null)
+
+            expect(sendToNeighbor).toHaveBeenCalledTimes(3)
+            expect(sendToNeighbor).toHaveBeenNthCalledWith(1, 'n1', msg)
+            expect(sendToNeighbor).toHaveBeenNthCalledWith(2, 'n2', msg)
+            expect(sendToNeighbor).toHaveBeenNthCalledWith(3, 'n3', msg)
+        })
+
+        it('message does not get propagated to source node (if present in getNeighbors)', () => {
+            getNeighbors.mockReturnValueOnce(['n1', 'n2', 'n3'])
+            const msg = makeMsg('s1', 0, 1000, 1)
+            propagation.feedUnseenMessage(msg, [...getNeighbors('s1#0')], 'n2')
+
+            expect(sendToNeighbor).toHaveBeenCalledTimes(2)
+            expect(sendToNeighbor).toHaveBeenNthCalledWith(1, 'n1', msg)
+            expect(sendToNeighbor).toHaveBeenNthCalledWith(2, 'n3', msg)
+        })
+    })
+
+    describe('#onNeighborJoined', () => {
+        let msg: StreamMessage
+
+        async function setUpAndFeed(neighbors: string[]): Promise<void> {
+            getNeighbors.mockReturnValueOnce(neighbors)
+            msg = makeMsg('s1', 0, 1000, 1)
+            propagation.feedUnseenMessage(msg, [...getNeighbors('s1#0')], 'n2')
+            await wait(0)
+            sendToNeighbor.mockClear()
+            getNeighbors.mockClear()
+        }
+
+        it('sends to new neighbor', async () => {
+            await setUpAndFeed(['n1', 'n2', 'n3'])
+            propagation.onNeighborJoined('n4')
+            expect(sendToNeighbor).toHaveBeenCalledTimes(1)
+            expect(sendToNeighbor).toHaveBeenNthCalledWith(1, 'n4', msg)
+        })
+
+        it('sends to previously failed neighbor', async () => {
+            sendToNeighbor.mockImplementation(async (neighbor) => {
+                if (neighbor === 'n3') {
+                    throw new Error('failed to send')
+                }
+            })
+            await setUpAndFeed(['n1', 'n2', 'n3'])
+            propagation.onNeighborJoined('n3')
+            expect(sendToNeighbor).toHaveBeenCalledTimes(1)
+            expect(sendToNeighbor).toHaveBeenNthCalledWith(1, 'n3', msg)
+        })
+
+        it('no-op if passed source node', async () => {
+            await setUpAndFeed(['n1', 'n2', 'n3'])
+            propagation.onNeighborJoined('n2')
+            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
+        })
+
+        it('no-op if passed already handled neighbor', async () => {
+            await setUpAndFeed(['n1', 'n2', 'n3'])
+            propagation.onNeighborJoined('n3')
+            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
+        })
+
+        it('no-op if initially `minPropagationTargets` were propagated to', async () => {
+            await setUpAndFeed(['n1', 'n2', 'n3', 'n4'])
+            propagation.onNeighborJoined('n5')
+            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
+        })
+
+        it('no-op if later `minPropagationTargets` have been propagated to', async () => {
+            await setUpAndFeed(['n1', 'n2', 'n3'])
+            propagation.onNeighborJoined('n4')
+            await wait(0)
+            sendToNeighbor.mockClear()
+            propagation.onNeighborJoined('n5')
+            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
+        })
+
+        it('no-op if TTL expires', async () => {
+            await setUpAndFeed(['n1', 'n2', 'n3'])
+            await wait(200)
+            propagation.onNeighborJoined('n3')
+            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
+        })
+    })
+})