@ikonintegration/ikapi 4.0.1 → 5.0.0

package/tests/Database/integrations/kysely/KyselyDatabase.test.ts

@@ -0,0 +1,113 @@
+import { jest } from '@jest/globals'
+import { PostgresDialect } from 'kysely'
+import * as pg from 'pg'
+
+import type { DbConfig } from '../../../../src/Database/index.js'
+import { KyselyDatabase } from '../../../../src/Database/integrations/kysely/KyselyDatabase.js'
+
+const config: DbConfig<'kysely'> = {
+  type: 'kysely',
+  username: 'username',
+  password: 'password',
+  host: 'host',
+  port: 1234,
+  database: 'database',
+  maxConnections: 1,
+  autoCommit: true,
+}
+
+const config2: DbConfig<'kysely'> = {
+  ...config,
+  readReplica: config,
+}
+
+const expectedImplConfig = {
+  host: config.host,
+  port: config.port,
+  user: config.username,
+  password: config.password,
+  database: config.database,
+  max: config.maxConnections,
+}
+
+describe('KyselyDatabase', () => {
+  let mockTrans
+  let mockClient
+  let mockDriver
+  let mockDialect
+  let mockPgTrans
+  let mockPgClient
+  beforeEach(() => {
+    mockTrans = {
+      execute: jest.fn(async (cb: any) => {
+        cb(mockTrans)
+      }),
+    } as any
+    mockClient = jest.fn(
+      () =>
+        ({
+          transaction: () => mockTrans,
+        }) as any as PostgresDialect
+    )
+    KyselyDatabase['kyselyProvider'] = mockClient as any
+
+    mockDriver = {
+      execute: jest.fn(async () => {}),
+    } as any
+    mockDialect = jest.fn(
+      () =>
+        ({
+          createDriver: () => mockDriver,
+        }) as any as PostgresDialect
+    )
+    KyselyDatabase['kyselyPgProvider'] = mockDialect as any
+
+    mockPgTrans = {
+      query: jest.fn(() => {}),
+    } as any
+    mockPgClient = jest.fn(
+      () =>
+        ({
+          connect: async () => mockPgTrans,
+        }) as pg.PoolClient
+    )
+    KyselyDatabase['pgProvider'] = mockPgClient as any
+  })
+
+  test('KyselyDatabase', async () => {
+    const underTest = new KyselyDatabase(config)
+    expect(mockPgClient).toHaveBeenNthCalledWith(1, expectedImplConfig)
+    expect(mockDialect).toHaveBeenCalledTimes(1)
+    expect(mockClient).toHaveBeenCalledTimes(1)
+    expect(mockClient.mock.calls[0][0].dialect).toEqual(underTest['pgClient'])
+    expect(mockClient.mock.calls[0][0].plugins).toBeInstanceOf(Array)
+    const trans = await underTest.transaction()
+
+    expect(mockTrans.execute).toHaveBeenCalledTimes(1)
+    expect(trans.reader).toBeUndefined()
+    expect(trans.writer).toBeInstanceOf(Object)
+    expect(trans.writer.transaction).toBeInstanceOf(Function)
+    expect(trans).toBeInstanceOf(Function)
+    expect(trans['transaction']).toBe(mockTrans)
+  })
+
+  test('KyselyDatabase -  read replica', async () => {
+    const underTest = new KyselyDatabase(config2)
+    expect(mockPgClient).toHaveBeenNthCalledWith(2, expectedImplConfig)
+    expect(mockDialect).toHaveBeenCalledTimes(2)
+    expect(mockClient).toHaveBeenCalledTimes(2)
+    expect(mockClient.mock.calls[0][0].dialect).toEqual(underTest['pgClient'])
+    expect(mockClient.mock.calls[0][0].plugins).toBeInstanceOf(Array)
+    expect(mockClient.mock.calls[1][0].dialect).toEqual(underTest['pgReadClient'])
+    expect(mockClient.mock.calls[1][0].plugins).toBeInstanceOf(Array)
+
+    const trans = await underTest.transaction()
+
+    expect(mockTrans.execute).toHaveBeenCalledTimes(1)
+    expect(trans.writer).toBeInstanceOf(Object)
+    expect(trans.writer.transaction).toBeInstanceOf(Function)
+    expect(trans.reader).toBeInstanceOf(Object)
+    expect(trans).toBeInstanceOf(Function)
+    expect(trans['transaction']).toBe(mockTrans)
+  })
+})

