@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-testnet-one.1

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -26,11 +26,12 @@ describe('Websocket Connection Management', () => {
     const serviceId = 'test'
     let wsServerManager: ConnectionManager
     let noWsServerManager: ConnectionManager
+    let biggerNoWsServerManager: ConnectionManager
 
     const simulator = new Simulator()
 
     const wsServerConnectorPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerWithServer').value,
+        nodeId: PeerID.fromString('2').value,
         type: NodeType.NODEJS,
         websocket: {
             host: '127.0.0.1',
@@ -40,12 +41,18 @@ describe('Websocket Connection Management', () => {
     }
 
     const noWsServerConnectorPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerWithoutServer').value,
+        nodeId: PeerID.fromString('1').value,
+        type: NodeType.NODEJS,
+    }
+
+    const biggerNoWsServerConnectorPeerDescriptor: PeerDescriptor = {
+        nodeId: PeerID.fromString('3').value,
         type: NodeType.NODEJS,
     }
 
     let connectorTransport1: SimulatorTransport
     let connectorTransport2: SimulatorTransport
+    let connectorTransport3: SimulatorTransport
 
     beforeEach(async () => {
 
@@ -53,6 +60,8 @@ describe('Websocket Connection Management', () => {
         await connectorTransport1.start()
         connectorTransport2 = new SimulatorTransport(noWsServerConnectorPeerDescriptor, simulator)
         await connectorTransport2.start()
+        connectorTransport3 = new SimulatorTransport(biggerNoWsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport3.start()
 
         const config1 = createConfig(wsServerConnectorPeerDescriptor, {
             transport: connectorTransport1,
@@ -62,22 +71,29 @@ describe('Websocket Connection Management', () => {
         const config2 = createConfig(noWsServerConnectorPeerDescriptor, {
             transport: connectorTransport2
         })
+        const config3 = createConfig(biggerNoWsServerConnectorPeerDescriptor, {
+            transport: connectorTransport3
+        })
 
         wsServerManager = new ConnectionManager(config1)
         noWsServerManager = new ConnectionManager(config2)
+        biggerNoWsServerManager = new ConnectionManager(config3)
 
         await wsServerManager.start()
         await noWsServerManager.start()
+        await biggerNoWsServerManager.start()
     })
 
     afterEach(async () => {
         await wsServerManager.stop()
         await noWsServerManager.stop()
+        await biggerNoWsServerManager.stop()
         await connectorTransport1.stop()
         await connectorTransport2.stop()
+        await connectorTransport3.stop()
     })
 
-    it('Can open connections to serverless peer', (done) => {
+    it('Can open connections to serverless peer with smaller peerId', (done) => {
         const dummyMessage: Message = {
             serviceId,
             body: {
@@ -99,6 +115,28 @@ describe('Websocket Connection Management', () => {
         wsServerManager.send(dummyMessage)
     })
 
+    it('Can open connections to serverless peer with bigger peerId', (done) => {
+        const dummyMessage: Message = {
+            serviceId,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageType: MessageType.RPC,
+            messageId: 'mockerer',
+            targetDescriptor: biggerNoWsServerConnectorPeerDescriptor
+        }
+        biggerNoWsServerManager.on('message', (message: Message) => {
+            expect(message.messageId).toEqual('mockerer')
+            expect(wsServerManager.getConnection(biggerNoWsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_SERVER)
+            expect(biggerNoWsServerManager.getConnection(wsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_CLIENT)
+
+            done()
+        })
+
+        wsServerManager.send(dummyMessage)
+    })
+
     it('Can open connections to peer with server', async () => {
         const dummyMessage: Message = {
             serviceId,

package/test/integration/WebsocketConnectorRpc.test.ts

@@ -17,12 +17,12 @@ describe('WebsocketConnectorRpc', () => {
     let client2: ProtoRpcClient<WebsocketConnectorRpcClient>
 
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: generateId('peer1'),
+        nodeId: generateId('peer1'),
         type: NodeType.NODEJS
     }
 
     const peerDescriptor2: PeerDescriptor = {
-        kademliaId: generateId('peer2'),
+        nodeId: generateId('peer2'),
         type: NodeType.NODEJS
     }
 
@@ -67,16 +67,14 @@ describe('WebsocketConnectorRpc', () => {
         },
         { targetDescriptor: peerDescriptor2 },
         )
-        const res1 = await response1
-        expect(res1.accepted).toEqual(true)
-
+        await response1
+        
         const response2 = client2.requestConnection({
             ip: '127.0.0.1',
             port: 9111
         },
         { targetDescriptor: peerDescriptor1 },
         )
-        const res2 = await response2
-        expect(res2.accepted).toEqual(true)
+        await response2
     })
 })

package/test/unit/ConnectivityHelpers.test.ts

@@ -5,7 +5,7 @@ import { ConnectionType } from '../../src/connection/IConnection'
 describe('Connectivity helpers', () => {
 
     const tlsServerPeerDescriptor = {
-        kademliaId: new Uint8Array(1),
+        nodeId: new Uint8Array(1),
         type: NodeType.NODEJS,
         websocket: {
             host: 'mock',
@@ -15,7 +15,7 @@ describe('Connectivity helpers', () => {
     }
 
     const noTlsServerPeerDescriptor = {
-        kademliaId: new Uint8Array(1),
+        nodeId: new Uint8Array(1),
         type: NodeType.NODEJS,
         websocket: {
             host: 'mock',
@@ -25,12 +25,12 @@ describe('Connectivity helpers', () => {
     }
 
     const browserPeerDescriptor = {
-        kademliaId: new Uint8Array(2),
+        nodeId: new Uint8Array(2),
         type: NodeType.BROWSER
     }
 
     const noServerPeerDescriptor = {
-        kademliaId: new Uint8Array(3),
+        nodeId: new Uint8Array(3),
         type: NodeType.NODEJS
     }
 

package/test/unit/Finder.test.ts

@@ -1,39 +1,51 @@
 import {
+    FindAction,
     Message,
     MessageType,
     NodeType,
     PeerDescriptor,
     RouteMessageAck,
+    RouteMessageError,
     RouteMessageWrapper
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
+import { PeerID } from '../../src/helpers/PeerID'
 import {
     createWrappedClosestPeersRequest,
     createFindRequest
 } from '../utils/utils'
 import { Finder } from '../../src/dht/find/Finder'
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { v4 } from 'uuid'
 import { MockRouter } from '../utils/mock/Router'
 import { MockTransport } from '../utils/mock/Transport'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
+import { IRouter } from '../../src/dht/routing/Router'
+import { ITransport } from '../../src/exports'
 
+const createMockRouter = (error?: RouteMessageError): Partial<IRouter> => {
+    return {
+        doRouteMessage: (routedMessage: RouteMessageWrapper) => {
+            return {
+                requestId: routedMessage.requestId,
+                error
+            }
+        },
+        isMostLikelyDuplicate: () => false,
+        addToDuplicateDetector: () => {}
+    }
+}
 describe('Finder', () => {
 
-    let finder: Finder
-    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
-
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerid').value,
+        nodeId: PeerID.fromString('peerid').value,
         type: NodeType.NODEJS
     }
     const peerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('destination').value,
+        nodeId: PeerID.fromString('destination').value,
         type: NodeType.NODEJS
     }
-    const findRequest = createFindRequest(false)
+    const findRequest = createFindRequest(FindAction.NODE)
     const message: Message = {
         serviceId: 'unknown',
         messageId: v4(),
@@ -50,41 +62,41 @@ describe('Finder', () => {
         requestId: 'REQ',
         routingPath: [],
         reachableThrough: [],
-        destinationPeer: peerDescriptor1,
-        sourcePeer: peerDescriptor2
+        sourcePeer: peerDescriptor1,
+        destinationPeer: peerDescriptor2
     }
     const rpcCommunicator = new FakeRpcCommunicator()
 
-    beforeEach(() => {
-        connections = new Map()
-        finder = new Finder({
+    const createFinder = (router: IRouter = new MockRouter(), transport: ITransport = new MockTransport()): Finder => {
+        return new Finder({
             localPeerDescriptor: peerDescriptor1,
-            router: new MockRouter(),
-            connections,
+            router,
+            connections: new Map(),
             serviceId: 'Finder',
             localDataStore: new LocalDataStore(),
-            sessionTransport: new MockTransport(),
-            addContact: (_contact, _setActive) => {},
+            sessionTransport: transport,
+            addContact: () => {},
             isPeerCloserToIdThanSelf: (_peer1, _compareToId) => true,
             rpcCommunicator: rpcCommunicator as any
         })
-    })
-
-    afterEach(() => {
-        finder.stop()
-    })
+    }
 
     it('Finder server', async () => {
+        const finder = createFinder()
         const res = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage) as RouteMessageAck
-        expect(res.error).toEqual('')
+        expect(res.error).toBeUndefined()
+        finder.stop()
     })
 
     it('startFind with mode Node returns self if no peers', async () => {
+        const finder = createFinder()
         const res = await finder.startFind(PeerID.fromString('find').value)
         expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
+        finder.stop()
     })
 
     it('Finder server throws if payload is not FindRequest', async () => {
+        const finder = createFinder(new MockRouter())
         const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
         const badMessage: Message = {
             serviceId: 'unknown',
@@ -105,6 +117,40 @@ describe('Finder', () => {
             destinationPeer: peerDescriptor1,
             sourcePeer: peerDescriptor2
         })).rejects.toThrow()
+        finder.stop()
+    })
+
+    it('no targets', async () => {
+        const router = createMockRouter(RouteMessageError.NO_TARGETS)
+        const send = jest.fn()
+        const transport = { 
+            send,
+            on: () => {},
+            off: () => {}
+        }
+        const finder = createFinder(router as any, transport as any)
+        const ack = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage)
+        expect(ack).toEqual({
+            requestId: routedMessage.requestId,
+            error: RouteMessageError.NO_TARGETS
+        })
+        expect(send).toHaveBeenCalledTimes(1)
+        finder.stop()
     })
 
+    it('error', async () => {
+        const router = createMockRouter(RouteMessageError.DUPLICATE)
+        const send = jest.fn()
+        const transport = { 
+            send
+        }
+        const finder = createFinder(router as any, transport as any)
+        const ack = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage)
+        expect(ack).toEqual({
+            requestId: routedMessage.requestId,
+            error: RouteMessageError.DUPLICATE
+        })
+        expect(send).not.toHaveBeenCalled()
+        finder.stop()
+    })
 })

package/test/unit/LocalDataStore.test.ts

@@ -11,16 +11,16 @@ import { Timestamp } from '../../src/proto/google/protobuf/timestamp'
 
 describe('LocalDataStore', () => {
     let localDataStore: LocalDataStore
-    const storer1: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 2, 3]),
+    const creator1: PeerDescriptor = {
+        nodeId: new Uint8Array([1, 2, 3]),
         type: NodeType.NODEJS
     }
-    const storer2: PeerDescriptor = {
-        kademliaId: new Uint8Array([3, 2, 1]),
+    const creator2: PeerDescriptor = {
+        nodeId: new Uint8Array([3, 2, 1]),
         type: NodeType.NODEJS
     }
-    const data1 = Any.pack(storer1, PeerDescriptor)
-    const data2 = Any.pack(storer2, PeerDescriptor)
+    const data1 = Any.pack(creator1, PeerDescriptor)
+    const data2 = Any.pack(creator2, PeerDescriptor)
 
     beforeEach(() => {
         localDataStore = new LocalDataStore()
@@ -31,59 +31,59 @@ describe('LocalDataStore', () => {
     })
 
     it('can store', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1, 
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1, 
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, creator1)).toBeTrue()
         })
     })
 
     it('multiple storers behind one key', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, 
-            data: data1, ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, 
+            data: data1, ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, creator1)).toBeTrue()
         })
     })
 
     it('can remove data entries', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, data: data2,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.deleteEntry(dataKey, storer1)
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, data: data2,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.deleteEntry(dataKey, creator1)
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer2)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, creator2)).toBeTrue()
         })
     })
 
     it('can remove all data entries', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, data: data2,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.deleteEntry(dataKey, storer1)
-        localDataStore.deleteEntry(dataKey, storer2)
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, data: data2,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.deleteEntry(dataKey, creator1)
+        localDataStore.deleteEntry(dataKey, creator2)
         const fetchedData = localDataStore.getEntry(dataKey)
         expect(fetchedData.size).toBe(0)
     })
 
     it('data is deleted after TTL', async () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 1000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+            ttl: 1000, stale: false, deleted: false, createdAt: Timestamp.now() })
         const intitialStore = localDataStore.getEntry(dataKey)
         expect(intitialStore.size).toBe(1)
         await wait(1100)
@@ -91,15 +91,32 @@ describe('LocalDataStore', () => {
         expect(fetchedData.size).toBe(0)
     })
 
-    it('can mark data as deleted', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        const notDeletedData = localDataStore.getEntry(dataKey)
-        expect(notDeletedData.get(keyFromPeerDescriptor(storer1))!.deleted).toBeFalse()
-        localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(storer1))
-        const deletedData = localDataStore.getEntry(dataKey)
-        expect(deletedData.get(keyFromPeerDescriptor(storer1))!.deleted).toBeTrue()
-    })
+    describe('mark data as deleted', () => {
+
+        it('happy path', () => {
+            const dataKey = peerIdFromPeerDescriptor(creator1)
+            localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+                ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+            const notDeletedData = localDataStore.getEntry(dataKey)
+            expect(notDeletedData.get(keyFromPeerDescriptor(creator1))!.deleted).toBeFalse()
+            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator1))
+            expect(returnValue).toBe(true)
+            const deletedData = localDataStore.getEntry(dataKey)
+            expect(deletedData.get(keyFromPeerDescriptor(creator1))!.deleted).toBeTrue()
+        })
 
+        it('data not stored', () => {
+            const dataKey = peerIdFromPeerDescriptor(creator1)
+            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator2))
+            expect(returnValue).toBe(false)
+        })
+
+        it('data not stored by the given creator', () => {
+            const dataKey = peerIdFromPeerDescriptor(creator1)
+            localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+                ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator2))
+            expect(returnValue).toBe(false)
+        })
+    })
 })

package/test/unit/RandomContactList.test.ts

@@ -1,8 +1,8 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
 import { PeerID } from '../../src/helpers/PeerID'
 
-const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
-    return { getPeerId: () => PeerID.fromValue(kademliaId) }
+const createItem = (nodeId: Uint8Array): { getPeerId: () => PeerID } => {
+    return { getPeerId: () => PeerID.fromValue(nodeId) }
 }
 
 describe('RandomContactList', () => {

package/test/unit/Router.test.ts

@@ -2,7 +2,15 @@ import { v4 } from 'uuid'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { Router } from '../../src/dht/routing/Router'
 import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
-import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { 
+    Message,
+    MessageType,
+    NodeType,
+    PeerDescriptor,
+    RouteMessageAck,
+    RouteMessageError,
+    RouteMessageWrapper
+} from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createWrappedClosestPeersRequest } from '../utils/utils'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
 
@@ -11,11 +19,11 @@ describe('Router', () => {
 
     const peerId = PeerID.fromString('router')
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: peerId.value,
+        nodeId: peerId.value,
         type: NodeType.NODEJS
     }
     const peerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('destination').value,
+        nodeId: PeerID.fromString('destination').value,
         type: NodeType.NODEJS
     }
     const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
@@ -69,7 +77,7 @@ describe('Router', () => {
             reachableThrough: [],
             routingPath: []
         }) as RouteMessageAck
-        expect(ack.error).toEqual('No routing candidates found')
+        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
     })
 
     it('doRouteMessage with connections', async () => {
@@ -82,40 +90,40 @@ describe('Router', () => {
             reachableThrough: [],
             routingPath: []
         }) as RouteMessageAck
-        expect(ack.error).toEqual('')
+        expect(ack.error).toBeUndefined()
     })
 
     it('route server is destination without connections', async () => {
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('')
+        expect(ack.error).toBeUndefined()
     })
 
     it('route server with connections', async () => {
         connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('')
+        expect(ack.error).toBeUndefined()
     })
 
     it('route server on duplicate message', async () => {
         router.addToDuplicateDetector(routedMessage.requestId)
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('message given to routeMessage() service is likely a duplicate')
+        expect(ack.error).toEqual(RouteMessageError.DUPLICATE)
     })
 
     it('forward server no connections', async () => {
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('No routing candidates found')
+        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
     })
 
     it('forward server with connections', async () => {
         connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('')
+        expect(ack.error).toBeUndefined()
     })
 
     it('forward server on duplicate message', async () => {
         router.addToDuplicateDetector(routedMessage.requestId)
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('message given to forwardMessage() service is likely a duplicate')
+        expect(ack.error).toEqual(RouteMessageError.DUPLICATE)
     })
 })

