@webda/aws 2.0.0-beta.3 → 2.1.0

package/lib/services/lambdaserver.spec.js

@@ -1,449 +1,361 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 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 __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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 });
-const mocha_1 = require("@testdeck/mocha");
-const core_1 = require("@webda/core");
-const test_1 = require("@webda/core/lib/test");
-const assert = __importStar(require("assert"));
-const fs = __importStar(require("fs"));
-const index_spec_1 = require("../index.spec");
-const lambdaserver_1 = require("./lambdaserver");
-let ExceptionExecutor = class ExceptionExecutor extends core_1.Service {
+import { suite, test } from "@testdeck/mocha";
+import { Bean, getCommonJS, HttpContext, Route, Service } from "@webda/core";
+import { TestApplication } from "@webda/core/lib/test.js";
+import * as assert from "assert";
+import * as fs from "fs";
+import { checkLocalStack, WebdaAwsTest } from "../index.spec.js";
+import { LambdaServer } from "./lambdaserver.js";
+const { __dirname } = getCommonJS(import.meta.url);
+let ExceptionExecutor = class ExceptionExecutor extends Service {
     initRoutes() {
+        super.initRoutes();
         this.addRoute("/broken/{type}", ["GET"], this._brokenRoute);
         this.addRoute("/route/string", ["GET"], this.onString);
     }
-    _brokenRoute(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ctx.parameters.type === "401") {
-                throw 401;
-            }
-            else if (ctx.parameters.type === "Error") {
-                throw new Error();
-            }
-        });
+    async _brokenRoute(ctx) {
+        if (ctx.parameters.type === "401") {
+            throw 401;
+        }
+        else if (ctx.parameters.type === "Error") {
+            throw new Error();
+        }
     }
-    onString(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            ctx.write(`CodeCoverage${ctx.getParameters().test || ""}`);
-        });
+    async onString(ctx) {
+        ctx.write(`CodeCoverage${ctx.getParameters().test || ""}`);
     }
-    onParamString(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            ctx.write(`CodeCoverage${ctx.getParameters().uuid}${ctx.getParameters().test || ""}`);
-        });
+    async onParamString(ctx) {
+        ctx.write(`CodeCoverage${ctx.getParameters().uuid}${ctx.getParameters().test || ""}`);
     }
 };
 __decorate([
-    (0, core_1.Route)("/route/broken/{type}")
+    Route("/route/broken/{type}")
 ], ExceptionExecutor.prototype, "_brokenRoute", null);
 __decorate([
-    (0, core_1.Route)("/route/string{?test}")
+    Route("/route/string{?test}")
 ], ExceptionExecutor.prototype, "onString", null);
 __decorate([
-    (0, core_1.Route)("/route/param/{uuid}{?test}")
+    Route("/route/param/{uuid}{?test}")
 ], ExceptionExecutor.prototype, "onParamString", null);
 ExceptionExecutor = __decorate([
-    core_1.Bean
+    Bean
 ], ExceptionExecutor);