package/tests/Database/integrations/kysely/KyselyTransaction.test.ts

@@ -0,0 +1,119 @@
+import { jest } from '@jest/globals'
+import { Kysely, Transaction } from 'kysely'
+
+import type { DbConfig } from '../../../../src/Database/index.js'
+import { KyselyDatabase } from '../../../../src/Database/integrations/kysely/KyselyDatabase.js'
+import { KyselyTransactionImpl } from '../../../../src/Database/integrations/kysely/KyselyTransaction.js'
+
+const testResources = async (config: Partial<DbConfig<'kysely'>>) => {
+  type DB = {
+    view: {
+      id: number
+    }
+    secondView: {
+      title: string
+    }
+  }
+
+  const database = {
+    config: {
+      autoCommit: true,
+      ...config,
+    } as DbConfig<'kysely'>,
+  } as any as KyselyDatabase<DB>
+
+  const transaction = jest.fn().mockImplementation(() => {
+    return {
+      execute: jest.fn(async (cb: any) => {
+        try {
+          await cb(transaction)
+        } catch (e) {
+          /* empty */
+        }
+      }),
+      executeQuery: jest.fn(),
+    }
+  })() as any as Transaction<DB>
+
+  const writer = jest.fn().mockImplementation(() => {
+    return {
+      transaction: jest.fn(() => transaction),
+    }
+  })() as any as Kysely<DB>
+
+  return {
+    transaction,
+    writer,
+    underTest: await KyselyTransactionImpl.newTransaction(writer, database),
+  }
+}
+
+describe('KyselyTransaction', () => {
+  test('Transaction starts opened', async () => {
+    const { transaction, underTest } = await testResources({})
+    expect(underTest.isOpen()).toBe(true)
+    expect(transaction['execute']).toHaveBeenCalledTimes(1)
+
+    await expect(underTest.begin).rejects.toThrowError(
+      'Cannot begin, transaction is already opened!'
+    )
+  })
+
+  test('Can only commit once', async () => {
+    const { underTest } = await testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+
+    await expect(underTest.commit).rejects.toThrowError(
+      'Cannot commit, transaction is already closed!'
+    )
+  })
+
+  test('Can only rollback once', async () => {
+    const { underTest } = await testResources({})
+    await underTest.rollback()
+    expect(underTest.isOpen()).toBe(false)
+    await expect(underTest.rollback).rejects.toThrowError(
+      'Cannot rollback, transaction is already closed!'
+    )
+  })
+
+  test("Can't open transaction twice", async () => {
+    const { underTest } = await testResources({})
+    expect(underTest.isOpen()).toBe(true)
+
+    await expect(underTest.begin).rejects.toThrowError(
+      'Cannot begin, transaction is already opened!'
+    )
+  })
+
+  test('Can commit, begin and commit again ', async () => {
+    const { underTest } = await testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+    await underTest.begin()
+    expect(underTest.isOpen()).toBe(true)
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+  })
+
+  test('Can commit, begin and rollback ', async () => {
+    const { underTest } = await testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+    await underTest.begin()
+    expect(underTest.isOpen()).toBe(true)
+    await underTest.rollback()
+    expect(underTest.isOpen()).toBe(false)
+  })
+
+  test('Can rollback, begin and commit ', async () => {
+    const { underTest } = await testResources({})
+    await underTest.rollback()
+    expect(underTest.isOpen()).toBe(false)
+    await underTest.begin()
+    expect(underTest.isOpen()).toBe(true)
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+  })
+})

package/tests/Database/integrations/pg/PostgresDatabase.test.ts

