@dxos/teleport 0.1.23 → 0.1.24

package/dist/lib/browser/testing/index.mjs

@@ -1,734 +1,135 @@
 import "@dxos/node-std/globals"
+import {
+  Teleport,
+  TestExtension
+} from "../chunk-F3DXMBSX.mjs";
 
 // packages/core/mesh/teleport/src/testing/test-builder.ts
+import assert from "@dxos/node-std/assert";
 import { pipeline } from "@dxos/node-std/stream";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { log as log3 } from "@dxos/log";
-
-// packages/core/mesh/teleport/src/teleport.ts
-import assert3 from "@dxos/node-std/assert";
-import { asyncTimeout, scheduleTaskInterval, runInContextAsync, synchronized, scheduleTask } from "@dxos/async";
-import { Context } from "@dxos/context";
-import { failUndefined as failUndefined2 } from "@dxos/debug";
 import { PublicKey } from "@dxos/keys";
-import { log as log2 } from "@dxos/log";
-import { schema as schema2 } from "@dxos/protocols";
-import { createProtoRpcPeer, RpcClosedError } from "@dxos/rpc";
-import { Callback } from "@dxos/util";
-
-// packages/core/mesh/teleport/src/muxing/framer.ts
-import assert from "@dxos/node-std/assert";
-import { Duplex } from "@dxos/node-std/stream";
-import * as varint from "varint";
-var Framer = class {
-  constructor() {
-    this._stream = new Duplex({
-      objectMode: false,
-      read: () => {
-      },
-      write: (chunk, encoding, callback) => {
-        assert(!this._subscribeCb, "Internal Framer bug. Concurrent writes detected.");
-        if (this._buffer && this._buffer.length > 0) {
-          this._buffer = Buffer.concat([
-            this._buffer,
-            chunk
-          ]);
-        } else {
-          this._buffer = chunk;
-        }
-        if (this._messageCb) {
-          this._popFrames();
-          callback();
-        } else {
-          this._subscribeCb = () => {
-            this._popFrames();
-            this._subscribeCb = void 0;
-            callback();
-          };
-        }
-      }
-    });
-    this.port = {
-      send: (message) => {
-        this._stream.push(encodeFrame(message));
-      },
-      subscribe: (callback) => {
-        var _a;
-        assert(!this._messageCb, "Rpc port already has a message listener.");
-        this._messageCb = callback;
-        (_a = this._subscribeCb) == null ? void 0 : _a.call(this);
-        return () => {
-          this._messageCb = void 0;
-        };
-      }
-    };
-  }
-  get stream() {
-    return this._stream;
-  }
-  /**
-  * Attempts to pop frames from the buffer and call the message callback.
-  */
-  _popFrames() {
-    let offset = 0;
-    while (offset < this._buffer.length) {
-      const frame = decodeFrame(this._buffer, offset);
-      if (!frame) {
-        break;
-      }
-      offset += frame.bytesConsumed;
-      this._messageCb(frame.payload);
-    }
-    if (offset < this._buffer.length) {
-      this._buffer = this._buffer.subarray(offset);
-    } else {
-      this._buffer = void 0;
-    }
-  }
-  destroy() {
-    this._stream.destroy();
-  }
-};
-var decodeFrame = (buffer, offset) => {
-  try {
-    const frameLength = varint.decode(buffer, offset);
-    const tagLength = varint.decode.bytes;
-    if (buffer.length < offset + tagLength + frameLength) {
-      return void 0;
-    }
-    const payload = buffer.subarray(offset + tagLength, offset + tagLength + frameLength);
-    return {
-      payload,
-      bytesConsumed: tagLength + frameLength
-    };
-  } catch (err) {
-    if (err instanceof RangeError) {
-      return void 0;
-    } else {
-      throw err;
-    }
-  }
-};
-var encodeFrame = (payload) => {
-  const tagLength = varint.encodingLength(payload.length);
-  const frame = Buffer.allocUnsafe(tagLength + payload.length);
-  varint.encode(payload.length, frame);
-  frame.set(payload, tagLength);
-  return frame;
-};
-
-// packages/core/mesh/teleport/src/muxing/muxer.ts
-import assert2 from "@dxos/node-std/assert";
-import { Duplex as Duplex2 } from "@dxos/node-std/stream";
-import { Event } from "@dxos/async";
-import { failUndefined } from "@dxos/debug";
 import { log } from "@dxos/log";
