@streamr/trackerless-network 100.0.0-testnet-three.5 → 100.0.0

package/test/benchmark/StreamPartIdDataKeyDistribution.test.ts

@@ -0,0 +1,60 @@
+/* eslint-disable no-console */
+
+import { groupBy, range } from 'lodash'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { DhtAddress } from '@streamr/dht'
+
+describe('StreamPartIdDataKeyDistribution', () => {
+
+    it('partitions are well distributed', () => {
+
+        const streamId = 'stream'
+        const dataKeys = range(100).map((i) => {
+            const streamPartId = StreamPartIDUtils.parse(streamId + '#' + i)
+            return streamPartIdToDataKey(streamPartId)
+        })
+        
+        const byInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0])
+        expect(Object.keys(byInitials).length).toEqual(16)
+        console.log(Object.values(byInitials).map((a) => a.length))
+    })
+
+    it('streamIds are well distributed', () => {
+        const dataKeys = range(10000).map(() => {
+            const streamPartId = StreamPartIDUtils.parse(Math.random().toString(32).substr(2, 32) + '#0')
+            return streamPartIdToDataKey(streamPartId)
+        })
+        const byInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0])
+        expect(Object.keys(byInitials).length).toEqual(16)
+        console.log(Object.values(byInitials).map((a) => a.length))
+    })
+
+    it('streamPartIds are well distributed', () => {
+        const streamIds = range(10000).map(() => Math.random().toString(32).substr(2, 32))
+        const dataKeys: DhtAddress[] = []
+        streamIds.forEach((streamId) => {
+            range(100).forEach((i) => {
+                const streamPartId = StreamPartIDUtils.parse(streamId + '#' + i)
+                dataKeys.push(streamPartIdToDataKey(streamPartId))
+            })
+        })
+
+        const byInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0])
+        expect(Object.keys(byInitials).length).toEqual(16)
+        console.log(Object.values(byInitials).map((a) => a.length))
+    
+        const byTwoInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0] + dataKey[1])
+        expect(Object.keys(byTwoInitials).length).toEqual(16 * 16)
+        console.log(Object.values(byTwoInitials).map((a) => a.length))
+
+        const byThreeInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0] + dataKey[1] + dataKey[2])
+        expect(Object.keys(byThreeInitials).length).toEqual(16 * 16 * 16)
+        console.log(Object.values(byThreeInitials).map((a) => a.length))
+
+        const byFourInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0] + dataKey[1] + dataKey[2] + dataKey[3])
+        expect(Object.keys(byFourInitials).length).toEqual(16 * 16 * 16 * 16)
+        console.log(Object.values(byFourInitials).map((a) => a.length))
+    })
+
+})

package/test/benchmark/first-message.ts

