@webda/aws 2.0.0-beta.2 → 2.0.1

package/lib/deployers/index.spec.js

@@ -1,67 +1,29 @@
-"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 });
-exports.MockAWSDeployerMethods = void 0;
-const client_acm_1 = require("@aws-sdk/client-acm");
-const client_ec2_1 = require("@aws-sdk/client-ec2");
-const client_route_53_1 = require("@aws-sdk/client-route-53");
-const client_s3_1 = require("@aws-sdk/client-s3");
-const client_sts_1 = require("@aws-sdk/client-sts");
-const mocha_1 = require("@testdeck/mocha");
-const core_1 = require("@webda/core");
-const deployertest_1 = require("@webda/shell/lib/deployers/deployertest");
-const assert = __importStar(require("assert"));
-const aws_sdk_client_mock_1 = require("aws-sdk-client-mock");
-const sinon = __importStar(require("sinon"));
-const _1 = require(".");
-class TestAWSDeployer extends _1.AWSDeployer {
-    deploy() {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    restrictedCall(method, ...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this[method](...args);
-        });
+import { ACM, DescribeCertificateCommand, ListCertificatesCommand, RequestCertificateCommand } from "@aws-sdk/client-acm";
+import { DescribeSubnetsCommand, DescribeVpcsCommand, EC2 } from "@aws-sdk/client-ec2";
+import { ChangeResourceRecordSetsCommand, ListHostedZonesCommand, Route53 } from "@aws-sdk/client-route-53";
+import { CreateBucketCommand, HeadBucketCommand, ListObjectsV2Command, NotFound, PutBucketTaggingCommand, PutObjectCommand, S3 } from "@aws-sdk/client-s3";
+import { GetCallerIdentityCommand, STS } from "@aws-sdk/client-sts";
+import { suite, test } from "@testdeck/mocha";
+import { CacheService, getCommonJS } from "@webda/core";
+import { DeployerTest } from "@webda/shell/lib/deployers/deployertest.js";
+import * as assert from "assert";
+import { mockClient } from "aws-sdk-client-mock";
+import * as sinon from "sinon";
+import { AWSDeployer } from "./index.js";
+const { __dirname, __filename } = getCommonJS(import.meta.url);
+class TestAWSDeployer extends AWSDeployer {
+    async deploy() { }
+    async restrictedCall(method, ...args) {
+        return this[method](...args);
     }
 }
-function MockAWSDeployerMethods(service, test) {
+export function MockAWSDeployerMethods(service, test) {
     test.mocks["putFilesOnBucket"] = sinon.stub(service, "putFilesOnBucket").resolves();
     test.mocks["createBucket"] = sinon.stub(service, "createBucket").resolves();
     test.mocks["doCreateCertificate"] = sinon.stub(service, "doCreateCertificate").resolves({});
@@ -84,12 +46,9 @@ function MockAWSDeployerMethods(service, test) {
         Statement: []
     });
 }
-exports.MockAWSDeployerMethods = MockAWSDeployerMethods;
-let AWSDeployerTest = class AWSDeployerTest extends deployertest_1.DeployerTest {
-    getDeployer(manager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new TestAWSDeployer(manager, {});
-        });
+let AWSDeployerTest = class AWSDeployerTest extends DeployerTest {
+    async getDeployer(manager) {
+        return new TestAWSDeployer(manager, {});
     }
     mapToArrayTags() {
         let deployer = new TestAWSDeployer(this.manager, { Tags: { Test: "Plop" } });
@@ -98,473 +57,449 @@ let AWSDeployerTest = class AWSDeployerTest extends deployertest_1.DeployerTest
             { Key: "Test", Value: "Plop" }
         ]);
     }