package/test/unit/RoutingSession.test.ts

@@ -0,0 +1,76 @@
+import { v4 } from 'uuid'
+import { RoutingSession } from '../../src/dht/routing/RoutingSession'
+import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createWrappedClosestPeersRequest } from '../utils/utils'
+import { hexToBinary } from '@streamr/utils'
+import { PeerIDKey } from '../../src/helpers/PeerID'
+import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
+import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
+import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+
+describe('RoutingSession', () => {
+
+    let session: RoutingSession
+    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
+    let rpcCommunicator: RoutingRpcCommunicator
+
+    const mockPeerDescriptor1: PeerDescriptor = {
+        nodeId: hexToBinary('eee1'),
+        type: NodeType.NODEJS
+    }
+
+    const mockPeerDescriptor2 = {
+        nodeId: hexToBinary('eee2'),
+        type: NodeType.NODEJS
+    }
+
+    const rpcWrapper = createWrappedClosestPeersRequest(mockPeerDescriptor1)
+    const message: Message = {
+        serviceId: 'unknown',
+        messageId: v4(),
+        messageType: MessageType.RPC,
+        body: {
+            oneofKind: 'rpcMessage',
+            rpcMessage: rpcWrapper
+        },
+        sourceDescriptor: mockPeerDescriptor1,
+        targetDescriptor: mockPeerDescriptor2
+    }
+    const routedMessage: RouteMessageWrapper = {
+        message,
+        requestId: 'REQ',
+        routingPath: [],
+        reachableThrough: [],
+        destinationPeer: mockPeerDescriptor1,
+        sourcePeer: mockPeerDescriptor2
+    }
+
+    const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {
+        return new DhtNodeRpcRemote(mockPeerDescriptor1, destination, {} as any, 'router')
+    }
+
+    beforeEach(() => {
+        rpcCommunicator = new RoutingRpcCommunicator('mock', async () => {})
+        connections = new Map()
+        session = new RoutingSession(rpcCommunicator, mockPeerDescriptor1, routedMessage, connections, 2)
+    })
+
+    afterEach(() => {
+        rpcCommunicator.stop()
+        session.stop()
+    })
+
+    it('findMoreContacts', () => {
+        connections.set(keyFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        const contacts = session.updateAndGetRoutablePeers()
+        expect(contacts.length).toBe(1)
+    })
+
+    it('findMoreContacts peer disconnects', () => {
+        connections.set(keyFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        expect(session.updateAndGetRoutablePeers().length).toBe(1)
+        connections.delete(keyFromPeerDescriptor(mockPeerDescriptor2))
+        expect(session.updateAndGetRoutablePeers().length).toBe(0)
+    })
+
+})