ac-ses 1.2.3 → 2.0.0

package/.eslintrc.js

@@ -20,7 +20,7 @@ const config = {
     it: true
   },
   'parserOptions': {
-    'ecmaVersion': 2018
+    'ecmaVersion': 2022
 },
 }
 

package/.ncurc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  target: (dependencyName, parsedVersion) => {
+    return dependencyName === 'chai' ? 'minor' : 'latest'
+  }
+}

package/CHANGELOG.md

@@ -1,3 +1,50 @@
+<a name="2.0.0"></a>
+ 
+# [2.0.0](https://github.com/admiralcloud/ac-ses/compare/v1.2.4..v2.0.0) (2024-01-06 09:43:38)
+
+
+### Bug Fix
+
+* **App:** Use async/await and remove some functions | MP | [7f9c4aee85e062dfc08fed09c1f4bf08d37e3673](https://github.com/admiralcloud/ac-ses/commit/7f9c4aee85e062dfc08fed09c1f4bf08d37e3673)    
+Package now uses async/await. No more support for blocktime and group messages - use your application logic for that.  
+Related issues: [undefined/undefined#master](undefined/browse/master)
+### Chores
+
+* **App:** Some minor updates | MP | [6cdc1d8f9927d5926836b1128e3f84b8ebb1c0f0](https://github.com/admiralcloud/ac-ses/commit/6cdc1d8f9927d5926836b1128e3f84b8ebb1c0f0)    
+Some minor updates  
+Related issues: [undefined/undefined#master](undefined/browse/master)
+### Chores
+
+* **App:** Updated packages | MP | [21369161d02172ccba704d286dca59b5e0dbbde5](https://github.com/admiralcloud/ac-ses/commit/21369161d02172ccba704d286dca59b5e0dbbde5)    
+Updated packages  
+Related issues: [undefined/undefined#master](undefined/browse/master)
+## BREAKING CHANGES
+* **App:** See README breaking changes for version 2
+<a name="1.2.4"></a>
+
+## [1.2.4](https://github.com/admiralcloud/ac-ses/compare/v1.2.3..v1.2.4) (2023-01-31 11:26:12)
+
+
+### Bug Fix
+
+* **App:** Add debug mode for SES headers | MP | [b11e0374c5956236e80f4b81d9895ba9fd5916f3](https://github.com/admiralcloud/ac-ses/commit/b11e0374c5956236e80f4b81d9895ba9fd5916f3)    
+Add debug mode for SES headers  
+Related issues: [undefined/undefined#master](undefined/browse/master)
+### Tests
+
+* **App:** Fixed tests after package updates | MP | [ba0a41496ffa202c9bac3d7fbde5a7c4b542d24b](https://github.com/admiralcloud/ac-ses/commit/ba0a41496ffa202c9bac3d7fbde5a7c4b542d24b)    
+Fixed tests after package updates  
+Related issues: [undefined/undefined#master](undefined/browse/master)
+### Chores
+
+* **App:** Updated packages | MP | [f3affc2c748a2ed6cb96eaad6a31fae2af646d37](https://github.com/admiralcloud/ac-ses/commit/f3affc2c748a2ed6cb96eaad6a31fae2af646d37)    
+Updated packages  
+Related issues: [undefined/undefined#master](undefined/browse/master)
+### Chores
+
+* **App:** Updated ESLint setting | MP | [a5dd3adfa10ef02ca1c886a0485d324b6ac73aee](https://github.com/admiralcloud/ac-ses/commit/a5dd3adfa10ef02ca1c886a0485d324b6ac73aee)    
+Updated ESLint setting to ECMA 2021  
+Related issues: [undefined/undefined#master](undefined/browse/master)
 <a name="1.2.3"></a>
 
 ## [1.2.3](https://github.com/admiralcloud/ac-ses/compare/v1.2.2..v1.2.3) (2022-07-22 05:34:50)

package/README.md

@@ -1,18 +1,19 @@
 # AC SES
 A helper tool to send emails via AWS SES.  
-It also support "convenience" calls, to inform groups (e.g. support with informSupport function)
 
-## Usage
+## BREAKING CHANGES VERSION 2
++ use async/await
++ no more support for blocktime - use your application logic instead
++ no more support for group messages - use your application logid instead
 
+## Usage
 ```
 const acses = require('ac-ses')
 
 // Min requirements
 acses.init({ 
-  aws: {
-    accessKeyId: 'xxx',
-    secretAccessKey: 'xxx',
-    region: 'eu-central-1'  
+  defaultSender: {
+    address: 'sender@domain.com
   }
 })
 
@@ -34,47 +35,35 @@ let email = {
     html: 'This is my <b>message</b>' // optional
 }
 
-acses.sendEmail(email, (err, result) => {
-  console.log(err, result)
-  // More infos regarding the result:
-  // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SES.html#sendEmail-property
-})
+await acses.sendEmail(email)
+// -> Response
+{
+  '$metadata': {
+    httpStatusCode: 200,
+    requestId: '123466-557d-4a75-8d5c-d71e336963ec',
+    extendedRequestId: undefined,
+    cfId: undefined,
+    attempts: 1,
+    totalRetryDelay: 0
+  },
+  MessageId: '12356-2c4f41dd-6f2b-402e-9c26-123355-000000'
+}
 ```
 
 Full setup
-
 ```
 acses.init({ 
-  aws: {
-    accessKeyId: 'xxx',
-    secretAccessKey: 'xxx',
-    region: 'eu-central-1'  
-  },
-  redis: REDISINSTANCE,
-  defaultBlockTime: BLOCKTIME FOR SAME MESSAGE,
   defaultSender: {
     address: 'defaultSender@admiralcloud.com',
     name: 'AdmiralCloud Sender'
   },
-  securityRecipient: {
-    address: 'defaultSecurityRecipient@admiralcloud.com',
-    name: 'AdmiralCloud Security'
-  },
-  supportRecipient: {
-    address:    address: 'defaultSupportRecipient@admiralcloud.com',
-    name: 'AdmiralCloud Support'
-  },
   environment: ENVIRONMENT // defaults to proces.env.NODE_ENV,
   useEnvironmentPrefixInSubject: TRUE|FALSE // defaults to TRUE - prefixes e-mail subject with environment to avoid confusion during development
 })
-
-
 ```
 
 ## Links
 - [Website](https://www.admiralcloud.com/)
-- [Twitter (@admiralcloud)](https://twitter.com/admiralcloud)
-- [Facebook](https://www.facebook.com/MediaAssetManagement/)
 
 ## License
-[MIT License](https://opensource.org/licenses/MIT) Copyright © 2009-present, AdmiralCloud, Mark Poepping
+[MIT License](https://opensource.org/licenses/MIT) Copyright © 2009-present, AdmiralCloud AG, Mark Poepping

package/index.js

@@ -1,39 +1,21 @@
 const _ = require('lodash')
-const async = require('async')
-const aws = require('aws-sdk')
-
-const crypto = require('crypto')
 const { v4: uuidV4 } = require('uuid')
 
 const quotedPrintable = require('quoted-printable')
 const utf8 = require('utf8')
 
-const acses = function() {
+const { SESClient, SendRawEmailCommand } = require("@aws-sdk/client-ses")
+
+const acses = () => {
   let ses
-  let redis // only required if blockTime should be used - use init to set a redis instance from your main app
 
   let defaultSender
-  let supportRecipient
-  let securityRecipient
-  let operationsRecipient
-  let defaultBlockTime = 60 // used for support and security
   let testMode // if true, no email is sent
   let environment = process.env.NODE_ENV || 'development'
   let useEnvironmentPrefixInSubject = environment !== 'production'
 
   const init = function(options) {
-    const awsConfig = {
-      accessKeyId: _.get(options, 'aws.accessKeyId', process.env.AWS_ACCESS_KEY),
-      secretAccessKey: _.get(options, 'aws.secretAccessKey', process.env.AWS_ACCESS_SECRET),
-      region: _.get(options, 'aws.region', process.env.AWS_REGION)
-    }
-    ses = new aws.SES(awsConfig)
-    if (_.get(options, 'redis')) {
-      redis = _.get(options, 'redis')
-    }
-    if (_.get(options, 'defaultBlockTime')) {
-      defaultBlockTime = _.get(options, 'defaultBlockTime')
-    }
+    ses = new SESClient()
     if (_.get(options, 'testMode')) {
       testMode = _.get(options, 'testMode')
     }
@@ -44,19 +26,11 @@ const acses = function() {
 
     // helper
     if (_.get(options, 'defaultSender') && prepareEmailAddress(_.get(options, 'defaultSender'))) defaultSender = _.get(options, 'defaultSender')
-    if (_.get(options, 'supportRecipient') && prepareEmailAddress(_.get(options, 'supportRecipient'))) supportRecipient = _.get(options, 'supportRecipient')
-    if (_.get(options, 'securityRecipient') && prepareEmailAddress(_.get(options, 'securityRecipient'))) securityRecipient = _.get(options, 'securityRecipient')
-    if (_.get(options, 'operationsRecipient') && prepareEmailAddress(_.get(options, 'operationsRecipient'))) operationsRecipient = _.get(options, 'operationsRecipient')
-
+ 
     return {
-      awsConfig: _.pick(awsConfig, ['accessKeyId', 'region']),
       testMode,
-      defaultBlockTime,
       environment,
-      defaultSender,
-      supportRecipient,
-      securityRecipient,
-      operationsRecipient
+      defaultSender
     }
   }
 
@@ -67,10 +41,10 @@ const acses = function() {
    * OUT John Doe <john.doe@example.com>
    * @param {*} params
    */
-  const prepareEmailAddress = function(params) {
-    if (!_.get(params, 'address')) throw new Error({ message: 'ACSES.prepareEmailAddress - address_required' })
-    if (!_.isString(_.get(params, 'address'))) throw new Error({ message: 'ACSES.prepareEmailAddress - address_mustBeAString' })
-    let email = (_.get(params, 'name') ? _.get(params, 'name') + ' <' : '') + _.get(params, 'address') + (_.get(params, 'name') ? '>' : '')
+  const prepareEmailAddress = ({ address, name }) => {
+    if (!address) throw new Error({ message: 'ACSES.prepareEmailAddress - address_required' })
+    if (!_.isString(address)) throw new Error({ message: 'ACSES.prepareEmailAddress - address_mustBeAString' })
+    let email = name ? `${name} <${address}>` : address
     return email
   }
 
@@ -89,14 +63,11 @@ const acses = function() {
    *
    * @param attachments ARRAY Optional array of objects with properties: filename, content (as base64) and encoding as 'base64'
    *
-   * @param blockTime INT OPTIONAL If set, you cannot send an email to the same recipient for the blockTime (helpful for warning messages - you don't want them every second!)
-   * @param redisKey STRING OPTIONAL You can use your own redisKey for the blockTime feature, or let this app create an MD5 hash from the parameters
    * @param encoding STRING OPTIONAL Encoding for multipart alternative parts - defaults to "quoted-printable"
    *
-   * @param {*} cb Optional callback
    */
-  const sendEmail = (params, cb) => {
-    if (!_.isObject(ses)) return cb({ message: 'pleaseUseInitBeforeSendingEmail' })
+  const sendEmail = async(params) => {
+    if (!_.isObject(ses)) throw new Error('pleaseUseInitBeforeSendingEmail')
     if (!_.get(params, 'from') && defaultSender) _.set(params, 'from', defaultSender)
     const fieldCheck = [
       { field: 'from', type: _.isPlainObject, required: true },
@@ -109,173 +80,95 @@ const acses = function() {
       // OPTIONS
       { field: 'replyTo', type: _.isArray },
       { field: 'attachments', type: _.isArray },
+      { field: 'debug', type: _.isBoolean },
     ]
 
     _.some(fieldCheck, (field) => {
-      if (field.required && !_.has(params, field.field)) return cb({ message: field.field + '_required' })
-      if (_.get(params, field.field) && !field.type(_.get(params, field.field))) return cb({ message: field.field + '_typeInvalid' })
+      if (field.required && !_.has(params, field.field)) throw new Error(field.field + '_required')
+      if (_.get(params, field.field) && !field.type(_.get(params, field.field))) throw new Error(field.field + '_typeInvalid')
     })
 
     const boundaryMixed = uuidV4()
     const boundaryAlternative = uuidV4()
     const encoding = _.get(params, 'encoding', 'quoted-printable')
 
-    async.series({
-      checkBlockTime: (done) => {
-        if (!redis || !params.blockTime) return done()
-        let sesParams = {
-          from: params.from,
-          to: params.to,
-          subject: params.subject,
-          text: params.text
-        }
-        let redisKey = _.get(params, 'redisKey', crypto.createHash('md5').update(JSON.stringify(sesParams)).digest('hex'))
-        redis.set(redisKey, 1, 'EX', params.blockTime, 'NX', (err, result) => {
-          if (err) return done(err)
-          if (result === 'OK') return done()
-          return done(423) // the key is already locked
+    // sendRawMessage
+    let raw = 'From: ' + prepareEmailAddress(_.get(params, 'from')) + '\n'
+    // prepare To, Cc, Bcc
+    _.forEach(['to', 'cc', 'bcc'], type => {
+      if (_.size(_.get(params, type))) {
+        let recipients = _.map(_.get(params, type), (recipient) => {
+          return prepareEmailAddress(recipient)
         })
-      },
-      sendRawMessage: (done) => {
-        let raw = 'From: ' + prepareEmailAddress(_.get(params, 'from')) + '\n'
-        // prepare To, Cc, Bcc
-        _.forEach(['to', 'cc', 'bcc'], type => {
-          if (_.size(_.get(params, type))) {
-            let recipients = _.map(_.get(params, type), (recipient) => {
-              return prepareEmailAddress(recipient)
-            })
-            raw += _.upperFirst(type) + ': ' + _.join(recipients, ', ') + '\n'
-          }
-        })
-        if (params.replyTo) {
-          let recipients = _.map(_.get(params, 'replyTo'), (recipient) => {
-            return prepareEmailAddress(recipient)
-          })
-          raw += 'Reply-To: ' + _.join(recipients, ', ') + '\n'
-        }
-
-        raw += 'Subject: ' + (useEnvironmentPrefixInSubject ? (_.toUpper(environment) + ' | ') : '') + params.subject + '\n'
-
-        // announce multipart/mixed
-        raw += 'Mime-Version: 1.0\n'
-        raw += 'Content-type: multipart/mixed; boundary="' + boundaryMixed + '"\n\n'
-        raw += 'This message is in MIME format. Since your mail reader does not understand this format, some or all of this message may not be legible.\n\n'
-
-        // text and HTML are multipart/alternatives with their own boundaries
-        raw += '--' + boundaryMixed + '\nContent-Type: multipart/alternative; boundary="' + boundaryAlternative + '"\n\n'
-        if (params.text) {
-          raw += '--' + boundaryAlternative + '\nContent-Type: text/plain; charset="UTF-8"\nContent-Transfer-Encoding: ' + encoding + '\n\n'
-          raw += quotedPrintable.encode(utf8.encode(params.text)) + '\n\n'
-        }
-        if (params.html) {
-          raw += '--' + boundaryAlternative + '\nContent-Type: text/html; charset="UTF-8"\nContent-Transfer-Encoding: ' + encoding + '\n\n'
-          raw += quotedPrintable.encode(utf8.encode(params.html)) + '\n\n'
-        }
-        raw += '--' + boundaryAlternative + '--\n\n'
-
-        if (params.attachments) {
-          _.forEach(params.attachments, attachment => {
-            raw += '--' + boundaryMixed + '\n'
-            raw += 'Content-Disposition: attachment; filename="' + attachment.filename + '"\n'
-            raw += 'Content-Type: ' + attachment.contentType + '; name="' + attachment.filename + '"\nContent-Transfer-Encoding: ' + attachment.encoding + '\n\n'
-            raw += attachment.content + '\n\n'
-          })
-          raw += '--' + boundaryMixed + '--\n'
-        }
-
-        const rawParams = {
-          RawMessage: { /* required */
-            Data: Buffer.from(raw)
-          }
-        }
-        if (testMode) {
-          // return fake response, but do not send message
-          let mockResponse = {
-            ResponseMetadata: {
-              RequestId: uuidV4()
-            },
-            MessageId: Math.random().toString(36) + '-' + uuidV4() + '-000000',
-            testMode: true
-          }
-          return done(null, mockResponse)
-        }
-        ses.sendRawEmail(rawParams, done)
+        raw += _.upperFirst(type) + ': ' + _.join(recipients, ', ') + '\n'
       }
-    }, (err, result) => {
-      if (err && err === 423) err = null // this is not an error, just blocked
-      if (_.isFunction(cb)) {
-        return cb(err, _.get(result, 'sendRawMessage'))
-      }
-      if (err) throw new Error(err)
     })
-  }
+    if (params.replyTo) {
+      let recipients = _.map(_.get(params, 'replyTo'), (recipient) => {
+        return prepareEmailAddress(recipient)
+      })
+      raw += 'Reply-To: ' + _.join(recipients, ', ') + '\n'
+    }
 
-  /**
-   * Use as as shortcut to inform support - no need for from or to, this is already pre-defined
-   * Other than that, it works similar to sendEmail
-   * Differences: no HTML to improve delivery
-   * @param {*} params
-   * @param {*} cb
-   */
-  const informSecurity = function(params, cb) {
-    if (!securityRecipient) return cb({ message: 'acses.informSecurity - securityRecipient_notSet' })
-    let message = {
-      to: [securityRecipient],
-      subject: params.subject,
-      text: params.text,
-      blockTime: _.get(params, 'blockTime', defaultBlockTime),
-      redisKey: _.get(params, 'redisKey')
+    raw += 'Subject: ' + (useEnvironmentPrefixInSubject ? (_.toUpper(environment) + ' | ') : '') + params.subject + '\n'
+    if (params?.debug) {
+      console.log('ACSES | DEBUG Headers | %j', raw.split('/n'))
     }
-    if (_.isFunction(cb)) sendEmail(message, cb)
-    else sendEmail(message)
-  }
 
-  /**
-   * Use as as shortcut to inform support - no need for from or to, this is already pre-defined
-   * Other than that, it works similar to sendEmail
-   * Differences: no HTML to improve delivery
-   * @param {*} params
-   * @param {*} cb
-   */
-  const informSupport = function(params, cb) {
-    if (!supportRecipient) return cb({ message: 'acses.informSecurity - supportRecipient_notSet' })
-    let message = {
-      to: [supportRecipient],
-      subject: params.subject,
-      text: params.text,
-      blockTime: _.get(params, 'blockTime', defaultBlockTime),
-      redisKey: _.get(params, 'redisKey')
+    // announce multipart/mixed
+    raw += 'Mime-Version: 1.0\n'
+    raw += 'Content-type: multipart/mixed; boundary="' + boundaryMixed + '"\n\n'
+    raw += 'This message is in MIME format. Since your mail reader does not understand this format, some or all of this message may not be legible.\n\n'
+
+    // text and HTML are multipart/alternatives with their own boundaries
+    raw += '--' + boundaryMixed + '\nContent-Type: multipart/alternative; boundary="' + boundaryAlternative + '"\n\n'
+    if (params.text) {
+      raw += '--' + boundaryAlternative + '\nContent-Type: text/plain; charset="UTF-8"\nContent-Transfer-Encoding: ' + encoding + '\n\n'
+      raw += quotedPrintable.encode(utf8.encode(params.text)) + '\n\n'
+    }
+    if (params.html) {
+      raw += '--' + boundaryAlternative + '\nContent-Type: text/html; charset="UTF-8"\nContent-Transfer-Encoding: ' + encoding + '\n\n'
+      raw += quotedPrintable.encode(utf8.encode(params.html)) + '\n\n'
+    }
+    raw += '--' + boundaryAlternative + '--\n\n'
+
+    if (params.attachments) {
+      _.forEach(params.attachments, attachment => {
+        raw += '--' + boundaryMixed + '\n'
+        raw += 'Content-Disposition: attachment; filename="' + attachment.filename + '"\n'
+        raw += 'Content-Type: ' + attachment.contentType + '; name="' + attachment.filename + '"\nContent-Transfer-Encoding: ' + attachment.encoding + '\n\n'
+        raw += attachment.content + '\n\n'
+      })
+      raw += '--' + boundaryMixed + '--\n'
     }
-    if (_.isFunction(cb)) sendEmail(message, cb)
-    else sendEmail(message)
-  }
 
-  /**
-   * Use as as shortcut to inform operations - no need for from or to, this is already pre-defined
-   * Other than that, it works similar to sendEmail
-   * Differences: no HTML to improve delivery
-   * @param {*} params
-   * @param {*} cb
-   */
-  const informOperations = function(params, cb) {
-    if (!operationsRecipient) return cb({ message: 'acses.informSecurity - operationsRecipient_notSet' })
-    let message = {
-      to: [operationsRecipient],
-      subject: params.subject,
-      text: params.text,
-      blockTime: _.get(params, 'blockTime', defaultBlockTime),
-      redisKey: _.get(params, 'redisKey')
+    const rawParams = {
+      RawMessage: { /* required */
+        Data: Buffer.from(raw)
+      }
+    }
+    
+    if (testMode) {
+      // return fake response, but do not send message
+      let mockResponse = {
+        '$metadata': {
+          httpStatusCode: 200,
+          requestId: uuidV4(),
+          attempts: 1
+        },
+        MessageId: Math.random().toString(36) + '-' + uuidV4() + '-000000',
+        testMode: true
+      }
+      return mockResponse
     }
-    if (_.isFunction(cb)) sendEmail(message, cb)
-    else sendEmail(message)
+    const command = new SendRawEmailCommand(rawParams)
+    const response = await ses.send(command)
+    return response
   }
 
   return {
     init,
-    sendEmail,
-    informSecurity,
-    informSupport,
-    informOperations
+    sendEmail
   }
 }
 

package/package.json

@@ -4,28 +4,27 @@
   "license": "MIT",
   "repository": "admiralcloud/ac-ses",
   "homepage": "https://www.admiralcloud.com",
-  "version": "1.2.3",
+  "version": "2.0.0",
   "dependencies": {
-    "async": "^3.2.4",
-    "aws-sdk": "^2.1180.0",
+    "@aws-sdk/client-ses": "^3.485.0",
     "lodash": "^4.17.21",
     "quoted-printable": "^1.0.1",
     "utf8": "^3.0.0",
-    "uuid": "^8.x"
+    "uuid": "^9.x"
   },
   "devDependencies": {
-    "ac-semantic-release": "^0.3.3",
-    "eslint": "7.x",
-    "expect": "^27.x",
-    "ioredis": "^4.28.5",
-    "mocha": "^9.2.2",
-    "mocha-jenkins-reporter": "0.4.7"
+    "ac-semantic-release": "^0.4.2",
+    "chai": "^4.4.0",
+    "eslint": "8.x",
+    "expect": "^29.7.0",
+    "mocha": "^10.2.0",
+    "mocha-jenkins-reporter": "0.4.8"
   },
   "scripts": {
     "test": "mocha --reporter spec",
     "test-jenkins": "JUNIT_REPORT_PATH=./report.xml mocha --colors --reporter mocha-jenkins-reporter --reporter-options junit_report_name='AC-SES'"
   },
   "engines": {
-    "node": ">=10.0.0"
+    "node": ">=16.0.0"
   }
 }

package/test/test.js

@@ -1,126 +1,41 @@
-const fs = require('fs')
+const fs = require('fs/promises')
 
-const expect = require('expect')
 const acses = require('../index')
 
-var Redis = require('ioredis')
-var redis = new Redis({
-  host: process.env.REDIS_HOST || 'localhost',
-  port: process.env.REDIS_PORT || 6379
-})
-
+const expect = require('chai').expect 
 const testConfig = require('./testConfig.js')
 
 describe('CHECKING ERRORS', function () {
-  it('Send email without init', function(done) {
+  it('Send email without init', async() => {
     let params = testConfig.email
-    acses.sendEmail(params, (err) => {
-      expect(err).toEqual({ message: 'pleaseUseInitBeforeSendingEmail' })
-      return done()
-    })
+    try {
+      await acses.sendEmail(params)
+    }
+    catch(e) {
+      expect(e.message).to.eql('pleaseUseInitBeforeSendingEmail')
+    }
   })
 })
 
 describe('TESTING EMAIL', function () {
-  it('Init AC SES', function(done) {
-    acses.init(testConfig.init)
-    return done()
-  })
-
-  it('Send a text email', function(done) {
-    let params = testConfig.email
-    acses.sendEmail(params, (err, result) => {
-      if (err) return done(err)
-      expect(result).toHaveProperty('ResponseMetadata')
-      expect(result).toHaveProperty('MessageId')
-      return done()
-    })
-  })
-
-  it('Send a HTML email', function(done) {
-    let params = testConfig.email
-    fs.readFile(process.cwd() + '/test/htmlTemplate.html', (err, data) => {
-      if (err) return done(err)
-      params.subject = 'HTML Test E-Mail'
-      params.html = data.toString()
-      acses.sendEmail(params, (err, result) => {
-        if (err) return done(err)
-        expect(result).toHaveProperty('ResponseMetadata')
-        expect(result).toHaveProperty('MessageId')
-        return done()
-      })
-    })
-  })
-
-  it('Send a security email', function(done) {
-    let params = testConfig.securityEmail
-    acses.informSecurity(params, (err, result) => {
-      if (err) return done(err)
-      expect(result).toHaveProperty('ResponseMetadata')
-      expect(result).toHaveProperty('MessageId')
-      return done()
-    })
-  })
-
-  it('Send a support email', function(done) {
-    let params = testConfig.supportEmail
-    acses.informSecurity(params, (err, result) => {
-      if (err) return done(err)
-      expect(result).toHaveProperty('ResponseMetadata')
-      expect(result).toHaveProperty('MessageId')
-      return done()
-    })
-  })
-})
-
-describe('TESTING BLOCK TIME', function() {
-  this.timeout(60000)
-
-  it('Init AC SES with Redis support', function(done) {
-    testConfig.init.redis = redis
+  it('Init AC SES', async() => {
     acses.init(testConfig.init)
-    return done()
   })
 
-  it('Send a text email', function(done) {
+  it('Send a text email', async() => {
     let params = testConfig.email
-    params.html = null
-    params.subject = 'Test email with blocktime'
-    params.blockTime = 10
-    acses.sendEmail(params, (err, result) => {
-      if (err) return done(err)
-      expect(result).toHaveProperty('ResponseMetadata')
-      expect(result).toHaveProperty('MessageId')
-      return done()
-    })
+    let result = await acses.sendEmail(params)
+    expect(result).to.have.property('$metadata')
+    expect(result).to.have.property('MessageId')
   })
 
-  it('Send a text email - should fail - it is the SAME email and block time is active', function(done) {
+  it('Send a HTML email', async() => {
     let params = testConfig.email
-    acses.sendEmail(params, (err, result) => {
-      if (err) return done(err)
-      expect(result).toBeUndefined()
-      return done()
-    })
-  })
-
-  it('Wait until blocktime is over', function(done) {
-    setTimeout(done, 10000)
-  })
-
-  it('Send a text email - should work again', function(done) {
-    let params = testConfig.email
-    params.html = null
-    params.subject = 'Test after block time'
-    acses.sendEmail(params, (err, result) => {
-      if (err) return done(err)
-      expect(result).toHaveProperty('ResponseMetadata')
-      expect(result).toHaveProperty('MessageId')
-      return done()
-    })
-  })
-
-  it('Close Redis connection', function(done) {
-    redis.quit(done)
-  })
-})
+    const data = await fs.readFile(process.cwd() + '/test/htmlTemplate.html')
+    params.subject = 'HTML Test E-Mail'
+    params.html = data.toString()
+    const result = await acses.sendEmail(params)
+    expect(result).to.have.property('$metadata')
+    expect(result).to.have.property('MessageId')
+  })
+})