-    putFilesOnBucket() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.deployer.putFilesOnBucket("plop", []);
-            yield assert.rejects(
-            // @ts-ignore
-            () => this.deployer.putFilesOnBucket("plop", [{ key: "/test" }]), /Should have src and key defined/);
-            let Contents = [{ Key: "awsevents.js", Size: 587, ETag: '"312d05552187d3fdfdda3860fbeef48f"' }];
-            let stub = sinon.stub().resolves({ Contents });
-            // Fake any uploads
-            let uploads = [];
-            (0, aws_sdk_client_mock_1.mockClient)(client_s3_1.S3)
-                .on(client_s3_1.ListObjectsV2Command)
-                .callsFake(stub)
-                .on(client_s3_1.PutObjectCommand)
-                .callsFake(arg => {
-                uploads.push(arg);
-                return {};
-            });
-            sinon.stub(this.deployer, "createBucket").resolves();
-            yield this.deployer.putFolderOnBucket("plop", "./test/moddas");
-            assert.strictEqual(uploads.length, 0);
-            Contents[0].ETag = "plop";
-            yield this.deployer.putFolderOnBucket("plop", "./test/moddas");
-            assert.strictEqual(uploads.length, 1);
-            uploads = [];
-            Contents[0].ETag = '"312d05552187d3fdfdda3860fbeef48f"';
-            Contents[0].Size = 123;
-            yield this.deployer.putFolderOnBucket("plop", "./test/moddas");
-            assert.strictEqual(uploads.length, 1);
+    async putFilesOnBucket() {
+        await this.deployer.putFilesOnBucket("plop", []);
+        await assert.rejects(
+        // @ts-ignore
+        () => this.deployer.putFilesOnBucket("plop", [{ key: "/test" }]), /Should have src and key defined/);
+        let Contents = [{ Key: "awsevents.js", Size: 527, ETag: '"ea1db4bb1545c62c50e6f0893e9f0992"' }];
+        let stub = sinon.stub().resolves({ Contents });
+        // Fake any uploads
+        let uploads = [];
+        mockClient(S3)
+            .on(ListObjectsV2Command)
+            .callsFake(stub)
+            .on(PutObjectCommand)
+            .callsFake(arg => {
+            uploads.push(arg);
+            return {};
         });
+        sinon.stub(this.deployer, "createBucket").resolves();
+        await this.deployer.putFolderOnBucket("plop", "./test/moddas");
+        assert.strictEqual(uploads.length, 0);
+        Contents[0].ETag = "plop";
+        await this.deployer.putFolderOnBucket("plop", "./test/moddas");
+        assert.strictEqual(uploads.length, 1);
+        uploads = [];
+        Contents[0].ETag = '"312d05552187d3fdfdda3860fbeef48f"';
+        Contents[0].Size = 123;
+        await this.deployer.putFolderOnBucket("plop", "./test/moddas");
+        assert.strictEqual(uploads.length, 1);
     }
-    testGetPolicyDocument() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_sts_1.STS).on(client_sts_1.GetCallerIdentityCommand).resolves({
-                Account: "test"
-            });
-            try {
-                // @ts-ignore
-                this.manager.getWebda().getServices()["customservice"].getARNPolicy = () => {
-                    return [
-                        { Sid: "", Effect: "Allow", Action: [], Resource: "*" },
-                        { Sid: "", Effect: "Allow", Action: [], Resource: "*" }
-                    ];
-                };
-                let result = yield this.deployer.getPolicyDocument();
-                assert.strictEqual(result.Statement.length, 4);
-            }
-            finally {
-                mock.restore();
-            }
+    async testGetPolicyDocument() {
+        const mock = mockClient(STS).on(GetCallerIdentityCommand).resolves({
+            Account: "test"
         });
+        try {
+            // @ts-ignore
+            this.manager.getWebda().getServices()["customservice"].getARNPolicy = () => {
+                return [
+                    { Sid: "", Effect: "Allow", Action: [], Resource: "*" },
+                    { Sid: "", Effect: "Allow", Action: [], Resource: "*" }
+                ];
+            };
+            let result = await this.deployer.getPolicyDocument();
+            assert.strictEqual(result.Statement.length, 4);
+        }
+        finally {
+            mock.restore();
+        }
     }
-    testGetDefaultVpc() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var vpcsSpy = sinon.stub().callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                if (vpcsSpy.callCount === 1) {
-                    return {
-                        Vpcs: []
-                    };
-                }
+    async testGetDefaultVpc() {
+        var vpcsSpy = sinon.stub().callsFake(async () => {
+            if (vpcsSpy.callCount === 1) {
                 return {
-                    Vpcs: [
-                        {
-                            VpcId: "vpc-667",
-                            IsDefault: false
-                        },
-                        {
-                            VpcId: "vpc-666",
-                            IsDefault: true
-                        }
-                    ]
+                    Vpcs: []
                 };
-            }));
-            var subnetsSpy = sinon.stub().callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                return {
-                    Subnets: [
-                        {
-                            SubnetId: "subnet-1"
-                        },
-                        {
-                            SubnetId: "subnet-2"
-                        }
-                    ]
-                };
-            }));
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_ec2_1.EC2)
-                .on(client_ec2_1.DescribeVpcsCommand)
-                .callsFake(vpcsSpy)
-                .on(client_ec2_1.DescribeSubnetsCommand)
-                .callsFake(subnetsSpy);
-            try {
-                let result = yield this.deployer.getDefaultVpc();
-                assert.strictEqual(vpcsSpy.calledOnce, true);
-                assert.strictEqual(subnetsSpy.notCalled, true);
-                assert.strictEqual(result, undefined);
-                core_1.CacheService.clearAllCache();
-                result = yield this.deployer.getDefaultVpc();
-                assert.deepStrictEqual(result, {
-                    Id: "vpc-666",
-                    Subnets: [{ SubnetId: "subnet-1" }, { SubnetId: "subnet-2" }]
-                });
-                assert.strictEqual(subnetsSpy.calledWith({
-                    Filters: [
-                        {
-                            Name: "vpc-id",
-                            Values: ["vpc-666"]
-                        }
-                    ]
-                }), true);
-            }
-            finally {
-                mock.restore();
             }
+            return {
+                Vpcs: [
+                    {
+                        VpcId: "vpc-667",
+                        IsDefault: false
+                    },
+                    {
+                        VpcId: "vpc-666",
+                        IsDefault: true
+                    }
+                ]
+            };
         });
