@streamr/dht 100.0.0-pretestnet.2 → 100.0.0-pretestnet.3

package/test/end-to-end/Layer0.test.ts

@@ -1,13 +1,9 @@
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 
 describe('Layer0', () => {
 
-    const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: Uint8Array.from([1, 2, 3]),
-        type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 10011, tls: false }
-    }
+    let epPeerDescriptor: PeerDescriptor
     
     let epDhtNode: DhtNode
     let node1: DhtNode
@@ -18,22 +14,44 @@ describe('Layer0', () => {
     const websocketPortRange = { min: 10012, max: 10015 } 
     beforeEach(async () => {
         
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epDhtNode = new DhtNode({ websocketHost: '127.0.0.1', websocketPortRange: { min: 10011, max: 10011 }, websocketServerEnableTls: false })
         await epDhtNode.start()
-        
+        epPeerDescriptor = epDhtNode.getLocalPeerDescriptor()
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node3 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node4 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ 
+            websocketPortRange,
+            websocketHost: '127.0.0.1',
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node2 = new DhtNode({ 
+            websocketPortRange,
+            websocketHost: '127.0.0.1',
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node3 = new DhtNode({ 
+            websocketPortRange,
+            websocketHost: '127.0.0.1',
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node4 = new DhtNode({ 
+            websocketPortRange, 
+            websocketHost: '127.0.0.1',
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
         
-        await node1.start()
-        await node2.start()
-        await node3.start()
-        await node4.start()
+        await Promise.all([
+            node1.start(),
+            node2.start(),
+            node3.start(),
+            node4.start()
+        ])
 
-    })
+    }, 10000)
 
     afterEach(async () => {
         await Promise.all([

package/test/end-to-end/Layer0MixedConnectionTypes.test.ts

@@ -21,15 +21,33 @@ describe('Layer0MixedConnectionTypes', () => {
     const websocketPortRange = { min: 11222, max: 11223 }
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, numberOfNodesPerKBucket: 2 })
+        epDhtNode = new DhtNode({ 
+            peerDescriptor: epPeerDescriptor,
+            numberOfNodesPerKBucket: 2,
+            websocketServerEnableTls: false
+        })
         await epDhtNode.start()
 
         await epDhtNode.joinDht([epPeerDescriptor])
-        node1 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node3 = new DhtNode({ entryPoints: [epPeerDescriptor] })
-        node4 = new DhtNode({ entryPoints: [epPeerDescriptor] })
-        node5 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ 
+            websocketPortRange,
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node2 = new DhtNode({ 
+            websocketPortRange,
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node3 = new DhtNode({ 
+            entryPoints: [epPeerDescriptor]
+        })
+        node4 = new DhtNode({ 
+            entryPoints: [epPeerDescriptor]
+        })
+        node5 = new DhtNode({
+            entryPoints: [epPeerDescriptor]
+        })
 
         await Promise.all([
             node1.start(),

package/test/end-to-end/{Layer0WebRTC-Layer1.test.ts → Layer0Webrtc-Layer1.test.ts}

@@ -30,7 +30,7 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
     beforeEach(async () => {
 
-        layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor })
+        layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor, websocketServerEnableTls: false })
 
         const layer0Node1Id = '11'
         layer0Node1 = new DhtNode({

package/test/end-to-end/{Layer0WebRTC.test.ts → Layer0Webrtc.test.ts}

@@ -19,7 +19,11 @@ describe('Layer0 with WebRTC connections', () => {
 
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, numberOfNodesPerKBucket: 8 })
+        epDhtNode = new DhtNode({
+            peerDescriptor: epPeerDescriptor,
+            numberOfNodesPerKBucket: 8,
+            websocketServerEnableTls: false
+        })
         await epDhtNode.start()
 
         await epDhtNode.joinDht([epPeerDescriptor])
@@ -57,18 +61,18 @@ describe('Layer0 with WebRTC connections', () => {
                 'connected',
                 20000,
                 (peerDescriptor: PeerDescriptor) => {
-                    return areEqualBinaries(peerDescriptor.kademliaId, node1.getPeerDescriptor().kademliaId)
+                    return areEqualBinaries(peerDescriptor.kademliaId, node1.getLocalPeerDescriptor().kademliaId)
                 }
             ),
             node2.joinDht([epPeerDescriptor]),
             node1.joinDht([epPeerDescriptor])
         ])
 
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getPeerDescriptor())!.connectionType)
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getLocalPeerDescriptor())!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getPeerDescriptor())!.connectionType)
+        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getLocalPeerDescriptor())!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
 
     }, 60000)
@@ -81,11 +85,11 @@ describe('Layer0 with WebRTC connections', () => {
             node4.joinDht([epPeerDescriptor])
         ])
 
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getPeerDescriptor())!.connectionType)
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getLocalPeerDescriptor())!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getPeerDescriptor())!.connectionType)
+        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getLocalPeerDescriptor())!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
     })
 })

