@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -1,48 +0,0 @@
-import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { randomDhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
-import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { createMockConnectionDhtNode } from '../utils/utils'
-
-describe('DhtNodeExternalApi', () => {
-
-    let simulator: Simulator
-    let dhtNode1: DhtNode
-    let remote: DhtNode
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.NONE)
-        dhtNode1 = await createMockConnectionDhtNode(simulator)
-        remote = await createMockConnectionDhtNode(simulator)
-        await dhtNode1.joinDht([dhtNode1.getLocalPeerDescriptor()])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            dhtNode1.stop(),
-            remote.stop()
-        ])
-        simulator.stop()
-    })
-
-    it('fetch data happy path', async () => {
-        const entry = createMockDataEntry()
-        await dhtNode1.storeDataToDht(toDhtAddress(entry.key), entry.data!)
-        const foundData = await remote.fetchDataFromDhtViaPeer(toDhtAddress(entry.key), dhtNode1.getLocalPeerDescriptor())
-        expectEqualData(foundData[0], entry)
-    })
-    
-    it('fetch data returns empty array if no data found', async () => {
-        const foundData = await remote.fetchDataFromDhtViaPeer(randomDhtAddress(), dhtNode1.getLocalPeerDescriptor())
-        expect(foundData).toEqual([])
-    })
-
-    it('external store data happy path', async () => {
-        const entry = createMockDataEntry()
-        await remote.storeDataToDhtViaPeer(toDhtAddress(entry.key), entry.data!, dhtNode1.getLocalPeerDescriptor())
-        const foundData = await remote.fetchDataFromDhtViaPeer(toDhtAddress(entry.key), dhtNode1.getLocalPeerDescriptor())
-        expectEqualData(foundData[0], entry)
-        expect(toDhtAddress(foundData[0].creator)).toEqual(toNodeId(remote.getLocalPeerDescriptor()))
-    })
-  
-})

package/test/integration/DhtNodeRpcRemote.test.ts

@@ -1,66 +0,0 @@
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { RpcCommunicator } from '@streamr/proto-rpc'
-import { createMockDhtRpc, createMockPeerDescriptor, createMockPeers } from '../utils/utils'
-import {
-    ClosestPeersRequest,
-    ClosestPeersResponse,
-    PingRequest,
-    PingResponse
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-import { toNodeId } from '../../src/identifiers'
-
-const SERVICE_ID = 'test'
-
-describe('DhtNodeRpcRemote', () => {
-
-    let rpcRemote: DhtNodeRpcRemote
-    let clientRpcCommunicator: RpcCommunicator<DhtCallContext>
-    let serverRpcCommunicator: RpcCommunicator<DhtCallContext>
-    const clientPeerDescriptor = createMockPeerDescriptor()
-    const serverPeerDescriptor = createMockPeerDescriptor()
-    const mockDhtRpc = createMockDhtRpc(createMockPeers())
-
-    beforeEach(() => {
-        clientRpcCommunicator = new RpcCommunicator()
-        serverRpcCommunicator = new RpcCommunicator()
-        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
-        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', mockDhtRpc.ping)
-        clientRpcCommunicator.setOutgoingMessageListener(async (message: RpcMessage) => {
-            serverRpcCommunicator.handleIncomingMessage(message, new DhtCallContext())
-        })
-        serverRpcCommunicator.setOutgoingMessageListener(async (message: RpcMessage) => {
-            clientRpcCommunicator.handleIncomingMessage(message, new DhtCallContext())
-        })
-        rpcRemote = new DhtNodeRpcRemote(clientPeerDescriptor, serverPeerDescriptor, SERVICE_ID, clientRpcCommunicator)
-    })
-
-    afterEach(() => {
-        clientRpcCommunicator.stop()
-        serverRpcCommunicator.stop()
-    })
-
-    it('Ping happy path', async () => {
-        const active = await rpcRemote.ping()
-        expect(active).toEqual(true)
-    })
-
-    it('getClosestPeers happy path', async () => {
-        const neighbors = await rpcRemote.getClosestPeers(toNodeId(clientPeerDescriptor))
-        expect(neighbors.length).toEqual(createMockPeers().length)
-    })
-
-    it('ping error path', async () => {
-        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', mockDhtRpc.throwPingError)
-        const active = await rpcRemote.ping()
-        expect(active).toEqual(false)
-    })
-
-    it('getClosestPeers error path', async () => {
-        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.throwGetClosestPeersError)
-        await expect(rpcRemote.getClosestPeers(toNodeId(clientPeerDescriptor)))
-            .rejects.toThrow('Closest peers error')
-    })
-
-})