-    }
-    testCommonPrefix() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.strictEqual(this.deployer.commonPrefix("/test/bouzf", "/test/reffff"), "/test/");
-            assert.strictEqual(this.deployer.commonPrefix("test/bouzf", "/test/reffff"), "");
-            assert.strictEqual(this.deployer.commonPrefix("/tes", "/test/reffff"), "/tes");
-            assert.strictEqual(this.deployer.commonPrefix("test/bouzf", "test/bouzf212"), "test/bouzf");
+        var subnetsSpy = sinon.stub().callsFake(async () => {
+            return {
+                Subnets: [
+                    {
+                        SubnetId: "subnet-1"
+                    },
+                    {
+                        SubnetId: "subnet-2"
+                    }
+                ]
+            };
         });
+        const mock = mockClient(EC2)
+            .on(DescribeVpcsCommand)
+            .callsFake(vpcsSpy)
+            .on(DescribeSubnetsCommand)
+            .callsFake(subnetsSpy);
+        try {
+            let result = await this.deployer.getDefaultVpc();
+            assert.strictEqual(vpcsSpy.calledOnce, true);
+            assert.strictEqual(subnetsSpy.notCalled, true);
+            assert.strictEqual(result, undefined);
+            CacheService.clearAllCache();
+            result = await this.deployer.getDefaultVpc();
+            assert.deepStrictEqual(result, {
+                Id: "vpc-666",
+                Subnets: [{ SubnetId: "subnet-1" }, { SubnetId: "subnet-2" }]
+            });
+            assert.strictEqual(subnetsSpy.calledWith({
+                Filters: [
+                    {
+                        Name: "vpc-id",
+                        Values: ["vpc-666"]
+                    }
+                ]
+            }), true);
+        }
+        finally {
+            mock.restore();
+        }
     }