@@ -155,7 +155,7 @@ run().then(() => {
     console.error(err)
     const streamrNode = currentNode.stack.getStreamrNode()
     const streamParts = streamrNode.getStreamParts()
-    const foundData = nodes[0].stack.getLayer0Node().getDataFromDht(streamPartIdToDataKey(streamParts[0]))
+    const foundData = nodes[0].stack.getLayer0Node().fetchDataFromDht(streamPartIdToDataKey(streamParts[0]))
     console.log(foundData)
     const layer0Node = currentNode.stack.getLayer0Node() as DhtNode
     console.log(layer0Node.getNeighbors().length)

package/test/end-to-end/proxy-key-exchange.test.ts

@@ -1,17 +1,20 @@
 import {
     ContentType,
     EncryptionType,
-    GroupKeyRequest,
-    GroupKeyResponse,
     MessageID,
-    serializeGroupKeyRequest,
-    serializeGroupKeyResponse, SignatureType,
+    GroupKeyRequest as OldGroupKeyRequest,
+    GroupKeyResponse as OldGroupKeyResponse,
+    SignatureType,
     StreamMessage,
     StreamMessageType,
     StreamPartIDUtils
 } from '@streamr/protocol'
 import { hexToBinary, toEthereumAddress, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
+import {
+    convertGroupKeyRequestToBytes,
+    convertGroupKeyResponseToBytes
+} from '../../src/logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
@@ -72,7 +75,7 @@ describe('proxy group key exchange', () => {
         await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
         await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
-        const groupKeyRequest = new GroupKeyRequest({
+        const groupKeyRequest = new OldGroupKeyRequest({
             recipient: publisherUserId,
             requestId: 'requestId',
             rsaPublicKey: 'mockKey',
@@ -90,9 +93,9 @@ describe('proxy group key exchange', () => {
                 '0'
             ),
             messageType: StreamMessageType.GROUP_KEY_REQUEST,
-            contentType: ContentType.JSON,
+            contentType: ContentType.BINARY,
             encryptionType: EncryptionType.NONE,
-            content: serializeGroupKeyRequest(groupKeyRequest),
+            content: convertGroupKeyRequestToBytes(groupKeyRequest),
             signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('1234')
         })
@@ -107,7 +110,7 @@ describe('proxy group key exchange', () => {
         await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
         await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
-        const groupKeyResponse = new GroupKeyResponse({
+        const groupKeyResponse = new OldGroupKeyResponse({
             recipient: publisherUserId,
             requestId: 'requestId',
             encryptedGroupKeys: []
@@ -122,9 +125,9 @@ describe('proxy group key exchange', () => {
                 '0'
             ),
             messageType: StreamMessageType.GROUP_KEY_RESPONSE,
-            contentType: ContentType.JSON,
+            contentType: ContentType.BINARY,
             encryptionType: EncryptionType.NONE,
-            content: serializeGroupKeyResponse(groupKeyResponse),
+            content: convertGroupKeyResponseToBytes(groupKeyResponse),
             signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('1234')
         })

package/test/integration/Handshakes.test.ts

@@ -11,7 +11,6 @@ import {
     HandshakeRpcClient
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../../src/logic/NodeList'
-import { mockConnectionLocker } from '../utils/utils'
 import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
 import { StreamPartIDUtils } from '@streamr/protocol'
@@ -33,8 +32,10 @@ describe('Handshakes', () => {
     let rpcCommunicator1: ListeningRpcCommunicator
     let rpcCommunicator2: ListeningRpcCommunicator
     let rpcCommunicator3: ListeningRpcCommunicator
-    let nodeView: NodeList
     let neighbors: NodeList
+    let leftNodeView: NodeList
+    let rightNodeView: NodeList
+    let nodeView: NodeList
     let handshaker: Handshaker
     const streamPartId = StreamPartIDUtils.parse('stream#0')
 
@@ -82,6 +83,8 @@ describe('Handshakes', () => {
         rpcCommunicator3 = new ListeningRpcCommunicator(streamPartId, simulatorTransport3)
 
         const handshakerNodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
+        leftNodeView = new NodeList(handshakerNodeId, 10)
+        rightNodeView = new NodeList(handshakerNodeId, 10)
         nodeView = new NodeList(handshakerNodeId, 10)
         neighbors = new NodeList(handshakerNodeId, 4)
         handshaker = new Handshaker({
@@ -89,8 +92,9 @@ describe('Handshakes', () => {
             streamPartId,
             nearbyNodeView: nodeView,
             randomNodeView: nodeView,
+            leftNodeView,
+            rightNodeView,
             neighbors,
-            connectionLocker: mockConnectionLocker,
             rpcCommunicator: rpcCommunicator2,
             maxNeighborCount: 4,
             ongoingHandshakes: new Set()

package/test/integration/NetworkNode.test.ts

@@ -98,12 +98,16 @@ describe('NetworkNode', () => {
         await node2.join(STREAM_PART_ID)
         const result1 = await node1.fetchNodeInfo(pd2)
         const result2 = await node2.fetchNodeInfo(pd1)
+        const result3 = await node1.fetchNodeInfo(node1.getPeerDescriptor())
         expect(result1.streamPartitions.length).toEqual(1)
         expect(result2.streamPartitions.length).toEqual(1)
-        expect(result1.controlLayer!.connections.length).toEqual(1)
-        expect(result2.controlLayer!.connections.length).toEqual(1)
-        expect(result1.controlLayer!.neighbors.length).toEqual(1)
-        expect(result2.controlLayer!.neighbors.length).toEqual(1)
+        expect(result3.streamPartitions.length).toEqual(1)
+        expect(result1.controlLayer.connections.length).toEqual(1)
+        expect(result2.controlLayer.connections.length).toEqual(1)
+        expect(result3.controlLayer.connections.length).toEqual(1)
+        expect(result1.controlLayer.neighbors.length).toEqual(1)
+        expect(result2.controlLayer.neighbors.length).toEqual(1)
+        expect(result3.controlLayer.neighbors.length).toEqual(1)
     })
 
 })

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -119,7 +119,7 @@ describe('stream without default entrypoints', () => {
             await nodes[i].join(STREAM_PART_ID, { minCount: (i > 0) ? 1 : 0, timeout: 15000 })
         }
         await waitForCondition(async () => {
-            const entryPointData = await nodes[15].stack.getLayer0Node().getDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
+            const entryPointData = await nodes[15].stack.getLayer0Node().fetchDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
             return entryPointData.length >= 7
         }, 15000)
         

package/test/integration/streamEntryPointReplacing.test.ts

@@ -68,20 +68,20 @@ describe('Stream Entry Points are replaced when known entry points leave streams
         simulator.stop()
     })
 
+    // TODO: Investigate why 60 second timeouts are needed
     it('stream entry points are replaced when nodes leave streams', async () => {
-        // TODO: Investigate why CI needs more than 15 seconds to find 4 neighbors for the stream.
-        await Promise.all(initialNodesOnStream.map((node) => node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 30000 })))
+        await Promise.all(initialNodesOnStream.map((node) => node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 60000 })))
 
         let receivedMessages = 0
         for (const node of laterNodesOnStream) {
-            await node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 30000 }) 
+            await node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 60000 }) 
             node.getStreamrNode().on('newMessage', () => {
                 receivedMessages += 1
             })
         }
 
         await Promise.all(initialNodesOnStream.map((node) => node.getStreamrNode().leaveStreamPart(STREAM_PART_ID)))
-        await waitForCondition(() => laterNodesOnStream.every((node) => node.getStreamrNode().getNeighbors(STREAM_PART_ID).length >= 4), 30000, 1000)
+        await waitForCondition(() => laterNodesOnStream.every((node) => node.getStreamrNode().getNeighbors(STREAM_PART_ID).length >= 4), 60000, 1000)
 
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
@@ -89,6 +89,6 @@ describe('Stream Entry Points are replaced when known entry points leave streams
             randomEthereumAddress()
         )
         newNodeInStream.getStreamrNode().broadcast(msg)
-        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 15000)
+        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 30000)
     }, 200000)
 })

package/test/unit/EntrypointDiscovery.test.ts

@@ -37,7 +37,7 @@ describe('EntryPointDiscovery', () => {
         deleted: true
     }
 
-    const fakeGetEntryPointData = async (): Promise<DataEntry[]> => {
+    const fakeFetchEntryPointData = async (): Promise<DataEntry[]> => {
         return [fakeData, fakeDeletedData]
     }
 
@@ -46,7 +46,7 @@ describe('EntryPointDiscovery', () => {
         return [peerDescriptor]
     }
 
-    const fakeEmptyGetEntryPointData = async (): Promise<DataEntry[]> => {
+    const fakeEmptyFetchEntryPointData = async (): Promise<DataEntry[]> => {
         return []
     }
 
@@ -70,7 +70,7 @@ describe('EntryPointDiscovery', () => {
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
             layer1Node,
-            getEntryPointData: fakeGetEntryPointData,
+            fetchEntryPointData: fakeFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
             storeInterval: 2000
@@ -79,7 +79,7 @@ describe('EntryPointDiscovery', () => {
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
             layer1Node,
-            getEntryPointData: fakeEmptyGetEntryPointData,
+            fetchEntryPointData: fakeEmptyFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
             storeInterval: 2000

package/test/unit/HandshakeRpcLocal.test.ts

@@ -2,7 +2,7 @@ import { DhtAddress, NodeType, getNodeIdFromPeerDescriptor, getRawFromDhtAddress
 import { NodeList } from '../../src/logic/NodeList'
 import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
 import { InterleaveRequest, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
@@ -26,7 +26,6 @@ describe('HandshakeRpcLocal', () => {
 
         rpcLocal = new HandshakeRpcLocal({
             streamPartId: STREAM_PART_ID,
-            connectionLocker: mockConnectionLocker,
             ongoingHandshakes,
             ongoingInterleaves,
             createRpcRemote: (_p) => createMockHandshakeRpcRemote(),
@@ -149,4 +148,21 @@ describe('HandshakeRpcLocal', () => {
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)
     })
 
+    it('rejects handshakes if the requestor has more than maxNeighborCount neighbors', async () => {
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        const req = StreamPartHandshakeRequest.create({
+            streamPartId: STREAM_PART_ID,
+            requestId: 'requestId'
+        })
+        const res = await rpcLocal.handshake(req, {
+            incomingSourceDescriptor: createMockPeerDescriptor()
+        } as any)
+        expect(res.accepted).toEqual(false)
+        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)
+    })
+
 })

package/test/unit/Handshaker.test.ts

@@ -2,7 +2,7 @@ import { ListeningRpcCommunicator, Simulator, SimulatorTransport, getNodeIdFromP
 import { range } from 'lodash'
 import { NodeList } from '../../src/logic/NodeList'
 import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { createMockPeerDescriptor, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockDeliveryRpcRemote } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshaker', () => {
@@ -14,6 +14,8 @@ describe('Handshaker', () => {
     const streamPartId = StreamPartIDUtils.parse('stream#0')
 
     let neighbors: NodeList
+    let leftNodeView: NodeList
+    let rightNodeView: NodeList
     let nearbyNodeView: NodeList
     let randomNodeView: NodeList
 
@@ -28,14 +30,17 @@ describe('Handshaker', () => {
 
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         neighbors = new NodeList(nodeId, 10)
+        leftNodeView = new NodeList(nodeId, 20)
+        rightNodeView = new NodeList(nodeId, 20)
         nearbyNodeView = new NodeList(nodeId, 20)
         randomNodeView = new NodeList(nodeId, 20)
 
         handshaker = new Handshaker({
             localPeerDescriptor: peerDescriptor,
             streamPartId,
-            connectionLocker: mockConnectionLocker,
             neighbors,
+            leftNodeView,
+            rightNodeView,
             nearbyNodeView,
             randomNodeView,
             rpcCommunicator,
@@ -56,7 +61,7 @@ describe('Handshaker', () => {
     })
 
     it('attemptHandshakesOnContact with known nodes that cannot be connected to', async () => {
-        range(2).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
+        range(2).forEach(() => randomNodeView.add(createMockDeliveryRpcRemote()))
         const res = await handshaker.attemptHandshakesOnContacts([])
         expect(res.length).toEqual(2)
     })

package/test/unit/NeighborFinder.test.ts

@@ -31,6 +31,9 @@ describe('NeighborFinder', () => {
         neighborFinder = new NeighborFinder({
             neighbors,
             nearbyNodeView,
+            leftNodeView: new NodeList(nodeId, 30),
+            rightNodeView: new NodeList(nodeId, 30),
+            randomNodeView: new NodeList(nodeId, 30),
             doFindNeighbors: (excluded) => mockDoFindNeighbors(excluded),
             minCount
         })

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -40,9 +40,6 @@ describe('NeighborUpdateRpcLocal', () => {
         neighborFinder = {
             start: jest.fn()
         } as any
-        const connectionLocker = {
-            unlockConnection: jest.fn()
-        } as any
         ongoingHandshakes = new Set()
 
         rpcLocal = new NeighborUpdateRpcLocal({
@@ -53,7 +50,6 @@ describe('NeighborUpdateRpcLocal', () => {
             streamPartId,
             rpcCommunicator,
             neighborTargetCount,
-            connectionLocker,
             ongoingHandshakes
         })
     })

package/test/unit/Propagation.test.ts

@@ -3,8 +3,7 @@ import {
     EncryptionType,
     MessageID,
     SignatureType,
-    StreamMessage,
-    StreamMessageType,
+    StreamMessage
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { Propagation } from '../../src/logic/propagation/Propagation'
 import { hexToBinary, toEthereumAddress, utf8ToBinary, wait } from '@streamr/utils'
@@ -23,12 +22,16 @@ function makeMsg(streamId: string, partition: number, ts: number, msgNo: number)
     }
     return {
         messageId,
-        content: new Uint8Array([1]),
-        contentType: ContentType.JSON,
-        encryptionType: EncryptionType.NONE,
         signature: hexToBinary('0x1111'),
-        messageType: StreamMessageType.MESSAGE,
-        signatureType: SignatureType.SECP256K1
+        signatureType: SignatureType.SECP256K1,
+        body: {
+            oneofKind: 'contentMessage',
+            contentMessage: {
+                content: new Uint8Array([1]),
+                contentType: ContentType.JSON,
+                encryptionType: EncryptionType.NONE
+            }
+        }
     }
 }
 

package/test/unit/StreamMessageTranslator.test.ts

@@ -9,7 +9,6 @@ import {
 } from '@streamr/protocol'
 import { binaryToHex, binaryToUtf8, hexToBinary, toEthereumAddress, utf8ToBinary } from '@streamr/utils'
 import { StreamMessageTranslator } from '../../src/logic/protocol-integration/stream-message/StreamMessageTranslator'
-import { StreamMessageType } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createStreamMessage } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('TEST#0')
@@ -49,10 +48,10 @@ describe('StreamMessageTranslator', () => {
         expect(translated.messageId!.sequenceNumber).toEqual(0)
         expect(binaryToHex(translated.messageId!.publisherId, true)).toEqual('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
         expect(translated.previousMessageRef).toEqual(undefined)
-        expect(translated.messageType).toEqual(StreamMessageType.MESSAGE)
-        expect(translated.groupKeyId).toEqual(undefined)
+        expect(translated.body.oneofKind).toEqual('contentMessage')
+        expect((translated.body as any).contentMessage.groupKeyId).toEqual(undefined)
         expect(translated.signature).toStrictEqual(signature)
-        expect(JSON.parse(binaryToUtf8(translated.content))).toEqual({ hello: 'WORLD' })
+        expect(JSON.parse(binaryToUtf8((translated.body as any).contentMessage.content))).toEqual({ hello: 'WORLD' })
     })
 
     it('translates protobuf to old protocol', () => {

package/test/unit/StreamPartIDDataKey.test.ts

@@ -0,0 +1,12 @@
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
+
+describe('StreamPartIDtoDataKey', () => {
+
+    it('generated key length is correct (160 bits)', () => {
+        const streamPartId = StreamPartIDUtils.parse('stream#0')
+        const dataKey = streamPartIdToDataKey(streamPartId)
+        expect(dataKey.length).toEqual(40)
+    })
+
+})

package/test/unit/TemporaryConnectionRpcLocal.test.ts

@@ -1,3 +1,4 @@
+import { StreamPartIDUtils } from '@streamr/protocol'
 import { TemporaryConnectionRpcLocal } from '../../src/logic/temporary-connection/TemporaryConnectionRpcLocal'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -13,7 +14,12 @@ describe('TemporaryConnectionRpcLocal', () => {
         rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
         rpcLocal = new TemporaryConnectionRpcLocal({
             localPeerDescriptor: peerDescriptor,
-            rpcCommunicator
+            rpcCommunicator,
+            streamPartId: StreamPartIDUtils.parse('mock#0'),
+            connectionLocker: {
+                weakLockConnection: jest.fn(),
+                weakUnlockConnection: jest.fn()
+            } as any
         })
     })
 

package/test/utils/mock/MockLayer0Node.ts

@@ -26,7 +26,7 @@ export class MockLayer0Node extends EventEmitter implements Layer0Node {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    async getDataFromDht(): Promise<DataEntry[]> {
+    async fetchDataFromDht(): Promise<DataEntry[]> {
         return []
     }
 

package/test/utils/mock/MockLayer1Node.ts

@@ -31,6 +31,9 @@ export class MockLayer1Node extends EventEmitter implements Layer1Node {
     // eslint-disable-next-line class-methods-use-this
     async joinDht(): Promise<void> {}
 
+    // eslint-disable-next-line class-methods-use-this
+    async joinRing(): Promise<void> {}
+
     // eslint-disable-next-line class-methods-use-this
     async start(): Promise<void> {}
 

package/test/utils/utils.ts

@@ -15,8 +15,7 @@ import {
     EncryptionType,
     MessageID,
     SignatureType,
-    StreamMessage,
-    StreamMessageType
+    StreamMessage
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
@@ -78,13 +77,17 @@ export const createStreamMessage = (
         messageChainId: 'messageChain0',
     }
     const msg: StreamMessage = {
-        messageType: StreamMessageType.MESSAGE,
-        encryptionType: EncryptionType.NONE,
-        content: utf8ToBinary(content),
-        contentType: ContentType.JSON,
         messageId,
-        signature: hexToBinary('0x1234'),
         signatureType: SignatureType.SECP256K1,
+        signature: hexToBinary('0x1234'),
+        body: {
+            oneofKind: 'contentMessage',
+            contentMessage: {
+                encryptionType: EncryptionType.NONE,
+                contentType: ContentType.JSON,
+                content: utf8ToBinary(content)
+            }
+        }
     }
     return msg
 }

package/test/unit/GroupKeyRequestTranslator.test.ts

@@ -1,36 +0,0 @@
-import { GroupKeyRequest as OldGroupKeyRequest } from '@streamr/protocol'
-import { hexToBinary, toEthereumAddress, utf8ToBinary } from '@streamr/utils'
-import { GroupKeyRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { GroupKeyRequestTranslator } from '../../src/logic/protocol-integration/stream-message/GroupKeyRequestTranslator'
-
-describe('GroupKeyRequestTranslator', () => {
-
-    const oldGroupKeyRequest = new OldGroupKeyRequest({
-        rsaPublicKey: 'aaaaaaaa',
-        recipient: toEthereumAddress('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
-        requestId: 'request',
-        groupKeyIds: ['id1', 'id2', 'id3']
-    })
-    const newGroupKeyRequest: GroupKeyRequest = {
-        rsaPublicKey: utf8ToBinary('aaaaaaaa'),
-        recipientId: hexToBinary('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
-        requestId: 'request',
-        groupKeyIds: ['id1', 'id2', 'id3']
-    }
-
-    it('translates old protocol to protobuf', () => {
-        const translated = GroupKeyRequestTranslator.toProtobuf(oldGroupKeyRequest)
-        expect(translated.rsaPublicKey).toEqual(newGroupKeyRequest.rsaPublicKey)
-        expect(translated.recipientId).toEqual(newGroupKeyRequest.recipientId)
-        expect(translated.requestId).toEqual(newGroupKeyRequest.requestId)
-        expect(translated.groupKeyIds).toEqual(newGroupKeyRequest.groupKeyIds)
-    })
-
-    it('translates protobuf to old protocol', () => {
-        const translated = GroupKeyRequestTranslator.toClientProtocol(newGroupKeyRequest)
-        expect(translated.rsaPublicKey).toEqual(oldGroupKeyRequest.rsaPublicKey)
-        expect(translated.recipient).toEqual(oldGroupKeyRequest.recipient)
-        expect(translated.requestId).toEqual(oldGroupKeyRequest.requestId)
-        expect(translated.groupKeyIds).toEqual(oldGroupKeyRequest.groupKeyIds)
-    })
-})