[TILES-V2-11]: add unit and integration tests for tiles v2 (#1033)

# Tests for Tiles v2

## Changes

1. Added a PostgreSQL container for integration tests
2. Extending existing mutation tests to work with both DynamoDB and PostgreSQL
3. Adding unit tests for PostgreSQL table functions
4. Implementing proper database type switching in mutations

Author: pregnantboy

packages/backend/src/apps/tiles/__tests__/actions/create-row.itest.ts

@@ -10,87 +10,93 @@ import {
   generateMockTableRowData,
 } from '@/graphql/__tests__/mutations/tiles/table.mock'
 import TableMetadata from '@/models/table-metadata'
+import { DatabaseType } from '@/models/tiles/types'
 import User from '@/models/user'
 import Context from '@/types/express/context'
 
 import tiles from '../..'
 import createRowAction from '../../actions/create-row'
 
-describe('tiles create row action', () => {
-  let context: Context
-  let dummyTable: TableMetadata
-  let dummyColumnIds: string[]
-  let editor: User
-  let viewer: User
-  let $: IGlobalVariable
+describe.each([['ddb'], ['pg']])(
+  'tiles create row action: %s',
+  (databaseType: DatabaseType) => {
+    let context: Context
+    let dummyTable: TableMetadata
+    let dummyColumnIds: string[]
+    let editor: User
+    let viewer: User
+    let $: IGlobalVariable
 
-  beforeEach(async () => {
-    context = await generateMockContext()
+    beforeEach(async () => {
+      context = await generateMockContext()
 
-    const mockTable = await generateMockTable({
-      userId: context.currentUser.id,
-    })
-    dummyTable = mockTable.table
-    editor = mockTable.editor
-    viewer = mockTable.viewer
+      const mockTable = await generateMockTable({
+        userId: context.currentUser.id,
+        databaseType,
+      })
+      dummyTable = mockTable.table
+      editor = mockTable.editor
+      viewer = mockTable.viewer
 
-    dummyColumnIds = await generateMockTableColumns({
-      tableId: dummyTable.id,
-      numColumns: 5,
-    })
+      dummyColumnIds = await generateMockTableColumns({
+        tableId: dummyTable.id,
+        numColumns: 5,
+        databaseType,
+      })
 
-    const validData = generateMockTableRowData({ columnIds: dummyColumnIds })
-    const rowData = Object.keys(validData).map((columnId) => ({
-      columnId,
-      cellValue: validData[columnId],
-    }))
+      const validData = generateMockTableRowData({ columnIds: dummyColumnIds })
+      const rowData = Object.keys(validData).map((columnId) => ({
+        columnId,
+        cellValue: validData[columnId],
+      }))
 
-    $ = {
-      user: context.currentUser,
-      flow: {
-        id: '123',
-        userId: context.currentUser.id,
-      },
-      step: {
-        id: '456',
-        appKey: tiles.name,
-        key: createRowAction.key,
-        position: 2,
-        parameters: {
-          tableId: dummyTable.id,
-          rowData,
+      $ = {
+        user: context.currentUser,
+        flow: {
+          id: '123',
+          userId: context.currentUser.id,
+        },
+        step: {
+          id: '456',
+          appKey: tiles.name,
+          key: createRowAction.key,
+          position: 2,
+          parameters: {
+            tableId: dummyTable.id,
+            rowData,
+          },
         },
-      },
-      app: {
-        name: tiles.name,
-      },
-      setActionItem: vi.fn(),
-    } as unknown as IGlobalVariable
-  })
+        app: {
+          name: tiles.name,
+        },
+        setActionItem: vi.fn(),
+      } as unknown as IGlobalVariable
+    })
 
-  it('should allow owners to create row', async () => {
-    await expect(createRowAction.run($)).resolves.toBeUndefined()
-    expect($.setActionItem).toBeCalled()
-  })
+    it('should allow owners to create row', async () => {
+      await expect(createRowAction.run($)).resolves.toBeUndefined()
+      expect($.setActionItem).toBeCalled()
+    })
 
-  it('should allow editors to create row', async () => {
-    $.user = editor
-    await expect(createRowAction.run($)).resolves.toBeUndefined()
-    expect($.setActionItem).toBeCalled()
-  })
+    it('should allow editors to create row', async () => {
+      $.user = editor
+      await expect(createRowAction.run($)).resolves.toBeUndefined()
+      expect($.setActionItem).toBeCalled()
+    })
 
-  it('should not allow viewers to create row', async () => {
-    $.user = viewer
-    await expect(createRowAction.run($)).rejects.toThrow(StepError)
-  })
+    it('should not allow viewers to create row', async () => {
+      $.user = viewer
+      await expect(createRowAction.run($)).rejects.toThrow(StepError)
+    })
 
-  it('should throw correct error if Tile deleted', async () => {
-    $.user = editor
-    await TableMetadata.query()
-      .patch({
-        deletedAt: new Date().toISOString(),
-      })
-      .where({ id: $.step.parameters.tableId })
-    await expect(createRowAction.run($)).rejects.toThrow(StepError)
-  })
-})
+    it('should throw correct error if Tile deleted', async () => {
+      $.user = editor
+      await TableMetadata.query()
+        .patch({
+          deletedAt: new Date().toISOString(),
+        })
+        .where({ id: $.step.parameters.tableId })
+      await expect(createRowAction.run($)).rejects.toThrow(StepError)
+    })
+  },
+)