-    testCreateBucket() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.deployer.resources.Tags = this.deployer.transformMapTagsToArray({ test: "mytag" });
-            var headSpy = sinon.stub();
-            headSpy.callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                let res = {};
-                switch (headSpy.callCount) {
-                    case 2:
-                        throw {
-                            name: "Forbidden"
-                        };
-                    case 3:
-                        throw new client_s3_1.NotFound({
-                            $metadata: {}
-                        });
-                }
-                return res;
-            }));
-            var createSpy = sinon.stub().resolves();
-            var tagSpy = sinon.stub().resolves();
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_s3_1.S3)
-                .on(client_s3_1.HeadBucketCommand)
-                .callsFake(headSpy)
-                .on(client_s3_1.CreateBucketCommand)
-                .callsFake(createSpy)
-                .on(client_s3_1.PutBucketTaggingCommand)
-                .callsFake(tagSpy);
-            try {
-                yield this.deployer.createBucket("plop");
-                // Bucket exists
-                assert.strictEqual(headSpy.callCount, 1);
-                assert.strictEqual(headSpy.calledWith({ Bucket: "plop" }), true);
-                assert.strictEqual(createSpy.notCalled, true);
-                assert.strictEqual(tagSpy.notCalled, true);
-                // Bucket exists in another account or we do not have rights
-                yield this.deployer.createBucket("plop");
-                assert.strictEqual(headSpy.callCount, 2);
-                assert.strictEqual(createSpy.notCalled, true);
-                yield this.deployer.createBucket("plop");
-                assert.strictEqual(headSpy.callCount, 3);
-                assert.strictEqual(createSpy.calledOnce, true);
-                assert.strictEqual(createSpy.calledWith({ Bucket: "plop" }), true);
-                assert.strictEqual(tagSpy.calledOnce, true);
-                assert.strictEqual(tagSpy.calledWith({ Bucket: "plop", Tagging: { TagSet: [{ Key: "test", Value: "mytag" }] } }), true);
-            }
-            finally {
-                mock.restore();
+    async testCommonPrefix() {
+        assert.strictEqual(this.deployer.commonPrefix("/test/bouzf", "/test/reffff"), "/test/");
+        assert.strictEqual(this.deployer.commonPrefix("test/bouzf", "/test/reffff"), "");
+        assert.strictEqual(this.deployer.commonPrefix("/tes", "/test/reffff"), "/tes");
+        assert.strictEqual(this.deployer.commonPrefix("test/bouzf", "test/bouzf212"), "test/bouzf");
+    }
+    async testCreateBucket() {
+        this.deployer.resources.Tags = this.deployer.transformMapTagsToArray({ test: "mytag" });
+        var headSpy = sinon.stub();
+        headSpy.callsFake(async () => {
+            let res = {};
+            switch (headSpy.callCount) {
+                case 2:
+                    throw {
+                        name: "Forbidden"
+                    };
+                case 3:
+                    throw new NotFound({
+                        $metadata: {}
+                    });
             }
+            return res;
         });
+        var createSpy = sinon.stub().resolves();
+        var tagSpy = sinon.stub().resolves();
+        const mock = mockClient(S3)
+            .on(HeadBucketCommand)
+            .callsFake(headSpy)
+            .on(CreateBucketCommand)
+            .callsFake(createSpy)
+            .on(PutBucketTaggingCommand)
+            .callsFake(tagSpy);
+        try {
+            await this.deployer.createBucket("plop");
+            // Bucket exists
+            assert.strictEqual(headSpy.callCount, 1);
+            assert.strictEqual(headSpy.calledWith({ Bucket: "plop" }), true);
+            assert.strictEqual(createSpy.notCalled, true);
+            assert.strictEqual(tagSpy.notCalled, true);
+            // Bucket exists in another account or we do not have rights
+            await this.deployer.createBucket("plop");
+            assert.strictEqual(headSpy.callCount, 2);
+            assert.strictEqual(createSpy.notCalled, true);
+            await this.deployer.createBucket("plop");
+            assert.strictEqual(headSpy.callCount, 3);
+            assert.strictEqual(createSpy.calledOnce, true);
+            assert.strictEqual(createSpy.calledWith({ Bucket: "plop" }), true);
+            assert.strictEqual(tagSpy.calledOnce, true);
+            assert.strictEqual(tagSpy.calledWith({ Bucket: "plop", Tagging: { TagSet: [{ Key: "test", Value: "mytag" }] } }), true);
+        }
+        finally {
+            mock.restore();
+        }
     }
-    testPutBucket() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var putSpy = sinon.stub();
-            var listSpy = sinon.stub();
-            var createBucket = sinon.stub(this.deployer, "createBucket");
-            createBucket.resolves();
-            putSpy.resolves();
-            listSpy.resolves({ Contents: [] });
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_s3_1.S3).on(client_s3_1.PutObjectCommand).callsFake(putSpy).on(client_s3_1.ListObjectsV2Command).callsFake(listSpy);
-            try {
-                // @ts-ignore shortcut to test both in one
-                yield this.deployer.putFilesOnBucket("plop", [
-                    { src: __filename },
-                    { src: __dirname + "/index.ts", key: "plop.ts" },
-                    { key: "buffer.out", src: Buffer.from("bouzouf"), mimetype: "text/plain" }
-                ]);
-                assert.strictEqual(putSpy.callCount, 3);
-                // checks call
-                assert.strictEqual(putSpy.firstCall.firstArg.Body.constructor.name, "ReadStream");
-                assert.strictEqual(putSpy.secondCall.firstArg.Body.constructor.name, "ReadStream");
-                assert.deepStrictEqual(putSpy.thirdCall.firstArg.Body.constructor.name, "Buffer");
-                assert.deepStrictEqual(putSpy.thirdCall.firstArg.Body.toString(), "bouzouf");
-                assert.strictEqual(createBucket.calledOnce, true);
-                // TODO Check upload optimization
+    async testPutBucket() {
+        var putSpy = sinon.stub();
+        var listSpy = sinon.stub();
+        var createBucket = sinon.stub(this.deployer, "createBucket");
+        createBucket.resolves();
+        putSpy.resolves();
+        listSpy.resolves({ Contents: [] });
+        const mock = mockClient(S3).on(PutObjectCommand).callsFake(putSpy).on(ListObjectsV2Command).callsFake(listSpy);
+        try {
+            // @ts-ignore shortcut to test both in one
+            await this.deployer.putFilesOnBucket("plop", [
+                { src: __filename },
+                { src: __dirname + "/index.ts", key: "plop.ts" },
+                { key: "buffer.out", src: Buffer.from("bouzouf"), mimetype: "text/plain" }
+            ]);
+            assert.strictEqual(putSpy.callCount, 3);
+            // checks call
+            assert.strictEqual(putSpy.firstCall.firstArg.Body.constructor.name, "ReadStream");
+            assert.strictEqual(putSpy.secondCall.firstArg.Body.constructor.name, "ReadStream");
+            assert.deepStrictEqual(putSpy.thirdCall.firstArg.Body.constructor.name, "Buffer");
+            assert.deepStrictEqual(putSpy.thirdCall.firstArg.Body.toString(), "bouzouf");
+            assert.strictEqual(createBucket.calledOnce, true);
+            // TODO Check upload optimization
+        }
+        finally {
+            mock.restore();
+        }
+    }
+    async testGetCertificate() {
+        var putSpy = sinon.stub();
+        var getZoneForDomainName = sinon.stub(this.deployer, "getZoneForDomainName");
+        var doCreateCertificate = sinon.stub(this.deployer, "doCreateCertificate");
+        getZoneForDomainName.callsFake(async () => {
+            if (getZoneForDomainName.callCount === 1) {
+                return undefined;
             }
-            finally {
-                mock.restore();
+            return { Id: "1234", HostedZone: "", Name: "", CallerReference: "" };
+        });
+        doCreateCertificate.resolves({ DomainName: "newlyCreated" });
+        putSpy.callsFake(async () => {
+            switch (putSpy.callCount) {
+                case 1:
+                    return {
+                        CertificateSummaryList: [
+                            {
+                                DomainName: "none.com"
+                            }
+                        ],
+                        NextToken: "page2"
+                    };
+                case 2:
+                    return {
+                        CertificateSummaryList: [
+                            {
+                                DomainName: "test.webda.io"
+                            }
+                        ]
+                    };
+                default:
+                    return { CertificateSummaryList: [] };
             }
         });
+        const mock = mockClient(ACM).on(ListCertificatesCommand).callsFake(putSpy);
+        try {
+            let certificate = await this.deployer.getCertificate("test.webda.io.");
+            assert.strictEqual(putSpy.calledTwice, true);
+            assert.strictEqual(doCreateCertificate.notCalled, true);
+            assert.strictEqual(getZoneForDomainName.notCalled, true);
+            assert.deepStrictEqual(certificate, { DomainName: "test.webda.io" });
+            await assert.rejects(async () => await this.deployer.getCertificate("test.webda.io"), /Cannot create certificate as Route53 Zone was not found/g);
+            assert.strictEqual(getZoneForDomainName.calledWith("test.webda.io"), true);
+            assert.strictEqual(doCreateCertificate.notCalled, true);
+            await this.deployer.getCertificate("test.webda.io", "us-east-1");
+            assert.strictEqual(doCreateCertificate.calledWith("test.webda.io", {
+                Id: "1234",
+                HostedZone: "",
+                Name: "",
+                CallerReference: ""
+            }), true);
+        }
+        finally {
+            mock.restore();
+        }
     }
-    testGetCertificate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var putSpy = sinon.stub();
-            var getZoneForDomainName = sinon.stub(this.deployer, "getZoneForDomainName");
-            var doCreateCertificate = sinon.stub(this.deployer, "doCreateCertificate");
-            getZoneForDomainName.callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                if (getZoneForDomainName.callCount === 1) {
-                    return undefined;
-                }
-                return { Id: "1234", HostedZone: "", Name: "", CallerReference: "" };
-            }));
-            doCreateCertificate.resolves({ DomainName: "newlyCreated" });
-            putSpy.callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                switch (putSpy.callCount) {
-                    case 1:
-                        return {
-                            CertificateSummaryList: [
-                                {
-                                    DomainName: "none.com"
-                                }
-                            ],
-                            NextToken: "page2"
-                        };
-                    case 2:
-                        return {
-                            CertificateSummaryList: [
-                                {
-                                    DomainName: "test.webda.io"
-                                }
-                            ]
-                        };
-                    default:
-                        return { CertificateSummaryList: [] };
-                }
-            }));
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_acm_1.ACM).on(client_acm_1.ListCertificatesCommand).callsFake(putSpy);
-            try {
-                let certificate = yield this.deployer.getCertificate("test.webda.io.");
-                assert.strictEqual(putSpy.calledTwice, true);
-                assert.strictEqual(doCreateCertificate.notCalled, true);
-                assert.strictEqual(getZoneForDomainName.notCalled, true);
-                assert.deepStrictEqual(certificate, { DomainName: "test.webda.io" });
-                yield assert.rejects(() => __awaiter(this, void 0, void 0, function* () { return yield this.deployer.getCertificate("test.webda.io"); }), /Cannot create certificate as Route53 Zone was not found/g);
-                assert.strictEqual(getZoneForDomainName.calledWith("test.webda.io"), true);
-                assert.strictEqual(doCreateCertificate.notCalled, true);
-                yield this.deployer.getCertificate("test.webda.io", "us-east-1");
-                assert.strictEqual(doCreateCertificate.calledWith("test.webda.io", {
-                    Id: "1234",
-                    HostedZone: "",
-                    Name: "",
-                    CallerReference: ""
-                }), true);
-            }
-            finally {
-                mock.restore();
+    async testGetZoneForDomainName() {
+        var callSpy = sinon.stub();
+        callSpy.callsFake(async () => {
+            switch (callSpy.callCount) {
+                case 1:
+                    return { HostedZones: [], NextMarker: "plop" };
+                default:
+                    return {
+                        HostedZones: [
+                            { Name: "webda.io." },
+                            { Name: "bouzouf.io." },
+                            { Name: "test2.test.webda.io." },
+                            { Name: "test.webda.io." }
+                        ]
+                    };
             }
         });
+        const mock = mockClient(Route53).on(ListHostedZonesCommand).callsFake(callSpy);
+        try {
+            let result = await this.deployer.getZoneForDomainName("subdomain.test2.test.webda.io.");
+            assert.deepStrictEqual(result, {
+                Name: "test2.test.webda.io."
+            });
+            assert.strictEqual(callSpy.calledTwice, true);
+            result = await this.deployer.getZoneForDomainName("subdomain.webda.io");
+            assert.deepStrictEqual(result, {
+                Name: "webda.io."
+            });
+            result = await this.deployer.getZoneForDomainName("loopingz.com.");
+            assert.strictEqual(result, undefined);
+        }
+        finally {
+            mock.restore();
+        }
     }
-    testGetZoneForDomainName() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var callSpy = sinon.stub();
-            callSpy.callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                switch (callSpy.callCount) {
+    async testDoCreateCertificate() {
+        var requestCertificate = sinon.stub();
+        var describeCertificate = sinon.stub();
+        var createDNSEntry = sinon.stub(this.deployer, "createDNSEntry");
+        var waitFor = sinon.stub(this.deployer, "waitFor");
+        createDNSEntry.callsFake(async () => { });
+        describeCertificate.resolves({});
+        const mock = mockClient(ACM)
+            .on(RequestCertificateCommand)
+            .callsFake(requestCertificate)
+            .on(DescribeCertificateCommand)
+            .callsFake(describeCertificate);
+        try {
+            waitFor.callsFake(async (callback) => {
+                switch (waitFor.callCount) {
                     case 1:
-                        return { HostedZones: [], NextMarker: "plop" };
-                    default:
-                        return {
-                            HostedZones: [
-                                { Name: "webda.io." },
-                                { Name: "bouzouf.io." },
-                                { Name: "test2.test.webda.io." },
-                                { Name: "test.webda.io." }
-                            ]
-                        };
+                        await callback();
+                    case 2:
+                        return new Promise(resolve => callback(resolve));
                 }
-            }));
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_route_53_1.Route53).on(client_route_53_1.ListHostedZonesCommand).callsFake(callSpy);
-            try {
-                let result = yield this.deployer.getZoneForDomainName("subdomain.test2.test.webda.io.");
-                assert.deepStrictEqual(result, {
-                    Name: "test2.test.webda.io."
-                });
-                assert.strictEqual(callSpy.calledTwice, true);
-                result = yield this.deployer.getZoneForDomainName("subdomain.webda.io");
-                assert.deepStrictEqual(result, {
-                    Name: "webda.io."
-                });
-                result = yield this.deployer.getZoneForDomainName("loopingz.com.");
-                assert.strictEqual(result, undefined);
-            }
-            finally {
-                mock.restore();
-            }
-        });
-    }
-    testDoCreateCertificate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var requestCertificate = sinon.stub();
-            var describeCertificate = sinon.stub();
-            var createDNSEntry = sinon.stub(this.deployer, "createDNSEntry");
-            var waitFor = sinon.stub(this.deployer, "waitFor");
-            createDNSEntry.callsFake(() => __awaiter(this, void 0, void 0, function* () { }));
-            describeCertificate.resolves({});
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_acm_1.ACM)
-                .on(client_acm_1.RequestCertificateCommand)
-                .callsFake(requestCertificate)
-                .on(client_acm_1.DescribeCertificateCommand)
-                .callsFake(describeCertificate);
-            try {
-                waitFor.callsFake((callback) => __awaiter(this, void 0, void 0, function* () {
-                    switch (waitFor.callCount) {
-                        case 1:
-                            yield callback();
-                        case 2:
-                            return new Promise(resolve => callback(resolve));
-                    }
-                }));
-                describeCertificate.callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                    if (describeCertificate.callCount === 1) {
-                        return {
-                            Certificate: {
-                                DomainValidationOptions: [{}]
-                            }
-                        };
-                    }
-                    else {
+            });
+            describeCertificate.callsFake(async () => {
+                if (describeCertificate.callCount === 1) {
+                    return {
+                        Certificate: {
+                            DomainValidationOptions: [{}]
+                        }
+                    };
+                }
+                else {
+                    return {
+                        Certificate: {
+                            Status: "FAILED",
+                            DomainValidationOptions: [{ ResourceRecord: "bouzouf" }]
+                        }
+                    };
+                }
+            });
+            requestCertificate.callsFake(async () => {
+                return { CertificateArn: "plop" };
+            });
+            await assert.rejects(async () => await this.deployer.doCreateCertificate("test.webda.io.", { Id: "1234" }), /Certificate validation has failed/g);
+            waitFor.callsFake(() => undefined);
+            await assert.rejects(async () => await this.deployer.doCreateCertificate("test.webda.io.", { Id: "1234" }), /Certificate validation has failed/g);
+            waitFor.resetHistory();
+            describeCertificate.resetHistory();
+            assert.strictEqual(createDNSEntry.notCalled, true);
+            // @ts-ignore
+            waitFor.callsFake(c => {
+                switch (waitFor.callCount) {
+                    case 1:
                         return {
-                            Certificate: {
-                                Status: "FAILED",
-                                DomainValidationOptions: [{ ResourceRecord: "bouzouf" }]
-                            }
+                            Status: "PENDING_VALIDATION",
+                            DomainValidationOptions: [{ ResourceRecord: { Value: "plop.com.", Name: "bouzouf.com" } }],
+                            CertificateArn: "arn:plop"
                         };
-                    }
-                }));
-                requestCertificate.callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                    return { CertificateArn: "plop" };
-                }));
-                yield assert.rejects(() => __awaiter(this, void 0, void 0, function* () { return yield this.deployer.doCreateCertificate("test.webda.io.", { Id: "1234" }); }), /Certificate validation has failed/g);
-                waitFor.callsFake(() => undefined);
-                yield assert.rejects(() => __awaiter(this, void 0, void 0, function* () { return yield this.deployer.doCreateCertificate("test.webda.io.", { Id: "1234" }); }), /Certificate validation has failed/g);
-                waitFor.resetHistory();
-                describeCertificate.resetHistory();
-                assert.strictEqual(createDNSEntry.notCalled, true);
-                // @ts-ignore
-                waitFor.callsFake(c => {
-                    switch (waitFor.callCount) {
-                        case 1:
-                            return {
-                                Status: "PENDING_VALIDATION",
-                                DomainValidationOptions: [{ ResourceRecord: { Value: "plop.com.", Name: "bouzouf.com" } }],
-                                CertificateArn: "arn:plop"
-                            };
-                        default:
-                            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                                for (let i = 0; i < 5; i++) {
-                                    if (yield c(resolve, reject)) {
-                                        return;
-                                    }
+                    default:
+                        return new Promise(async (resolve, reject) => {
+                            for (let i = 0; i < 5; i++) {
+                                if (await c(resolve, reject)) {
+                                    return;
                                 }
-                                reject("max");
-                            }));
-                    }
-                });
-                describeCertificate.callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                    if (describeCertificate.callCount < 3) {
-                        return {
-                            Certificate: {
-                                Status: "PENDING_VALIDATION"
                             }
-                        };
-                    }
-                    else {
-                        return {
-                            Certificate: {
-                                Status: "ISSUED"
-                            }
-                        };
-                    }
-                }));
-                yield this.deployer.doCreateCertificate("test.webda.io.", { Id: "1234", Name: "", CallerReference: "" });
-                assert.strictEqual(createDNSEntry.calledWith("bouzouf.com", "CNAME", "plop.com.", { Id: "1234", Name: "", CallerReference: "" }), true);
-                assert.strictEqual(describeCertificate.callCount, 3);
-                waitFor.resetHistory();
-                describeCertificate.resolves({ Certificate: { Status: "ERROR" } });
-                let exception = false;
-                try {
-                    // Should be able to use assert.rejects
-                    yield this.deployer.doCreateCertificate("test.webda.io.", { Id: "1234" });
+                            reject("max");
+                        });
                 }
