Skip to content

Commit ba94b08

Browse files
pregnantboypregnantboy
committed
chore: fix tests to support tiles v1 and v2
1 parent fcb9775 commit ba94b08

File tree

2 files changed

+178
-163
lines changed

2 files changed

+178
-163
lines changed

‎packages/backend/src/apps/tiles/__tests__/actions/find-multiple-row.itest.ts‎

Lines changed: 177 additions & 162 deletions
Original file line numberDiff line numberDiff line change
@@ -10,10 +10,12 @@ import {
1010
generateMockTableColumns,
1111
generateMockTableRowData,
1212
} from '@/graphql/__tests__/mutations/tiles/table.mock'
13-
import { createTableRow, TableRowFilter } from '@/models/dynamodb/table-row'
14-
import * as tableFunctions from '@/models/dynamodb/table-row/functions'
1513
import TableColumnMetadata from '@/models/table-column-metadata'
1614
import TableMetadata from '@/models/table-metadata'
15+
import * as ddbTableRowFunctions from '@/models/tiles/dynamodb/table-row/functions'
16+
import { getTableOperations } from '@/models/tiles/factory'
17+
import * as pgTableRowFunctions from '@/models/tiles/pg/table-row-functions'
18+
import { DatabaseType, TableRowFilter } from '@/models/tiles/types'
1719
import User from '@/models/user'
1820
import Context from '@/types/express/context'
1921

@@ -42,180 +44,193 @@ vi.mock('@/models/step', () => ({
4244
},
4345
}))
4446