package/test/end-to-end/Layer1-Scale-WebSocket.test.ts

@@ -25,7 +25,10 @@ describe('Layer1 Scale', () => {
     const websocketPortRange = { min: 62200, max: 62200 + NUM_OF_NODES }
 
     beforeEach(async () => {
-        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epLayer0Node = new DhtNode({
+            peerDescriptor: epPeerDescriptor,
+            websocketServerEnableTls: false
+        })
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
@@ -38,8 +41,9 @@ describe('Layer1 Scale', () => {
 
         for (let i = 0; i < NUM_OF_NODES; i++) {
             const node = new DhtNode({ 
-                websocketPortRange, 
+                websocketPortRange,
                 entryPoints: [epPeerDescriptor],
+                websocketServerEnableTls: false,
                 numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
             })
             await node.start()
@@ -47,7 +51,7 @@ describe('Layer1 Scale', () => {
             const layer1 = new DhtNode({
                 transport: node,
                 entryPoints: [epPeerDescriptor],
-                peerDescriptor: node.getPeerDescriptor(),
+                peerDescriptor: node.getLocalPeerDescriptor(),
                 serviceId: STREAM_ID,
                 numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
             })
@@ -59,7 +63,7 @@ describe('Layer1 Scale', () => {
 
         await Promise.all(layer1Nodes.map((node) => node.joinDht([epPeerDescriptor])))
 
-    }, 60000)
+    }, 120000)
 
     afterEach(async () => {
         await Promise.all(layer1Nodes.map((node) => node.stop()))

package/test/end-to-end/{Layer1-Scale-WebRTC.test.ts → Layer1-Scale-Webrtc.test.ts}

@@ -23,7 +23,7 @@ describe('Layer1 Scale', () => {
     let epLayer1Node: DhtNode
 
     beforeEach(async () => {
-        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
@@ -44,7 +44,7 @@ describe('Layer1 Scale', () => {
             const layer1 = new DhtNode({
                 transport: node,
                 entryPoints: [epPeerDescriptor],
-                peerDescriptor: node.getPeerDescriptor(),
+                peerDescriptor: node.getLocalPeerDescriptor(),
                 serviceId: STREAM_ID,
                 rpcRequestTimeout: 5000,
                 numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET

package/test/end-to-end/RecoveryFromFailedAutoCertification.test.ts

@@ -0,0 +1,52 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import os from 'os'
+
+describe('Failed autocertification', () => {
+    
+    let entryPoint: DhtNode
+    let failedAutocertificationNode: DhtNode
+    let node: DhtNode
+    let entryPointPeerDescriptor: PeerDescriptor
+
+    beforeEach(async () => {
+        entryPoint = new DhtNode({ websocketHost: '127.0.0.1', websocketPortRange: { min: 11112, max: 11112 }, websocketServerEnableTls: false })
+        await entryPoint.start()
+        entryPointPeerDescriptor = entryPoint.getLocalPeerDescriptor()
+        await entryPoint.joinDht([entryPointPeerDescriptor])
+        
+        failedAutocertificationNode = new DhtNode({ 
+            websocketPortRange: { min: 11113, max: 11113 },
+            websocketHost: '127.0.0.1',
+            entryPoints: [entryPointPeerDescriptor],
+            websocketServerEnableTls: true,
+            autoCertifierConfigFile: os.tmpdir() + '/failedAutoCertificationConfigFile.json',
+            autoCertifierUrl: 'http://localhost:44444'
+        })
+
+        node = new DhtNode({
+            websocketPortRange: { min: 11114, max: 11114 },
+            websocketHost: '127.0.0.1',
+            entryPoints: [entryPointPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+    
+        await node.start()
+        await node.joinDht([entryPointPeerDescriptor])
+    })
+
+    afterEach(async () => {
+        await failedAutocertificationNode.stop()
+        await entryPoint.stop()
+        await node.stop()
+    })
+
+    it('failed auto certification should default to no tls', async () => {
+        await failedAutocertificationNode.start()
+        const failedAutocertificationPeerDescriptor = failedAutocertificationNode.getLocalPeerDescriptor()
+        expect(failedAutocertificationPeerDescriptor.websocket!.tls).toBe(false)
+        await failedAutocertificationNode.joinDht([entryPointPeerDescriptor])
+        expect(failedAutocertificationNode.getBucketSize()).toEqual(2)
+    })
+
+})

package/test/end-to-end/{WebSocketConnectionRequest.test.ts → WebsocketConnectionRequest.test.ts}

@@ -5,7 +5,7 @@ import { PeerID } from '../../src/helpers/PeerID'
 import { waitForCondition } from '@streamr/utils'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
-describe('WebSocket IConnection Requests', () => {
+describe('Websocket IConnection Requests', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: PeerID.fromString('3').value,
         type: NodeType.NODEJS,
@@ -17,13 +17,21 @@ describe('WebSocket IConnection Requests', () => {
 
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
         await epDhtNode.start()
 
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ websocketPortRange: { min: 10022, max: 10022 }, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ 
+            websocketPortRange: { min: 10022, max: 10022 },
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node2 = new DhtNode({ 
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+
         await node1.start()
         await node2.start()
     })
@@ -40,12 +48,12 @@ describe('WebSocket IConnection Requests', () => {
         let connected2 = false
 
         node1.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (areEqualPeerDescriptors(peerDescriptor, node2.getPeerDescriptor())) {
+            if (areEqualPeerDescriptors(peerDescriptor, node2.getLocalPeerDescriptor())) {
                 connected1 = true
             }
         })
         node2.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (areEqualPeerDescriptors(peerDescriptor, node1.getPeerDescriptor())) {
+            if (areEqualPeerDescriptors(peerDescriptor, node1.getLocalPeerDescriptor())) {
                 connected2 = true
             }
         })
@@ -55,8 +63,8 @@ describe('WebSocket IConnection Requests', () => {
 
         await waitForCondition(() => { return (connected1 && connected2) })
 
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
 
     }, 10000)
 })

package/test/end-to-end/memory-leak.test.ts

@@ -0,0 +1,85 @@
+import LeakDetector from 'jest-leak-detector'
+import { binaryToHex, waitForCondition } from '@streamr/utils'
+import { randomBytes } from 'crypto'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { Message, MessageType, NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+
+const MESSAGE_ID = 'mock-message-id'
+
+describe('memory leak', () => {
+
+    it('send message', async () => {
+        const entryPointDescriptor = {
+            kademliaId: randomBytes(10),
+            type: NodeType.NODEJS,
+            websocket: {
+                host: '127.0.0.1',
+                port: 11224,
+                tls: false
+            }
+        }
+        let entryPoint: DhtNode | undefined = new DhtNode({
+            peerId: binaryToHex(entryPointDescriptor.kademliaId),
+            websocketHost: entryPointDescriptor.websocket!.host,
+            websocketPortRange: {
+                min: entryPointDescriptor.websocket.port,
+                max: entryPointDescriptor.websocket.port
+            },
+            entryPoints: [entryPointDescriptor],
+            websocketServerEnableTls: false
+        })
+        await entryPoint.start()
+        await entryPoint.joinDht([entryPointDescriptor])
+        let sender: DhtNode | undefined = new DhtNode({})
+        let receiver: DhtNode | undefined = new DhtNode({})
+        /*TODO should this work? await Promise.all([
+            async () => {
+                await sender.start()
+                await sender.joinDht([entryPointDescriptor])
+            },
+            async () => {
+                await receiver.start()
+                await receiver.joinDht([entryPointDescriptor])
+            }
+        ])*/
+        await sender.start()
+        await sender.joinDht([entryPointDescriptor])
+        await receiver.start()
+        await receiver.joinDht([entryPointDescriptor])
+
+        let receivedMessage: Message | undefined = undefined
+        receiver.on('message', (msg: Message) => receivedMessage = msg)
+        const msg: Message = {
+            serviceId: 'mock-service-id',
+            targetDescriptor: receiver.getLocalPeerDescriptor(),
+            messageType: MessageType.RPC,
+            messageId: 'mock-message-id',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            }
+        }
+        await sender.send(msg)
+        await waitForCondition(() => receivedMessage !== undefined)
+        expect(receivedMessage!.messageId).toEqual(MESSAGE_ID)
+
+        await Promise.all([
+            entryPoint.stop(),
+            sender.stop(),
+            receiver.stop()
+        ])
+
+        const detector1 = new LeakDetector(entryPoint)
+        entryPoint = undefined
+        expect(await detector1.isLeaking()).toBe(false)
+
+        const detector2 = new LeakDetector(sender)
+        sender = undefined
+        expect(await detector2.isLeaking()).toBe(false)
+
+        const detector3 = new LeakDetector(receiver)
+        receiver = undefined
+        expect(await detector3.isLeaking()).toBe(false)
+    })
+})

package/test/integration/ConnectionLocking.test.ts

@@ -1,17 +1,17 @@
 import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
-import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { Simulator } from '../../src/connection/simulator/Simulator'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { ITransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 
-const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, transport: ITransport) => {
+const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
             transport,
-            createOwnPeerDescriptor: () => ownPeerDescriptor
+            createLocalPeerDescriptor: () => localPeerDescriptor
         }),
         metricsContext: new MetricsContext()
     })

package/test/integration/ConnectionManager.test.ts

@@ -1,7 +1,7 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { ConnectivityResponse, Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID } from '../../src/helpers/PeerID'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { createPeerDescriptor } from '../../src/dht/DhtNode'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { Logger, MetricsContext } from '@streamr/utils'
@@ -37,12 +37,13 @@ describe('ConnectionManager', () => {
     const mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
     const mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
 
-    let createOwnPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
+    let createLocalPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
 
-    const createConnectionManager = (opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+    const createConnectionManager = (opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
         return new ConnectionManager({
             createConnectorFacade: () => new DefaultConnectorFacade({
-                createOwnPeerDescriptor,
+                createLocalPeerDescriptor,
+                websocketServerEnableTls: false,
                 ...opts
             }),
             metricsContext: new MetricsContext()
@@ -50,7 +51,7 @@ describe('ConnectionManager', () => {
     }
 
     beforeEach(() => {
-        createOwnPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response))
+        createLocalPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response))
     })
 
     beforeAll(async () => {
@@ -59,7 +60,7 @@ describe('ConnectionManager', () => {
         await mockConnectorTransport2.start()
     })
 
-    afterAll(async ()=> {
+    afterAll(async () => {
         await mockTransport.stop()
         await mockConnectorTransport1.stop()
         await mockConnectorTransport2.stop()
@@ -70,12 +71,11 @@ describe('ConnectionManager', () => {
         const connectionManager = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 9991, max: 9991 },
+            websocketPortRange: { min: 9991, max: 9991 }
         })
 
         await connectionManager.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
         await connectionManager.stop()
     })
@@ -103,8 +103,7 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager1.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
         const connectionManager2 = createConnectionManager({
             transport: mockConnectorTransport2,
@@ -115,8 +114,7 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager2.start()
-        expect(createOwnPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[1][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
 
         await connectionManager1.stop()
         await connectionManager2.stop()
@@ -130,20 +128,18 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager1.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
         const connectionManager2 = createConnectionManager({
             transport: mockConnectorTransport2,
             websocketPortRange: { min: 9996, max: 9996 },
             entryPoints: [
-                connectionManager1.getPeerDescriptor()
+                connectionManager1.getLocalPeerDescriptor()
             ]
         })
 
         await connectionManager2.start()
-        expect(createOwnPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[1][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
 
         const msg: Message = {
             serviceId,
@@ -174,7 +170,7 @@ describe('ConnectionManager', () => {
             })
         })
 
-        msg.targetDescriptor = connectionManager2.getPeerDescriptor()
+        msg.targetDescriptor = connectionManager2.getLocalPeerDescriptor()
         connectionManager1.send(msg)
 
         await Promise.all([promise, connectedPromise1, connectedPromise2])
@@ -191,14 +187,14 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager1.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
         const connectionManager2 = createConnectionManager({
             transport: mockConnectorTransport2,
             websocketPortRange: { min: 9999, max: 9999 },
+            websocketServerEnableTls: false,
             entryPoints: [
-                connectionManager1.getPeerDescriptor()
+                connectionManager1.getLocalPeerDescriptor()
             ]
         })
 
@@ -234,13 +230,13 @@ describe('ConnectionManager', () => {
                 resolve()
             })
         })
-        msg.targetDescriptor = connectionManager2.getPeerDescriptor()
+        msg.targetDescriptor = connectionManager2.getLocalPeerDescriptor()
         connectionManager1.send(msg)
 
         await promise
 
         // @ts-expect-error private field
-        connectionManager1.closeConnection(connectionManager2.getPeerDescriptor())
+        connectionManager1.closeConnection(connectionManager2.getLocalPeerDescriptor())
 
         await Promise.all([disconnectedPromise1, disconnectedPromise2])
 
@@ -307,7 +303,7 @@ describe('ConnectionManager', () => {
         await connectionManager4.stop()
     })
 
-    it('Cannot send to own WebSocketServer if kademliaIds do not match', async () => {
+    it('Cannot send to own WebsocketServer if kademliaIds do not match', async () => {
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
@@ -315,10 +311,9 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager1.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
         
-        const peerDescriptor = connectionManager1.getPeerDescriptor()
+        const peerDescriptor = connectionManager1.getLocalPeerDescriptor()
         peerDescriptor.kademliaId = new Uint8Array([12, 12, 12, 12])
         const msg: Message = {
             serviceId,
@@ -336,4 +331,18 @@ describe('ConnectionManager', () => {
         
         await connectionManager1.stop()
     })
+
+    it('Failed autocertification', async () => {
+        const connectionManager1 = createConnectionManager({
+            transport: mockTransport,
+            websocketHost: '127.0.0.1',
+            autoCertifierUrl: 'https://localhost:12333',
+            websocketServerEnableTls: true,
+            websocketPortRange: { min: 10003, max: 10003 }
+        })
+
+        await connectionManager1.start()
+        expect(connectionManager1.getLocalPeerDescriptor().websocket!.tls).toEqual(false)
+        await connectionManager1.stop()
+    })
 })

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -1,5 +1,5 @@
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
-import { getRandomRegion } from '../../src/connection/Simulator/pings'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
+import { getRandomRegion } from '../../src/connection/simulator/pings'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'