-                catch (err) {
-                    assert.deepStrictEqual(err, { Status: "ERROR" });
-                    exception = true;
+            });
+            describeCertificate.callsFake(async () => {
+                if (describeCertificate.callCount < 3) {
+                    return {
+                        Certificate: {
+                            Status: "PENDING_VALIDATION"
+                        }
+                    };
                 }
-                assert.strictEqual(exception, true);
-            }
-            finally {
-                mock.restore();
-            }
-        });
-    }
-    testCreateDNSEntry() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var callSpy = sinon.stub();
-            var getZoneForDomainName = sinon.stub(this.deployer, "getZoneForDomainName");
-            getZoneForDomainName.callsFake(() => __awaiter(this, void 0, void 0, function* () {
-                if (getZoneForDomainName.callCount === 1) {
-                    return undefined;
+                else {
+                    return {
+                        Certificate: {
+                            Status: "ISSUED"
+                        }
+                    };
                 }
-                return { Id: "1234", CallerReference: "", Name: "" };
-            }));
-            callSpy.resolves();
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_route_53_1.Route53).on(client_route_53_1.ChangeResourceRecordSetsCommand).callsFake(callSpy);
+            });
+            await this.deployer.doCreateCertificate("test.webda.io.", { Id: "1234", Name: "", CallerReference: "" });
+            assert.strictEqual(createDNSEntry.calledWith("bouzouf.com", "CNAME", "plop.com.", { Id: "1234", Name: "", CallerReference: "" }), true);
+            assert.strictEqual(describeCertificate.callCount, 3);
+            waitFor.resetHistory();
+            describeCertificate.resolves({ Certificate: { Status: "ERROR" } });
+            let exception = false;
             try {
-                yield assert.rejects(() => __awaiter(this, void 0, void 0, function* () { return yield this.deployer.restrictedCall("createDNSEntry", "webda.io", "CNAME", "loopingz.com"); }), /Domain is not handled on AWS/g);
-                assert.strictEqual(callSpy.notCalled, true);
-                yield this.deployer.restrictedCall("createDNSEntry", "webda.io.", "CNAME", "loopingz.com");
-                assert.strictEqual(callSpy.calledOnce, true);
-                assert.deepStrictEqual(callSpy.firstCall.firstArg, {
-                    HostedZoneId: "1234",
-                    ChangeBatch: {
-                        Changes: [
-                            {
-                                Action: "UPSERT",
-                                ResourceRecordSet: {
-                                    Name: "webda.io.",
-                                    ResourceRecords: [
-                                        {
-                                            Value: "loopingz.com"
-                                        }
-                                    ],
-                                    TTL: 360,
-                                    Type: "CNAME"
-                                }
-                            }
-                        ],
-                        Comment: "webda-automated-deploiement"
-                    }
-                });
+                // Should be able to use assert.rejects
+                await this.deployer.doCreateCertificate("test.webda.io.", { Id: "1234" });
             }