-let LambdaHandlerTest = class LambdaHandlerTest extends index_spec_1.WebdaAwsTest {
+let LambdaHandlerTest = class LambdaHandlerTest extends WebdaAwsTest {
     constructor() {
         super(...arguments);
         this.context = {};
         this.badCheck = false;
     }
-    before() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield (0, index_spec_1.checkLocalStack)();
-            let app = new test_1.TestApplication(this.getTestConfiguration());
-            app.addService("test/awsevents", (yield Promise.resolve().then(() => __importStar(require("../../test/moddas/awsevents.js")))).default);
-            yield app.load();
-            this.webda = this.handler = new lambdaserver_1.LambdaServer(app);
-            this.webda.initStatics();
-            this.webda.registerRequestFilter({
-                checkRequest: () => __awaiter(this, void 0, void 0, function* () { return true; })
-            });
-            this.evt = {
-                httpMethod: "GET",
-                headers: {
-                    Cookie: "webda=plop;",
-                    "X-Forwarded-Port": "443",
-                    "X-Forwarded-Proto": "https"
-                },
-                requestContext: {
-                    identity: {}
-                },
-                path: "/prefix/route/string",
-                resource: "/route/string",
-                body: JSON.stringify({})
-            };
-            this.debugMailer = this.handler.getService("DebugMailer");
-        });
-    }
-    checkRequestFalse() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.handler.init();
-            // @ts-ignore
-            this.handler._requestFilters = [];
-            this.ensureGoodCSRF();
-            this.evt.queryStringParameters = { test: "Plop" };
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 403);
-        });
-    }
-    handleRequestCustomLaunch() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.handler.handleRequest({
-                command: "launch",
-                service: "DebugMailer",
-                method: "send",
-                args: ["test"]
-            }, undefined);
-            assert.strictEqual(this.debugMailer.sent[0], "test");
-        });
-    }
-    handleRequestCustomLaunchBadService() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.handler.handleRequest({
-                command: "launch",
-                service: "DebugMailers",
-                method: "send",
-                args: ["test"]
-            }, undefined);
-            assert.strictEqual(this.debugMailer.sent.length, 0);
-        });
-    }
-    handleRequestCustomLaunchBadMethod() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.handler.handleRequest({
-                command: "launch",
-                service: "DebugMailer",
-                method: "sends"
-            }, undefined);
-            assert.strictEqual(this.debugMailer.sent.length, 0);
-        });
-    }
-    handleRequestKnownRoute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.body, "CodeCoverage");
-        });
-    }
-    handleRequestIdHeader() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.handler.getConfiguration().parameters.lambdaRequestHeader = "x-webda-request-id";
-            let res = yield this.handler.handleRequest(this.evt, Object.assign(Object.assign({}, this.context), { awsRequestId: "toto" }));
-            assert.strictEqual(res.body, "CodeCoverage");
-            assert.strictEqual(res.headers["x-webda-request-id"], "toto");
-        });
-    }
-    handleRequestKnownRouteWithParamAndQuery() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.queryStringParameters = { test: "Plop" };
-            this.evt.path = "/prefix/route/param/myid";
-            this.evt.resource = "/route/param/{uuid}";
-            this.evt.pathParameters = { uuid: "myid" };
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.body, "CodeCoveragemyidPlop");
-        });
-    }
-    handleRequestKnownRouteWithParam() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.path = "/prefix/route/param/myid";
-            this.evt.resource = "/route/param/{uuid}";
-            this.evt.pathParameters = { uuid: "myid" };
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.body, "CodeCoveragemyid");
-        });
-    }
-    handleRequestKnownRouteWithQuery() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.queryStringParameters = { test: "Plop" };
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.body, "CodeCoveragePlop");
-        });
-    }
-    handleRequestUnknownRoute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.path = "/route/unknown";
-            this.evt.resource = "/route/unknown";
-            delete this.evt.headers.Cookie;
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 404);
-        });
-    }
-    handleRequestThrow401() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.path = "/route/broken/401";
-            this.evt.resource = "/route/broken/401";
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 401);
-        });
-    }
-    handleRequestThrowError() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.path = "/route/broken/Error";
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 500);
-        });
-    }
-    handleRequestOPTIONS() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.httpMethod = "OPTIONS";
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 204);
-            assert.strictEqual(res.headers["Access-Control-Allow-Methods"], "GET,OPTIONS");
-        });
-    }
-    handleRequestOPTIONSWith404() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.path = "/route/unknown";
-            this.evt.httpMethod = "OPTIONS";
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 404);
-        });
-    }
-    cov() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ensureGoodCSRF();
-            this.evt.headers["X-Forwarded-Port"] = "wew";
-            this.evt.headers["Content-Type"] = "text/plain";
-            this.evt.body = "{wew''";
-            // Should fallback on port 443
-            yield this.handler.handleRequest(this.evt, this.context);
-        });
-    }
-    handleRequestQueryParams() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO Check parameter retrieval
-            this.evt.queryStringParameters = {
-                test: "plop"
-            };
-            this.evt.headers.Origin = "https://test.webda.io";
-            this.evt.headers.Host = "test.webda.io";
-            yield this.handler.handleRequest(this.evt, this.context);
+    async before() {
+        await checkLocalStack();
+        let app = new TestApplication(this.getTestConfiguration());
+        app.addService("test/awsevents", (await import("../../test/moddas/awsevents.js")).AWSEventsHandler);
+        await app.load();
+        this.webda = this.handler = new LambdaServer(app);
+        await this.webda.init();
+        this.webda.registerRequestFilter({
+            checkRequest: async () => true
         });
+        this.evt = {
+            httpMethod: "GET",
+            headers: {
+                Cookie: "webda=plop;",
+                "X-Forwarded-Port": "443",
+                "X-Forwarded-Proto": "https"
+            },
+            requestContext: {
+                identity: {}
+            },
+            path: "/prefix/route/string",
+            resource: "/route/string",
+            body: JSON.stringify({})
+        };
+        this.debugMailer = this.handler.getService("DebugMailer");
+    }
+    async checkRequestFalse() {
+        await this.handler.init();
+        // @ts-ignore
+        this.handler._requestFilters = [];
+        this.ensureGoodCSRF();
+        this.evt.queryStringParameters = { test: "Plop" };
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 403);
+    }
+    async handleRequestCustomLaunch() {
+        await this.handler.handleRequest({
+            command: "launch",
+            service: "DebugMailer",
+            method: "send",
+            args: ["test"]
+        }, undefined);
+        assert.strictEqual(this.debugMailer.sent[0], "test");
+    }
+    async handleRequestCustomLaunchBadService() {
+        await this.handler.handleRequest({
+            command: "launch",
+            service: "DebugMailers",
+            method: "send",
+            args: ["test"]
+        }, undefined);
+        assert.strictEqual(this.debugMailer.sent.length, 0);
+    }
+    async handleRequestCustomLaunchBadMethod() {
+        await this.handler.handleRequest({
+            command: "launch",
+            service: "DebugMailer",
+            method: "sends"
+        }, undefined);
+        assert.strictEqual(this.debugMailer.sent.length, 0);
+    }
+    async handleRequestKnownRoute() {
+        this.ensureGoodCSRF();
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.body, "CodeCoverage");
+    }
+    async handleRequestIdHeader() {
+        this.ensureGoodCSRF();
+        this.handler.getConfiguration().parameters.lambdaRequestHeader = "x-webda-request-id";
+        let res = await this.handler.handleRequest(this.evt, { ...this.context, awsRequestId: "toto" });
+        assert.strictEqual(res.body, "CodeCoverage");
+        assert.strictEqual(res.headers["x-webda-request-id"], "toto");
+    }
+    async handleRequestKnownRouteWithParamAndQuery() {
+        this.ensureGoodCSRF();
+        this.evt.queryStringParameters = { test: "Plop" };
+        this.evt.path = "/prefix/route/param/myid";
+        this.evt.resource = "/route/param/{uuid}";
+        this.evt.pathParameters = { uuid: "myid" };
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.body, "CodeCoveragemyidPlop");
+    }
+    async handleRequestKnownRouteWithParam() {
+        this.ensureGoodCSRF();
+        this.evt.path = "/prefix/route/param/myid";
+        this.evt.resource = "/route/param/{uuid}";
+        this.evt.pathParameters = { uuid: "myid" };
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.body, "CodeCoveragemyid");
+    }
+    async handleRequestKnownRouteWithQuery() {
+        this.ensureGoodCSRF();
+        this.evt.queryStringParameters = { test: "Plop" };
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.body, "CodeCoveragePlop");
+    }
+    async handleRequestUnknownRoute() {
+        this.ensureGoodCSRF();
+        this.evt.path = "/route/unknown";
+        this.evt.resource = "/route/unknown";
+        delete this.evt.headers.Cookie;
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 404);
+    }
+    async handleRequestThrow401() {
+        this.ensureGoodCSRF();
+        this.evt.path = "/route/broken/401";
+        this.evt.resource = "/route/broken/401";
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 401);
+    }
+    async handleRequestThrowError() {
+        this.ensureGoodCSRF();
+        this.evt.path = "/route/broken/Error";
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 500);
+    }
+    async handleRequestOPTIONS() {
+        this.ensureGoodCSRF();
+        this.evt.httpMethod = "OPTIONS";
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 204);
+        assert.strictEqual(res.headers["Access-Control-Allow-Methods"], "GET,OPTIONS");
+    }
+    async handleRequestOPTIONSWith404() {
+        this.ensureGoodCSRF();
+        this.evt.path = "/route/unknown";
+        this.evt.httpMethod = "OPTIONS";
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 404);
+    }
+    async cov() {
+        this.ensureGoodCSRF();
+        this.evt.headers["X-Forwarded-Port"] = "wew";
+        this.evt.headers["Content-Type"] = "text/plain";
+        this.evt.body = "{wew''";
+        // Should fallback on port 443
+        await this.handler.handleRequest(this.evt, this.context);
+    }
+    async handleRequestQueryParams() {
+        // TODO Check parameter retrieval
+        this.evt.queryStringParameters = {
+            test: "plop"
+        };
+        this.evt.headers.Origin = "https://test.webda.io";
+        this.evt.headers.Host = "test.webda.io";
+        await this.handler.handleRequest(this.evt, this.context);
     }