package/test/integration/DhtRpc.test.ts

@@ -1,121 +0,0 @@
-import { createMockDhtRpc, createMockPeerDescriptor, createMockPeers } from '../utils/utils'
-import { ProtoRpcClient, RpcCommunicator, RpcError, toProtoRpcClient } from '@streamr/proto-rpc'
-import { DhtNodeRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
-import { ClosestPeersRequest, ClosestPeersResponse } from '../../generated/packages/dht/protos/DhtRpc'
-import { wait } from '@streamr/utils'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { toNodeId } from '../../src/identifiers'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-
-describe('DhtRpc', () => {
-
-    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
-    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
-    let client1: ProtoRpcClient<DhtNodeRpcClient>
-    let client2: ProtoRpcClient<DhtNodeRpcClient>
-    const peerDescriptor1 = createMockPeerDescriptor()
-    const peerDescriptor2 = createMockPeerDescriptor()
-    const neighbors = createMockPeers()
-    const mockDhtRpc = createMockDhtRpc(neighbors)
-
-    const outgoingListener2 = async (message: RpcMessage) => {
-        rpcCommunicator1.handleIncomingMessage(message, new DhtCallContext())
-    }
-
-    beforeEach(() => {
-        rpcCommunicator1 = new RpcCommunicator()
-        rpcCommunicator1.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
-
-        rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
-
-        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
-        })
-
-        rpcCommunicator2.setOutgoingMessageListener(outgoingListener2)
-
-        client1 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator1.getRpcClientTransport()))
-        client2 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator1.getRpcClientTransport()))
-    })
-
-    afterEach(async () => {
-        rpcCommunicator1.stop()
-        rpcCommunicator2.stop()
-    })
-
-    it('Happy path', async () => {
-        const response1 = client1.getClosestPeers(
-            { nodeId: peerDescriptor1.nodeId, requestId: '1' },
-            {
-                sourceDescriptor: peerDescriptor1,
-                targetDescriptor: peerDescriptor2,
-            }
-        )
-        const res1 = await response1
-        expect(res1.peers.map((p) => toNodeId(p))).toEqual(neighbors.map((n) => toNodeId(n)))
-
-        const response2 = client2.getClosestPeers(
-            { nodeId: peerDescriptor2.nodeId, requestId: '1' },
-            {
-                sourceDescriptor: peerDescriptor2,
-                targetDescriptor: peerDescriptor1
-            }
-        )
-        const res2 = await response2
-        expect(res2.peers.map((p) => toNodeId(p))).toEqual(neighbors.map((n) => toNodeId(n)))
-    })
-
-    it('Default RPC timeout, client side', async () => {
-        rpcCommunicator2.setOutgoingMessageListener(async () => {
-            await wait(3000)
-        })
-        const response2 = client2.getClosestPeers(
-            { nodeId: peerDescriptor2.nodeId, requestId: '1' },
-            {
-                sourceDescriptor: peerDescriptor2,
-                targetDescriptor: peerDescriptor1
-            }
-        )
-        await expect(response2).rejects.toEqual(
-            new RpcError.RpcTimeout('Rpc request timed out')
-        )
-    }, 15000)
-
-    it('Server side timeout', async () => {
-        let timeout: NodeJS.Timeout
-
-        async function respondGetClosestPeersWithTimeout(): Promise<ClosestPeersResponse> {
-            const neighbors = createMockPeers()
-            const response: ClosestPeersResponse = {
-                peers: neighbors,
-                requestId: 'why am i still here'
-            }
-            await wait(5000)
-            return response
-        }
-
-        rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', respondGetClosestPeersWithTimeout)
-        const response = client2.getClosestPeers(
-            { nodeId: peerDescriptor2.nodeId, requestId: '1' },
-            {
-                sourceDescriptor: peerDescriptor2,
-                targetDescriptor: peerDescriptor1
-            }
-        )
-        await expect(response).rejects.toEqual(
-            new RpcError.RpcTimeout('Server timed out on request')
-        )
-        clearTimeout(timeout!)
-    })
-
-    it('Server responds with error on unknown method', async () => {
-        const response = client2.ping(
-            { requestId: '1' },
-            { targetDescriptor: peerDescriptor1 }
-        )
-        await expect(response).rejects.toEqual(
-            new RpcError.UnknownRpcMethod('Server does not implement method ping')
-        )
-    })
-})