-            finally {
-                mock.restore();
+            catch (err) {
+                assert.deepStrictEqual(err, { Status: "ERROR" });
+                exception = true;
             }
-        });
+            assert.strictEqual(exception, true);
+        }
+        finally {
+            mock.restore();
+        }
     }
-    testHash() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.strictEqual(yield this.deployer.restrictedCall("md5", "bouzouf"), "fc45f69f910da129848cd265448a5d00");
-            assert.strictEqual(yield this.deployer.restrictedCall("hash", "bouzouf"), "fc45f69f910da129848cd265448a5d00");
-            assert.strictEqual(yield this.deployer.restrictedCall("hash", "bouzouf", "md5", "base64"), "/EX2n5ENoSmEjNJlRIpdAA==");
-            assert.strictEqual(yield this.deployer.restrictedCall("hash", "bouzouf", "sha256", "hex"), "af6773b1075007089c46a6d0b8e9ac03abfdb526de0683bfeb723f2448ea3f66");
+    async testCreateDNSEntry() {
+        var callSpy = sinon.stub();
+        var getZoneForDomainName = sinon.stub(this.deployer, "getZoneForDomainName");
+        getZoneForDomainName.callsFake(async () => {
+            if (getZoneForDomainName.callCount === 1) {
+                return undefined;
+            }
+            return { Id: "1234", CallerReference: "", Name: "" };
         });
+        callSpy.resolves();
+        const mock = mockClient(Route53).on(ChangeResourceRecordSetsCommand).callsFake(callSpy);
+        try {
+            await assert.rejects(async () => await this.deployer.restrictedCall("createDNSEntry", "webda.io", "CNAME", "loopingz.com"), /Domain is not handled on AWS/g);
+            assert.strictEqual(callSpy.notCalled, true);
+            await this.deployer.restrictedCall("createDNSEntry", "webda.io.", "CNAME", "loopingz.com");
+            assert.strictEqual(callSpy.calledOnce, true);
+            assert.deepStrictEqual(callSpy.firstCall.firstArg, {
+                HostedZoneId: "1234",
+                ChangeBatch: {
+                    Changes: [
+                        {
+                            Action: "UPSERT",
+                            ResourceRecordSet: {
+                                Name: "webda.io.",
+                                ResourceRecords: [
+                                    {
+                                        Value: "loopingz.com"
+                                    }
+                                ],
+                                TTL: 360,
+                                Type: "CNAME"
+                            }
+                        }
+                    ],
+                    Comment: "webda-automated-deploiement"
+                }
+            });
+        }
+        finally {
+            mock.restore();
+        }
     }