-    handleRequestOrigin() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.evt.headers.Origin = "https://test.webda.io";
-            this.evt.headers.Host = "test.webda.io";
-            let wait = false;
-            this.handler.on("Webda.Result", () => {
-                return new Promise((resolve, reject) => {
-                    // Delay 100ms to ensure it waited
-                    setTimeout(() => {
-                        wait = true;
-                        resolve();
-                    }, 100);
-                });
+    async handleRequestOrigin() {
+        this.evt.headers.Origin = "https://test.webda.io";
+        this.evt.headers.Host = "test.webda.io";
+        let wait = false;
+        this.handler.on("Webda.Result", () => {
+            return new Promise((resolve, reject) => {
+                // Delay 100ms to ensure it waited
+                setTimeout(() => {
+                    wait = true;
+                    resolve();
+                }, 100);
             });
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.headers["Access-Control-Allow-Origin"], this.evt.headers.Origin);
-            assert.strictEqual(wait, true);
-        });
-    }
-    handleRequestOriginCSRF() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.evt.headers.Origin = "https://test3.webda.io";
-            this.evt.headers.Host = "test3.webda.io";
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 401);
-        });
-    }
-    handleRequestRefererCSRF() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.evt.headers.Referer = "https://test3.webda.io";
-            this.evt.headers.Host = "test3.webda.io";
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 401);
-        });
-    }
-    handleRequestRefererGoodCORS() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.evt.headers.Referer = "https://test.webda.io";
-            this.evt.headers.Host = "test.webda.io";
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.headers["Access-Control-Allow-Origin"], this.evt.headers.Referer);
-        });
-    }
-    handleRequestHardStopCheckRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.evt.headers.Referer = "https://test.webda.io";
-            this.evt.headers.Host = "test.webda.io";
-            this.handler.registerRequestFilter(this);
-            let res = yield this.handler.handleRequest(this.evt, this.context);
-            assert.strictEqual(res.statusCode, 410);
-            this.badCheck = true;
-            yield assert.rejects(() => this.handler.handleRequest(this.evt, this.context), /Unknown/);
         });
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.headers["Access-Control-Allow-Origin"], this.evt.headers.Origin);
+        assert.strictEqual(wait, true);
+    }
+    async handleRequestOriginCSRF() {
+        this.evt.headers.Origin = "https://test3.webda.io";
+        this.evt.headers.Host = "test3.webda.io";
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 401);
+    }
+    async handleRequestRefererCSRF() {
+        this.evt.headers.Referer = "https://test3.webda.io";
+        this.evt.headers.Host = "test3.webda.io";
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 401);
+    }
+    async handleRequestRefererGoodCORS() {
+        this.evt.headers.Referer = "https://test.webda.io";
+        this.evt.headers.Host = "test.webda.io";
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.headers["Access-Control-Allow-Origin"], this.evt.headers.Referer);
     }
