@streamr/trackerless-network 0.0.1-tatum.7 → 100.0.0-pretestnet.0

package/test/integration/Propagation.test.ts

@@ -1,14 +1,15 @@
-import { DhtNode, Simulator } from '@streamr/dht'
+import { Simulator } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createMockPeerDescriptor, createMockRandomGraphNodeAndDhtNode, createStreamMessage } from '../utils/utils'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 
 describe('Propagation', () => {
     const entryPointDescriptor = createMockPeerDescriptor()
-    let dhtNodes: DhtNode[]
+    let layer1Nodes: Layer1Node[]
     let randomGraphNodes: RandomGraphNode[]
     const STREAM_PART_ID = StreamPartIDUtils.parse('testingtesting#0')
     let totalReceived: number
@@ -17,38 +18,38 @@ describe('Propagation', () => {
     beforeEach(async () => {
         totalReceived = 0
         const simulator = new Simulator()
-        dhtNodes = []
+        layer1Nodes = []
         randomGraphNodes = []
         const [entryPoint, node1] = await createMockRandomGraphNodeAndDhtNode(entryPointDescriptor, entryPointDescriptor, STREAM_PART_ID, simulator)
         await entryPoint.start()
         await entryPoint.joinDht([entryPointDescriptor])
         await node1.start()
         node1.on('message', () => {totalReceived += 1})
-        dhtNodes.push(entryPoint)
+        layer1Nodes.push(entryPoint)
         randomGraphNodes.push(node1)
 
         await Promise.all(range(NUM_OF_NODES).map(async (_i) => {
             const descriptor = createMockPeerDescriptor()
-            const [dht, graph] = await createMockRandomGraphNodeAndDhtNode(
+            const [layer1, randomGraphNode] = await createMockRandomGraphNodeAndDhtNode(
                 descriptor,
                 entryPointDescriptor,
                 STREAM_PART_ID,
                 simulator
             )
-            await dht.start()
-            await graph.start()
+            await layer1.start()
+            await randomGraphNode.start()
             // eslint-disable-next-line promise/always-return
-            await dht.joinDht([entryPointDescriptor]).then(() => {
-                graph.on('message', () => { totalReceived += 1 })
-                dhtNodes.push(dht)
-                randomGraphNodes.push(graph)
+            await layer1.joinDht([entryPointDescriptor]).then(() => {
+                randomGraphNode.on('message', () => { totalReceived += 1 })
+                layer1Nodes.push(layer1)
+                randomGraphNodes.push(randomGraphNode)
             })
         }))
     }, 45000)
 
     afterEach(async () => {
         await Promise.all(randomGraphNodes.map((node) => node.stop()))
-        await Promise.all(dhtNodes.map((node) => node.stop()))
+        await Promise.all(layer1Nodes.map((node) => node.stop()))
     })
 
     it('All nodes receive messages', async () => {

package/test/integration/RandomGraphNode-Layer1Node-Latencies.test.ts

@@ -5,11 +5,12 @@ import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 
 describe('RandomGraphNode-DhtNode-Latencies', () => {
     const numOfNodes = 64
-    let dhtNodes: DhtNode[]
-    let dhtEntryPoint: DhtNode
+    let layer1Nodes: Layer1Node[]
+    let dhtEntryPoint: Layer1Node
     let entryPointRandomGraphNode: RandomGraphNode
     let graphNodes: RandomGraphNode[]
 
@@ -32,41 +33,41 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
-        dhtNodes = range(numOfNodes).map((i) => new DhtNode({
+        layer1Nodes = range(numOfNodes).map((i) => new DhtNode({
             transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
         graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
             streamPartId,
-            layer1: dhtNodes[i],
-            P2PTransport: cms[i],
+            layer1Node: layer1Nodes[i],
+            transport: cms[i],
             connectionLocker: cms[i],
             ownPeerDescriptor: peerDescriptors[i]
         }))
         entryPointRandomGraphNode = createRandomGraphNode({
             streamPartId,
-            layer1: dhtEntryPoint,
-            P2PTransport: entrypointCm,
+            layer1Node: dhtEntryPoint,
+            transport: entrypointCm,
             connectionLocker: entrypointCm,
             ownPeerDescriptor: entrypointDescriptor
         })
 
         await dhtEntryPoint.start()
         await dhtEntryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(dhtNodes.map((node) => node.start()))
+        await Promise.all(layer1Nodes.map((node) => node.start()))
     })
 
     afterEach(async () => {
         dhtEntryPoint.stop()
         entryPointRandomGraphNode.stop()
-        await Promise.all(dhtNodes.map((node) => node.stop()))
+        await Promise.all(layer1Nodes.map((node) => node.stop()))
         await Promise.all(graphNodes.map((node) => node.stop()))
         Simulator.useFakeTimers(false)
     })
 
     it('happy path single node', async () => {
-        await dhtNodes[0].joinDht([entrypointDescriptor])
+        await layer1Nodes[0].joinDht([entrypointDescriptor])
         entryPointRandomGraphNode.start()
         await graphNodes[0].start()
         await Promise.all([
@@ -81,7 +82,7 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         entryPointRandomGraphNode.start()
         range(4).forEach((i) => graphNodes[i].start())
         await Promise.all(range(4).map(async (i) => {
-            await dhtNodes[i].joinDht([entrypointDescriptor])
+            await layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(range(4).map((i) => {
             return waitForCondition(() => {
@@ -109,7 +110,7 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
     it('happy path 64 nodes', async () => {
         await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
         await Promise.all(range(numOfNodes).map((i) => {
-            dhtNodes[i].joinDht([entrypointDescriptor])
+            layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(graphNodes.map((node) =>
             waitForCondition(() => node.getTargetNeighborIds().length >= 4, 10000)

package/test/integration/RandomGraphNode-Layer1Node.test.ts

@@ -5,13 +5,14 @@ import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 
 const logger = new Logger(module)
 
 describe('RandomGraphNode-DhtNode', () => {
     const numOfNodes = 64
-    let dhtNodes: DhtNode[]
-    let dhtEntryPoint: DhtNode
+    let layer1Nodes: Layer1Node[]
+    let dhtEntryPoint: Layer1Node
     let entryPointRandomGraphNode: RandomGraphNode
     let graphNodes: RandomGraphNode[]
 
@@ -49,7 +50,7 @@ describe('RandomGraphNode-DhtNode', () => {
             serviceId: streamPartId
         })
 
-        dhtNodes = range(numOfNodes).map((i) => new DhtNode({
+        layer1Nodes = range(numOfNodes).map((i) => new DhtNode({
             transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
@@ -57,8 +58,8 @@ describe('RandomGraphNode-DhtNode', () => {
 
         graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
             streamPartId,
-            layer1: dhtNodes[i],
-            P2PTransport: cms[i],
+            layer1Node: layer1Nodes[i],
+            transport: cms[i],
             connectionLocker: cms[i],
             ownPeerDescriptor: peerDescriptors[i],
             neighborUpdateInterval: 2000
@@ -66,8 +67,8 @@ describe('RandomGraphNode-DhtNode', () => {
 
         entryPointRandomGraphNode = createRandomGraphNode({
             streamPartId,
-            layer1: dhtEntryPoint,
-            P2PTransport: entrypointCm,
+            layer1Node: dhtEntryPoint,
+            transport: entrypointCm,
             connectionLocker: entrypointCm,
             ownPeerDescriptor: entrypointDescriptor,
             neighborUpdateInterval: 2000
@@ -75,20 +76,20 @@ describe('RandomGraphNode-DhtNode', () => {
 
         await dhtEntryPoint.start()
         await dhtEntryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(dhtNodes.map((node) => node.start()))
+        await Promise.all(layer1Nodes.map((node) => node.start()))
     })
 
     afterEach(async () => {
         await dhtEntryPoint.stop()
         entryPointRandomGraphNode.stop()
-        await Promise.all(dhtNodes.map((node) => node.stop()))
+        await Promise.all(layer1Nodes.map((node) => node.stop()))
         await Promise.all(graphNodes.map((node) => node.stop()))
         Simulator.useFakeTimers(false)
     })
 
     it('happy path single node ', async () => {
         await entryPointRandomGraphNode.start()
-        await dhtNodes[0].joinDht([entrypointDescriptor])
+        await layer1Nodes[0].joinDht([entrypointDescriptor])
 
         await graphNodes[0].start()
 
@@ -101,7 +102,7 @@ describe('RandomGraphNode-DhtNode', () => {
         entryPointRandomGraphNode.start()
         range(4).forEach((i) => graphNodes[i].start())
         await Promise.all(range(4).map(async (i) => {
-            await dhtNodes[i].joinDht([entrypointDescriptor])
+            await layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
 
         await waitForCondition(() => range(4).every((i) => graphNodes[i].getTargetNeighborIds().length === 4))
@@ -126,7 +127,7 @@ describe('RandomGraphNode-DhtNode', () => {
     it('happy path 64 nodes', async () => {
         await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
         await Promise.all(range(numOfNodes).map((i) => {
-            dhtNodes[i].joinDht([entrypointDescriptor])
+            layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(graphNodes.map((node) =>
             waitForCondition(() => node.getTargetNeighborIds().length >= 4, 10000)

package/test/integration/StreamrNode.test.ts

@@ -10,11 +10,12 @@ import { waitForEvent3, waitForCondition } from '@streamr/utils'
 import { createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
+import { Layer0Node } from '../../src/logic/Layer0Node'
 
 describe('StreamrNode', () => {
 
-    let layer01: DhtNode
-    let layer02: DhtNode
+    let layer0Node1: Layer0Node
+    let layer0Node2: Layer0Node
     let transport1: SimulatorTransport
     let transport2: SimulatorTransport
     let node1: StreamrNode
@@ -49,30 +50,30 @@ describe('StreamrNode', () => {
         await transport1.start()
         transport2 = new SimulatorTransport(peerDescriptor2, simulator)
         await transport2.start()
-        layer01 = new DhtNode({
+        layer0Node1 = new DhtNode({
             transport: transport1,
             peerDescriptor: peerDescriptor1,
             entryPoints: [peerDescriptor1]
         })
-        layer02 = new DhtNode({
+        layer0Node2 = new DhtNode({
             transport: transport2,
             peerDescriptor: peerDescriptor2,
             entryPoints: [peerDescriptor1]
         })
         await Promise.all([
-            layer01.start(),
-            layer02.start()
+            layer0Node1.start(),
+            layer0Node2.start()
         ])
         await Promise.all([
-            layer01.joinDht([peerDescriptor1]),
-            layer02.joinDht([peerDescriptor1])
+            layer0Node1.joinDht([peerDescriptor1]),
+            layer0Node2.joinDht([peerDescriptor1])
         ])
 
         node1 = new StreamrNode({})
         node2 = new StreamrNode({})
-        await node1.start(layer01, transport1, transport1)
+        await node1.start(layer0Node1, transport1, transport1)
         node1.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
-        await node2.start(layer02, transport2, transport2)
+        await node2.start(layer0Node2, transport2, transport2)
         node2.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
     })
 

package/test/integration/joining-streams-on-offline-peers.test.ts

@@ -86,8 +86,8 @@ describe('Joining stream parts on offline nodes', () => {
         let messageReceived = false
 
         // store offline peer descriptors to DHT
-        await entryPoint.getLayer0DhtNode().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor1, PeerDescriptor))
-        await entryPoint.getLayer0DhtNode().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor2, PeerDescriptor))
+        await entryPoint.getLayer0Node().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor1, PeerDescriptor))
+        await entryPoint.getLayer0Node().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor2, PeerDescriptor))
         
         node1.getStreamrNode().joinStreamPart(STREAM_PART_ID)
         node1.getStreamrNode().on('newMessage', () => { messageReceived = true })

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.getLayer0DhtNode().getDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
+            const entryPointData = await nodes[15].stack.getLayer0Node().getDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
             return entryPointData.length >= 7
         }, 15000)
         

package/test/unit/EntrypointDiscovery.test.ts

@@ -5,7 +5,7 @@ import { range } from 'lodash'
 import { EntryPointDiscovery } from '../../src/logic/EntryPointDiscovery'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { DataEntry } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { MockLayer1 } from '../utils/mock/MockLayer1'
+import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
@@ -52,7 +52,7 @@ describe('EntryPointDiscovery', () => {
 
     const fakeDeleteEntryPointData = async (): Promise<void> => {}
 
-    const addNodesToStreamPart = (layer1: MockLayer1, count: number) => {
+    const addNodesToStreamPart = (layer1: MockLayer1Node, count: number) => {
         range(count).forEach(() => {
             layer1.addNewRandomPeerToKBucket()
             layer1.addNewRandomPeerToKBucket()
@@ -61,15 +61,15 @@ describe('EntryPointDiscovery', () => {
         })
     } 
 
-    let layer1: MockLayer1
+    let layer1Node: MockLayer1Node
 
     beforeEach(() => {
         storeCalled = 0
-        layer1 = new MockLayer1()
+        layer1Node = new MockLayer1Node()
         entryPointDiscoveryWithData = new EntryPointDiscovery({
             ownPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
-            layer1,
+            layer1Node,
             getEntryPointData: fakeGetEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
@@ -78,7 +78,7 @@ describe('EntryPointDiscovery', () => {
         entryPointDiscoveryWithoutData = new EntryPointDiscovery({
             ownPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
-            layer1,
+            layer1Node,
             getEntryPointData: fakeEmptyGetEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
@@ -115,7 +115,7 @@ describe('EntryPointDiscovery', () => {
     })
 
     it('store on stream without saturated entrypoint count', async () => {
-        addNodesToStreamPart(layer1, 4)
+        addNodesToStreamPart(layer1Node, 4)
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
     })

package/test/unit/RandomGraphNode.test.ts

@@ -4,7 +4,7 @@ import { NodeList } from '../../src/logic/NodeList'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
 import { MockHandshaker } from '../utils/mock/MockHandshaker'
-import { MockLayer1 } from '../utils/mock/MockLayer1'
+import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
 import { MockNeighborFinder } from '../utils/mock/MockNeighborFinder'
 import { MockNeighborUpdateManager } from '../utils/mock/MockNeighborUpdateManager'
 import { MockTransport } from '../utils/mock/Transport'
@@ -20,22 +20,23 @@ describe('RandomGraphNode', () => {
     let nearbyNodeView: NodeList
     let randomNodeView: NodeList
 
-    let layer1: MockLayer1
+    let layer1Node: MockLayer1Node
+
     beforeEach(async () => {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
 
         targetNeighbors = new NodeList(nodeId, 10)
         randomNodeView = new NodeList(nodeId, 10)
         nearbyNodeView = new NodeList(nodeId, 10)
-        layer1 = new MockLayer1()
+        layer1Node = new MockLayer1Node()
 
         randomGraphNode = createRandomGraphNode({
             targetNeighbors,
             randomNodeView,
             nearbyNodeView,
-            P2PTransport: new MockTransport(),
+            transport: new MockTransport(),
             ownPeerDescriptor: peerDescriptor,
-            layer1,
+            layer1Node,
             connectionLocker: mockConnectionLocker,
             handshaker: new MockHandshaker(),
             neighborUpdateManager: new MockNeighborUpdateManager(),
@@ -67,7 +68,7 @@ describe('RandomGraphNode', () => {
     it('Adds Closest Nodes from layer1 newContact event to nearbyNodeView', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
-        layer1.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        layer1Node.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 2)
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
@@ -76,7 +77,7 @@ describe('RandomGraphNode', () => {
     it('Adds Random Nodes from layer1 newRandomContact event to randomNodeView', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
-        layer1.emit('newRandomContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        layer1Node.emit('newRandomContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => randomNodeView.size() === 2)
         expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
@@ -85,8 +86,8 @@ describe('RandomGraphNode', () => {
     it('Adds Nodes from layer1 KBucket to nearbyNodeView if its size is below nodeViewSize', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
-        layer1.addNewRandomPeerToKBucket()
-        layer1.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        layer1Node.addNewRandomPeerToKBucket()
+        layer1Node.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 3)
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()

package/test/unit/StreamrNode.test.ts

@@ -3,7 +3,7 @@ import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { waitForCondition } from '@streamr/utils'
 import { StreamrNode } from '../../src/logic/StreamrNode'
-import { MockLayer0 } from '../utils/mock/MockLayer0'
+import { MockLayer0Node } from '../utils/mock/MockLayer0Node'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor, createStreamMessage, mockConnectionLocker } from '../utils/utils'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
@@ -15,7 +15,7 @@ describe('StreamrNode', () => {
 
     beforeEach(async () => {
         node = new StreamrNode({})
-        const mockLayer0 = new MockLayer0(peerDescriptor)
+        const mockLayer0 = new MockLayer0Node(peerDescriptor)
         await node.start(mockLayer0, new MockTransport(), mockConnectionLocker)
     })
 

package/test/utils/mock/{MockLayer0.ts → MockLayer0Node.ts}

@@ -1,8 +1,8 @@
-import { PeerDescriptor, DataEntry } from '@streamr/dht'
-import { ILayer0 } from '../../../src/logic/ILayer0'
+import { PeerDescriptor, DataEntry, ITransport } from '@streamr/dht'
+import { Layer0Node } from '../../../src/logic/Layer0Node'
 import { EventEmitter } from 'eventemitter3'
 
-export class MockLayer0 extends EventEmitter implements ILayer0 {
+export class MockLayer0Node extends EventEmitter implements Layer0Node {
 
     private readonly peerDescriptor: PeerDescriptor
 
@@ -11,6 +11,16 @@ export class MockLayer0 extends EventEmitter implements ILayer0 {
         this.peerDescriptor = peerDescriptor
     }
 
+    // eslint-disable-next-line class-methods-use-this
+    joinDht(): Promise<void> {
+        throw new Error('not implemented')
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    hasJoined(): boolean {
+        throw new Error('not implemented')
+    }
+
     getPeerDescriptor(): PeerDescriptor {
         return this.peerDescriptor
     }
@@ -22,7 +32,6 @@ export class MockLayer0 extends EventEmitter implements ILayer0 {
 
     // eslint-disable-next-line class-methods-use-this
     async deleteDataFromDht(): Promise<void> {
-        
     }
 
     // eslint-disable-next-line class-methods-use-this
@@ -45,8 +54,15 @@ export class MockLayer0 extends EventEmitter implements ILayer0 {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    async stop(): Promise<void> {
+    getTransport(): ITransport {
+        throw new Error('not implemented')
+    }
 
+    // eslint-disable-next-line class-methods-use-this
+    async start(): Promise<void> {
     }
 
+    // eslint-disable-next-line class-methods-use-this
+    async stop(): Promise<void> {
+    }
 }

package/test/utils/mock/{MockLayer1.ts → MockLayer1Node.ts}

@@ -1,9 +1,9 @@
 import { PeerDescriptor } from '@streamr/dht'
 import { EventEmitter } from 'eventemitter3'
-import { ILayer1 } from '../../../src/logic/ILayer1'
+import { Layer1Node } from '../../../src/logic/Layer1Node'
 import { createMockPeerDescriptor } from '../utils'
 
-export class MockLayer1 extends EventEmitter implements ILayer1 {
+export class MockLayer1Node extends EventEmitter implements Layer1Node {
     
     private readonly kbucketPeers: PeerDescriptor[] = []
 

package/test/utils/utils.ts

@@ -15,6 +15,7 @@ import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { EthereumAddress, hexToBinary, utf8ToBinary } from '@streamr/utils'
 import { StreamPartID, StreamPartIDUtils } from '@streamr/protocol'
 import { NodeID } from '../../src/identifiers'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 
 export const mockConnectionLocker: ConnectionLocker = {
     lockConnection: () => {},
@@ -28,10 +29,10 @@ export const createMockRandomGraphNodeAndDhtNode = async (
     entryPointDescriptor: PeerDescriptor,
     streamPartId: StreamPartID,
     simulator: Simulator
-): Promise<[ DhtNode, RandomGraphNode ]> => {
+): Promise<[ Layer1Node, RandomGraphNode ]> => {
     const mockCm = new SimulatorTransport(ownPeerDescriptor, simulator)
     await mockCm.start()
-    const dhtNode = new DhtNode({
+    const layer1Node = new DhtNode({
         transport: mockCm,
         peerDescriptor: ownPeerDescriptor,
         numberOfNodesPerKBucket: 4,
@@ -39,12 +40,12 @@ export const createMockRandomGraphNodeAndDhtNode = async (
     })
     const randomGraphNode = createRandomGraphNode({
         streamPartId,
-        P2PTransport: mockCm,
-        layer1: dhtNode,
+        transport: mockCm,
+        layer1Node,
         connectionLocker: mockCm,
         ownPeerDescriptor
     })
-    return [dhtNode, randomGraphNode]
+    return [layer1Node, randomGraphNode]
 }
 
 export const createStreamMessage = (

package/dist/src/logic/ILayer0.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ILayer0.js","sourceRoot":"","sources":["../../../src/logic/ILayer0.ts"],"names":[],"mappings":""}

package/dist/src/logic/ILayer1.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ILayer1.js","sourceRoot":"","sources":["../../../src/logic/ILayer1.ts"],"names":[],"mappings":""}