@streamr/trackerless-network 100.0.0-testnet-three.0 → 100.0.0-testnet-three.2

package/src/logic/inspect/Inspector.ts

@@ -13,6 +13,7 @@ interface InspectorConfig {
     connectionLocker: ConnectionLocker
     inspectionTimeout?: number
     openInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
+    closeInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
 }
 
 const logger = new Logger(module)
@@ -27,6 +28,7 @@ export class Inspector {
     private readonly connectionLocker: ConnectionLocker
     private readonly inspectionTimeout: number
     private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
+    private readonly closeInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
 
     constructor(config: InspectorConfig) {
         this.streamPartId = config.streamPartId
@@ -35,6 +37,7 @@ export class Inspector {
         this.connectionLocker = config.connectionLocker
         this.inspectionTimeout = config.inspectionTimeout ?? DEFAULT_TIMEOUT
         this.openInspectConnection = config.openInspectConnection ?? this.defaultOpenInspectConnection
+        this.closeInspectConnection = config.closeInspectConnection ?? this.defaultCloseInspectConnection
     }
 
     async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: LockID): Promise<void> {
@@ -48,6 +51,17 @@ export class Inspector {
         this.connectionLocker.lockConnection(peerDescriptor, lockId)
     }
 
+    async defaultCloseInspectConnection(peerDescriptor: PeerDescriptor, lockId: LockID): Promise<void> {
+        const rpcRemote = new TemporaryConnectionRpcRemote(
+            this.localPeerDescriptor,
+            peerDescriptor,
+            this.rpcCommunicator,
+            TemporaryConnectionRpcClient
+        )
+        await rpcRemote.closeConnection()
+        this.connectionLocker.unlockConnection(peerDescriptor, lockId)
+    }
+
     async inspect(peerDescriptor: PeerDescriptor): Promise<boolean> {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         const session = new InspectSession({
@@ -63,8 +77,8 @@ export class Inspector {
         } catch (err) {
             logger.trace('Inspect session timed out, removing')
         } finally {
+            await this.closeInspectConnection(peerDescriptor, lockId)
             this.sessions.delete(nodeId)
-            this.connectionLocker.unlockConnection(peerDescriptor, lockId)
         }
         return success || session.getInspectedMessageCount() < 1
     }

package/src/logic/neighbor-discovery/NeighborUpdateManager.ts

@@ -16,6 +16,7 @@ interface NeighborUpdateManagerConfig {
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     neighborUpdateInterval: number
+    neighborTargetCount: number
 }
 
 const logger = new Logger(module)

package/src/logic/neighbor-discovery/NeighborUpdateRpcLocal.ts

@@ -15,6 +15,7 @@ interface NeighborUpdateRpcLocalConfig {
     nearbyNodeView: NodeList
     neighborFinder: NeighborFinder
     rpcCommunicator: ListeningRpcCommunicator
+    neighborTargetCount: number
 }
 
 export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
@@ -25,38 +26,49 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
         this.config = config
     }
 
+    private updateContacts(neighborDescriptors: PeerDescriptor[]): void {
+        const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        const newPeerDescriptors = neighborDescriptors.filter((peerDescriptor) => {
+            const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+            return nodeId !== ownNodeId && !this.config.neighbors.getIds().includes(nodeId)
+        })
+        newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
+            new DeliveryRpcRemote(
+                this.config.localPeerDescriptor,
+                peerDescriptor,
+                this.config.rpcCommunicator,
+                DeliveryRpcClient
+            ))
+        )
+    }
+
+    private createResponse(removeMe: boolean): NeighborUpdate {
+        return {
+            streamPartId: this.config.streamPartId,
+            neighborDescriptors: this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+            removeMe
+        }
+    }
+
     // INeighborUpdateRpc server method
     async neighborUpdate(message: NeighborUpdate, context: ServerCallContext): Promise<NeighborUpdate> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
-        if (this.config.neighbors.has(senderId)) {
-            const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
-            const newPeerDescriptors = message.neighborDescriptors.filter((peerDescriptor) => {
-                const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-                return nodeId !== ownNodeId && !this.config.neighbors.getIds().includes(nodeId)
-            })
-            newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
-                new DeliveryRpcRemote(
-                    this.config.localPeerDescriptor,
-                    peerDescriptor,
-                    this.config.rpcCommunicator,
-                    DeliveryRpcClient
-                ))
-            )
-            this.config.neighborFinder.start()
-            const response: NeighborUpdate = {
-                streamPartId: this.config.streamPartId,
-                neighborDescriptors: this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
-                removeMe: false
-            }
-            return response
+        this.updateContacts(message.neighborDescriptors)
+        if (!this.config.neighbors.has(senderId)) {
+            return this.createResponse(true)
         } else {
-            const response: NeighborUpdate = {
-                streamPartId: this.config.streamPartId,
-                neighborDescriptors: this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
-                removeMe: true
+            const isOverNeighborCount = this.config.neighbors.size() > this.config.neighborTargetCount
+                // Motivation: We don't know the remote's neighborTargetCount setting here. We only ask to cut connections
+                // if the remote has a "sufficient" number of neighbors, where "sufficient" means our neighborTargetCount
+                // setting.
+                && message.neighborDescriptors.length > this.config.neighborTargetCount
+            if (!isOverNeighborCount) {
+                this.config.neighborFinder.start()
+            } else {
+                this.config.neighbors.remove(senderId)
             }
-            return response
+            return this.createResponse(isOverNeighborCount)
         }
     }
 }

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -1,11 +1,16 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { TemporaryConnectionRequest, TemporaryConnectionResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { 
+    CloseTemporaryConnection,
+    TemporaryConnectionRequest,
+    TemporaryConnectionResponse
+} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { Empty } from '../../proto/google/protobuf/empty'
 
 interface TemporaryConnectionRpcLocalConfig {
     rpcCommunicator: ListeningRpcCommunicator
@@ -47,4 +52,10 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
             accepted: true
         }
     }
