@adminide-stack/extension-api 1.1.3-alpha.86 → 2.0.1-alpha.2

package/lib/connections/remote-rpc/browser-server-rpc.test.js

@@ -1,323 +1,317 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const abort_controller_1 = require("abort-controller");
-const mock_socket_1 = require("mock-socket");
-const connection_1 = require("../jsonrpc2/connection");
-const assert = require("assert");
-const browser_remote_rpc_1 = require("./browser-remote-rpc");
-const utils_1 = require("../../utils");
-const extension_module_server_1 = require("@workbench-stack/extension-module-server");
-const rpc_protocol_1 = require("../../protocol/rpc-protocol");
-const event_1 = require("@vscode-alt/monaco-editor/esm/vs/base/common/event");
-const rpc_logger_1 = require("../../protocol/rpc-logger");
-const test_helper_1 = require("../jsonrpc2/test-helper");
-const proxy_1 = require("../proxy/proxy");
-// import 'jest';
-const protocol_1 = require("../../protocol");
-const buffer_1 = require("@vscode-alt/monaco-editor/esm/vs/base/common/buffer");
-const consoleLogger = {
-    error(message) {
-        console.error(message);
-    },
-    warn(message) {
-        console.warn(message);
-    },
-    info(message) {
-        // tslint:disable-next-line:no-console
-        console.info(message);
-    },
-    log(message) {
-        // tslint:disable-next-line:no-console
-        console.log(message);
-    },
-};
-class MessagePassingProtocol {
-    constructor(hostId = 0 /* HostIdentifier.ServerExtHost */) {
-        this._onNativeMessage = new event_1.Emitter();
-        this.onMessage = this._onNativeMessage.event;
-        this._localHostId = hostId;
-    }
-    setPair(other) {
-        this._pair = other;
-    }
-    send(buffer, hostIdentifier) {
-        console.log('--send From Ext', hostIdentifier);
-        const headerBuf = buffer_1.VSBuffer.alloc(2);
-        // add destination host id
-        headerBuf.writeUInt8(hostIdentifier, 0);
-        // add sender host id
-        headerBuf.writeUInt8(this._localHostId, 1);
-        const cocatBuf = buffer_1.VSBuffer.concat([headerBuf, buffer]);
-        process.nextTick(() => {
-            this._pair._onNativeMessage.fire(cocatBuf);
-        });
-    }
-}
-class MultiMessagePassingProtocol {
-    constructor(hostId = 1 /* HostIdentifier.ServerMainThread */) {
-        this._wsProtocol = new extension_module_server_1.WsProtocol();
-        this._onNativeMessage = new event_1.Emitter();
-        this._onMessage = new event_1.EventMultiplexer();
-        this.onMessage = this._onMessage.event;
-        this._localHostId = hostId;
-        this._onMessage.add(this._onNativeMessage.event);
-        this._onMessage.add(this._wsProtocol.onMessage);
-    }
-    connect(socket) {
-        this._wsProtocol.connect(socket);
-    }
-    setPair(other) {
-        this._pair = other;
-    }
-    send(buffer, hostIdentifier) {
-        const transportType = this.getRequestTypeRouting(hostIdentifier);
-        const headerBuf = buffer_1.VSBuffer.alloc(2);
-        // add destination host id
-        headerBuf.writeUInt8(hostIdentifier, 0);
-        // add sender host id
-        headerBuf.writeUInt8(this._localHostId, 1);
-        const cocatBuf = buffer_1.VSBuffer.concat([headerBuf, buffer]);
-        this._send(cocatBuf, transportType);
-    }
-    _send(buffer, transportType) {
-        console.log('---_send fromMulitp transportType websocket', transportType === 1 /* TransportType.WebSocket */);
-        if (transportType === 1 /* TransportType.WebSocket */) {
-            this.webSend(buffer);
-        }
-        else {
-            this.nativeSend(buffer);
-        }
-    }
-    forward(buffer, hostIdentifier) {
-        console.log('---forward the request to hostId', hostIdentifier);
-        const transportType = this.getRequestTypeRouting(hostIdentifier);
-        if (transportType === 1 /* TransportType.WebSocket */) {
-            this._send(buffer, 1 /* TransportType.WebSocket */);
-        }
-        else {
-            this._send(buffer, 0 /* TransportType.Socket */);
-        }
-    }
-    webSend(buffer) {
-        return this._wsProtocol.send(buffer);
-    }
-    nativeSend(buffer) {
-        process.nextTick(() => {
-            this._pair._onNativeMessage.fire(buffer);
-        });
-    }
-    getRequestTypeRouting(hostIdentifier) {
-        if (hostIdentifier === 0 /* HostIdentifier.ServerExtHost */) {
-            return 0 /* TransportType.Socket */;
-        }
-        else if (hostIdentifier === 2 /* HostIdentifier.BrowserExtHost */) {
-            return 1 /* TransportType.WebSocket */;
-        }
-        else {
-            return 0 /* TransportType.Socket */;
-        }
-    }
-}
-describe('Websocket RPC', () => {
-    let fakeURL;
-    let mockServer;
-    let socket1;
-    let delegate;
-    let bProxyFromA;
-    let bProdyFromC;
-    let aProxyFromB;
-    let aProxyFromC;
-    let cProxyFromA;
-    class AClass {
-        $m(a1, a2) {
-            return Promise.resolve(delegate.call(null, a1, a2));
-        }
-    }
-    class BClass {
-        $n(a1, a2) {
-            return Promise.resolve(delegate.call(null, a1, a2));
-        }
-    }
-    class CClass {
-        $o(a1, a2) {
-            return Promise.resolve(delegate.call(null, a1, a2));
-        }
-    }
-    beforeEach((done) => {
-        fakeURL = 'ws://localhost:8080';
-        mockServer = new mock_socket_1.Server(fakeURL);
-        let b_protocol = new browser_remote_rpc_1.BrowserRemoteRPC();
-        b_protocol.connect(fakeURL, () => {
-            socket1 = new mock_socket_1.WebSocket(fakeURL);
-            socket1.binaryType = 'arraybuffer';
-            return socket1;
-        });
-        mockServer.on('connection', socket => {
-            console.log('---SOCKET MOCK SErver', socket);
-            let a_protocol = new MultiMessagePassingProtocol();
-            a_protocol.connect(socket);
-            let c_protocol = new MessagePassingProtocol();
-            c_protocol.setPair(a_protocol);
-            a_protocol.setPair(c_protocol);
-            let A = new rpc_protocol_1.RPCProtocol(a_protocol, 1 /* HostIdentifier.ServerMainThread */, new rpc_logger_1.RPCLogger(), null);
-            let B = new rpc_protocol_1.RPCProtocol(b_protocol, 2 /* HostIdentifier.BrowserExtHost */, new rpc_logger_1.RPCLogger(), null);
-            let C = new rpc_protocol_1.RPCProtocol(c_protocol, 0 /* HostIdentifier.ServerExtHost */, new rpc_logger_1.RPCLogger(), null);
-            const bIdentifier = new protocol_1.ProxyIdentifier(false, 'bb', 2 /* HostIdentifier.BrowserExtHost */);
-            const bInstance = new BClass();
-            const aIdentifier = new protocol_1.ProxyIdentifier(false, 'aa', 1 /* HostIdentifier.ServerMainThread */);
-            const aInstance = new AClass();
-            const cIdentifer = new protocol_1.ProxyIdentifier(false, 'cc', 0 /* HostIdentifier.ServerExtHost */);
-            const cInstance = new CClass();
-            B.set(bIdentifier, bInstance);
-            A.set(aIdentifier, aInstance);
-            C.set(cIdentifer, cInstance);
-            bProxyFromA = A.getProxy(bIdentifier);
-            aProxyFromC = C.getProxy(aIdentifier);
-            aProxyFromB = B.getProxy(aIdentifier);
-            cProxyFromA = A.getProxy(cIdentifer);
-            bProdyFromC = C.getProxy(bIdentifier);
-            cProxyFromA = A.getProxy(cIdentifer);
-            done();
-        });
-    });
-    afterEach(() => {
-        socket1.close();
-        mockServer.close();
-    });
-    test('simple call C -> A', function (done) {
-        delegate = (a1, a2) => a1 + a2;
-        aProxyFromC.$m(4, 1).then((res) => {
-            assert.equal(res, 5);
-            done();
-        }, done.fail);
-    });
-    test('simple call B -> A', function (done) {
-        delegate = (a1, a2) => a1 + a2;
-        aProxyFromB.$m(4, 1).then((res) => {
-            assert.equal(res, 5);
-            done();
-        }, done.fail);
-    });
-    test('simple call C -> B', function (done) {
-        delegate = (a1, a2) => a1 + a2;
-        bProdyFromC.$n(4, 1).then((res) => {
-            assert.equal(res, 5);
-            done();
-        }, done.fail);
-    });
-    test('simple call A -> C', function (done) {
-        delegate = (a1, a2) => a1 + a2;
-        cProxyFromA.$o(4, 1).then((res) => {
-            assert.equal(res, 5);
-            done();
-        }, done.fail);
-    });
-    test('test buffer', function () {
-        const b1 = Buffer.allocUnsafe(2);
-        const b2 = Buffer.allocUnsafe(1);
-        b1.writeUInt8(10, 0);
-        b1.writeUInt8(99, 1);
-        b2.writeUInt8(20, 0);
-        const buf = Buffer.concat([b1, b2]);
-        const a1 = buf.readUInt8(0);
-        // const bufNew = buf.slice(3);
-        const a2 = buf.readUInt8(2);
-        console.log('---a1', a1);
-        console.log('---a2', a2);
-    });
-    test('simple call  A->C', function (done) {
-        delegate = (a1, a2) => a1 + a2;
-        cProxyFromA.$o(6, 1).then((res) => {
-            assert.equal(res, 7);
-            done();
-        }, done.fail);
-    });
-    test('works', () => {
-        const result = [];
-        const m = new event_1.EventMultiplexer();
-        m.event(r => result.push(r));
-        const e1 = new event_1.Emitter();
-        m.add(e1.event);
-        assert.deepEqual(result, []);
-        e1.fire(0);
-        assert.deepEqual(result, [0]);
-    });
-});
-xdescribe('Connection', () => {
-    let delegate;
-    let aProxy;
-    class AClass {
-        $m(a1, a2) {
-            return Promise.resolve(delegate.call(null, a1, a2));
-        }
-    }
-    class BClass {
-        $m(b1, b2) {
-            return Promise.resolve(delegate.call(null, b1, b2));
-        }
-    }
-    // Polyfill
-    ;
-    global.AbortController = abort_controller_1.default;
-    let mockServer, socket1;
-    const aIdentifier = new protocol_1.ProxyIdentifier(false, 'aa');
-    let A, B;
-    beforeEach((done) => {
-    });
-    afterEach(() => {
-        socket1.close();
-        mockServer.close();
-    });
-    xtest('handle single request', (done) => __awaiter(void 0, void 0, void 0, function* () {
-        const [serverTransports, clientTransports] = (0, test_helper_1.createMessageTransports)();
-        delegate = (a1, a2) => a1 + a2;
-        const server = (0, connection_1.createConnection)(serverTransports, consoleLogger);
-        (0, proxy_1.handleServerProxyRequest)(server, B, aIdentifier);
-        server.listen();
-        server.onClose(event => done());
-        const client = (0, connection_1.createConnection)(clientTransports);
-        client.listen();
-        const signal = new abort_controller_1.default().signal;
-        const result = yield client.sendRequest('aa/$m', [4, 1], signal);
-        expect(result).toBe(5);
-        done();
-    }));
-    xit('abort undispatched request', (done) => __awaiter(void 0, void 0, void 0, function* () {
-        const [serverTransports, clientTransports] = (0, test_helper_1.createMessageTransports)();
-        const b1 = (0, utils_1.createBarrier)();
-        const b2 = (0, utils_1.createBarrier)();
-        delegate = (a1, a2) => a1 + a2;
-        const server = (0, connection_1.createConnection)(serverTransports, consoleLogger);
-        server.onRequest('block', () => __awaiter(void 0, void 0, void 0, function* () {
-            b2.done();
-            yield b1.wait;
-        }));
-        // server.onRequest('undispatched', () => {
-        //     throw new Error('handler should not be called')
-        // })
-        (0, proxy_1.handleServerProxyRequest)(server, B, aIdentifier);
-        server.listen();
-        const client = (0, connection_1.createConnection)(clientTransports);
-        client.listen();
-        server.onClose(event => done());
-        client.sendRequest('block').catch(null);
-        yield b2.wait;
-        const abortController = new abort_controller_1.default();
-        // const result = client.sendRequest('undispatched', ['foo'], abortController.signal)
-        const result = client.sendRequest('aa/$m', [4, 1], abortController.signal);
-        abortController.abort();
-        b1.done();
-        yield assert.rejects(result, (err /** : AbortError*/) => err.name === 'AbortError');
-    }));
-});
+// import 'reflect-metadata';
+// import AbortController from 'abort-controller';
+// import { WebSocket, Server } from 'mock-socket';
+// import { Logger, createConnection } from '../jsonrpc2/connection';
+// import * as assert from 'assert';
+// import { BrowserRemoteRPC } from './browser-remote-rpc';
+// import { createBarrier } from '../../utils';
+// import { WsProtocol } from '@workbench-stack/extension-module-server';
+// import { RPCProtocol, IRPCMessagePassingProtocol } from '../../protocol/rpc-protocol';
+// // import { MessageBuffer as ServerMessageBuffer, MessageIO as ServerMessageIO } from '../../protocol/server-message-io';
+// // import { MessageBuffer as BrowserMessageBuffer, MessageIO as BrowserMessageIO, MessageBuffer } from '../../protocol/browser-message-io';
+// import { logger } from '@cdm-logger/server';
+// import { Event, Emitter, EventMultiplexer } from '@vscode-alt/monaco-editor/esm/vs/base/common/event';
+// import { RPCLogger } from '../../protocol/rpc-logger';
+// import { createMessagePipe, createMessageTransports } from '../jsonrpc2/test-helper';
+// import { handleServerProxyRequest } from '../proxy/proxy';
+// // import 'jest';
+// import { ProxyIdentifier, TransportType, HostIdentifier, RequestType } from '../../protocol';
+// import { VSBuffer } from '@vscode-alt/monaco-editor/esm/vs/base/common/buffer';
+// const consoleLogger: Logger = {
+//     error(message: string): void {
+//         console.error(message);
+//     },
+//     warn(message: string): void {
+//         console.warn(message);
+//     },
+//     info(message: string): void {
+//         // tslint:disable-next-line:no-console
+//         console.info(message);
+//     },
+//     log(message: string): void {
+//         // tslint:disable-next-line:no-console
+//         console.log(message);
+//     },
+// };
+// class MessagePassingProtocol implements IRPCMessagePassingProtocol {
+//     private _pair: MultiMessagePassingProtocol;
+//     public readonly _onNativeMessage = new Emitter<VSBuffer>();
+//     public readonly onMessage: Event<VSBuffer> = this._onNativeMessage.event;
+//     private readonly _localHostId: HostIdentifier;
+//     constructor(hostId: HostIdentifier = HostIdentifier.ServerExtHost) {
+//         this._localHostId = hostId;
+//     }
+//     public setPair(other: MultiMessagePassingProtocol) {
+//         this._pair = other;
+//     }
+//     public send(buffer: VSBuffer, hostIdentifier: HostIdentifier): void {
+//         console.log('--send From Ext', hostIdentifier);
+//         const headerBuf = VSBuffer.alloc(2);
+//         // add destination host id
+//         headerBuf.writeUInt8(hostIdentifier, 0);
+//         // add sender host id
+//         headerBuf.writeUInt8(this._localHostId, 1);
+//         const cocatBuf = VSBuffer.concat([headerBuf, buffer]);
+//         process.nextTick(() => {
+//             this._pair._onNativeMessage.fire(cocatBuf);
+//         });
+//     }
+// }
+// class MultiMessagePassingProtocol implements IRPCMessagePassingProtocol {
+//     private _pair: MessagePassingProtocol;
+//     private _wsProtocol = new WsProtocol();
+//     public readonly _onNativeMessage = new Emitter<VSBuffer>();
+//     private readonly _onMessage = new EventMultiplexer<VSBuffer>();
+//     private readonly _localHostId: HostIdentifier;
+//     constructor(hostId: HostIdentifier = HostIdentifier.ServerMainThread) {
+//         this._localHostId = hostId;
+//         this._onMessage.add(this._onNativeMessage.event);
+//         this._onMessage.add(this._wsProtocol.onMessage);
+//     }
+//     public onMessage: Event<VSBuffer> = this._onMessage.event;
+//     public connect(socket: any) {
+//         this._wsProtocol.connect(socket);
+//     }
+//     public setPair(other: MessagePassingProtocol) {
+//         this._pair = other;
+//     }
+//     public send(buffer: VSBuffer, hostIdentifier: HostIdentifier): void {
+//         const transportType = this.getRequestTypeRouting(hostIdentifier);
+//         const headerBuf = VSBuffer.alloc(2);
+//         // add destination host id
+//         headerBuf.writeUInt8(hostIdentifier, 0);
+//         // add sender host id
+//         headerBuf.writeUInt8(this._localHostId, 1);
+//         const cocatBuf = VSBuffer.concat([headerBuf, buffer]);
+//         this._send(cocatBuf, transportType);
+//     }
+//     public _send(buffer: VSBuffer, transportType?: TransportType): void {
+//         console.log('---_send fromMulitp transportType websocket', transportType === TransportType.WebSocket);
+//         if (transportType === TransportType.WebSocket) {
+//             this.webSend(buffer);
+//         } else {
+//             this.nativeSend(buffer);
+//         }
+//     }
+//     public forward(buffer: VSBuffer, hostIdentifier?: HostIdentifier) {
+//         console.log('---forward the request to hostId', hostIdentifier);
+//         const transportType = this.getRequestTypeRouting(hostIdentifier);
+//         if (transportType === TransportType.WebSocket) {
+//             this._send(buffer, TransportType.WebSocket);
+//         } else {
+//             this._send(buffer, TransportType.Socket);
+//         }
+//     }
+//     private webSend(buffer: VSBuffer) {
+//         return this._wsProtocol.send(buffer);
+//     }
+//     private nativeSend(buffer: VSBuffer): void {
+//         process.nextTick(() => {
+//             this._pair._onNativeMessage.fire(buffer);
+//         });
+//     }
+//     private getRequestTypeRouting(hostIdentifier?: HostIdentifier) {
+//         if (hostIdentifier === HostIdentifier.ServerExtHost) {
+//             return TransportType.Socket;
+//         } else if (hostIdentifier === HostIdentifier.BrowserExtHost) {
+//             return TransportType.WebSocket;
+//         } else {
+//             return TransportType.Socket;
+//         }
+//     }
+// }
+// describe('Websocket RPC', () => {
+//     let fakeURL;
+//     let mockServer;
+//     let socket1;
+//     let delegate: (a1: any, a2: any) => any;
+//     let bProxyFromA: BClass;
+//     let bProdyFromC: BClass;
+//     let aProxyFromB: AClass;
+//     let aProxyFromC: AClass;
+//     let cProxyFromA: CClass;
+//     class AClass {
+//         public $m(a1: any, a2: any): Promise<any> {
+//             return Promise.resolve(delegate.call(null, a1, a2));
+//         }
+//     }
+//     class BClass {
+//         public $n(a1: any, a2: any): Promise<any> {
+//             return Promise.resolve(delegate.call(null, a1, a2));
+//         }
+//     }
+//     class CClass {
+//         public $o(a1: any, a2: any): Promise<any> {
+//             return Promise.resolve(delegate.call(null, a1, a2));
+//         }
+//     }
+//     beforeEach((done) => {
+//         fakeURL = 'ws://localhost:8080';
+//         mockServer = new Server(fakeURL);
+//         let b_protocol = new BrowserRemoteRPC();
+//         b_protocol.connect(fakeURL, () => {
+//             socket1 = new WebSocket(fakeURL);
+//             socket1.binaryType = 'arraybuffer';
+//             return socket1;
+//         });
+//         mockServer.on('connection', socket => {
+//             console.log('---SOCKET MOCK SErver', socket);
+//             let a_protocol = new MultiMessagePassingProtocol();
+//             a_protocol.connect(socket);
+//             let c_protocol = new MessagePassingProtocol();
+//             c_protocol.setPair(a_protocol);
+//             a_protocol.setPair(c_protocol);
+//             let A = new RPCProtocol(a_protocol, HostIdentifier.ServerMainThread, new RPCLogger(), null);
+//             let B = new RPCProtocol(b_protocol, HostIdentifier.BrowserExtHost, new RPCLogger(), null);
+//             let C = new RPCProtocol(c_protocol, HostIdentifier.ServerExtHost, new RPCLogger(), null);
+//             const bIdentifier = new ProxyIdentifier<BClass>(false, 'bb', HostIdentifier.BrowserExtHost);
+//             const bInstance = new BClass();
+//             const aIdentifier = new ProxyIdentifier<AClass>(false, 'aa', HostIdentifier.ServerMainThread);
+//             const aInstance = new AClass();
+//             const cIdentifer = new ProxyIdentifier<CClass>(false, 'cc', HostIdentifier.ServerExtHost);
+//             const cInstance = new CClass();
+//             B.set(bIdentifier, bInstance);
+//             A.set(aIdentifier, aInstance);
+//             C.set(cIdentifer, cInstance);
+//             bProxyFromA = A.getProxy(bIdentifier);
+//             aProxyFromC = C.getProxy(aIdentifier);
+//             aProxyFromB = B.getProxy(aIdentifier);
+//             cProxyFromA = A.getProxy(cIdentifer);
+//             bProdyFromC = C.getProxy(bIdentifier);
+//             cProxyFromA = A.getProxy(cIdentifer);
+//             done();
+//         });
+//     });
+//     afterEach(() => {
+//         socket1.close();
+//         mockServer.close();
+//     });
+//     test('simple call C -> A', function (done) {
+//         delegate = (a1: number, a2: number) => a1 + a2;
+//         aProxyFromC.$m(4, 1).then((res: number) => {
+//             assert.equal(res, 5);
+//             done();
+//         }, done.fail);
+//     });
+//     test('simple call B -> A', function (done) {
+//         delegate = (a1: number, a2: number) => a1 + a2;
+//         aProxyFromB.$m(4, 1).then((res: number) => {
+//             assert.equal(res, 5);
+//             done();
+//         }, done.fail);
+//     });
+//     test('simple call C -> B', function (done) {
+//         delegate = (a1: number, a2: number) => a1 + a2;
+//         bProdyFromC.$n(4, 1).then((res: number) => {
+//             assert.equal(res, 5);
+//             done();
+//         }, done.fail);
+//     });
+//     test('simple call A -> C', function (done) {
+//         delegate = (a1: number, a2: number) => a1 + a2;
+//         cProxyFromA.$o(4, 1).then((res: number) => {
+//             assert.equal(res, 5);
+//             done();
+//         }, done.fail);
+//     });
+//     test('test buffer', function () {
+//         const b1 = Buffer.allocUnsafe(2);
+//         const b2 = Buffer.allocUnsafe(1);
+//         b1.writeUInt8(10, 0);
+//         b1.writeUInt8(99, 1);
+//         b2.writeUInt8(20, 0);
+//         const buf = Buffer.concat([b1, b2]);
+//         const a1 = buf.readUInt8(0);
+//         // const bufNew = buf.slice(3);
+//         const a2 = buf.readUInt8(2);
+//         console.log('---a1', a1);
+//         console.log('---a2', a2);
+//     });
+//     test('simple call  A->C', function (done) {
+//         delegate = (a1: number, a2: number) => a1 + a2;
+//         cProxyFromA.$o(6, 1).then((res: number) => {
+//             assert.equal(res, 7);
+//             done();
+//         }, done.fail);
+//     });
+//     test('works', () => {
+//         const result: number[] = [];
+//         const m = new EventMultiplexer<number>();
+//         m.event(r => result.push(r));
+//         const e1 = new Emitter<number>();
+//         m.add(e1.event);
+//         assert.deepEqual(result, []);
+//         e1.fire(0);
+//         assert.deepEqual(result, [0]);
+//     });
+// });
+// xdescribe('Connection', () => {
+//     let delegate: (a1: any, a2: any) => any;
+//     interface IAClass {
+//         $m(a1: any, a2: any): Promise<any>;
+//     }
+//     let aProxy: AClass;
+//     class AClass implements IAClass {
+//         public $m(a1: any, a2: any): Promise<any> {
+//             return Promise.resolve(delegate.call(null, a1, a2));
+//         }
+//     }
+//     class BClass {
+//         public $m(b1: any, b2: any): Promise<any> {
+//             return Promise.resolve(delegate.call(null, b1, b2));
+//         }
+//     }
+//     // Polyfill
+//     ; (global as any).AbortController = AbortController;
+//     let mockServer, socket1: WebSocket;
+//     const aIdentifier = new ProxyIdentifier<AClass>(false, 'aa');
+//     let A, B;
+//     beforeEach((done) => {
+//     });
+//     afterEach(() => {
+//         socket1.close();
+//         mockServer.close();
+//     });
+//     xtest('handle single request', async (done) => {
+//         const [serverTransports, clientTransports] = createMessageTransports();
+//         delegate = (a1: number, a2: number) => a1 + a2;
+//         const server = createConnection(serverTransports, consoleLogger);
+//         handleServerProxyRequest(server, B, aIdentifier);
+//         server.listen();
+//         server.onClose(event => done());
+//         const client = createConnection(clientTransports);
+//         client.listen();
+//         const signal = new AbortController().signal;
+//         const result = await client.sendRequest('aa/$m', [4, 1], signal as any);
+//         expect(result).toBe(5);
+//         done();
+//     });
+//     xit('abort undispatched request', async (done) => {
+//         const [serverTransports, clientTransports] = createMessageTransports();
+//         const b1 = createBarrier();
+//         const b2 = createBarrier();
+//         delegate = (a1: number, a2: number) => a1 + a2;
+//         const server = createConnection(serverTransports, consoleLogger);
+//         server.onRequest('block', async () => {
+//             b2.done();
+//             await b1.wait;
+//         });
+//         // server.onRequest('undispatched', () => {
+//         //     throw new Error('handler should not be called')
+//         // })
+//         handleServerProxyRequest(server, B, aIdentifier);
+//         server.listen();
+//         const client = createConnection(clientTransports);
+//         client.listen();
+//         server.onClose(event => done());
+//         client.sendRequest('block').catch(null);
+//         await b2.wait;
+//         const abortController = new AbortController();
+//         // const result = client.sendRequest('undispatched', ['foo'], abortController.signal)
+//         const result = client.sendRequest('aa/$m', [4, 1], abortController.signal as any);
+//         abortController.abort();
+//         b1.done();
+//         await assert.rejects(result, (err/** : AbortError*/) => err.name === 'AbortError');
+//     });
+// });
 //# sourceMappingURL=browser-server-rpc.test.js.map