-import { schema } from "@dxos/protocols";
-var codec = schema.getCodecForType("dxos.mesh.muxer.Command");
-var Muxer = class {
-  constructor() {
-    this._framer = new Framer();
-    this.stream = this._framer.stream;
-    this._channelsByLocalId = /* @__PURE__ */ new Map();
-    this._channelsByTag = /* @__PURE__ */ new Map();
-    this._nextId = 0;
-    this._destroyed = false;
-    this._destroying = false;
-    this.close = new Event();
-    this._framer.port.subscribe((msg) => {
-      this._handleCommand(codec.decode(msg));
-    });
-  }
-  /**
-  * Creates a duplex Node.js-style stream.
-  * The remote peer is expected to call `createStream` with the same tag.
-  * The stream is immediately readable and writable.
-  * NOTE: The data will be buffered until the stream is opened remotely with the same tag (may cause a memory leak).
-  */
-  createStream(tag, opts = {}) {
-    const channel = this._getOrCreateStream({
-      tag,
-      contentType: opts.contentType
-    });
-    assert2(!channel.push, `Channel already open: ${tag}`);
-    const stream = new Duplex2({
-      write: (data, encoding, callback) => {
-        this._sendData(channel, data);
-        callback();
-      },
-      read: () => {
-      }
-      // No-op. We will push data when we receive it.
-    });
-    channel.push = (data) => {
-      stream.push(data);
-    };
-    channel.destroy = (err) => {
-      stream.destroy(err);
-    };
-    this._sendCommand({
-      openChannel: {
-        id: channel.id,
-        tag: channel.tag,
-        contentType: channel.contentType
-      }
-    });
-    return stream;
-  }
-  /**
-  * Creates an RPC port.
-  * The remote peer is expected to call `createPort` with the same tag.
-  * The port is immediately usable.
-  * NOTE: The data will be buffered until the stream is opened remotely with the same tag (may cause a memory leak).
-  */
-  createPort(tag, opts = {}) {
-    const channel = this._getOrCreateStream({
-      tag,
-      contentType: opts.contentType
-    });
-    assert2(!channel.push, `Channel already open: ${tag}`);
-    let inboundBuffer = [];
-    let callback;
-    channel.push = (data) => {
-      if (callback) {
-        callback(data);
-      } else {
-        inboundBuffer.push(data);
-      }
-    };
-    const port = {
-      send: (data) => {
-        this._sendData(channel, data);
-      },
-      subscribe: (cb) => {
-        assert2(!callback, "Only one subscriber is allowed");
-        callback = cb;
-        for (const data of inboundBuffer) {
-          cb(data);
-        }
-        inboundBuffer = [];
-      }
-    };
-    this._sendCommand({
-      openChannel: {
-        id: channel.id,
-        tag: channel.tag,
-        contentType: channel.contentType
-      }
-    });
-    return port;
-  }
-  /**
-  * Force-close with optional error.
-  */
-  destroy(err) {
-    if (this._destroying) {
-      return;
-    }
-    this._destroying = true;
-    this._sendCommand({
-      destroy: {
-        error: err == null ? void 0 : err.message
-      }
-    });
-    this._dispose();
-  }
-  _dispose(err) {
-    var _a;
-    if (this._destroyed) {
-      return;
-    }
-    this._destroyed = true;
-    this._framer.destroy();
-    for (const channel of this._channelsByTag.values()) {
-      (_a = channel.destroy) == null ? void 0 : _a.call(channel, err);
-    }
-    this.close.emit(err);
-    this._channelsByLocalId.clear();
-    this._channelsByTag.clear();
-  }
-  _handleCommand(cmd) {
-    var _a;
-    log("Received command", {
-      cmd
-    }, {
-      file: "muxer.ts",
-      line: 194,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    if (this._destroyed || this._destroying) {
-      log.warn("Received command after destroy", {}, {
-        file: "muxer.ts",
-        line: 197,
-        scope: this,
-        callSite: (f, a) => f(...a)
-      });
-      return;
-    }
-    if (cmd.openChannel) {
-      const channel = this._getOrCreateStream({
-        tag: cmd.openChannel.tag,
-        contentType: cmd.openChannel.contentType
-      });
-      channel.remoteId = cmd.openChannel.id;
-      for (const data of channel.buffer) {
-        this._sendCommand({
-          data: {
-            channelId: channel.remoteId,
-            data
-          }
-        });
-      }
-      channel.buffer = [];
-    } else if (cmd.data) {
-      const stream = (_a = this._channelsByLocalId.get(cmd.data.channelId)) != null ? _a : failUndefined();
-      if (!stream.push) {
-        log.warn("Received data for channel before it was opened", {
-          tag: stream.tag
-        }, {
-          file: "muxer.ts",
-          line: 221,
-          scope: this,
-          callSite: (f, a) => f(...a)
-        });
-        return;
-      }
-      stream.push(cmd.data.data);
-    } else if (cmd.destroy) {
-      this._dispose();
-    }
-  }
-  _sendCommand(cmd) {
-    Promise.resolve(this._framer.port.send(codec.encode(cmd))).catch((err) => {
-      this.destroy(err);
-    });
-  }
-  _getOrCreateStream(params) {
-    let channel = this._channelsByTag.get(params.tag);
-    if (!channel) {
-      channel = {
-        id: this._nextId++,
-        remoteId: null,
-        tag: params.tag,
-        contentType: params.contentType,
-        buffer: [],
-        push: null,
-        destroy: null
-      };
-      this._channelsByTag.set(channel.tag, channel);
-      this._channelsByLocalId.set(channel.id, channel);
-    }
-    return channel;
-  }
-  _sendData(channel, data) {
-    if (channel.remoteId === null) {
-      channel.buffer.push(data);
-    } else {
-      this._sendCommand({
-        data: {
-          channelId: channel.remoteId,
-          data
-        }
-      });
-    }
-  }
-};
-
-// packages/core/mesh/teleport/src/teleport.ts
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var Teleport = class {
-  constructor({ initiator, localPeerId, remotePeerId }) {
-    this._ctx = new Context({
-      onError: (err) => {
-        void this.destroy(err).catch(() => {
-          log2.error("Error during destroy", err, {
-            file: "teleport.ts",
-            line: 34,
-            scope: this,
-            callSite: (f, a) => f(...a)
-          });
-        });
-      }
-    });
-    this._muxer = new Muxer();
-    this._control = new ControlExtension({
-      heartbeatInterval: 3e3,
-      heartbeatTimeout: 3e3,
-      onTimeout: () => {
-        this.destroy(new Error("Connection timed out")).catch((err) => log2.catch(err, {}, {
-          file: "teleport.ts",
-          line: 45,
-          scope: this,
-          callSite: (f, a) => f(...a)
-        }));
-      }
-    });
-    this._extensions = /* @__PURE__ */ new Map();
-    this._remoteExtensions = /* @__PURE__ */ new Set();
-    this._open = false;
-    assert3(typeof initiator === "boolean");
-    assert3(PublicKey.isPublicKey(localPeerId));
-    assert3(PublicKey.isPublicKey(remotePeerId));
-    assert3(typeof initiator === "boolean");
-    this.initiator = initiator;
-    this.localPeerId = localPeerId;
-    this.remotePeerId = remotePeerId;
-    this._control.onExtensionRegistered.set(async (name) => {
-      log2("remote extension", {
-        name
-      }, {
-        file: "teleport.ts",
-        line: 64,
-        scope: this,
-        callSite: (f, a) => f(...a)
-      });
-      assert3(!this._remoteExtensions.has(name), "Remote extension already exists");
-      this._remoteExtensions.add(name);
-      if (this._extensions.has(name)) {
-        try {
-          await this._openExtension(name);
-        } catch (err) {
-          await this.destroy(err);
-        }
-      }
-    });
-    {
-      this._muxer.stream.on("close", async () => {
-        await this.destroy();
-      });
-      this._muxer.stream.on("error", async (err) => {
-        await this.destroy(err);
-      });
-    }
-  }
-  get stream() {
-    return this._muxer.stream;
-  }
-  /**
-  * Blocks until the handshake is complete.
-  */
-  async open() {
-    this._setExtension("dxos.mesh.teleport.control", this._control);
-    await this._openExtension("dxos.mesh.teleport.control");
-    this._open = true;
-  }
-  async close(err) {
-    await this.destroy(err);
-  }
-  async destroy(err) {
-    if (this._ctx.disposed) {
-      return;
-    }
-    await this._ctx.dispose();
-    for (const extension of this._extensions.values()) {
-      try {
-        await extension.onClose(err);
-      } catch (err1) {
-        log2.catch(err1, {}, {
-          file: "teleport.ts",
-          line: 120,
-          scope: this,
-          callSite: (f, a) => f(...a)
-        });
-      }
-    }
-    this._muxer.destroy(err);
-  }
-  addExtension(name, extension) {
-    if (!this._open) {
-      throw new Error("Not open");
-    }
-    log2("addExtension", {
-      name
-    }, {
-      file: "teleport.ts",
-      line: 132,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    this._setExtension(name, extension);
-    scheduleTask(this._ctx, async () => {
-      try {
-        await this._control.registerExtension(name);
-      } catch (err) {
-        if (err instanceof RpcClosedError) {
-          return;
-        }
-        throw err;
-      }
-    });
-    if (this._remoteExtensions.has(name)) {
-      scheduleTask(this._ctx, async () => {
-        await this._openExtension(name);
-      });
-    }
-  }
-  _setExtension(extensionName, extension) {
-    assert3(!extensionName.includes("/"), "Invalid extension name");
-    assert3(!this._extensions.has(extensionName), "Extension already exists");
-    this._extensions.set(extensionName, extension);
-  }
-  async _openExtension(extensionName) {
-    var _a;
-    log2("open extension", {
-      extensionName
-    }, {
-      file: "teleport.ts",
-      line: 162,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    const extension = (_a = this._extensions.get(extensionName)) != null ? _a : failUndefined2();
-    const context = {
-      initiator: this.initiator,
-      localPeerId: this.localPeerId,
-      remotePeerId: this.remotePeerId,
-      createPort: (channelName, opts) => {
-        assert3(!channelName.includes("/"), "Invalid channel name");
-        return this._muxer.createPort(`${extensionName}/${channelName}`, opts);
-      },
-      createStream: (channelName, opts) => {
-        assert3(!channelName.includes("/"), "Invalid channel name");
-        return this._muxer.createStream(`${extensionName}/${channelName}`, opts);
-      },
-      close: (err) => {
-        void runInContextAsync(this._ctx, async () => {
-          await this.close(err);
-        });
-      }
-    };
-    await extension.onOpen(context);
-    log2("extension opened", {
-      extensionName
-    }, {
-      file: "teleport.ts",
-      line: 185,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-  }
-};
-__decorate([
-  synchronized
-], Teleport.prototype, "destroy", null);
-var ControlExtension = class {
-  constructor(opts) {
-    this.opts = opts;
-    this._ctx = new Context({
-      onError: (err) => {
-        this._extensionContext.close(err);
-      }
-    });
-    this.onExtensionRegistered = new Callback();
-  }
-  async onOpen(extensionContext) {
-    this._extensionContext = extensionContext;
-    this._rpc = createProtoRpcPeer({
-      requested: {
-        Control: schema2.getService("dxos.mesh.teleport.control.ControlService")
-      },
-      exposed: {
-        Control: schema2.getService("dxos.mesh.teleport.control.ControlService")
-      },
-      handlers: {
-        Control: {
-          registerExtension: async (request) => {
-            this.onExtensionRegistered.call(request.name);
-          },
-          heartbeat: async (request) => {
-          }
-        }
-      },
-      port: extensionContext.createPort("rpc", {
-        contentType: 'application/x-protobuf; messagType="dxos.rpc.Message"'
-      })
-    });
-    await this._rpc.open();
-    scheduleTaskInterval(this._ctx, async () => {
-      try {
-        await asyncTimeout(this._rpc.rpc.Control.heartbeat(), this.opts.heartbeatTimeout);
-      } catch (err) {
-        this.opts.onTimeout();
-      }
-    }, this.opts.heartbeatInterval);
-  }
-  async onClose(err) {
-    await this._ctx.dispose();
-    await this._rpc.close();
-  }
-  async registerExtension(name) {
-    await this._rpc.rpc.Control.registerExtension({
-      name
-    });
-  }
-};
-
-// packages/core/mesh/teleport/src/testing/test-builder.ts
 var TestBuilder = class {
   constructor() {
-    this._peers = new Array();
+    this._peers = /* @__PURE__ */ new Set();
   }
-  createPeer(peerId) {
-    const peer = new TestPeer(peerId);
-    this._peers.push(peer);
+  createPeer(opts) {
+    const peer = opts.factory();
+    this._peers.add(peer);
     return peer;
   }
+  *createPeers(opts) {
+    while (true) {
+      yield this.createPeer(opts);
+    }
+  }
   async destroy() {
-    await Promise.all(this._peers.map((agent) => agent.destroy()));
+    await Promise.all(Array.from(this._peers).map((agent) => agent.destroy()));
   }
-  /**
-  * Simulates two peers connected via P2P network.
-  */
-  async createPipedPeers({ peerId1, peerId2 } = {}) {
-    const peer1 = this.createPeer(peerId1);
-    const peer2 = this.createPeer(peerId2);
-    peer1.initializeTeleport({
+  async connect(peer1, peer2) {
+    assert(peer1 !== peer2);
+    assert(this._peers.has(peer1));
+    assert(this._peers.has(peer1));
+    const connection1 = peer1.createConnection({
       initiator: true,
       remotePeerId: peer2.peerId
     });
-    peer2.initializeTeleport({
+    const connection2 = peer2.createConnection({
       initiator: false,
       remotePeerId: peer1.peerId
     });
-    peer1.pipeline(peer2);
-    peer2.pipeline(peer1);
+    pipeStreams(connection1.teleport.stream, connection2.teleport.stream);
+    await Promise.all([
+      peer1.openConnection(connection1),
+      peer2.openConnection(connection2)
+    ]);
+    return [
+      connection1,
+      connection2
+    ];
+  }
+  async disconnect(peer1, peer2) {
+    assert(peer1 !== peer2);
+    assert(this._peers.has(peer1));
+    assert(this._peers.has(peer1));
+    const connection1 = Array.from(peer1.connections).find((connection) => connection.remotePeerId.equals(peer2.peerId));
+    const connection2 = Array.from(peer2.connections).find((connection) => connection.remotePeerId.equals(peer1.peerId));
+    assert(connection1);
+    assert(connection2);
     await Promise.all([
-      peer1.teleport.open(),
-      peer2.teleport.open()
+      peer1.closeConnection(connection1),
+      peer2.closeConnection(connection2)
     ]);
-    return {
-      peer1,
-      peer2
-    };
   }
 };
 var TestPeer = class {
-  constructor(peerId = PublicKey2.random()) {
+  constructor(peerId = PublicKey.random()) {
     this.peerId = peerId;
+    this.connections = /* @__PURE__ */ new Set();
   }
-  initializeTeleport({ initiator, remotePeerId }) {
-    if (this.teleport) {
-      return this;
-    }
-    this.teleport = new Teleport({
-      initiator,
-      localPeerId: this.peerId,
-      remotePeerId
-    });
-    return this;
-  }
-  pipeline(peer) {
-    if (!this.teleport || !peer.teleport) {
-      throw new Error("Teleport not initialized");
-    }
-    pipeline(this.teleport.stream, peer.teleport.stream, (err) => {
-      if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
-        log3.catch(err, {}, {
-          file: "test-builder.ts",
-          line: 67,
-          scope: this,
-          callSite: (f, a) => f(...a)
-        });
-      }
-    });
+  async onOpen(connection) {
   }
-  async destroy() {
-    var _a;
-    await ((_a = this.teleport) == null ? void 0 : _a.destroy());
+  async onClose(connection) {
   }
-};
-
-// packages/core/mesh/teleport/src/testing/test-extension.ts
-import assert4 from "@dxos/node-std/assert";
-import { asyncTimeout as asyncTimeout2, Trigger } from "@dxos/async";
-import { log as log4 } from "@dxos/log";
-import { schema as schema3 } from "@dxos/protocols";
-import { createProtoRpcPeer as createProtoRpcPeer2 } from "@dxos/rpc";
-var TestExtension = class {
-  constructor(callbacks = {}) {
-    this.callbacks = callbacks;
-    this.open = new Trigger();
-    this.closed = new Trigger();
+  createConnection({ initiator, remotePeerId }) {
+    const connection = new TestConnection(this.peerId, remotePeerId, initiator);
+    this.connections.add(connection);
+    return connection;
   }
-  get remotePeerId() {
-    var _a;
-    return (_a = this.extensionContext) == null ? void 0 : _a.remotePeerId;
+  async openConnection(connection) {
+    assert(this.connections.has(connection));
+    await connection.teleport.open();
+    await this.onOpen(connection);
   }
-  async onOpen(context) {
-    var _a, _b;
-    log4("onOpen", {
-      localPeerId: context.localPeerId,
-      remotePeerId: context.remotePeerId
-    }, {
-      file: "test-extension.ts",
-      line: 33,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    this.extensionContext = context;
-    this._rpc = createProtoRpcPeer2({
-      port: context.createPort("rpc", {
-        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
-      }),
-      requested: {
-        TestService: schema3.getService("example.testing.rpc.TestService")
-      },
-      exposed: {
-        TestService: schema3.getService("example.testing.rpc.TestService")
-      },
-      handlers: {
-        TestService: {
-          voidCall: async (request) => {
-          },
-          testCall: async (request) => {
-            return {
-              data: request.data
-            };
-          }
-        }
-      },
-      timeout: 1e3
-    });
-    await this._rpc.open();
-    await ((_b = (_a = this.callbacks).onOpen) == null ? void 0 : _b.call(_a));
-    this.open.wake();
+  async closeConnection(connection) {
+    assert(this.connections.has(connection));
+    await this.onClose(connection);
+    await connection.teleport.close();
+    this.connections.delete(connection);
   }
-  async onClose(err) {
-    var _a, _b, _c;
-    log4("onClose", {
-      err
-    }, {
-      file: "test-extension.ts",
-      line: 67,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    await ((_b = (_a = this.callbacks).onClose) == null ? void 0 : _b.call(_a));
-    this.closed.wake();
-    await ((_c = this._rpc) == null ? void 0 : _c.close());
+  async destroy() {
+    for (const teleport of this.connections) {
+      await this.closeConnection(teleport);
+    }
   }
-  async test() {
-    await this.open.wait({
-      timeout: 500
+};
+var pipeStreams = (stream1, stream2) => {
+  pipeline(stream1, stream2, (err) => {
+    if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+      log.catch(err, {}, {
+        file: "test-builder.ts",
+        line: 106,
+        scope: void 0,
+        callSite: (f, a) => f(...a)
+      });
+    }
+  });
+  pipeline(stream2, stream1, (err) => {
+    if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+      log.catch(err, {}, {
+        file: "test-builder.ts",
+        line: 111,
+        scope: void 0,
+        callSite: (f, a) => f(...a)
+      });
+    }
+  });
+};
+var TestConnection = class {
+  constructor(localPeerId, remotePeerId, initiator) {
+    this.localPeerId = localPeerId;
+    this.remotePeerId = remotePeerId;
+    this.initiator = initiator;
+    this.teleport = new Teleport({
+      initiator,
+      localPeerId,
+      remotePeerId
     });
-    const res = await asyncTimeout2(this._rpc.rpc.TestService.testCall({
-      data: "test"
-    }), 500);
-    assert4(res.data === "test");
   }
 };
 export {
   TestBuilder,
+  TestConnection,
   TestExtension,
   TestPeer
 };