package/test/integration/Find.test.ts

@@ -1,45 +0,0 @@
-import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode, waitForStableTopology } from '../utils/utils'
-import { toDhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
-
-const NUM_NODES = 100
-const K = 8
-
-describe('Find correctness', () => {
-
-    let entryPoint: DhtNode
-    let nodes: DhtNode[]
-    let entrypointDescriptor: PeerDescriptor
-    const simulator = new Simulator(LatencyType.REAL)
-
-    beforeEach(async () => {
-        nodes = []
-        entryPoint = await createMockConnectionDhtNode(simulator, undefined, K)
-        nodes.push(entryPoint)
-        entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
-        for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, undefined, K, 15, 60000)
-            nodes.push(node)
-        }
-        await entryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
-        await waitForStableTopology(nodes, 15, 45 * 1000)
-    }, 90000)
-
-    afterEach(async () => {
-        await Promise.all([
-            entryPoint.stop(),
-            ...nodes.map(async (node) => await node.stop())
-        ])
-    })
-
-    it('Entrypoint can find a node from the network (exact match)', async () => {
-        const targetId = toDhtAddressRaw(nodes[45].getNodeId())
-        const closestNodes = await entryPoint.findClosestNodesFromDht(toDhtAddress(targetId))
-        expect(closestNodes.length).toBeGreaterThanOrEqual(5)
-        expect(toDhtAddress(targetId)).toEqual(toNodeId(closestNodes[0]))
-    }, 90000)
-
-})

package/test/integration/GeoIpConnectivityChecking.test.ts

@@ -1,72 +0,0 @@
-import { MetricsContext } from '@streamr/utils'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { sendConnectivityRequest } from '../../src/connection/connectivityChecker'
-import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
-import { WebsocketServerConnection } from '../../src/connection/websocket/WebsocketServerConnection'
-import fs from 'fs'
-
-// helsinki.fi
-const testIp = '128.214.222.50'
-
-// Helsinki, Finland
-const testLatitude = 60.1719
-const testLongitude = 24.9347
-
-const dbPath = '/tmp/geoipdatabasesintegration'
-
-describe('ConnectivityChecking', () => {
-
-    let server: ConnectionManager
-    const PORT = 15002
-    const HOST = '127.0.0.1'
-    let mock: jest.SpyInstance<string, [], any> 
-
-    beforeEach(async () => {
-        server = new ConnectionManager({
-            createConnectorFacade: () => new DefaultConnectorFacade({
-                createLocalPeerDescriptor: async () => {
-                    return {
-                        ...createMockPeerDescriptor(),
-                        websocket: {
-                            host: HOST,
-                            port: PORT,
-                            tls: false
-                        }
-                    }
-                },
-                websocketHost: HOST,
-                websocketPortRange: { min: PORT, max: PORT },
-                websocketServerEnableTls: false,
-                transport: new MockTransport(),
-                geoIpDatabaseFolder: dbPath
-            }),
-            metricsContext: new MetricsContext(),
-            allowIncomingPrivateConnections: false
-        })
-        await server.start()
-        mock = jest.spyOn(WebsocketServerConnection.prototype, 'getRemoteIpAddress').mockImplementation(() => testIp)
-    }, 15000)
-
-    afterEach(async () => {
-        await server.stop()
-        fs.unlinkSync(dbPath + '/GeoLite2-City.mmdb')
-        fs.rmSync(dbPath, { recursive: true })
-        mock.mockRestore()
-    })
-
-    it('connectivityCheck replies with correct latitude and longitude', async () => {
-        const request = {
-            host: HOST,
-            port: PORT,
-            tls: false,
-            allowSelfSignedCertificate: false
-        }
-        const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor())
-        expect(response.protocolVersion).toEqual(LOCAL_PROTOCOL_VERSION)
-        expect(response.latitude).toEqual(testLatitude)
-        expect(response.longitude).toEqual(testLongitude)
-    })
-})

