@creator.co/wapi 1.2.4 → 1.2.6

package/tests/Config/EnvironmentVar.test.ts

@@ -17,9 +17,15 @@ function testRemoteEnv(mock, type, command) {
 
     test('Does not accept sync resolve', async () => {
       mock.on(command).resolves({
-        Parameter: {
-          Value: undefined,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
       })
       let err = null
       try {
@@ -34,9 +40,15 @@ function testRemoteEnv(mock, type, command) {
 
     test('Optional value with null value', async () => {
       mock.on(command).resolves({
-        Parameter: {
-          Value: undefined,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
       })
       const env = new EnvironmentVar('abc', type, true)
       const token = await env.resolve()
@@ -53,9 +65,15 @@ function testRemoteEnv(mock, type, command) {
     test('Optional value with valid response', async () => {
       const value = 'abc'
       mock.on(command).resolves({
-        Parameter: {
-          Value: value,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: value,
+              },
+            }
+          : {
+              SecretString: value,
+            }),
       })
       const env = new EnvironmentVar(value, type, true)
       const token = await env.resolve()
@@ -80,9 +98,15 @@ function testRemoteEnv(mock, type, command) {
 
     test('Does not accept sync resolve', async () => {
       mock.on(command).resolves({
-        Parameter: {
-          Value: undefined,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
       })
       let err = null
       try {
@@ -97,9 +121,15 @@ function testRemoteEnv(mock, type, command) {
 
     test('Required fails when null', async () => {
       mock.on(command).resolves({
-        Parameter: {
-          Value: undefined,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
       })
       let err = null
       try {
@@ -129,9 +159,15 @@ function testRemoteEnv(mock, type, command) {
     test('Required value with valid response', async () => {
       const value = 'abc'
       mock.on(command).resolves({
-        Parameter: {
-          Value: value,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: value,
+              },
+            }
+          : {
+              SecretString: value,
+            }),
       })
       const env = new EnvironmentVar(value, type)
       const token = await env.resolve()

package/tests/Database/DatabaseManager.test.ts

@@ -0,0 +1,55 @@
+import { expect } from 'chai'
+
+import { DatabaseManager } from '../../src/Database/DatabaseManager'
+import type { DatabaseType, DbConfig } from '../../src/Database/types'
+
+type FakeDatabase = { host: string; type: 'knex' | 'pg' }
+
+const fakeConfig = (host: string, type: DatabaseType) => {
+  return {
+    type,
+    host,
+  } as DbConfig<typeof type>
+}
+
+describe('Database Manager', () => {
+  test('should correctly create and cache database instances', () => {
+    const underTest = new DatabaseManager()
+
+    underTest['databases'] = {
+      knex: jest.fn(config => {
+        return { host: config.host, type: 'knex' } as any
+      }) as any,
+      pg: jest.fn(config => {
+        return { host: config.host, type: 'pg' } as any
+      }) as any,
+    }
+
+    const create = config => underTest.create({ ...config }) as unknown as FakeDatabase
+
+    const knexConfig1 = fakeConfig('localhost', 'knex')
+    const knexConfig2 = fakeConfig('other', 'knex')
+    const pgConfig1 = fakeConfig('localhost', 'pg')
+    const pgConfig2 = fakeConfig('other', 'pg')
+
+    const knex1 = create(knexConfig1)
+    const knex2 = create(knexConfig1)
+    const knex3 = create(knexConfig2)
+
+    const pg1 = create(pgConfig1)
+    const pg2 = create(pgConfig1)
+    const pg3 = create(pgConfig2)
+
+    expect(knex1).to.equal(knex2).to.not.equal(knex3).to.not.equal(pg1)
+
+    expect(knexConfig1).to.be.deep.equal(knex1).to.be.deep.equal(knex2)
+
+    expect(knex3).to.be.deep.equal(knexConfig2)
+
+    expect(pg1).to.equal(pg2).to.not.equal(pg3)
+
+    expect(pgConfig1).to.be.deep.equal(pg1).to.be.deep.equal(pg2)
+
+    expect(pg3).to.be.deep.equal(pgConfig2)
+  })
+})

package/tests/Database/integrations/knex/KnexDatabase.test.ts

@@ -0,0 +1,53 @@
+import { Knex } from 'knex'
+
+import { KnexDatabase } from '../../../../src/Database/integrations/knex/KnexDatabase'
+import { KnexTransactionImpl } from '../../../../src/Database/integrations/knex/KnexTransaction'
+import type { DbConfig } from '../../../../src/Database/types'
+
+const config: DbConfig<'knex'> = {
+  type: 'knex',
+  username: 'username',
+  password: 'password',
+  host: 'host',
+  port: 1234,
+  database: 'database',
+  driver: 'driver',
+  maxConnections: 1,
+  autoCommit: true,
+}
+
+const expectedImplConfig = {
+  client: config.driver,
+  connection: {
+    host: config.host,
+    port: config.port,
+    user: config.username,
+    password: config.password,
+    database: config.database,
+  },
+  pool: {
+    min: 1,
+    max: config.maxConnections,
+  },
+}
+
+describe('KnexDatabase', () => {
+  test('KnexDatabase', async () => {
+    const mockTrans = { a: 'b' } as any
+    const mockClient = jest.fn(
+      () =>
+        ({
+          transaction: async () => mockTrans,
+        }) as Knex
+    )
+    KnexDatabase['knexProvider'] = mockClient
+
+    const underTest = new KnexDatabase(config)
+    expect(mockClient).toBeCalledWith(expectedImplConfig)
+
+    const trans = await underTest.transaction()
+
+    expect(trans).toBeInstanceOf(KnexTransactionImpl)
+    expect(trans['delegate']).toBe(mockTrans)
+  })
+})

package/tests/Database/integrations/knex/KnexTransaction.test.ts

@@ -0,0 +1,133 @@
+import { Knex } from 'knex'
+
+import { KnexDatabase } from '../../../../src/Database/integrations/knex/KnexDatabase'
+import { KnexTransactionImpl } from '../../../../src/Database/integrations/knex/KnexTransaction'
+import type { DbConfig } from '../../../../src/Database/types'
+
+const testResources = (config: Partial<DbConfig<'knex'>>) => {
+  const database = {
+    config: {
+      autoCommit: true,
+      ...config,
+    } as DbConfig<'knex'>,
+  } as KnexDatabase
+
+  const delegate = jest.fn().mockImplementation(() => {
+    return {
+      commit: jest.fn(),
+      rollback: jest.fn(),
+      select: jest.fn(),
+    }
+  })() as any as Knex.Transaction
+
+  return {
+    delegate,
+    underTest: KnexTransactionImpl.wrapDelegate(delegate, database),
+  }
+}
+
+describe('KnexTransaction', () => {
+  test('Can only commit once', async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen).toBe(false)
+    expect(delegate.commit).toBeCalled()
+
+    await expect(underTest.commit).rejects.toThrowError(
+      'Cannot commit, transaction is already closed!'
+    )
+  })
+
+  test("Can't commit after rollback", async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.rollback()
+    expect(underTest.isOpen).toBe(false)
+    expect(delegate.rollback).toBeCalled()
+
+    await expect(underTest.commit).rejects.toThrowError(
+      'Cannot commit, transaction is already closed!'
+    )
+  })
+
+  test('Forwards calls to delegate', async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.select('name')
+    expect(delegate.select).toBeCalledWith('name')
+  })
+
+  test('Blocks delegate calls after commit', async () => {
+    const { delegate, underTest } = testResources({})
+    expect(underTest.select).toBeDefined()
+
+    await underTest.commit()
+    expect(delegate.commit).toBeCalled()
+    expect(underTest.isOpen).toBe(false)
+
+    expect(underTest.select).toBeUndefined()
+  })
+})
+
+describe('KnexTransaction - closeSuccess', () => {
+  test('Close success commits', async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.closeSuccess()
+    expect(delegate.commit).toBeCalled()
+  })
+
+  test("Close success, doesn't commit again if already committed", async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.commit()
+    expect(delegate.commit).toBeCalledTimes(1)
+    await underTest.closeSuccess()
+    expect(delegate.commit).toBeCalledTimes(1)
+  })
+
+  test('Close success, rolls back if not autocommit', async () => {
+    const { delegate, underTest } = testResources({ autoCommit: false })
+    await underTest.closeSuccess()
+    expect(delegate.rollback).toBeCalled()
+  })
+
+  test("Close success, doesn't rollback if already committed", async () => {
+    const { delegate, underTest } = testResources({ autoCommit: false })
+    await underTest.commit()
+    expect(delegate.commit).toBeCalledTimes(1)
+    await underTest.closeSuccess()
+    expect(delegate.rollback).not.toBeCalled()
+    expect(delegate.commit).toBeCalledTimes(1)
+  })
+
+  test("Close success, doesn't rollback if already rolled back", async () => {
+    const { delegate, underTest } = testResources({ autoCommit: false })
+    await underTest.rollback()
+    expect(delegate.rollback).toBeCalledTimes(1)
+    await underTest.closeSuccess()
+    expect(delegate.rollback).toBeCalledTimes(1)
+    expect(delegate.commit).not.toBeCalled()
+  })
+})
+
+describe('KnexTransaction - closeFailure', () => {
+  test('Close failure rolls back', async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.closeFailure()
+    expect(delegate.rollback).toBeCalled()
+  })
+
+  test("Close failure, doesn't rollback again if already rolled back", async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.rollback()
+    expect(delegate.rollback).toBeCalledTimes(1)
+    await underTest.closeFailure()
+    expect(delegate.rollback).toBeCalledTimes(1)
+  })
+
+  test("Close failure, doesn't rollback if already committed", async () => {
+    const { delegate, underTest } = testResources({ autoCommit: false })
+    await underTest.commit()
+    expect(delegate.commit).toBeCalledTimes(1)
+    await underTest.closeFailure()
+    expect(delegate.rollback).not.toBeCalled()
+    expect(delegate.commit).toBeCalledTimes(1)
+  })
+})

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

@@ -0,0 +1,50 @@
+import { PoolClient } from 'pg'
+
+import { PostgresDatabase } from '../../../../src/Database/integrations/pgsql/PostgresDatabase'
+import { PostgresTransactionImpl } from '../../../../src/Database/integrations/pgsql/PostgresTransaction'
+import type { DbConfig } from '../../../../src/Database/types'
+
+const config: DbConfig<'pg'> = {
+  type: 'pg',
+  username: 'username',
+  password: 'password',
+  host: 'host',
+  port: 1234,
+  database: 'database',
+  driver: 'driver',
+  maxConnections: 1,
+  autoCommit: true,
+}
+
+const expectedImplConfig = {
+  host: config.host,
+  port: config.port,
+  user: config.username,
+  password: config.password,
+  database: config.database,
+  max: config.maxConnections,
+}
+
+describe('PostgresDatabase', () => {
+  test('PostgresDatabase', async () => {
+    const mockTrans = {
+      query: jest.fn(() => {}),
+    } as any
+    const mockClient = jest.fn(
+      () =>
+        ({
+          connect: async () => mockTrans,
+        }) as PoolClient
+    )
+    PostgresDatabase['pgProvider'] = mockClient as any
+
+    const underTest = new PostgresDatabase(config)
+    expect(mockClient).toBeCalledWith(expectedImplConfig)
+
+    const trans = await underTest.transaction()
+
+    expect(mockTrans.query).toBeCalledWith('BEGIN')
+    expect(trans).toBeInstanceOf(PostgresTransactionImpl)
+    expect(trans['delegate']).toBe(mockTrans)
+  })
+})

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

@@ -0,0 +1,51 @@
+import { PoolClient } from 'pg'
+
+import { PostgresDatabase } from '../../../../src/Database/integrations/pgsql/PostgresDatabase'
+import { PostgresTransactionImpl } from '../../../../src/Database/integrations/pgsql/PostgresTransaction'
+import type { DbConfig } from '../../../../src/Database/types'
+
+const testResources = (config: Partial<DbConfig<'pg'>>) => {
+  const database = {
+    config: {
+      autoCommit: true,
+      ...config,
+    } as DbConfig<'pg'>,
+  } as PostgresDatabase
+
+  const delegate = jest.fn().mockImplementation(() => {
+    return {
+      commit: jest.fn(),
+      rollback: jest.fn(),
+      query: jest.fn(),
+    }
+  })() as any as PoolClient
+
+  return {
+    delegate,
+    underTest: PostgresTransactionImpl.wrapDelegate(delegate, database),
+  }
+}
+
+describe('PostgresTransaction', () => {
+  test('Can only commit once', async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen).toBe(false)
+    expect(delegate.query).toBeCalledWith('COMMIT')
+
+    await expect(underTest.commit).rejects.toThrowError(
+      'Cannot commit, transaction is already closed!'
+    )
+  })
+
+  test('Can only rollback once', async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.rollback()
+    expect(underTest.isOpen).toBe(false)
+    expect(delegate.query).toBeCalledWith('ROLLBACK')
+
+    await expect(underTest.rollback).rejects.toThrowError(
+      'Cannot rollback, transaction is already closed!'
+    )
+  })
+})

package/tests/Publisher/Publisher.test.ts

@@ -28,7 +28,7 @@ describe('Encryption', () => {
     })
     const res = await provider.publishOnTopic(msg, topic)
     expect(res).is.not.null
-    expect(res.MessageId).to.be.equals(messageId)
+    expect(res?.MessageId).to.be.equals(messageId)
   })
 
   test('Publishes with success (additional props)', async () => {
@@ -45,7 +45,7 @@ describe('Encryption', () => {
       FifoGroup: 123,
     })
     expect(res).is.not.null
-    expect(res.MessageId).to.be.equals(messageId)
+    expect(res?.MessageId).to.be.equals(messageId)
   })
 
   test('Publish failure', async () => {
@@ -53,7 +53,7 @@ describe('Encryption', () => {
     const topic = '123'
     SNSMock.on(PublishCommand).rejects(new Error('failed!'))
     const res = await provider.publishOnTopic(msg, topic)
-    expect(res).is.null
+    expect(res).is.undefined
   })
 })
 

package/tests/Server/lib/ContainerServer.test.ts

@@ -1,5 +1,4 @@
-import { expect as j_expect } from '@jest/globals'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 import * as request from 'supertest'
 import { z } from 'zod'
 
@@ -37,7 +36,7 @@ describe('Container server routing', () => {
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
       .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals('Healthy!')
+    c_expect(res.text).to.be.equals('Healthy!')
     // Not handled
     await request(defaultUrl)
       .get(`/abc`)
@@ -46,8 +45,8 @@ describe('Container server routing', () => {
 
     // Unload
     await server.stop('Error')
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(1)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(1)
   })
 
   test('Simple route', async () => {
@@ -68,14 +67,14 @@ describe('Container server routing', () => {
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
       .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals('Healthy!')
+    c_expect(res.text).to.be.equals('Healthy!')
     // Found route
     const resG = await request(defaultUrl)
       .get(`/abc`)
       .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(200)
-    expect(resG.body['name']).to.be.deep.equals('abc')
-    expect(resG.body['transactionID']).to.not.be.null
+    c_expect(resG.body['name']).to.be.deep.equals('abc')
+    c_expect(resG.body['transactionID']).to.not.be.null
     // Found route, but not method
     await request(defaultUrl)
       .post(`/abc`)
@@ -88,8 +87,8 @@ describe('Container server routing', () => {
       .expect(404)
     // Unload
     await server.stop('Error')
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(1)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(1)
   })
 })
 
@@ -117,11 +116,11 @@ describe('Container server basics', () => {
           .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
           .expect('Content-Type', 'text/html; charset=utf-8')
           .expect(200)
-        expect(res.text).to.be.equals('Healthy!')
+        c_expect(res.text).to.be.equals('Healthy!')
         // Unload
         await server.stop()
-        j_expect(mockExit).toHaveBeenCalledTimes(1)
-        j_expect(mockExit).toBeCalledWith(0)
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        expect(mockExit).toBeCalledWith(0)
         resolve(null)
       }, 2000)
     })
@@ -133,8 +132,8 @@ describe('Container server basics', () => {
     process.emit('SIGINT')
     return new Promise(resolve => {
       setTimeout(async () => {
-        j_expect(mockExit).toHaveBeenCalledTimes(1)
-        j_expect(mockExit).toBeCalledWith(0)
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        expect(mockExit).toBeCalledWith(0)
         resolve(null)
       }, 2000)
     })
@@ -147,8 +146,8 @@ describe('Container server basics', () => {
     process.emit('unhandledRejection')
     return new Promise(resolve => {
       setTimeout(async () => {
-        j_expect(mockExit).toHaveBeenCalledTimes(1)
-        j_expect(mockExit).toBeCalledWith(0)
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        expect(mockExit).toBeCalledWith(0)
         resolve(null)
       }, 2000)
     })
@@ -170,11 +169,11 @@ describe('Container server validation', () => {
   })
 
   function validateValidationFailure(res: any, failureCount?: number) {
-    expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
-    expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
-    expect(res.body['transactionID']).to.not.be.null
-    expect(res.body['transactionID']).to.be.an('string')
-    expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 4)
+    c_expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
+    c_expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
+    c_expect(res.body['transactionID']).to.not.be.null
+    c_expect(res.body['transactionID']).to.be.an('string')
+    c_expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 4)
   }
 
   test('Validates empty body', async () => {