45-
describe('findMultipleRowsAction', () => {
46-
let context: Context
47-
let dummyTable: TableMetadata
48-
let dummyColumnIds: string[]
49-
let editor: User
50-
let viewer: User
51-
let $: IGlobalVariable
47+
describe.each([['ddb'], ['pg']])(
48+
'findMultipleRowsAction: %s',
49+
(databaseType: DatabaseType) => {
50+
let context: Context
51+
let dummyTable: TableMetadata
52+
let dummyColumnIds: string[]
53+
let editor: User
54+
let viewer: User
55+
let $: IGlobalVariable
5256

53-
beforeEach(async () => {
54-
context = await generateMockContext()
57+
beforeEach(async () => {
58+
context = await generateMockContext()
5559

56-
const mockTable = await generateMockTable({
57-
userId: context.currentUser.id,
60+
const mockTable = await generateMockTable({
61+
userId: context.currentUser.id,
62+
databaseType,
63+
})
64+
65+
dummyTable = mockTable.table
66+
editor = mockTable.editor
67+
viewer = mockTable.viewer
68+
69+
dummyColumnIds = await generateMockTableColumns({
70+
tableId: dummyTable.id,
71+
numColumns: 5,
72+
databaseType,
73+
})
74+
75+
const originalData = generateMockTableRowData({
76+
columnIds: dummyColumnIds,
77+
})
78+
79+
const tableOperations = getTableOperations(databaseType)
80+
81+
for (let i = 0; i < 5; i++) {
82+
await tableOperations.createTableRow({
83+
tableId: dummyTable.id,
84+
data: originalData,
85+
})
86+
}
87+
88+
$ = {
89+
user: context.currentUser,
90+
flow: {
91+
id: '123',
92+
userId: context.currentUser.id,
93+
},
94+
step: {
95+
id: '456',
96+
appKey: tiles.name,
97+
key: findMultipleRowsAction.key,
98+
position: 2,
99+
parameters: {
100+
tableId: dummyTable.id,
101+
filters: [
102+
{
103+
columnId: dummyColumnIds[0],
104+
operator: 'equals',
105+
value: originalData[dummyColumnIds[0]],
106+
},
107+
] as TableRowFilter[],
108+
order: 'asc',
109+
},
110+
},
111+
app: {
112+
name: tiles.name,
113+
},
114+
setActionItem: vi.fn(),
115+
} as unknown as IGlobalVariable
58116
})
59117

60-
dummyTable = mockTable.table
61-
editor = mockTable.editor
62-
viewer = mockTable.viewer
118+
it('should allow owners to find multiple rows', async () => {
119+
await expect(findMultipleRowsAction.run($)).resolves.toBeUndefined()
120+
expect($.setActionItem).toBeCalled()
121+
})
63122

64-
dummyColumnIds = await generateMockTableColumns({
65-
tableId: dummyTable.id,
66-
numColumns: 5,
123+
it('should allow editors to find multiple rows', async () => {
124+
$.user = editor
125+
await expect(findMultipleRowsAction.run($)).resolves.toBeUndefined()
126+
expect($.setActionItem).toBeCalled()
67127
})
68128

69-
const originalData = generateMockTableRowData({
70-
columnIds: dummyColumnIds,
129+
it('should not allow viewers to find multiple rows', async () => {
130+
$.user = viewer
131+
await expect(findMultipleRowsAction.run($)).rejects.toThrow(StepError)
71132
})
72133

73-
for (let i = 0; i < 5; i++) {
74-
await createTableRow({
75-
tableId: dummyTable.id,
76-
data: originalData,
77-
})
78-
}
134+
it('should throw correct error if Tile deleted', async () => {
135+
$.user = editor
136+
await TableMetadata.query()
137+
.patch({
138+
deletedAt: new Date().toISOString(),
139+
})
140+
.where({ id: $.step.parameters.tableId })
141+
await TableColumnMetadata.query()
142+
.patch({
143+
deletedAt: new Date().toISOString(),
144+
})
145+
.where({ table_id: $.step.parameters.tableId })
146+
await expect(findMultipleRowsAction.run($)).rejects.toThrow(StepError)
147+
})
79148

80-
$ = {
81-
user: context.currentUser,
82-
flow: {
83-
id: '123',
84-
userId: context.currentUser.id,
85-
},
86-
step: {
87-
id: '456',
88-
appKey: tiles.name,
89-
key: findMultipleRowsAction.key,
90-
position: 2,
91-
parameters: {
92-
tableId: dummyTable.id,
93-
filters: [
94-
{
95-
columnId: dummyColumnIds[0],
96-
operator: 'equals',
97-
value: originalData[dummyColumnIds[0]],
98-
},
99-
] as TableRowFilter[],
100-
order: 'asc',
101-
},
102-
},
103-
app: {
104-
name: tiles.name,
105-
},
106-
setActionItem: vi.fn(),
107-
} as unknown as IGlobalVariable
108-
})
109-
110-
it('should allow owners to find multiple rows', async () => {
111-
await expect(findMultipleRowsAction.run($)).resolves.toBeUndefined()
112-
expect($.setActionItem).toBeCalled()
113-
})
114-
115-
it('should allow editors to find multiple rows', async () => {
116-
$.user = editor
117-
await expect(findMultipleRowsAction.run($)).resolves.toBeUndefined()
118-
expect($.setActionItem).toBeCalled()
119-
})
120-
121-
it('should not allow viewers to find multiple rows', async () => {
122-
$.user = viewer
123-
await expect(findMultipleRowsAction.run($)).rejects.toThrow(StepError)
124-
})
125-
126-
it('should throw correct error if Tile deleted', async () => {
127-
$.user = editor
128-
await TableMetadata.query()
129-
.patch({
130-
deletedAt: new Date().toISOString(),
149+
it('should call getTableRows with scan limit if exists in step config', async () => {
150+
const getTableRowsSpy = vi
151+
.spyOn(
152+
databaseType === 'ddb' ? ddbTableRowFunctions : pgTableRowFunctions,
153+
'getTableRows',
154+
)
155+
.mockResolvedValueOnce({
156+
rows: [],
157+
stringifiedCursor: undefined,
158+
})
159+
await findMultipleRowsAction.run($)
160+
expect(getTableRowsSpy).toHaveBeenCalledWith({
161+
columnIds: dummyColumnIds,
162+
tableId: $.step.parameters.tableId,
163+
filters: $.step.parameters.filters,
164+
scanLimit: mocks.TILE_SCAN_LIMIT,
165+
order: 'asc',
131166
})
132-
.where({ id: $.step.parameters.tableId })
133-
await TableColumnMetadata.query()
134-
.patch({
135-
deletedAt: new Date().toISOString(),
136-
})
137-
.where({ table_id: $.step.parameters.tableId })
138-
await expect(findMultipleRowsAction.run($)).rejects.toThrow(StepError)
139-
})
140-
141-
it('should call getTableRows with scan limit if exists in step config', async () => {
142-
const getTableRowsSpy = vi
143-
.spyOn(tableFunctions, 'getTableRows')
144-
.mockResolvedValueOnce({
145-
rows: [],
167+
})
168+
169+
it('should limit the returned rows to 500 even if more rows match the conditions', async () => {
170+
const mockRows = Array(520)
171+
.fill(null)
172+
.map((_, i) => ({
173+
rowId: `row${i}`,
174+
data: generateMockTableRowData({ columnIds: dummyColumnIds }),
175+
}))
176+
177+
vi.spyOn(
178+
databaseType === 'ddb' ? ddbTableRowFunctions : pgTableRowFunctions,
179+
'getTableRows',
180+
).mockResolvedValueOnce({
181+
rows: mockRows,
146182
stringifiedCursor: undefined,
147183
})
148-
await findMultipleRowsAction.run($)
149-
expect(getTableRowsSpy).toHaveBeenCalledWith({
150-
columnIds: dummyColumnIds,
151-
tableId: $.step.parameters.tableId,
152-
filters: $.step.parameters.filters,
153-
scanLimit: mocks.TILE_SCAN_LIMIT,
154-
order: 'asc',
155-
})
156-
})
157-
158-
it('should limit the returned rows to 500 even if more rows match the conditions', async () => {
159-
const mockRows = Array(520)
160-
.fill(null)
161-
.map((_, i) => ({
162-
rowId: `row${i}`,
163-
data: generateMockTableRowData({ columnIds: dummyColumnIds }),
164-
}))
165-
166-
vi.spyOn(tableFunctions, 'getTableRows').mockResolvedValueOnce({
167-
rows: mockRows,
168-
stringifiedCursor: undefined,
169-
})
170184

171-
await findMultipleRowsAction.run($)
172-
173-
expect($.setActionItem).toHaveBeenCalledWith({
174-
raw: expect.objectContaining({
175-
rowsFound: 500,
176-
data: expect.objectContaining({
177-
rows: expect.arrayContaining([
178-
expect.objectContaining({
179-
data: expect.any(Object),
180-
rowId: expect.any(String),
181-
}),
182-
]),
183-
columns: expect.arrayContaining([
184-
expect.objectContaining({
185-
id: dummyColumnIds[0],
186-
name: 'Test Column 0',
187-
value: `data.rows.*.data.${dummyColumnIds[0]}`,
188-
}),
189-
expect.objectContaining({
190-
id: dummyColumnIds[1],
191-
name: 'Test Column 1',
192-
value: `data.rows.*.data.${dummyColumnIds[1]}`,
193-
}),
194-
expect.objectContaining({
195-
id: dummyColumnIds[2],
196-
name: 'Test Column 2',
197-
value: `data.rows.*.data.${dummyColumnIds[2]}`,
198-
}),
199-
expect.objectContaining({
200-
id: dummyColumnIds[3],
201-
name: 'Test Column 3',
202-
value: `data.rows.*.data.${dummyColumnIds[3]}`,
203-
}),
204-
expect.objectContaining({
205-
id: dummyColumnIds[4],
206-
name: 'Test Column 4',
207-
value: `data.rows.*.data.${dummyColumnIds[4]}`,
208-
}),
209-
]),
210-
inputSource: FOR_EACH_INPUT_SOURCE.TILES,
185+
await findMultipleRowsAction.run($)
186+
187+
expect($.setActionItem).toHaveBeenCalledWith({
188+
raw: expect.objectContaining({
189+
rowsFound: 500,
190+
data: expect.objectContaining({
191+
rows: expect.arrayContaining([
192+
expect.objectContaining({
193+
data: expect.any(Object),
194+
rowId: expect.any(String),
195+
}),
196+
]),
197+
columns: expect.arrayContaining([
198+
expect.objectContaining({
199+
id: dummyColumnIds[0],
200+
name: 'Test Column 0',
201+
value: `data.rows.*.data.${dummyColumnIds[0]}`,
202+
}),
203+
expect.objectContaining({
204+
id: dummyColumnIds[1],
205+
name: 'Test Column 1',
206+
value: `data.rows.*.data.${dummyColumnIds[1]}`,
207+
}),
208+
expect.objectContaining({
209+
id: dummyColumnIds[2],
210+
name: 'Test Column 2',
211+
value: `data.rows.*.data.${dummyColumnIds[2]}`,
212+
}),
213+
expect.objectContaining({
214+
id: dummyColumnIds[3],
215+
name: 'Test Column 3',
216+
value: `data.rows.*.data.${dummyColumnIds[3]}`,
217+
}),
218+
expect.objectContaining({
219+
id: dummyColumnIds[4],
220+
name: 'Test Column 4',
221+
value: `data.rows.*.data.${dummyColumnIds[4]}`,
222+
}),
223+
]),
224+
inputSource: FOR_EACH_INPUT_SOURCE.TILES,
225+
}),
211226
}),
212-
}),
213-
})
227+
})
214228

215-
const rows = ($.setActionItem as any).mock.calls[0][0].raw.data.rows
229+
const rows = ($.setActionItem as any).mock.calls[0][0].raw.data.rows
216230

217-
expect(rows).toHaveLength(500)
218-
expect(rows[0].rowId).toBe('row0')
219-
expect(rows[499].rowId).toBe('row499')
220-
})
221-
})
231+
expect(rows).toHaveLength(500)
232+
expect(rows[0].rowId).toBe('row0')
233+
expect(rows[499].rowId).toBe('row499')
234+
})
235+
},
236+
)

‎packages/backend/test/tiles-pg-global-setup.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ const TILES_POSTGRES_USERNAME = process.env.TILES_POSTGRES_USERNAME as string
1111
const TILES_POSTGRES_PASSWORD = process.env.TILES_POSTGRES_PASSWORD as string
1212

1313
export async function setup() {
14-
postgresContainer = await new PostgreSqlContainer()
14+
postgresContainer = await new PostgreSqlContainer('postgres:16.4-alpine')
1515
.withDatabase(TILES_POSTGRES_DATABASE)
1616
.withUsername(TILES_POSTGRES_USERNAME)
1717
.withPassword(TILES_POSTGRES_PASSWORD)

0 commit comments

Comments
 (0)