@@ -0,0 +1,76 @@
+import { jest } from '@jest/globals'
+import * as pg from 'pg'
+
+import type { DbConfig } from '../../../../src/Database/index.js'
+import { PostgresDatabase } from '../../../../src/Database/integrations/pgsql/PostgresDatabase.js'
+
+const config: DbConfig<'pg'> = {
+  type: 'pg',
+  username: 'username',
+  password: 'password',
+  host: 'host',
+  port: 1234,
+  database: 'database',
+  maxConnections: 1,
+  autoCommit: true,
+}
+
+const config2: DbConfig<'pg'> = {
+  ...config,
+  readReplica: config,
+}
+
+const expectedImplConfig = {
+  host: config.host,
+  port: config.port,
+  user: config.username,
+  password: config.password,
+  database: config.database,
+  max: config.maxConnections,
+}
+
+describe('PostgresDatabase', () => {
+  let mockTrans
+  let mockClient
+  beforeEach(() => {
+    mockTrans = {
+      query: jest.fn(() => {}),
+    } as any
+    mockClient = jest.fn(
+      () =>
+        ({
+          connect: async () => mockTrans,
+        }) as pg.PoolClient
+    )
+    PostgresDatabase['pgProvider'] = mockClient as any
+  })
+
+  test('PostgresDatabase', async () => {
+    const underTest = new PostgresDatabase(config)
+    expect(mockClient).toHaveBeenNthCalledWith(1, expectedImplConfig)
+
+    const trans = await underTest.transaction()
+
+    expect(mockTrans.query).toBeCalledWith('BEGIN')
+    expect(trans.reader).toBeUndefined()
+    expect(trans.writer).toBeInstanceOf(Object)
+    expect(trans.writer.connect).toBeInstanceOf(Function)
+    expect(trans).toBeInstanceOf(Function)
+    expect(trans['transaction']).toBe(mockTrans)
+  })
+
+  test('PostgresDatabase - read replica', async () => {
+    const underTest = new PostgresDatabase(config2)
+    expect(mockClient).toHaveBeenNthCalledWith(2, expectedImplConfig)
+
+    const trans = await underTest.transaction()
+
+    expect(mockTrans.query).toBeCalledWith('BEGIN')
+    expect(trans.reader).toBeInstanceOf(Object)
+    expect(trans.reader.connect).toBeInstanceOf(Function)
+    expect(trans.writer).toBeInstanceOf(Object)
+    expect(trans.writer.connect).toBeInstanceOf(Function)
+    expect(trans).toBeInstanceOf(Function)
+    expect(trans['transaction']).toBe(mockTrans)
+  })
+})

package/tests/Database/integrations/pg/PostgresTransaction.test.ts

@@ -0,0 +1,118 @@
+import { jest } from '@jest/globals'
+import * as pg from 'pg'
+
+import type { DbConfig } from '../../../../src/Database/index.js'
+import { PostgresDatabase } from '../../../../src/Database/integrations/pgsql/PostgresDatabase.js'
+import { PostgresTransactionImpl } from '../../../../src/Database/integrations/pgsql/PostgresTransaction.js'
+
+const testResources = async (config: Partial<DbConfig<'pg'>>) => {
+  const database = {
+    config: {
+      autoCommit: true,
+      ...config,
+    } as DbConfig<'pg'>,
+  } as any as PostgresDatabase
+
+  const transaction = jest.fn().mockImplementation(() => {
+    return {
+      commit: jest.fn(),
+      rollback: jest.fn(),
+      query: jest.fn(),
+    }
+  })() as any as pg.PoolClient
+
+  const writer = jest.fn().mockImplementation(() => {
+    return {
+      connect: jest.fn(() => transaction),
+    }
+  })() as any as pg.Pool
+
+  return {
+    transaction,
+    writer,
+    underTest: await PostgresTransactionImpl.newTransaction(writer, database),
+  }
+}
+
+describe('PostgresTransaction', () => {
+  test('Transaction starts opened', async () => {
+    const { transaction, underTest } = await testResources({})
+    expect(underTest.isOpen()).toBe(true)
+    expect(transaction.query).toHaveBeenNthCalledWith(1, 'BEGIN')
+
+    await expect(underTest.begin).rejects.toThrowError(
+      'Cannot begin, transaction is already opened!'
+    )
+  })
+
+  test('Can only commit once', async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+    expect(transaction.query).toBeCalledWith('COMMIT')
+
+    await expect(underTest.commit).rejects.toThrowError(
+      'Cannot commit, transaction is already closed!'
+    )
+  })
+
+  test('Can only rollback once', async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.rollback()
+    expect(underTest.isOpen()).toBe(false)
+    expect(transaction.query).toBeCalledWith('ROLLBACK')
+
+    await expect(underTest.rollback).rejects.toThrowError(
+      'Cannot rollback, transaction is already closed!'
+    )
+  })
+
+  test("Can't open transaction twice", async () => {
+    const { transaction, underTest } = await testResources({})
+    expect(underTest.isOpen()).toBe(true)
+    expect(transaction.query).toHaveBeenNthCalledWith(1, 'BEGIN')
+
+    await expect(underTest.begin).rejects.toThrowError(
+      'Cannot begin, transaction is already opened!'
+    )
+  })
+
+  test('Can commit, begin and commit again ', async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+    expect(transaction.query).toBeCalledWith('COMMIT')
+    await underTest.begin()
+    expect(underTest.isOpen()).toBe(true)
+    expect(transaction.query).toHaveBeenNthCalledWith(3, 'BEGIN')
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+    expect(transaction.query).toHaveBeenNthCalledWith(4, 'COMMIT')
+  })
+
+  test('Can commit, begin and rollback ', async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+    expect(transaction.query).toBeCalledWith('COMMIT')
+    await underTest.begin()
+    expect(underTest.isOpen()).toBe(true)
+    expect(transaction.query).toHaveBeenNthCalledWith(3, 'BEGIN')
+    await underTest.rollback()
+    expect(underTest.isOpen()).toBe(false)
+    expect(transaction.query).toHaveBeenNthCalledWith(4, 'ROLLBACK')
+  })
+
+  test('Can rollback, begin and commit ', async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.rollback()
+    expect(underTest.isOpen()).toBe(false)
+    expect(transaction.query).toBeCalledWith('ROLLBACK')
+    await underTest.begin()
+    expect(underTest.isOpen()).toBe(true)
+    expect(transaction.query).toHaveBeenNthCalledWith(3, 'BEGIN')
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+    expect(transaction.query).toHaveBeenNthCalledWith(4, 'COMMIT')
+  })
+})