-    checkRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.badCheck) {
-                throw new Error("Unknown");
-            }
-            throw 410;
-        });
+    async handleRequestHardStopCheckRequest() {
+        this.evt.headers.Referer = "https://test.webda.io";
+        this.evt.headers.Host = "test.webda.io";
+        this.handler.registerRequestFilter(this);
+        let res = await this.handler.handleRequest(this.evt, this.context);
+        assert.strictEqual(res.statusCode, 410);
+        this.badCheck = true;
+        await assert.rejects(() => this.handler.handleRequest(this.evt, this.context), /Unknown/);
+    }
+    async checkRequest() {
+        if (this.badCheck) {
+            throw new Error("Unknown");
+        }
+        throw 410;
     }
     ensureGoodCSRF() {
         this.evt.headers.Referer = "https://test.webda.io";
         this.evt.headers.Host = "test.webda.io";
     }
-    awsEvents() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let service = this.handler.getService("awsEvents");
-            let files = fs.readdirSync(__dirname + "/../../test/aws-events");
-            for (let f in files) {
-                let file = files[f];
-                let event = JSON.parse(fs.readFileSync(__dirname + "/../../test/aws-events/" + file).toString());
-                yield this.handler.handleRequest(event, this.context);
-                if (file === "api-gateway-aws-proxy.json") {
-                    assert.strictEqual(service.getEvents().length, 0, "API Gateway should go throught the normal request handling");
-                }
-                else {
-                    assert.notStrictEqual(service.getEvents().length, 0, "Should have get some events:" + JSON.stringify(event));
-                }
+    async awsEvents() {
+        let service = this.handler.getService("awsEvents");
+        let files = fs.readdirSync(__dirname + "/../../test/aws-events");
+        for (let f in files) {
+            let file = files[f];
+            let event = JSON.parse(fs.readFileSync(__dirname + "/../../test/aws-events/" + file).toString());
+            await this.handler.handleRequest(event, this.context);
+            if (file === "api-gateway-aws-proxy.json") {
+                assert.strictEqual(service.getEvents().length, 0, "API Gateway should go through the normal request handling");
             }
-        });
+            else {
+                assert.notStrictEqual(service.getEvents().length, 0, "Should have get some events:" + JSON.stringify(event));
+            }
+        }
     }
     /**
      * Wildcard path from API Gateway were missing the prefix
      *
      * @see https://github.com/loopingz/webda.io/issues/193
      */