package/test/integration/Layer1-scale.test.ts

@@ -1,189 +0,0 @@
-import { Simulator } from '../../src/connection/simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { toDhtAddress } from '../../src/identifiers'
-import { createMockConnectionDhtNode, createMockConnectionLayer1Node, createMockPeerDescriptor } from '../utils/utils'
-
-const NODE_COUNT = 48
-const NUM_OF_NODES_PER_KBUCKET = 8
-
-describe('Layer1', () => {
-
-    let simulator: Simulator
-    const entryPoint0Descriptor = createMockPeerDescriptor()
-    let layer0EntryPoint: DhtNode
-    let nodes: DhtNode[]
-    let layer1CleanUp: DhtNode[]
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        layer0EntryPoint = await createMockConnectionDhtNode(simulator, toDhtAddress(entryPoint0Descriptor.nodeId))
-        await layer0EntryPoint.joinDht([entryPoint0Descriptor])
-
-        nodes = []
-        layer1CleanUp = []
-
-        for (let i = 0; i < NODE_COUNT; i++) {
-            const node = await createMockConnectionDhtNode(
-                simulator,
-                undefined,
-                undefined,
-                undefined,
-                60000
-            )
-            nodes.push(node)
-        }
-
-        await Promise.all(nodes.map((node) => node.joinDht([entryPoint0Descriptor])))
-
-    }, 30000)
-
-    afterEach(async () => {
-        await Promise.all(layer1CleanUp.map((node) => node.stop()))
-        await Promise.all(nodes.map((node) => node.stop()))
-        await layer0EntryPoint.stop()
-        simulator.stop()
-    })
-
-    it('single layer1 dht', async () => {
-        const layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
-        await layer1EntryPoint.joinDht([entryPoint0Descriptor])
-        layer1CleanUp.push(layer1EntryPoint)
-
-        const layer1Nodes: DhtNode[] = []
-        for (let i = 0; i < NODE_COUNT; i++) {
-            const layer0 = nodes[i]
-            const layer1 = await createMockConnectionLayer1Node(layer0, undefined, NUM_OF_NODES_PER_KBUCKET)
-            layer1Nodes.push(layer1)
-            layer1CleanUp.push(layer1)
-        }
-
-        await Promise.all(layer1Nodes.map((node) => node.joinDht([entryPoint0Descriptor])))
-
-        for (let i = 0; i < NODE_COUNT; i++) {
-            const layer0Node = nodes[i]
-            const layer1Node = layer1Nodes[i]
-            expect(layer1Node.getNodeId()).toEqual(layer0Node.getNodeId())
-            expect(layer1Node.getConnectionsView().getConnectionCount()).toEqual(layer0Node.getConnectionsView().getConnectionCount())
-            expect(layer1Node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
-            expect(layer1Node.getConnectionsView().getConnections()).toEqual(layer0Node.getConnectionsView().getConnections())
-        }
-    }, 120000)
-
-    it('multiple layer1 dht', async () => {
-        const stream1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'one')
-        await stream1EntryPoint.joinDht([entryPoint0Descriptor])
-
-        const stream2EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'two')
-        await stream2EntryPoint.joinDht([entryPoint0Descriptor])
-
-        const stream3EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'three')
-        await stream3EntryPoint.joinDht([entryPoint0Descriptor])
-
-        const stream4EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'four')
-        await stream4EntryPoint.joinDht([entryPoint0Descriptor])
-
-        layer1CleanUp.push(stream1EntryPoint)
-        layer1CleanUp.push(stream2EntryPoint)
-        layer1CleanUp.push(stream3EntryPoint)
-        layer1CleanUp.push(stream4EntryPoint)
-
-        const stream1: DhtNode[] = []
-        const stream2: DhtNode[] = []
-        const stream3: DhtNode[] = []
-        const stream4: DhtNode[] = []
-
-        for (let i = 0; i < NODE_COUNT; i++) {
-            const layer0 = nodes[i]
-            const one = await createMockConnectionLayer1Node(layer0, 'one')
-            const two = await createMockConnectionLayer1Node(layer0, 'two')
-            const three = await createMockConnectionLayer1Node(layer0, 'three')
-            const four = await createMockConnectionLayer1Node(layer0, 'four')
-
-            stream1.push(one)
-            stream2.push(two)
-            stream3.push(three)
-            stream4.push(four)
-
-            layer1CleanUp.push(one)
-            layer1CleanUp.push(two)
-            layer1CleanUp.push(three)
-            layer1CleanUp.push(four)
-        }
-
-        await Promise.all(layer1CleanUp.map((node) => node.joinDht([entryPoint0Descriptor])))
-
-        for (let i = 0; i < NODE_COUNT; i++) {
-            const layer0Node = nodes[i]
-            const stream1Node = stream1[i]
-            const stream2Node = stream2[i]
-            const stream3Node = stream3[i]
-            const stream4Node = stream4[i]
-
-            expect(layer0Node.getConnectionsView().getConnectionCount()).toEqual(stream1Node.getConnectionsView().getConnectionCount())
-            expect(layer0Node.getConnectionsView().getConnectionCount()).toEqual(stream2Node.getConnectionsView().getConnectionCount())
-            expect(layer0Node.getConnectionsView().getConnectionCount()).toEqual(stream3Node.getConnectionsView().getConnectionCount())
-            expect(layer0Node.getConnectionsView().getConnectionCount()).toEqual(stream4Node.getConnectionsView().getConnectionCount())
-
-        }
-    }, 120000)
-
-    // TODO: Make this work
-    // it('layer1 routing', async () => {
-    //     const layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint)
-    //     await layer1EntryPoint.joinDht(entryPoint0Descriptor)
-    //     layer1CleanUp.push(layer1EntryPoint)
-    //
-    //     const receivedMessages: Map<string, Set<string>> = new Map()
-    //
-    //     const layer1Nodes: DhtNode[] = []
-    //     for (let i = 0; i < NODE_COUNT; i++) {
-    //         const layer0 = nodes[i]
-    //         if (i > NODE_COUNT - 5) {
-    //             const layer1 = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0)
-    //             layer1Nodes.push(layer1)
-    //             layer1CleanUp.push(layer1)
-    //             receivedMessages.set(layer0.getNodeId().toKey(), new Set())
-    //             layer1.on('message', (msg: Message) => {
-    //                 const peerId = PeerID.fromValue(msg.sourceDescriptor!.nodeId)
-    //                 receivedMessages.get(layer0.getNodeId().toKey())!.add(peerId.toKey())
-    //             })
-    //         }
-    //     }
-    //
-    //     await Promise.all(layer1Nodes.map((node) => node.joinDht(entryPoint0Descriptor)))
-    //
-    //     layer1Nodes.forEach((sender) => {
-    //         layer1Nodes.forEach(async (receiver) => {
-    //             if (!sender.getNodeId().equals(receiver.getNodeId())) {
-    //                 const rpcWrapper = createWrappedClosestPeersRequest(sender.getPeerDescriptor(), receiver.getPeerDescriptor())
-    //                 const message: Message = {
-    //                     serviceId: 'service',
-    //                     messageId: v4(),
-    //                     body: {
-    //                         oneofKind: 'rpcMessage',
-    //                         rpcMessage: rpcWrapper
-    //                     },
-    //                     sourceDescriptor: sender.getPeerDescriptor(),
-    //                     targetDescriptor: receiver.getPeerDescriptor()
-    //                 }
-    //                 await sender.doRouteMessage({
-    //                     message,
-    //                     target: receiver.getPeerDescriptor().nodeId,
-    //                     sourcePeer: sender.getPeerDescriptor(),
-    //                     requestId: v4(),
-    //                     reachableThrough: [],
-    //                     routingPath: []
-    //                 })
-    //             }
-    //         })
-    //     })
-    //
-    //     await until(() => {
-    //         return [...receivedMessages.values()].every((set) => {
-    //             return set.size === receivedMessages.size - 1
-    //         })
-    //     }, 15000)
-    //
-    // }, 120000)
-
-})