package/tests/Logger/Logger.test.ts

@@ -0,0 +1,215 @@
+import { jest } from '@jest/globals'
+import { expect as c_expect } from 'chai'
+
+// get console ref and mock before logger import
+const consoleProxy = console
+const mock = jest.spyOn(consoleProxy, 'log')
+// import logger after first ref
+import Logger from '../../src/Logger/Logger.js'
+// get console reference after logger import
+const transactionID = '123-456'
+
+function setContainerFlag(isContainer: boolean) {
+  if (isContainer) {
+    process.env['HYBRIDLESS_RUNTIME'] = 'true'
+  } else {
+    process.env['HYBRIDLESS_RUNTIME'] = undefined
+  }
+}
+
+function fixLogTypePrefix(logType: string) {
+  if (logType == 'exception') return 'error'
+  if (logType == 'warning') return 'warn'
+  if (logType == 'log') return 'info'
+  return logType
+}
+
+function randomDeepObject(count, endKey) {
+  if (count <= 1) return { [endKey]: 'value' }
+  const object = {}
+  for (let i = 0; i < count; i++) {
+    const key = (+new Date() * Math.random()).toString(36).substring(0, 6)
+    object[key] = randomDeepObject(Math.floor(Math.random() * (count / 2)), endKey)
+  }
+  return object
+}
+
+function testLogs(isContainer: boolean, provider?: Logger) {
+  const type = isContainer ? 'container' : 'serverless'
+  const loggerType = !provider ? 'Console' : 'Logger'
+  const localProvider = provider || console
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log('my password is 123')
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('] my password is 123')
+    )
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (object)`, async () => {
+    setContainerFlag(isContainer)
+    const object = { password: '123' }
+    localProvider.log('TEST', object)
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('] TEST {\n  "password": "**SUPPRESSED_SENSITIVE_DATA** (3 len)"\n}')
+    )
+    // test if object is not mutate
+    c_expect(object.password).to.be.equals('123')
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (long-object)`, async () => {
+    setContainerFlag(isContainer)
+    const object = randomDeepObject(99, 'password')
+    localProvider.log('TEST', object)
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(1, expect.stringContaining('] TEST'))
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('"password": "**SUPPRESSED_SENSITIVE_DATA** (5 len)"')
+    )
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (object with sensitive string)`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log({ object: JSON.stringify({ password: '123' }) })
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining(
+        '] {\n  "object": {\n    "password": "**SUPPRESSED_SENSITIVE_DATA** (3 len)"\n  }\n}'
+      )
+    )
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (object with sensitive number)`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log({ object: JSON.stringify({ password: 123 }) })
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining(
+        '] {\n  "object": {\n    "password": "**SUPPRESSED_SENSITIVE_DATA** (3 len)"\n  }\n}'
+      )
+    )
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (null key)`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log({ object: JSON.stringify({ password: null }) })
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('] {\n  "object": {\n    "password": null\n  }\n}')
+    )
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (null)`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log(null)
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(1, expect.stringContaining('] '))
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (array)`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log('TEST2', [{ password: '1234' }])
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining(
+        '] TEST2 [\n  {\n    "password": "**SUPPRESSED_SENSITIVE_DATA** (4 len)"\n  }\n]'
+      )
+    )
+  })
+
+  test(`${type} - ${loggerType} Log - Circular reference (Error)`, async () => {
+    setContainerFlag(isContainer)
+    class SelfRefError extends Error {
+      public self: SelfRefError
+      constructor() {
+        super()
+        this.self = this
+      }
+    }
+    localProvider.log(new SelfRefError())
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('tests/Logger/Logger.test.ts:')
+    )
+  })
+
+  for (const logType of ['log', 'debug', 'info', 'warn', 'warning', 'error', 'exception']) {
+    test(`${type} - ${loggerType} ${logType}`, async () => {
+      setContainerFlag(isContainer)
+      localProvider[logType](logType.toUpperCase())
+      // alias
+      const logTypePrefix = fixLogTypePrefix(logType)
+      expect(consoleProxy.log).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining(
+          (isContainer ? `${transactionID} ` : '') +
+            `[${logTypePrefix.toUpperCase()}] [Logger.test.ts:`
+        )
+      )
+      expect(consoleProxy.log).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining(`] ${logType.toUpperCase()}`)
+      )
+    })
+  }
+}
+
+describe('Logger', () => {
+  beforeEach(() => {
+    mock.mockClear()
+  })
+  const provider = new Logger(
+    {
+      logLevel: 'DEBUG',
+      sensitiveFilteringKeywords: true,
+    },
+    transactionID
+  )
+  provider.notGlobalLogger()
+  // Test serverless logs
+  testLogs(false, provider)
+  testLogs(false)
+  // Test container logs
+  testLogs(true, provider)
+  testLogs(true)
+})
+
+export {}

package/tests/Mailer/Mailer.test.ts

@@ -0,0 +1,59 @@
+import { SESClient, SendRawEmailCommand } from '@aws-sdk/client-ses'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
+
+import Mailer from '../../src/Mailer/Mailer.js'
+
+const SESMock = mockClient(SESClient)
+
+describe('SendRaw', () => {
+  // reset mock
+  beforeEach(() => {
+    SESMock.reset()
+  })
+
+  const provider = new Mailer('dev+tests@gmail.com', 'ca-central-1')
+
+  test('Send raw with success', async () => {
+    const messageId = 'id-123'
+    SESMock.on(SendRawEmailCommand).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.sendRawEmail('test@test.com', 'My message', 'My subject')
+    expect(res).is.not.null
+    console.log(res)
+  })
+
+  test('Send raw with success', async () => {
+    const messageId = 'id-123'
+    const from = 'test@test.com'
+    const to = 'test@test2.com'
+    const msg = 'My message'
+    const subject = 'My subject'
+    const cc = 'test@test3.com'
+    const replyTo = 'test@test4.com'
+    SESMock.on(SendRawEmailCommand).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.sendRawEmail(to, msg, subject, cc, from, replyTo)
+    expect(res).is.not.null
+    console.log(res)
+  })
+
+  test('Send raw with failure', async () => {
+    SESMock.on(SendRawEmailCommand).rejects(new Error('failed!'))
+    let res: any = null,
+      err: any = null
+    try {
+      res = await provider.sendRawEmail('test@test.com', 'My message', 'My subject')
+    } catch (e) {
+      err = e
+    }
+    expect(res).is.null
+    expect(err?.message).to.be.equals('failed!')
+    expect(res).is.null
+    console.log(res)
+  })
+})
+
+export {}