@creator.co/wapi 1.2.3 → 1.2.5

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/tsconfig.json

@@ -1,6 +1,11 @@
 {
   "exclude": ["**/*.test.*", "**/__mocks__/*", "**/__tests__/*", "**/tests/*"],
   "compilerOptions": {
+    "lib": [
+      "es5",
+      "es6",
+      "dom"
+    ],
     "noImplicitAny": false,
     "noEmitOnError": true,
     "removeComments": false,