+
+    async closeConnection(_request: CloseTemporaryConnection, context: ServerCallContext): Promise<Empty> {
+        const senderId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
+        this.removeNode(senderId)
+        return {}
+    }
 }

package/src/logic/temporary-connection/TemporaryConnectionRpcRemote.ts

@@ -15,4 +15,15 @@ export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionR
             return false
         }
     }
+
+    async closeConnection(): Promise<void> {
+        try {
+            await this.getClient().closeConnection({}, this.formDhtRpcOptions({
+                connect: false,
+                notification: true
+            }))
+        } catch (err) {
+            logger.trace(`closeConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+        }
+    }
 }

package/src/proto/google/protobuf/any.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/any.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -39,7 +39,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { isJsonObject } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
@@ -272,8 +271,9 @@ class Any$Type extends MessageType<Any> {
         return name;
     }
     create(value?: PartialMessage<Any>): Any {
-        const message = { typeUrl: "", value: new Uint8Array(0) };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.typeUrl = "";
+        message.value = new Uint8Array(0);
         if (value !== undefined)
             reflectionMergePartial<Any>(this, message, value);
         return message;

package/src/proto/google/protobuf/empty.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/empty.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -39,7 +39,6 @@ import type { BinaryReadOptions } from "@protobuf-ts/runtime";
 import type { IBinaryReader } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
 /**
  * A generic empty message that you can re-use to avoid defining duplicated
@@ -62,8 +61,7 @@ class Empty$Type extends MessageType<Empty> {
         super("google.protobuf.Empty", []);
     }
     create(value?: PartialMessage<Empty>): Empty {
-        const message = {};
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
         if (value !== undefined)
             reflectionMergePartial<Empty>(this, message, value);
         return message;

package/src/proto/google/protobuf/timestamp.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -40,7 +40,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
 import type { JsonReadOptions } from "@protobuf-ts/runtime";
@@ -234,8 +233,9 @@ class Timestamp$Type extends MessageType<Timestamp> {
         return target;
     }
     create(value?: PartialMessage<Timestamp>): Timestamp {
-        const message = { seconds: 0, nanos: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.seconds = 0;
+        message.nanos = 0;
         if (value !== undefined)
             reflectionMergePartial<Timestamp>(this, message, value);
         return message;

package/src/proto/packages/dht/protos/DhtRpc.ts

@@ -339,6 +339,10 @@ export interface ConnectivityResponse {
      * @generated from protobuf field: uint32 ipAddress = 4;
      */
     ipAddress: number;
+    /**
+     * @generated from protobuf field: string version = 5;
+     */
+    version: string;
 }
 /**
  * @generated from protobuf message dht.HandshakeRequest
@@ -943,7 +947,8 @@ class ConnectivityResponse$Type extends MessageType$<ConnectivityResponse> {
             { no: 1, name: "host", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "natType", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 3, name: "websocket", kind: "message", T: () => ConnectivityMethod },
-            { no: 4, name: "ipAddress", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+            { no: 4, name: "ipAddress", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 5, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }

package/src/proto/packages/trackerless-network/protos/NetworkRpc.client.ts

@@ -5,6 +5,7 @@ import { NodeInfoRpc } from "./NetworkRpc";
 import type { NodeInfoResponse } from "./NetworkRpc";
 import type { NodeInfoRequest } from "./NetworkRpc";
 import { TemporaryConnectionRpc } from "./NetworkRpc";
+import type { CloseTemporaryConnection } from "./NetworkRpc";
 import type { TemporaryConnectionResponse } from "./NetworkRpc";
 import type { TemporaryConnectionRequest } from "./NetworkRpc";
 import { NeighborUpdateRpc } from "./NetworkRpc";
@@ -160,6 +161,10 @@ export interface ITemporaryConnectionRpcClient {
      * @generated from protobuf rpc: openConnection(TemporaryConnectionRequest) returns (TemporaryConnectionResponse);
      */
     openConnection(input: TemporaryConnectionRequest, options?: RpcOptions): UnaryCall<TemporaryConnectionRequest, TemporaryConnectionResponse>;
+    /**
+     * @generated from protobuf rpc: closeConnection(CloseTemporaryConnection) returns (google.protobuf.Empty);
+     */
+    closeConnection(input: CloseTemporaryConnection, options?: RpcOptions): UnaryCall<CloseTemporaryConnection, Empty>;
 }
 /**
  * @generated from protobuf service TemporaryConnectionRpc
@@ -177,6 +182,13 @@ export class TemporaryConnectionRpcClient implements ITemporaryConnectionRpcClie
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
         return stackIntercept<TemporaryConnectionRequest, TemporaryConnectionResponse>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: closeConnection(CloseTemporaryConnection) returns (google.protobuf.Empty);
+     */
+    closeConnection(input: CloseTemporaryConnection, options?: RpcOptions): UnaryCall<CloseTemporaryConnection, Empty> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<CloseTemporaryConnection, Empty>("unary", this._transport, method, opt, input);
+    }
 }
 /**
  * @generated from protobuf service NodeInfoRpc

package/src/proto/packages/trackerless-network/protos/NetworkRpc.server.ts

@@ -3,6 +3,7 @@
 // tslint:disable
 import { NodeInfoResponse } from "./NetworkRpc";
 import { NodeInfoRequest } from "./NetworkRpc";
+import { CloseTemporaryConnection } from "./NetworkRpc";
 import { TemporaryConnectionResponse } from "./NetworkRpc";
 import { TemporaryConnectionRequest } from "./NetworkRpc";
 import { NeighborUpdate } from "./NetworkRpc";
@@ -68,6 +69,10 @@ export interface ITemporaryConnectionRpc<T = ServerCallContext> {
      * @generated from protobuf rpc: openConnection(TemporaryConnectionRequest) returns (TemporaryConnectionResponse);
      */
     openConnection(request: TemporaryConnectionRequest, context: T): Promise<TemporaryConnectionResponse>;
+    /**
+     * @generated from protobuf rpc: closeConnection(CloseTemporaryConnection) returns (google.protobuf.Empty);
+     */
+    closeConnection(request: CloseTemporaryConnection, context: T): Promise<Empty>;
 }
 /**
  * @generated from protobuf service NodeInfoRpc

package/src/proto/packages/trackerless-network/protos/NetworkRpc.ts

@@ -273,6 +273,11 @@ export interface TemporaryConnectionResponse {
      */
     accepted: boolean;
 }
+/**
+ * @generated from protobuf message CloseTemporaryConnection
+ */
+export interface CloseTemporaryConnection {
+}
 /**
  * @generated from protobuf message StreamPartitionInfo
  */
@@ -616,6 +621,16 @@ class TemporaryConnectionResponse$Type extends MessageType<TemporaryConnectionRe
  */
 export const TemporaryConnectionResponse = new TemporaryConnectionResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class CloseTemporaryConnection$Type extends MessageType<CloseTemporaryConnection> {
+    constructor() {
+        super("CloseTemporaryConnection", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message CloseTemporaryConnection
+ */
+export const CloseTemporaryConnection = new CloseTemporaryConnection$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class StreamPartitionInfo$Type extends MessageType<StreamPartitionInfo> {
     constructor() {
         super("StreamPartitionInfo", [
@@ -696,7 +711,8 @@ export const NeighborUpdateRpc = new ServiceType("NeighborUpdateRpc", [
  * @generated ServiceType for protobuf service TemporaryConnectionRpc
  */
 export const TemporaryConnectionRpc = new ServiceType("TemporaryConnectionRpc", [
-    { name: "openConnection", options: {}, I: TemporaryConnectionRequest, O: TemporaryConnectionResponse }
+    { name: "openConnection", options: {}, I: TemporaryConnectionRequest, O: TemporaryConnectionResponse },
+    { name: "closeConnection", options: {}, I: CloseTemporaryConnection, O: Empty }
 ]);
 /**
  * @generated ServiceType for protobuf service NodeInfoRpc

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -0,0 +1,125 @@
+import { ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
+import { NeighborUpdateRpcLocal } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcLocal'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { NodeList } from '../../src/logic/NodeList'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { MockTransport } from '../utils/mock/Transport'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
+import { range } from 'lodash'
+
+describe('NeighborUpdateRpcLocal', () => {
+
+    const streamPartId = StreamPartIDUtils.parse('stream#0')
+    const localPeerDescriptor = createMockPeerDescriptor()
+    const neighborTargetCount = 4
+
+    let rpcLocal: NeighborUpdateRpcLocal
+    let neighbors: NodeList
+    let nearbyNodeView: NodeList
+    let neighborFinder: NeighborFinder
+    let rpcCommunicator: ListeningRpcCommunicator
+
+    const addNeighbors = (count: number) => {
+        for (let i = 0; i < count; i++) {
+            neighbors.add(new DeliveryRpcRemote(
+                localPeerDescriptor,
+                createMockPeerDescriptor(),
+                rpcCommunicator,
+                DeliveryRpcClient
+            ))
+        }
+    }
+
+    beforeEach(() => {
+        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
+        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborTargetCount + 1)
+        nearbyNodeView = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborTargetCount)
+        neighborFinder = {
+            start: jest.fn()
+        } as any
+
+        rpcLocal = new NeighborUpdateRpcLocal({
+            localPeerDescriptor,
+            neighbors,
+            nearbyNodeView,
+            neighborFinder,
+            streamPartId,
+            rpcCommunicator,
+            neighborTargetCount
+        })
+    })
+
+    afterEach(() => {
+        rpcCommunicator.destroy()
+    })
+
+    it('response contains neighbor list of expected size', async () => {
+        addNeighbors(neighborTargetCount)
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor],
+            removeMe: false
+        }, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
+        expect(res.neighborDescriptors.length).toEqual(neighborTargetCount)
+    })
+
+    it('updates contacts based on callers neighbors', async () => {
+        addNeighbors(neighborTargetCount)
+        expect(nearbyNodeView.size()).toEqual(0)
+        await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: range(neighborTargetCount).map(() => createMockPeerDescriptor()),
+            removeMe: false
+        }, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
+        expect(nearbyNodeView.size()).toEqual(4)
+    })
+
+    it('does not ask to be removed if caller is a neighbor', async () => {
+        const caller = createMockPeerDescriptor()
+        const neighbor = new DeliveryRpcRemote(
+            localPeerDescriptor,
+            caller,
+            rpcCommunicator,
+            DeliveryRpcClient
+        )
+        neighbors.add(neighbor)
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor],
+            removeMe: false
+        }, { incomingSourceDescriptor: caller } as any)
+        expect(res.removeMe).toEqual(false)
+    })
+
+    it('asks to be removed if caller is not a neighbor', async () => {
+        const caller = createMockPeerDescriptor()
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor],
+            removeMe: false
+        }, { incomingSourceDescriptor: caller } as any)
+        expect(res.removeMe).toEqual(true)
+    })
+
+    it('asks to be removed if caller is a neighbor and both have too many neighbors', async () => {
+        const caller = createMockPeerDescriptor()
+        const neighbor = new DeliveryRpcRemote(
+            localPeerDescriptor,
+            caller,
+            rpcCommunicator,
+            DeliveryRpcClient
+        )
+        neighbors.add(neighbor)
+        addNeighbors(neighborTargetCount)
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor, ...range(neighborTargetCount).map(() => createMockPeerDescriptor())],
+            removeMe: false
+        }, { incomingSourceDescriptor: caller } as any)
+        expect(res.removeMe).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(caller))).toEqual(false)
+    })
+
+})

package/test/unit/TemporaryConnectionRpcLocal.test.ts

@@ -0,0 +1,32 @@
+import { TemporaryConnectionRpcLocal } from '../../src/logic/temporary-connection/TemporaryConnectionRpcLocal'
+import { MockTransport } from '../utils/mock/Transport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { ListeningRpcCommunicator, getDhtAddressFromRaw } from '@streamr/dht'
+
+describe('TemporaryConnectionRpcLocal', () => {
+
+    const peerDescriptor = createMockPeerDescriptor()
+    let rpcCommunicator: ListeningRpcCommunicator
+    let rpcLocal: TemporaryConnectionRpcLocal
+
+    beforeEach(() => {
+        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
+        rpcLocal = new TemporaryConnectionRpcLocal({
+            localPeerDescriptor: peerDescriptor,
+            rpcCommunicator
+        })
+    })
+
+    afterEach(() => {
+        rpcCommunicator.destroy()
+    })
+
+    it('Open and Close Connection', async () => {
+        const caller = createMockPeerDescriptor()
+        await rpcLocal.openConnection({}, { incomingSourceDescriptor: caller } as any)
+        expect(rpcLocal.getNodes().get(getDhtAddressFromRaw(caller.nodeId))).toBeDefined()
+        await rpcLocal.closeConnection({}, { incomingSourceDescriptor: caller } as any)
+        expect(rpcLocal.getNodes().get(getDhtAddressFromRaw(caller.nodeId))).toBeUndefined()
+    })
+
+})