-    cov() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.strictEqual(this.deployer.getRegion(), "us-east-1");
-            this.deployer.waitFor((resolve) => __awaiter(this, void 0, void 0, function* () {
-                resolve();
-                return true;
-            }), 1, "test", 1);
-            this.deployer.resources.Tags = [{ Key: "plop", Value: "test" }];
-            // @ts-ignore
-            this.deployer.resources.Plop = { Tags: { plop2: "oké yep" } };
-            assert.strictEqual(this.deployer.getDefaultTagsAsS3Tagging("Plop"), "plop2=ok%C3%A9%20yep&plop=test");
-        });
+    async testHash() {
+        assert.strictEqual(await this.deployer.restrictedCall("md5", "bouzouf"), "fc45f69f910da129848cd265448a5d00");
+        assert.strictEqual(await this.deployer.restrictedCall("hash", "bouzouf"), "fc45f69f910da129848cd265448a5d00");
+        assert.strictEqual(await this.deployer.restrictedCall("hash", "bouzouf", "md5", "base64"), "/EX2n5ENoSmEjNJlRIpdAA==");
+        assert.strictEqual(await this.deployer.restrictedCall("hash", "bouzouf", "sha256", "hex"), "af6773b1075007089c46a6d0b8e9ac03abfdb526de0683bfeb723f2448ea3f66");
+    }
+    async cov() {
+        assert.strictEqual(this.deployer.getRegion(), "us-east-1");
+        this.deployer.waitFor(async (resolve) => {
+            resolve();
+            return true;
+        }, 1, "test", 1);
+        this.deployer.resources.Tags = [{ Key: "plop", Value: "test" }];
+        // @ts-ignore
+        this.deployer.resources.Plop = { Tags: { plop2: "oké yep" } };
+        assert.strictEqual(this.deployer.getDefaultTagsAsS3Tagging("Plop"), "plop2=ok%C3%A9%20yep&plop=test");
     }
     replaceForAWS() {
         assert.strictEqual(this.deployer._replaceForAWS("my/id"), "my_id");
@@ -578,51 +513,51 @@ let AWSDeployerTest = class AWSDeployerTest extends deployertest_1.DeployerTest
     }
 };
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "mapToArrayTags", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "putFilesOnBucket", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testGetPolicyDocument", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testGetDefaultVpc", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testCommonPrefix", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testCreateBucket", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testPutBucket", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testGetCertificate", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testGetZoneForDomainName", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testDoCreateCertificate", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testCreateDNSEntry", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "testHash", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "cov", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "replaceForAWS", null);
 __decorate([
-    mocha_1.test
+    test
 ], AWSDeployerTest.prototype, "transformArrayTagsToMap", null);
 AWSDeployerTest = __decorate([
-    mocha_1.suite
+    suite
 ], AWSDeployerTest);
 //# sourceMappingURL=index.spec.js.map