@antelopejs/api 0.0.1

package/dist/test/interface/api.js

@@ -0,0 +1,739 @@
+"use strict";
+var __decorate = (this && this.__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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestWebsocketController1 = exports.TestExecutionController3 = exports.TestExecutionController2 = exports.TestExecutionController1 = exports.TestRoutingController3 = exports.TestRoutingController2 = exports.TestRoutingController1 = exports.TestRoutingController0 = void 0;
+const beta_1 = require("@ajs/api/beta");
+const decorators_1 = require("@ajs/core/beta/decorators");
+const assert_1 = __importDefault(require("assert"));
+const sinon_1 = __importDefault(require("sinon"));
+const stream_1 = require("stream");
+const ws_1 = __importDefault(require("ws"));
+const SpyMethod = (0, decorators_1.MakeMethodDecorator)((_target, _key, descriptor) => {
+    descriptor.value = sinon_1.default.spy(descriptor.value);
+});
+const URL_BASE = 'http://127.0.0.1:5010';
+function FetchTest(name, options) {
+    it(`${name}: ${options.method ?? 'GET'} ${options.route}`, async function () {
+        const init = { method: options.method ?? 'GET' };
+        if (options.prepare) {
+            await options.prepare.apply(this, [init, options]);
+        }
+        const res = await fetch(URL_BASE + options.route, init);
+        if (res.status !== options.status) {
+            throw new Error(`Wrong response status (expected ${options.status}, got ${res.status}): ${await res.text()}`);
+        }
+        if (options.result !== undefined) {
+            assert_1.default.equal(await res.text(), options.result, 'Incorrect response body');
+        }
+        if (options.callCount) {
+            sinon_1.default.assert.callCount(options.callCount[0], options.callCount[1]);
+        }
+        if (options.postCheck) {
+            await options.postCheck.apply(this, [res, options]);
+        }
+    });
+}
+class TestRoutingController0 extends (0, beta_1.Controller)('/') {
+    test() { }
+    testPrefixHigh() { }
+    testPrefixLow() { }
+    testPriority() { }
+    testPostfixHigh() { }
+    testPostfixLow() { }
+    testPrefixEarlyReturn() {
+        return 'Ok Early';
+    }
+    testEarlyReturn() {
+        return 'Not Ok';
+    }
+    testOverride() {
+        return 'Not Ok';
+    }
+    testPostfixOverride() {
+        return 'Ok Override';
+    }
+}
+exports.TestRoutingController0 = TestRoutingController0;
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "test", null);
+__decorate([
+    (0, beta_1.Prefix)('get', 'testPriority', beta_1.HandlerPriority.HIGH),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testPrefixHigh", null);
+__decorate([
+    (0, beta_1.Prefix)('get', 'testPriority', beta_1.HandlerPriority.LOW),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testPrefixLow", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testPriority", null);
+__decorate([
+    (0, beta_1.Postfix)('get', 'testPriority', beta_1.HandlerPriority.HIGH),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testPostfixHigh", null);
+__decorate([
+    (0, beta_1.Postfix)('get', 'testPriority', beta_1.HandlerPriority.LOW),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testPostfixLow", null);
+__decorate([
+    (0, beta_1.Prefix)('get', 'testEarlyReturn'),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testPrefixEarlyReturn", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testEarlyReturn", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testOverride", null);
+__decorate([
+    (0, beta_1.Postfix)('get', 'testOverride'),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController0.prototype, "testPostfixOverride", null);
+class TestRoutingController1 extends (0, beta_1.Controller)('/routing/controller1') {
+    test() {
+        return 'Ok';
+    }
+    testPost() {
+        return 'Ok Post';
+    }
+    testPut() {
+        return 'Ok Put';
+    }
+    testDelete() {
+        return 'Ok Delete';
+    }
+    testCustom() {
+        return 'Ok Patch';
+    }
+}
+exports.TestRoutingController1 = TestRoutingController1;
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController1.prototype, "test", null);
+__decorate([
+    (0, beta_1.Post)('test'),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController1.prototype, "testPost", null);
+__decorate([
+    (0, beta_1.Put)('test'),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController1.prototype, "testPut", null);
+__decorate([
+    (0, beta_1.Delete)('test'),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController1.prototype, "testDelete", null);
+__decorate([
+    (0, beta_1.Route)('handler', 'patch', 'test'),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController1.prototype, "testCustom", null);
+class TestRoutingController2 extends TestRoutingController1.extend('/explicit') {
+    test() {
+        return 'Ok 2';
+    }
+}
+exports.TestRoutingController2 = TestRoutingController2;
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController2.prototype, "test", null);
+class TestRoutingController3 extends (0, beta_1.Controller)('///routing///controller2///') {
+    test() { }
+}
+exports.TestRoutingController3 = TestRoutingController3;
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestRoutingController3.prototype, "test", null);
+describe('Routing', () => {
+    describe('Controller', () => {
+        FetchTest('Root Controller', { route: '/test', method: 'GET', status: 200 });
+        FetchTest('Normal Controller', {
+            route: '/routing/controller1/test',
+            method: 'GET',
+            status: 200,
+            result: 'Ok',
+        });
+        FetchTest('Extended Controller', {
+            route: '/routing/controller1/explicit/test',
+            method: 'GET',
+            status: 200,
+            result: 'Ok 2',
+        });
+        FetchTest('Redundant Slash Controller', { route: '/routing/controller2/test', method: 'GET', status: 200 });
+    });
+    describe('Handler', () => {
+        const testRoute1 = TestRoutingController1.prototype.test;
+        FetchTest('Normal Call', {
+            route: '/routing/controller1/test',
+            method: 'GET',
+            status: 200,
+            callCount: [testRoute1, 1],
+            prepare: () => testRoute1.resetHistory(),
+        });
+        FetchTest('Options Call', {
+            route: '/routing/controller1/test',
+            method: 'OPTIONS',
+            status: 404,
+            callCount: [testRoute1, 0],
+            prepare: () => testRoute1.resetHistory(),
+        });
+        FetchTest('Head Call', {
+            route: '/routing/controller1/test',
+            method: 'HEAD',
+            status: 200,
+            result: '',
+            callCount: [testRoute1, 1],
+            prepare: () => testRoute1.resetHistory(),
+        });
+        FetchTest('Post Call', {
+            route: '/routing/controller1/test',
+            method: 'POST',
+            status: 200,
+            result: 'Ok Post',
+        });
+        FetchTest('Put Call', {
+            route: '/routing/controller1/test',
+            method: 'PUT',
+            status: 200,
+            result: 'Ok Put',
+        });
+        FetchTest('Delete Call', {
+            route: '/routing/controller1/test',
+            method: 'DELETE',
+            status: 200,
+            result: 'Ok Delete',
+        });
+        FetchTest('Custom Call (PATCH)', {
+            route: '/routing/controller1/test',
+            method: 'PATCH',
+            status: 200,
+            result: 'Ok Patch',
+        });
+        FetchTest('Prefix Priority', {
+            route: '/testPriority',
+            method: 'GET',
+            status: 200,
+            postCheck: () => {
+                sinon_1.default.assert.callOrder(TestRoutingController0.prototype.testPrefixHigh, TestRoutingController0.prototype.testPrefixLow, TestRoutingController0.prototype.testPriority);
+            },
+        });
+        FetchTest('Prefix Early Return', {
+            route: '/testEarlyReturn',
+            method: 'GET',
+            status: 200,
+            result: 'Ok Early',
+            callCount: [TestRoutingController0.prototype.testEarlyReturn, 0],
+        });
+        FetchTest('Postfix Priority', {
+            route: '/testPriority',
+            method: 'GET',
+            status: 200,
+            postCheck: () => {
+                sinon_1.default.assert.callOrder(TestRoutingController0.prototype.testPriority, TestRoutingController0.prototype.testPostfixHigh, TestRoutingController0.prototype.testPostfixLow);
+            },
+        });
+        FetchTest('Postfix Override', {
+            route: '/testOverride',
+            method: 'GET',
+            status: 200,
+            result: 'Ok Override',
+            callCount: [TestRoutingController0.prototype.testOverride, 1],
+        });
+    });
+});
+const ConstantProvider = (0, decorators_1.MakeParameterAndPropertyDecorator)((target, key, index, value) => (0, beta_1.SetParameterProvider)(target, key, index, () => value));
+class TestExecutionController1 extends (0, beta_1.Controller)('/execution/controller1') {
+    testProperty() {
+        return this.prop;
+    }
+    testParameter(param) {
+        return param;
+    }
+}
+exports.TestExecutionController1 = TestExecutionController1;
+__decorate([
+    ConstantProvider('Ok'),
+    __metadata("design:type", String)
+], TestExecutionController1.prototype, "prop", void 0);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestExecutionController1.prototype, "testProperty", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, ConstantProvider('Ok')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController1.prototype, "testParameter", null);
+class TestExecutionController2 extends (0, beta_1.Controller)('/execution/controller2') {
+    testProviderContext(_ctx) { }
+    testProviderRawBody(_body) { }
+    testProviderParameterParam(_param) { }
+    testProviderParameterHeader(_param) { }
+    testProviderParameterQuery(_param) { }
+    testProviderMultiParameterHeader(_params) { }
+    testProviderMultiParameterQuery(_params) { }
+    testProviderWriteStream(param) {
+        param.write('Ok');
+        param.end();
+    }
+    testProviderResult() {
+        return 'Ok';
+    }
+    testProviderResultPostfix(_res) { }
+    testModifierTransform(_param) { }
+}
+exports.TestExecutionController2 = TestExecutionController2;
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderContext", null);
+__decorate([
+    (0, beta_1.Post)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.RawBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Buffer]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderRawBody", null);
+__decorate([
+    (0, beta_1.Get)('testProviderParameterParam/:key'),
+    SpyMethod(),
+    __param(0, (0, beta_1.Parameter)('key', 'param')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderParameterParam", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.Parameter)('key', 'header')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderParameterHeader", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.Parameter)('key', 'query')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderParameterQuery", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.MultiParameter)('key', 'header')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderMultiParameterHeader", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.MultiParameter)('key', 'query')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderMultiParameterQuery", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.WriteStream)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [stream_1.PassThrough]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderWriteStream", null);
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderResult", null);
+__decorate([
+    (0, beta_1.Postfix)('get', 'testProviderResult'),
+    SpyMethod(),
+    __param(0, (0, beta_1.Result)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testProviderResultPostfix", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, ConstantProvider('O')),
+    __param(0, (0, beta_1.Transform)((_ctx, val) => val + 'k')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController2.prototype, "testModifierTransform", null);
+class TestExecutionController3 extends (0, beta_1.Controller)('/execution/controller3') {
+    test() {
+        return new beta_1.HTTPResult();
+    }
+    testThrow() {
+        throw new beta_1.HTTPResult();
+    }
+    testStatus() {
+        return new beta_1.HTTPResult(201);
+    }
+    testHeader() {
+        const res = new beta_1.HTTPResult(200);
+        res.addHeader('key', 'Ok');
+        return res;
+    }
+    testBody() {
+        return new beta_1.HTTPResult(200, 'Ok', 'text/plain');
+    }
+    testConsistencyPrefix(res) {
+        res.addHeader('key1', 'Ok');
+    }
+    testConsistency(res) {
+        res.addHeader('key2', 'Ok');
+        res.setStatus(200);
+        res.setBody('Ok', 'text/plain');
+        return res;
+    }
+    testConsistencyPostfix(res) {
+        res.addHeader('key3', 'Ok');
+    }
+    async testControllerInstance(ctx) {
+        const controller1 = await (0, beta_1.GetControllerInstance)(TestExecutionController1, ctx);
+        return controller1.prop;
+    }
+}
+exports.TestExecutionController3 = TestExecutionController3;
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestExecutionController3.prototype, "test", null);
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestExecutionController3.prototype, "testThrow", null);
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestExecutionController3.prototype, "testStatus", null);
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestExecutionController3.prototype, "testHeader", null);
+__decorate([
+    (0, beta_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestExecutionController3.prototype, "testBody", null);
+__decorate([
+    (0, beta_1.Postfix)('get', 'testConsistency'),
+    __param(0, (0, beta_1.Result)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [beta_1.HTTPResult]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController3.prototype, "testConsistencyPrefix", null);
+__decorate([
+    (0, beta_1.Get)(),
+    __param(0, (0, beta_1.Result)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [beta_1.HTTPResult]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController3.prototype, "testConsistency", null);
+__decorate([
+    (0, beta_1.Postfix)('get', 'testConsistency'),
+    __param(0, (0, beta_1.Result)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [beta_1.HTTPResult]),
+    __metadata("design:returntype", void 0)
+], TestExecutionController3.prototype, "testConsistencyPostfix", null);
+__decorate([
+    (0, beta_1.Get)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TestExecutionController3.prototype, "testControllerInstance", null);
+describe('Execution', () => {
+    FetchTest('Property Access', {
+        route: '/execution/controller1/testProperty',
+        method: 'GET',
+        status: 200,
+        result: 'Ok',
+    });
+    FetchTest('Parameter Access', {
+        route: '/execution/controller1/testParameter',
+        method: 'GET',
+        status: 200,
+        result: 'Ok',
+    });
+    FetchTest('GetControllerInstance', {
+        route: '/execution/controller3/testControllerInstance',
+        method: 'GET',
+        status: 200,
+        result: 'Ok',
+    });
+    describe('Providers', () => {
+        FetchTest('Context', {
+            route: '/execution/controller2/testProviderContext',
+            method: 'GET',
+            status: 200,
+            postCheck() {
+                const res = TestExecutionController2.prototype.testProviderContext.lastCall
+                    .args[0];
+                assert_1.default.equal(typeof res, 'object', 'Context object type');
+                (0, assert_1.default)(res.rawRequest, 'Context object');
+            },
+        });
+        FetchTest('RawBody', {
+            route: '/execution/controller2/testProviderRawBody',
+            method: 'POST',
+            status: 200,
+            prepare(init) {
+                init.body = 'Test';
+            },
+            postCheck() {
+                const res = TestExecutionController2.prototype.testProviderRawBody.lastCall.args[0];
+                (0, assert_1.default)(Buffer.isBuffer(res), 'Buffer object');
+                assert_1.default.equal(res.toString(), 'Test');
+            },
+        });
+        FetchTest('Parameter (param)', {
+            route: '/execution/controller2/testProviderParameterParam/Ok',
+            method: 'GET',
+            status: 200,
+            postCheck() {
+                assert_1.default.equal(TestExecutionController2.prototype.testProviderParameterParam.lastCall.args[0], 'Ok', 'Parameter value');
+            },
+        });
+        FetchTest('Parameter (header)', {
+            route: '/execution/controller2/testProviderParameterHeader',
+            method: 'GET',
+            status: 200,
+            prepare(init) {
+                init.headers = { key: 'Ok' };
+            },
+            postCheck() {
+                assert_1.default.equal(TestExecutionController2.prototype.testProviderParameterHeader.lastCall.args[0], 'Ok', 'Parameter value');
+            },
+        });
+        FetchTest('Parameter (query)', {
+            route: '/execution/controller2/testProviderParameterQuery?key=Ok',
+            method: 'GET',
+            status: 200,
+            postCheck() {
+                assert_1.default.equal(TestExecutionController2.prototype.testProviderParameterQuery.lastCall.args[0], 'Ok', 'Parameter value');
+            },
+        });
+        FetchTest('MultiParameter (header)', {
+            route: '/execution/controller2/testProviderMultiParameterHeader',
+            method: 'GET',
+            status: 200,
+            prepare(init) {
+                init.headers = { key: ['Ok 1', 'Ok 2'] };
+            },
+            postCheck() {
+                assert_1.default.equal(TestExecutionController2.prototype.testProviderMultiParameterHeader.lastCall.args[0].toString(), ['Ok 1', 'Ok 2'].toString(), 'Parameter value');
+            },
+        });
+        FetchTest('MultiParameter (query)', {
+            route: '/execution/controller2/testProviderMultiParameterQuery?key=Ok1&key=Ok2',
+            method: 'GET',
+            status: 200,
+            postCheck() {
+                assert_1.default.equal(TestExecutionController2.prototype.testProviderMultiParameterQuery.lastCall.args[0].toString(), ['Ok1', 'Ok2'].toString(), 'Parameter value');
+            },
+        });
+        FetchTest('Result', {
+            route: '/execution/controller2/testProviderResult',
+            method: 'GET',
+            status: 200,
+            postCheck() {
+                const res = TestExecutionController2.prototype.testProviderResultPostfix.lastCall
+                    .args[0];
+                (0, assert_1.default)(res instanceof beta_1.HTTPResult, 'HTTPResult object');
+                assert_1.default.equal(res.getBody(), 'Ok', 'HTTPResult value');
+            },
+        });
+        FetchTest('WriteStream', {
+            route: '/execution/controller2/testProviderWriteStream',
+            method: 'Get',
+            status: 200,
+            result: 'Ok',
+            postCheck() {
+                const res = TestExecutionController2.prototype.testProviderWriteStream.lastCall
+                    .args[0];
+                (0, assert_1.default)(res instanceof stream_1.PassThrough, 'Stream object');
+            },
+        });
+    });
+    describe('Modifiers', () => {
+        FetchTest('Transform', {
+            route: '/execution/controller2/testModifierTransform',
+            method: 'GET',
+            status: 200,
+            postCheck() {
+                assert_1.default.equal(TestExecutionController2.prototype.testModifierTransform.lastCall.args[0], 'Ok', 'Parameter value');
+            },
+        });
+    });
+    describe('HTTPResult', () => {
+        FetchTest('Normal Return', { route: '/execution/controller3/test', method: 'GET', status: 200 });
+        FetchTest('Throw', { route: '/execution/controller3/testThrow', method: 'GET', status: 200 });
+        FetchTest('Status', { route: '/execution/controller3/testStatus', method: 'GET', status: 201 });
+        FetchTest('Header', {
+            route: '/execution/controller3/testHeader',
+            method: 'GET',
+            status: 200,
+            postCheck(res) {
+                assert_1.default.equal(res.headers.get('key'), 'Ok', 'Header value');
+            },
+        });
+        FetchTest('Body', { route: '/execution/controller3/testBody', method: 'GET', status: 200, result: 'Ok' });
+        FetchTest('Prefix/Postfix Consistency', {
+            route: '/execution/controller3/testConsistency',
+            method: 'GET',
+            status: 200,
+            result: 'Ok',
+            postCheck(res) {
+                assert_1.default.equal(res.headers.get('key1'), 'Ok', 'Prefix Header value');
+                assert_1.default.equal(res.headers.get('key2'), 'Ok', 'Handler Header value');
+                assert_1.default.equal(res.headers.get('key3'), 'Ok', 'Postfix Header value');
+            },
+        });
+    });
+});
+const testWSReceiver = sinon_1.default.spy();
+let testWSSocket;
+class TestWebsocketController1 extends (0, beta_1.Controller)('/websocket/controller1') {
+    test(connection) {
+        testWSSocket = connection;
+        connection.on('message', testWSReceiver);
+    }
+}
+exports.TestWebsocketController1 = TestWebsocketController1;
+__decorate([
+    (0, beta_1.WebsocketHandler)(),
+    SpyMethod(),
+    __param(0, (0, beta_1.Connection)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ws_1.default]),
+    __metadata("design:returntype", void 0)
+], TestWebsocketController1.prototype, "test", null);
+describe('WebSocket', () => {
+    let ws;
+    const clientReceiver = sinon_1.default.spy();
+    after(() => ws && ws.close());
+    it('Connect', async () => {
+        ws = new ws_1.default(URL_BASE + '/websocket/controller1/test');
+        ws.on('message', clientReceiver);
+        await new Promise((resolve, reject) => {
+            ws.on('open', resolve);
+            ws.on('error', reject);
+        });
+    });
+    it('Client -> Server', async () => {
+        ws.send('Ok');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        sinon_1.default.assert.calledOnce(testWSReceiver);
+        assert_1.default.equal(testWSReceiver.lastCall.firstArg.toString(), 'Ok');
+    });
+    it('Client <- Server', async () => {
+        testWSSocket.send('Ok');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        sinon_1.default.assert.calledOnce(clientReceiver);
+        assert_1.default.equal(clientReceiver.lastCall.firstArg.toString(), 'Ok');
+    });
+    it('Close', async () => {
+        await new Promise((resolve) => {
+            ws.on('close', resolve);
+            testWSSocket.close();
+        });
+    });
+});
+//# sourceMappingURL=api.js.map