MirrorSave
/
budibase
mirror of https://github.com/Budibase/budibase.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #13459 from Budibase/slim-down-integration-tests 

Reduce duplication in search.spec.ts
This commit is contained in:
Sam Rose 2024-04-11 16:30:18 +01:00 committed by GitHub
parent a1d8a803e8 c5edfea51b
commit 45f39daa2a
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 187 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

386
packages/server/src/api/routes/tests/search.spec.ts
View File

@ -6,10 +6,12 @@ import {
Datasource, Datasource,
EmptyFilterOption, EmptyFilterOption,
FieldType, FieldType,
Row, RowSearchParams,
SearchFilters, SearchFilters,
Table, Table,
TableSchema,
} from "@budibase/types" } from "@budibase/types"
import _ from "lodash"
jest.unmock("mssql") jest.unmock("mssql")
@ -25,8 +27,8 @@ describe.each([
const config = setup.getConfig() const config = setup.getConfig()
let envCleanup: (() => void) | undefined let envCleanup: (() => void) | undefined
let table: Table
let datasource: Datasource | undefined let datasource: Datasource | undefined
let table: Table
beforeAll(async () => { beforeAll(async () => {
if (isSqs) { if (isSqs) {
@ -47,231 +49,217 @@ describe.each([
} }
}) })
async function createTable(schema: TableSchema) {
table = await config.api.table.save(
tableForDatasource(datasource, { schema })
)
}
async function createRows(rows: Record<string, any>[]) {
await Promise.all(rows.map(r => config.api.row.save(table._id!, r)))
}
class SearchAssertion {
constructor(private readonly query: RowSearchParams) {}
async toFind(expectedRows: any[]) {
const { rows: foundRows } = await config.api.row.search(table._id!, {
...this.query,
tableId: table._id!,
})
// eslint-disable-next-line jest/no-standalone-expect
expect(foundRows).toHaveLength(expectedRows.length)
// eslint-disable-next-line jest/no-standalone-expect
expect(foundRows).toEqual(
expect.arrayContaining(
expectedRows.map((expectedRow: any) =>
expect.objectContaining(
foundRows.find(foundRow => _.isMatch(foundRow, expectedRow))
)
)
)
)
}
async toFindNothing() {
await this.toFind([])
}
}
function expectSearch(query: Omit<RowSearchParams, "tableId">) {
return new SearchAssertion({ ...query, tableId: table._id! })
}
function expectQuery(query: SearchFilters) {
return expectSearch({ query })
}
describe("strings", () => { describe("strings", () => {
beforeAll(async () => { beforeAll(async () => {
table = await config.api.table.save( await createTable({
tableForDatasource(datasource, { name: { name: "name", type: FieldType.STRING },
schema: { })
name: { await createRows([{ name: "foo" }, { name: "bar" }])
name: "name",
type: FieldType.STRING,
},
},
})
)
}) })
const rows = [{ name: "foo" }, { name: "bar" }] describe("misc", () => {
let savedRows: Row[] it("should return all if no query is passed", () =>
expectSearch({} as RowSearchParams).toFind([
{ name: "foo" },
{ name: "bar" },
]))
beforeAll(async () => { it("should return all if empty query is passed", () =>
savedRows = await Promise.all( expectQuery({}).toFind([{ name: "foo" }, { name: "bar" }]))
rows.map(r => config.api.row.save(table._id!, r))
) it("should return all if onEmptyFilter is RETURN_ALL", () =>
expectQuery({
onEmptyFilter: EmptyFilterOption.RETURN_ALL,
}).toFind([{ name: "foo" }, { name: "bar" }]))
it("should return nothing if onEmptyFilter is RETURN_NONE", () =>
expectQuery({
onEmptyFilter: EmptyFilterOption.RETURN_NONE,
}).toFindNothing())
}) })
interface StringSearchTest { describe("equal", () => {
query: SearchFilters it("successfully finds a row", () =>
expected: (typeof rows)[number][] expectQuery({ equal: { name: "foo" } }).toFind([{ name: "foo" }]))
}
const stringSearchTests: StringSearchTest[] = [ it("fails to find nonexistent row", () =>
// These three test cases are generic and don't really need expectQuery({ equal: { name: "none" } }).toFindNothing())
// to be repeated for all data types, so we just do them here. })
{ query: {}, expected: rows },
{
query: { onEmptyFilter: EmptyFilterOption.RETURN_ALL },
expected: rows,
},
{
query: { onEmptyFilter: EmptyFilterOption.RETURN_NONE },
expected: [],
},
// The rest of these tests are specific to strings.
{ query: { string: { name: "foo" } }, expected: [rows[0]] },
{ query: { string: { name: "none" } }, expected: [] },
{ query: { fuzzy: { name: "oo" } }, expected: [rows[0]] },
{ query: { equal: { name: "foo" } }, expected: [rows[0]] },
{ query: { notEqual: { name: "foo" } }, expected: [rows[1]] },
{ query: { oneOf: { name: ["foo"] } }, expected: [rows[0]] },
]
it.each(stringSearchTests)( describe("notEqual", () => {
`should be able to run query: $query`, it("successfully finds a row", () =>
async ({ query, expected }) => { expectQuery({ notEqual: { name: "foo" } }).toFind([{ name: "bar" }]))
const { rows: foundRows } = await config.api.row.search(table._id!, {
tableId: table._id!, it("fails to find nonexistent row", () =>
query, expectQuery({ notEqual: { name: "bar" } }).toFind([{ name: "foo" }]))
}) })
expect(foundRows).toHaveLength(expected.length)
expect(foundRows).toEqual( describe("oneOf", () => {
expect.arrayContaining( it("successfully finds a row", () =>
expected.map(r => expectQuery({ oneOf: { name: ["foo"] } }).toFind([{ name: "foo" }]))
expect.objectContaining(savedRows.find(sr => sr.name === r.name)!)
) it("fails to find nonexistent row", () =>
) expectQuery({ oneOf: { name: ["none"] } }).toFindNothing())
) })
}
) describe("fuzzy", () => {
it("successfully finds a row", () =>
expectQuery({ fuzzy: { name: "oo" } }).toFind([{ name: "foo" }]))
it("fails to find nonexistent row", () =>
expectQuery({ fuzzy: { name: "none" } }).toFindNothing())
})
}) })
describe("number", () => { describe("numbers", () => {
beforeAll(async () => { beforeAll(async () => {
table = await config.api.table.save( await createTable({
tableForDatasource(datasource, { age: { name: "age", type: FieldType.NUMBER },
schema: { })
age: { await createRows([{ age: 1 }, { age: 10 }])
name: "age",
type: FieldType.NUMBER,
},
},
})
)
}) })
const rows = [{ age: 1 }, { age: 10 }] describe("equal", () => {
let savedRows: Row[] it("successfully finds a row", () =>
expectQuery({ equal: { age: 1 } }).toFind([{ age: 1 }]))
beforeAll(async () => { it("fails to find nonexistent row", () =>
savedRows = await Promise.all( expectQuery({ equal: { age: 2 } }).toFindNothing())
rows.map(r => config.api.row.save(table._id!, r))
)
}) })
interface NumberSearchTest { describe("notEqual", () => {
query: SearchFilters it("successfully finds a row", () =>
expected: (typeof rows)[number][] expectQuery({ notEqual: { age: 1 } }).toFind([{ age: 10 }]))
}
const numberSearchTests: NumberSearchTest[] = [ it("fails to find nonexistent row", () =>
{ query: { equal: { age: 1 } }, expected: [rows[0]] }, expectQuery({ notEqual: { age: 10 } }).toFind([{ age: 1 }]))
{ query: { equal: { age: 2 } }, expected: [] }, })
{ query: { notEqual: { age: 1 } }, expected: [rows[1]] },
{ query: { oneOf: { age: [1] } }, expected: [rows[0]] },
{ query: { range: { age: { low: 1, high: 5 } } }, expected: [rows[0]] },
{ query: { range: { age: { low: 0, high: 1 } } }, expected: [rows[0]] },
{ query: { range: { age: { low: 3, high: 4 } } }, expected: [] },
{ query: { range: { age: { low: 0, high: 11 } } }, expected: rows },
]
it.each(numberSearchTests)( describe("oneOf", () => {
`should be able to run query: $query`, it("successfully finds a row", () =>
async ({ query, expected }) => { expectQuery({ oneOf: { age: [1] } }).toFind([{ age: 1 }]))
const { rows: foundRows } = await config.api.row.search(table._id!, {
tableId: table._id!, it("fails to find nonexistent row", () =>
query, expectQuery({ oneOf: { age: [2] } }).toFindNothing())
}) })
expect(foundRows).toHaveLength(expected.length)
expect(foundRows).toEqual( describe("range", () => {
expect.arrayContaining( it("successfully finds a row", () =>
expected.map(r => expectQuery({
expect.objectContaining(savedRows.find(sr => sr.age === r.age)!) range: { age: { low: 1, high: 5 } },
) }).toFind([{ age: 1 }]))
)
) it("successfully finds multiple rows", () =>
} expectQuery({
) range: { age: { low: 1, high: 10 } },
}).toFind([{ age: 1 }, { age: 10 }]))
it("successfully finds a row with a high bound", () =>
expectQuery({
range: { age: { low: 5, high: 10 } },
}).toFind([{ age: 10 }]))
})
}) })
describe("dates", () => { describe("dates", () => {
beforeEach(async () => { const JAN_1ST = "2020-01-01T00:00:00.000Z"
table = await config.api.table.save( const JAN_2ND = "2020-01-02T00:00:00.000Z"
tableForDatasource(datasource, { const JAN_5TH = "2020-01-05T00:00:00.000Z"
schema: { const JAN_10TH = "2020-01-10T00:00:00.000Z"
dob: {
name: "dob", beforeAll(async () => {
type: FieldType.DATETIME, await createTable({
}, dob: { name: "dob", type: FieldType.DATETIME },
}, })
})
) await createRows([{ dob: JAN_1ST }, { dob: JAN_10TH }])
}) })
const rows = [ describe("equal", () => {
{ dob: new Date("2020-01-01").toISOString() }, it("successfully finds a row", () =>
{ dob: new Date("2020-01-10").toISOString() }, expectQuery({ equal: { dob: JAN_1ST } }).toFind([{ dob: JAN_1ST }]))
]
let savedRows: Row[]
beforeEach(async () => { it("fails to find nonexistent row", () =>
savedRows = await Promise.all( expectQuery({ equal: { dob: JAN_2ND } }).toFindNothing())
rows.map(r => config.api.row.save(table._id!, r))
)
}) })
interface DateSearchTest { describe("notEqual", () => {
query: SearchFilters it("successfully finds a row", () =>
expected: (typeof rows)[number][] expectQuery({ notEqual: { dob: JAN_1ST } }).toFind([{ dob: JAN_10TH }]))
}
const dateSearchTests: DateSearchTest[] = [ it("fails to find nonexistent row", () =>
{ expectQuery({ notEqual: { dob: JAN_10TH } }).toFind([{ dob: JAN_1ST }]))
query: { equal: { dob: new Date("2020-01-01").toISOString() } }, })
expected: [rows[0]],
},
{
query: { equal: { dob: new Date("2020-01-02").toISOString() } },
expected: [],
},
{
query: { notEqual: { dob: new Date("2020-01-01").toISOString() } },
expected: [rows[1]],
},
{
query: { oneOf: { dob: [new Date("2020-01-01").toISOString()] } },
expected: [rows[0]],
},
{
query: {
range: {
dob: {
low: new Date("2020-01-01").toISOString(),
high: new Date("2020-01-05").toISOString(),
},
},
},
expected: [rows[0]],
},
{
query: {
range: {
dob: {
low: new Date("2020-01-01").toISOString(),
high: new Date("2020-01-10").toISOString(),
},
},
},
expected: rows,
},
{
query: {
range: {
dob: {
low: new Date("2020-01-05").toISOString(),
high: new Date("2020-01-10").toISOString(),
},
},
},
expected: [rows[1]],
},
]
it.each(dateSearchTests)( describe("oneOf", () => {
`should be able to run query: $query`, it("successfully finds a row", () =>
async ({ query, expected }) => { expectQuery({ oneOf: { dob: [JAN_1ST] } }).toFind([{ dob: JAN_1ST }]))
const { rows: foundRows } = await config.api.row.search(table._id!, {
tableId: table._id!, it("fails to find nonexistent row", () =>
query, expectQuery({ oneOf: { dob: [JAN_2ND] } }).toFindNothing())
}) })
expect(foundRows).toHaveLength(expected.length)
expect(foundRows).toEqual( describe("range", () => {
expect.arrayContaining( it("successfully finds a row", () =>
expected.map(r => expectQuery({
expect.objectContaining(savedRows.find(sr => sr.dob === r.dob)!) range: { dob: { low: JAN_1ST, high: JAN_5TH } },
) }).toFind([{ dob: JAN_1ST }]))
)
) it("successfully finds multiple rows", () =>
} expectQuery({
) range: { dob: { low: JAN_1ST, high: JAN_10TH } },
}).toFind([{ dob: JAN_1ST }, { dob: JAN_10TH }]))
it("successfully finds a row with a high bound", () =>
expectQuery({
range: { dob: { low: JAN_5TH, high: JAN_10TH } },
}).toFind([{ dob: JAN_10TH }]))
})
}) })
}) })