package/test/integration/Mock-Layer1-Layer0.test.ts

@@ -1,85 +0,0 @@
-import { Logger } from '@streamr/utils'
-import { Simulator } from '../../src/connection/simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
-import { randomDhtAddress } from '../../src/identifiers'
-
-const logger = new Logger(module)
-
-describe('Layer 1 on Layer 0 with mocked connections', () => {
-
-    const simulator = new Simulator()
-    let layer0EntryPoint: DhtNode
-    let layer1Node1: DhtNode
-    let layer0Node1: DhtNode
-    let layer1EntryPoint: DhtNode
-    let layer0Node2: DhtNode
-    let layer1Node2: DhtNode
-    let layer0Node3: DhtNode
-    let layer1Node3: DhtNode
-    let layer0Node4: DhtNode
-    let layer1Node4: DhtNode
-
-    beforeEach(async () => {
-
-        layer0EntryPoint = await createMockConnectionDhtNode(simulator, randomDhtAddress())
-        layer0Node1 = await createMockConnectionDhtNode(simulator, randomDhtAddress())
-        layer0Node2 = await createMockConnectionDhtNode(simulator, randomDhtAddress())
-        layer0Node3 = await createMockConnectionDhtNode(simulator, randomDhtAddress())
-        layer0Node4 = await createMockConnectionDhtNode(simulator, randomDhtAddress())
-
-        layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
-
-        layer1Node1 = await createMockConnectionLayer1Node(layer0Node1)
-        layer1Node2 = await createMockConnectionLayer1Node(layer0Node2)
-        layer1Node3 = await createMockConnectionLayer1Node(layer0Node3)
-        layer1Node4 = await createMockConnectionLayer1Node(layer0Node4)
-
-        await layer0EntryPoint.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-        await layer1EntryPoint.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            layer0EntryPoint.stop(),
-            layer0Node1.stop(),
-            layer0Node2.stop(),
-            layer0Node3.stop(),
-            layer0Node4.stop(),
-            layer1EntryPoint.stop(),
-            layer1Node1.stop(),
-            layer1Node2.stop(),
-            layer1Node3.stop(),
-            layer1Node4.stop()
-        ])
-    })
-
-    it('Happy Path', async () => {
-        await layer0Node1.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-        await layer0Node2.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-        await layer0Node3.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-        await layer0Node4.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-
-        await layer1Node1.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-        await layer1Node2.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-        await layer1Node3.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-        await layer1Node4.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
-
-        logger.info('layer1EntryPoint.getNeighborCount() ' + layer1EntryPoint.getNeighborCount())
-        logger.info('layer1Node1.getNeighborCount()' + layer1Node1.getNeighborCount())
-        logger.info('layer1Node2.getNeighborCount()' + layer1Node2.getNeighborCount())
-        logger.info('layer1Node3.getNeighborCount()' + layer1Node3.getNeighborCount())
-        logger.info('layer1Node4.getNeighborCount()' + layer1Node4.getNeighborCount())
-
-        expect(layer1Node1.getNeighborCount()).toEqual(layer0Node1.getNeighborCount())
-        expect(layer1Node2.getNeighborCount()).toEqual(layer0Node2.getNeighborCount())
-        expect(layer1Node3.getNeighborCount()).toEqual(layer0Node3.getNeighborCount())
-        expect(layer1Node4.getNeighborCount()).toEqual(layer0Node4.getNeighborCount())
-
-        expect(layer1Node1.getNeighbors()).toContainValues(layer0Node1.getNeighbors())
-        expect(layer1Node2.getNeighbors()).toContainValues(layer0Node2.getNeighbors())
-        expect(layer1Node3.getNeighbors()).toContainValues(layer0Node3.getNeighbors())
-        expect(layer1Node4.getNeighbors()).toContainValues(layer0Node4.getNeighbors())
-
-    }, 60000)
-})