-    computePrefix() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let httpContext = new core_1.HttpContext("test.webda.io", "GET", "/prefix/static1234/test/subfolder/index.html");
-            this.handler.computePrefix({
-                path: "/prefix/static1234/test/subfolder/index.html",
-                resource: "/static1234/{path+}",
-                pathParameters: {
-                    path: "test/subfolder/index.html"
-                }
-            }, httpContext);
-            assert.strictEqual(httpContext.getRelativeUri(), "/static1234/test/subfolder/index.html");
-            assert.strictEqual(httpContext.prefix, "/prefix");
-        });
+    async computePrefix() {
+        let httpContext = new HttpContext("test.webda.io", "GET", "/prefix/static1234/test/subfolder/index.html");
+        this.handler.computePrefix({
+            path: "/prefix/static1234/test/subfolder/index.html",
+            resource: "/static1234/{path+}",
+            pathParameters: {
+                path: "test/subfolder/index.html"
+            }
+        }, httpContext);
+        assert.strictEqual(httpContext.getRelativeUri(), "/static1234/test/subfolder/index.html");
+        assert.strictEqual(httpContext.prefix, "/prefix");
     }
 };
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "checkRequestFalse", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestCustomLaunch", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestCustomLaunchBadService", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestCustomLaunchBadMethod", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestKnownRoute", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestIdHeader", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestKnownRouteWithParamAndQuery", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestKnownRouteWithParam", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestKnownRouteWithQuery", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestUnknownRoute", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestThrow401", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestThrowError", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestOPTIONS", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestOPTIONSWith404", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "cov", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestQueryParams", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestOrigin", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestOriginCSRF", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestRefererCSRF", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestRefererGoodCORS", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "handleRequestHardStopCheckRequest", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "awsEvents", null);
 __decorate([
-    mocha_1.test
+    test
 ], LambdaHandlerTest.prototype, "computePrefix", null);
 LambdaHandlerTest = __decorate([
-    mocha_1.suite
+    suite
 ], LambdaHandlerTest);
 //# sourceMappingURL=lambdaserver.spec.js.map