From d4f9822c748244152434608f236a41157e513837 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Fri, 15 Mar 2024 17:03:47 +0000 Subject: [PATCH 1/7] Move viewV2 tests out of row.spec.ts and into viewV2.spec.ts. --- .../server/src/api/routes/tests/row.spec.ts | 653 +----------------- .../src/api/routes/tests/viewV2.spec.ts | 491 ++++++++++++- 2 files changed, 507 insertions(+), 637 deletions(-) diff --git a/packages/server/src/api/routes/tests/row.spec.ts b/packages/server/src/api/routes/tests/row.spec.ts index 854410dcf6..64a156b15a 100644 --- a/packages/server/src/api/routes/tests/row.spec.ts +++ b/packages/server/src/api/routes/tests/row.spec.ts @@ -392,6 +392,23 @@ describe.each([ expect(row.arrayFieldArrayStrKnown).toEqual(["One"]) expect(row.optsFieldStrKnown).toEqual("Alpha") }) + + isInternal && + it("doesn't allow creating in user table", async () => { + const userTableId = InternalTable.USER_METADATA + const response = await config.api.row.save( + userTableId, + { + tableId: userTableId, + firstName: "Joe", + lastName: "Joe", + email: "joe@joe.com", + roles: {}, + }, + { status: 400 } + ) + expect(response.message).toBe("Cannot create new user entry.") + }) }) describe("get", () => { @@ -890,642 +907,6 @@ describe.each([ }) }) - describe("view 2.0", () => { - async function userTable(): Promise { - return saveTableRequest({ - name: `users_${uuid.v4()}`, - type: "table", - schema: { - name: { - type: FieldType.STRING, - name: "name", - }, - surname: { - type: FieldType.STRING, - name: "surname", - }, - age: { - type: FieldType.NUMBER, - name: "age", - }, - address: { - type: FieldType.STRING, - name: "address", - }, - jobTitle: { - type: FieldType.STRING, - name: "jobTitle", - }, - }, - }) - } - - const randomRowData = () => ({ - name: generator.first(), - surname: generator.last(), - age: generator.age(), - address: generator.address(), - jobTitle: generator.word(), - }) - - describe("create", () => { - it("should persist a new row with only the provided view fields", async () => { - const table = await config.api.table.save(await userTable()) - const view = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - schema: { - name: { visible: true }, - surname: { visible: true }, - address: { visible: true }, - }, - }) - - const data = randomRowData() - const newRow = await config.api.row.save(view.id, { - tableId: table!._id, - _viewId: view.id, - ...data, - }) - - const row = await config.api.row.get(table._id!, newRow._id!) - expect(row).toEqual({ - name: data.name, - surname: data.surname, - address: data.address, - tableId: table!._id, - _id: newRow._id, - _rev: newRow._rev, - id: newRow.id, - ...defaultRowFields, - }) - expect(row._viewId).toBeUndefined() - expect(row.age).toBeUndefined() - expect(row.jobTitle).toBeUndefined() - }) - }) - - describe("patch", () => { - it("should update only the view fields for a row", async () => { - const table = await config.api.table.save(await userTable()) - const tableId = table._id! - const view = await config.api.viewV2.create({ - tableId: tableId, - name: generator.guid(), - schema: { - name: { visible: true }, - address: { visible: true }, - }, - }) - - const newRow = await config.api.row.save(view.id, { - tableId, - _viewId: view.id, - ...randomRowData(), - }) - const newData = randomRowData() - await config.api.row.patch(view.id, { - tableId, - _viewId: view.id, - _id: newRow._id!, - _rev: newRow._rev!, - ...newData, - }) - - const row = await config.api.row.get(tableId, newRow._id!) - expect(row).toEqual({ - ...newRow, - name: newData.name, - address: newData.address, - _id: newRow._id, - _rev: expect.any(String), - id: newRow.id, - ...defaultRowFields, - }) - expect(row._viewId).toBeUndefined() - expect(row.age).toBeUndefined() - expect(row.jobTitle).toBeUndefined() - }) - }) - - describe("destroy", () => { - it("should be able to delete a row", async () => { - const table = await config.api.table.save(await userTable()) - const tableId = table._id! - const view = await config.api.viewV2.create({ - tableId: tableId, - name: generator.guid(), - schema: { - name: { visible: true }, - address: { visible: true }, - }, - }) - - const createdRow = await config.api.row.save(table._id!, {}) - const rowUsage = await getRowUsage() - - await config.api.row.bulkDelete(view.id, { rows: [createdRow] }) - - await assertRowUsage(rowUsage - 1) - - await config.api.row.get(tableId, createdRow._id!, { - status: 404, - }) - }) - - it("should be able to delete multiple rows", async () => { - const table = await config.api.table.save(await userTable()) - const tableId = table._id! - const view = await config.api.viewV2.create({ - tableId: tableId, - name: generator.guid(), - schema: { - name: { visible: true }, - address: { visible: true }, - }, - }) - - const rows = await Promise.all([ - config.api.row.save(table._id!, {}), - config.api.row.save(table._id!, {}), - config.api.row.save(table._id!, {}), - ]) - const rowUsage = await getRowUsage() - - await config.api.row.bulkDelete(view.id, { rows: [rows[0], rows[2]] }) - - await assertRowUsage(rowUsage - 2) - - await config.api.row.get(tableId, rows[0]._id!, { - status: 404, - }) - await config.api.row.get(tableId, rows[2]._id!, { - status: 404, - }) - await config.api.row.get(tableId, rows[1]._id!, { status: 200 }) - }) - }) - - describe("view search", () => { - let table: Table - const viewSchema = { age: { visible: true }, name: { visible: true } } - - beforeAll(async () => { - table = await config.api.table.save( - saveTableRequest({ - name: `users_${uuid.v4()}`, - schema: { - name: { - type: FieldType.STRING, - name: "name", - constraints: { type: "string" }, - }, - age: { - type: FieldType.NUMBER, - name: "age", - constraints: {}, - }, - }, - }) - ) - }) - - it("returns empty rows from view when no schema is passed", async () => { - const rows = await Promise.all( - Array.from({ length: 10 }, () => - config.api.row.save(table._id!, { tableId: table._id }) - ) - ) - - const createViewResponse = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - }) - const response = await config.api.viewV2.search(createViewResponse.id) - - expect(response.rows).toHaveLength(10) - expect(response).toEqual({ - rows: expect.arrayContaining( - rows.map(r => ({ - _viewId: createViewResponse.id, - tableId: table._id, - _id: r._id, - _rev: r._rev, - ...defaultRowFields, - })) - ), - ...(isInternal - ? {} - : { - hasNextPage: false, - bookmark: null, - }), - }) - }) - - it("searching respects the view filters", async () => { - await Promise.all( - Array.from({ length: 10 }, () => - config.api.row.save(table._id!, { - tableId: table._id, - name: generator.name(), - age: generator.integer({ min: 10, max: 30 }), - }) - ) - ) - - const expectedRows = await Promise.all( - Array.from({ length: 5 }, () => - config.api.row.save(table._id!, { - tableId: table._id, - name: generator.name(), - age: 40, - }) - ) - ) - - const createViewResponse = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - query: [ - { operator: SearchQueryOperators.EQUAL, field: "age", value: 40 }, - ], - schema: viewSchema, - }) - - const response = await config.api.viewV2.search(createViewResponse.id) - - expect(response.rows).toHaveLength(5) - expect(response).toEqual({ - rows: expect.arrayContaining( - expectedRows.map(r => ({ - _viewId: createViewResponse.id, - tableId: table._id, - name: r.name, - age: r.age, - _id: r._id, - _rev: r._rev, - ...defaultRowFields, - })) - ), - ...(isInternal - ? {} - : { - hasNextPage: false, - bookmark: null, - }), - }) - }) - - const sortTestOptions: [ - { - field: string - order?: SortOrder - type?: SortType - }, - string[] - ][] = [ - [ - { - field: "name", - order: SortOrder.ASCENDING, - type: SortType.STRING, - }, - ["Alice", "Bob", "Charly", "Danny"], - ], - [ - { - field: "name", - }, - ["Alice", "Bob", "Charly", "Danny"], - ], - [ - { - field: "name", - order: SortOrder.DESCENDING, - }, - ["Danny", "Charly", "Bob", "Alice"], - ], - [ - { - field: "name", - order: SortOrder.DESCENDING, - type: SortType.STRING, - }, - ["Danny", "Charly", "Bob", "Alice"], - ], - [ - { - field: "age", - order: SortOrder.ASCENDING, - type: SortType.number, - }, - ["Danny", "Alice", "Charly", "Bob"], - ], - [ - { - field: "age", - order: SortOrder.ASCENDING, - }, - ["Danny", "Alice", "Charly", "Bob"], - ], - [ - { - field: "age", - order: SortOrder.DESCENDING, - }, - ["Bob", "Charly", "Alice", "Danny"], - ], - [ - { - field: "age", - order: SortOrder.DESCENDING, - type: SortType.number, - }, - ["Bob", "Charly", "Alice", "Danny"], - ], - ] - - describe("sorting", () => { - let table: Table - beforeAll(async () => { - table = await config.api.table.save(await userTable()) - const users = [ - { name: "Alice", age: 25 }, - { name: "Bob", age: 30 }, - { name: "Charly", age: 27 }, - { name: "Danny", age: 15 }, - ] - await Promise.all( - users.map(u => - config.api.row.save(table._id!, { - tableId: table._id, - ...u, - }) - ) - ) - }) - - it.each(sortTestOptions)( - "allow sorting (%s)", - async (sortParams, expected) => { - const createViewResponse = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - sort: sortParams, - schema: viewSchema, - }) - - const response = await config.api.viewV2.search( - createViewResponse.id - ) - - expect(response.rows).toHaveLength(4) - expect(response.rows).toEqual( - expected.map(name => expect.objectContaining({ name })) - ) - } - ) - - it.each(sortTestOptions)( - "allow override the default view sorting (%s)", - async (sortParams, expected) => { - const createViewResponse = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - sort: { - field: "name", - order: SortOrder.ASCENDING, - type: SortType.STRING, - }, - schema: viewSchema, - }) - - const response = await config.api.viewV2.search( - createViewResponse.id, - { - sort: sortParams.field, - sortOrder: sortParams.order, - sortType: sortParams.type, - query: {}, - } - ) - - expect(response.rows).toHaveLength(4) - expect(response.rows).toEqual( - expected.map(name => expect.objectContaining({ name })) - ) - } - ) - }) - - it("when schema is defined, defined columns and row attributes are returned", async () => { - const table = await config.api.table.save(await userTable()) - const rows = await Promise.all( - Array.from({ length: 10 }, () => - config.api.row.save(table._id!, { - tableId: table._id, - name: generator.name(), - age: generator.age(), - }) - ) - ) - - const view = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - schema: { name: { visible: true } }, - }) - const response = await config.api.viewV2.search(view.id) - - expect(response.rows).toHaveLength(10) - expect(response.rows).toEqual( - expect.arrayContaining( - rows.map(r => ({ - ...(isInternal - ? expectAnyInternalColsAttributes - : expectAnyExternalColsAttributes), - _viewId: view.id, - name: r.name, - })) - ) - ) - }) - - it("views without data can be returned", async () => { - const table = await config.api.table.save(await userTable()) - const createViewResponse = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - }) - const response = await config.api.viewV2.search(createViewResponse.id) - expect(response.rows).toHaveLength(0) - }) - - it("respects the limit parameter", async () => { - const table = await config.api.table.save(await userTable()) - await Promise.all( - Array.from({ length: 10 }, () => config.api.row.save(table._id!, {})) - ) - - const limit = generator.integer({ min: 1, max: 8 }) - - const createViewResponse = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - }) - const response = await config.api.viewV2.search(createViewResponse.id, { - limit, - query: {}, - }) - - expect(response.rows).toHaveLength(limit) - }) - - it("can handle pagination", async () => { - const table = await config.api.table.save(await userTable()) - await Promise.all( - Array.from({ length: 10 }, () => config.api.row.save(table._id!, {})) - ) - const view = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - }) - const rows = (await config.api.viewV2.search(view.id)).rows - - const page1 = await config.api.viewV2.search(view.id, { - paginate: true, - limit: 4, - query: {}, - }) - expect(page1).toEqual({ - rows: expect.arrayContaining(rows.slice(0, 4)), - totalRows: isInternal ? 10 : undefined, - hasNextPage: true, - bookmark: expect.anything(), - }) - - const page2 = await config.api.viewV2.search(view.id, { - paginate: true, - limit: 4, - bookmark: page1.bookmark, - - query: {}, - }) - expect(page2).toEqual({ - rows: expect.arrayContaining(rows.slice(4, 8)), - totalRows: isInternal ? 10 : undefined, - hasNextPage: true, - bookmark: expect.anything(), - }) - - const page3 = await config.api.viewV2.search(view.id, { - paginate: true, - limit: 4, - bookmark: page2.bookmark, - query: {}, - }) - expect(page3).toEqual({ - rows: expect.arrayContaining(rows.slice(8)), - totalRows: isInternal ? 10 : undefined, - hasNextPage: false, - bookmark: expect.anything(), - }) - }) - - isInternal && - it("doesn't allow creating in user table", async () => { - const userTableId = InternalTable.USER_METADATA - const response = await config.api.row.save( - userTableId, - { - tableId: userTableId, - firstName: "Joe", - lastName: "Joe", - email: "joe@joe.com", - roles: {}, - }, - { status: 400 } - ) - expect(response.message).toBe("Cannot create new user entry.") - }) - - describe("permissions", () => { - let table: Table - let view: ViewV2 - - beforeAll(async () => { - table = await config.api.table.save(await userTable()) - await Promise.all( - Array.from({ length: 10 }, () => - config.api.row.save(table._id!, {}) - ) - ) - - view = await config.api.viewV2.create({ - tableId: table._id!, - name: generator.guid(), - }) - }) - - beforeEach(() => { - mocks.licenses.useViewPermissions() - }) - - it("does not allow public users to fetch by default", async () => { - await config.publish() - await config.api.viewV2.publicSearch(view.id, undefined, { - status: 403, - }) - }) - - it("allow public users to fetch when permissions are explicit", async () => { - await config.api.permission.add({ - roleId: roles.BUILTIN_ROLE_IDS.PUBLIC, - level: PermissionLevel.READ, - resourceId: view.id, - }) - await config.publish() - - const response = await config.api.viewV2.publicSearch(view.id) - - expect(response.rows).toHaveLength(10) - }) - - it("allow public users to fetch when permissions are inherited", async () => { - await config.api.permission.add({ - roleId: roles.BUILTIN_ROLE_IDS.PUBLIC, - level: PermissionLevel.READ, - resourceId: table._id!, - }) - await config.publish() - - const response = await config.api.viewV2.publicSearch(view.id) - - expect(response.rows).toHaveLength(10) - }) - - it("respects inherited permissions, not allowing not public views from public tables", async () => { - await config.api.permission.add({ - roleId: roles.BUILTIN_ROLE_IDS.PUBLIC, - level: PermissionLevel.READ, - resourceId: table._id!, - }) - await config.api.permission.add({ - roleId: roles.BUILTIN_ROLE_IDS.POWER, - level: PermissionLevel.READ, - resourceId: view.id, - }) - await config.publish() - - await config.api.viewV2.publicSearch(view.id, undefined, { - status: 403, - }) - }) - }) - }) - }) - let o2mTable: Table let m2mTable: Table beforeAll(async () => { diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts index ded5e08d29..9c53ade52e 100644 --- a/packages/server/src/api/routes/tests/viewV2.spec.ts +++ b/packages/server/src/api/routes/tests/viewV2.spec.ts @@ -5,20 +5,25 @@ import { FieldSchema, FieldType, INTERNAL_TABLE_SOURCE_ID, + PermissionLevel, + QuotaUsageType, SaveTableRequest, SearchQueryOperators, SortOrder, SortType, + StaticQuotaName, Table, TableSourceType, UIFieldMetadata, UpdateViewRequest, ViewV2, } from "@budibase/types" -import { generator } from "@budibase/backend-core/tests" +import { generator, mocks } from "@budibase/backend-core/tests" import * as uuid from "uuid" import { databaseTestProviders } from "../../../integrations/tests/utils" import merge from "lodash/merge" +import { quotas } from "@budibase/pro" +import { roles } from "@budibase/backend-core" jest.unmock("mysql2") jest.unmock("mysql2/promise") @@ -33,6 +38,7 @@ describe.each([ ["mariadb", databaseTestProviders.mariadb], ])("/v2/views (%s)", (_, dsProvider) => { const config = setup.getConfig() + const isInternal = !dsProvider let table: Table let datasource: Datasource @@ -99,6 +105,18 @@ describe.each([ setup.afterAll() }) + const getRowUsage = async () => { + const { total } = await config.doInContext(undefined, () => + quotas.getCurrentUsageValues(QuotaUsageType.STATIC, StaticQuotaName.ROWS) + ) + return total + } + + const assertRowUsage = async (expected: number) => { + const usage = await getRowUsage() + expect(usage).toBe(expected) + } + describe("create", () => { it("persist the view when the view is successfully created", async () => { const newView: CreateViewRequest = { @@ -525,4 +543,475 @@ describe.each([ expect(row.Country).toEqual("Aussy") }) }) + + describe.only("row operations", () => { + let table: Table, view: ViewV2 + beforeEach(async () => { + table = await config.api.table.save( + saveTableRequest({ + schema: { + one: { type: FieldType.STRING, name: "one" }, + two: { type: FieldType.STRING, name: "two" }, + }, + }) + ) + view = await config.api.viewV2.create({ + tableId: table._id!, + name: generator.guid(), + schema: { + two: { visible: true }, + }, + }) + }) + + describe("create", () => { + it("should persist a new row with only the provided view fields", async () => { + const newRow = await config.api.row.save(view.id, { + tableId: table!._id, + _viewId: view.id, + one: "foo", + two: "bar", + }) + + const row = await config.api.row.get(table._id!, newRow._id!) + expect(row.one).toBeUndefined() + expect(row.two).toEqual("bar") + }) + }) + + describe("patch", () => { + it("should update only the view fields for a row", async () => { + const newRow = await config.api.row.save(table._id!, { + one: "foo", + two: "bar", + }) + await config.api.row.patch(view.id, { + tableId: table._id!, + _id: newRow._id!, + _rev: newRow._rev!, + one: "newFoo", + two: "newBar", + }) + + const row = await config.api.row.get(table._id!, newRow._id!) + expect(row.one).toEqual("foo") + expect(row.two).toEqual("newBar") + }) + }) + + describe("destroy", () => { + it("should be able to delete a row", async () => { + const createdRow = await config.api.row.save(table._id!, {}) + const rowUsage = await getRowUsage() + await config.api.row.bulkDelete(view.id, { rows: [createdRow] }) + await assertRowUsage(rowUsage - 1) + await config.api.row.get(table._id!, createdRow._id!, { + status: 404, + }) + }) + + it("should be able to delete multiple rows", async () => { + const rows = await Promise.all([ + config.api.row.save(table._id!, {}), + config.api.row.save(table._id!, {}), + config.api.row.save(table._id!, {}), + ]) + const rowUsage = await getRowUsage() + + await config.api.row.bulkDelete(view.id, { rows: [rows[0], rows[2]] }) + + await assertRowUsage(rowUsage - 2) + + await config.api.row.get(table._id!, rows[0]._id!, { + status: 404, + }) + await config.api.row.get(table._id!, rows[2]._id!, { + status: 404, + }) + await config.api.row.get(table._id!, rows[1]._id!, { status: 200 }) + }) + }) + + describe("search", () => { + it("returns empty rows from view when no schema is passed", async () => { + const rows = await Promise.all( + Array.from({ length: 10 }, () => config.api.row.save(table._id!, {})) + ) + const response = await config.api.viewV2.search(view.id) + expect(response.rows).toHaveLength(10) + expect(response).toEqual({ + rows: expect.arrayContaining( + rows.map(r => ({ + _viewId: view.id, + tableId: table._id, + _id: r._id, + _rev: r._rev, + ...(isInternal + ? { + type: "row", + updatedAt: expect.any(String), + createdAt: expect.any(String), + } + : {}), + })) + ), + ...(isInternal + ? {} + : { + hasNextPage: false, + bookmark: null, + }), + }) + }) + + it("searching respects the view filters", async () => { + await config.api.row.save(table._id!, { + one: "foo", + two: "bar", + }) + const two = await config.api.row.save(table._id!, { + one: "foo2", + two: "bar2", + }) + + const view = await config.api.viewV2.create({ + tableId: table._id!, + name: generator.guid(), + query: [ + { + operator: SearchQueryOperators.EQUAL, + field: "two", + value: "bar2", + }, + ], + schema: { + two: { visible: true }, + }, + }) + + const response = await config.api.viewV2.search(view.id) + expect(response.rows).toHaveLength(1) + expect(response).toEqual({ + rows: expect.arrayContaining([ + { + _viewId: view.id, + tableId: table._id, + two: two.two, + _id: two._id, + _rev: two._rev, + ...(isInternal + ? { + type: "row", + createdAt: expect.any(String), + updatedAt: expect.any(String), + } + : {}), + }, + ]), + ...(isInternal + ? {} + : { + hasNextPage: false, + bookmark: null, + }), + }) + }) + + it("views without data can be returned", async () => { + const response = await config.api.viewV2.search(view.id) + expect(response.rows).toHaveLength(0) + }) + + it("respects the limit parameter", async () => { + await Promise.all( + Array.from({ length: 10 }, () => config.api.row.save(table._id!, {})) + ) + const limit = generator.integer({ min: 1, max: 8 }) + const response = await config.api.viewV2.search(view.id, { + limit, + query: {}, + }) + expect(response.rows).toHaveLength(limit) + }) + + it("can handle pagination", async () => { + await Promise.all( + Array.from({ length: 10 }, () => config.api.row.save(table._id!, {})) + ) + const rows = (await config.api.viewV2.search(view.id)).rows + + const page1 = await config.api.viewV2.search(view.id, { + paginate: true, + limit: 4, + query: {}, + }) + expect(page1).toEqual({ + rows: expect.arrayContaining(rows.slice(0, 4)), + totalRows: isInternal ? 10 : undefined, + hasNextPage: true, + bookmark: expect.anything(), + }) + + const page2 = await config.api.viewV2.search(view.id, { + paginate: true, + limit: 4, + bookmark: page1.bookmark, + query: {}, + }) + expect(page2).toEqual({ + rows: expect.arrayContaining(rows.slice(4, 8)), + totalRows: isInternal ? 10 : undefined, + hasNextPage: true, + bookmark: expect.anything(), + }) + + const page3 = await config.api.viewV2.search(view.id, { + paginate: true, + limit: 4, + bookmark: page2.bookmark, + query: {}, + }) + expect(page3).toEqual({ + rows: expect.arrayContaining(rows.slice(8)), + totalRows: isInternal ? 10 : undefined, + hasNextPage: false, + bookmark: expect.anything(), + }) + }) + + const sortTestOptions: [ + { + field: string + order?: SortOrder + type?: SortType + }, + string[] + ][] = [ + [ + { + field: "name", + order: SortOrder.ASCENDING, + type: SortType.STRING, + }, + ["Alice", "Bob", "Charly", "Danny"], + ], + [ + { + field: "name", + }, + ["Alice", "Bob", "Charly", "Danny"], + ], + [ + { + field: "name", + order: SortOrder.DESCENDING, + }, + ["Danny", "Charly", "Bob", "Alice"], + ], + [ + { + field: "name", + order: SortOrder.DESCENDING, + type: SortType.STRING, + }, + ["Danny", "Charly", "Bob", "Alice"], + ], + [ + { + field: "age", + order: SortOrder.ASCENDING, + type: SortType.number, + }, + ["Danny", "Alice", "Charly", "Bob"], + ], + [ + { + field: "age", + order: SortOrder.ASCENDING, + }, + ["Danny", "Alice", "Charly", "Bob"], + ], + [ + { + field: "age", + order: SortOrder.DESCENDING, + }, + ["Bob", "Charly", "Alice", "Danny"], + ], + [ + { + field: "age", + order: SortOrder.DESCENDING, + type: SortType.number, + }, + ["Bob", "Charly", "Alice", "Danny"], + ], + ] + + describe("sorting", () => { + let table: Table + const viewSchema = { age: { visible: true }, name: { visible: true } } + + beforeAll(async () => { + table = await config.api.table.save( + saveTableRequest({ + name: `users_${uuid.v4()}`, + type: "table", + schema: { + name: { + type: FieldType.STRING, + name: "name", + }, + surname: { + type: FieldType.STRING, + name: "surname", + }, + age: { + type: FieldType.NUMBER, + name: "age", + }, + address: { + type: FieldType.STRING, + name: "address", + }, + jobTitle: { + type: FieldType.STRING, + name: "jobTitle", + }, + }, + }) + ) + + const users = [ + { name: "Alice", age: 25 }, + { name: "Bob", age: 30 }, + { name: "Charly", age: 27 }, + { name: "Danny", age: 15 }, + ] + await Promise.all( + users.map(u => + config.api.row.save(table._id!, { + tableId: table._id, + ...u, + }) + ) + ) + }) + + it.each(sortTestOptions)( + "allow sorting (%s)", + async (sortParams, expected) => { + const view = await config.api.viewV2.create({ + tableId: table._id!, + name: generator.guid(), + sort: sortParams, + schema: viewSchema, + }) + + const response = await config.api.viewV2.search(view.id) + + expect(response.rows).toHaveLength(4) + expect(response.rows).toEqual( + expected.map(name => expect.objectContaining({ name })) + ) + } + ) + + it.each(sortTestOptions)( + "allow override the default view sorting (%s)", + async (sortParams, expected) => { + const view = await config.api.viewV2.create({ + tableId: table._id!, + name: generator.guid(), + sort: { + field: "name", + order: SortOrder.ASCENDING, + type: SortType.STRING, + }, + schema: viewSchema, + }) + + const response = await config.api.viewV2.search(view.id, { + sort: sortParams.field, + sortOrder: sortParams.order, + sortType: sortParams.type, + query: {}, + }) + + expect(response.rows).toHaveLength(4) + expect(response.rows).toEqual( + expected.map(name => expect.objectContaining({ name })) + ) + } + ) + }) + }) + + describe("permissions", () => { + beforeEach(async () => { + mocks.licenses.useViewPermissions() + await Promise.all( + Array.from({ length: 10 }, () => config.api.row.save(table._id!, {})) + ) + }) + + it("does not allow public users to fetch by default", async () => { + await config.publish() + await config.api.viewV2.publicSearch(view.id, undefined, { + status: 403, + }) + }) + + it("does not allow public users to fetch by default", async () => { + await config.publish() + await config.api.viewV2.publicSearch(view.id, undefined, { + status: 403, + }) + }) + + it("allow public users to fetch when permissions are explicit", async () => { + await config.api.permission.add({ + roleId: roles.BUILTIN_ROLE_IDS.PUBLIC, + level: PermissionLevel.READ, + resourceId: view.id, + }) + await config.publish() + + const response = await config.api.viewV2.publicSearch(view.id) + + expect(response.rows).toHaveLength(10) + }) + + it("allow public users to fetch when permissions are inherited", async () => { + await config.api.permission.add({ + roleId: roles.BUILTIN_ROLE_IDS.PUBLIC, + level: PermissionLevel.READ, + resourceId: table._id!, + }) + await config.publish() + + const response = await config.api.viewV2.publicSearch(view.id) + + expect(response.rows).toHaveLength(10) + }) + + it("respects inherited permissions, not allowing not public views from public tables", async () => { + await config.api.permission.add({ + roleId: roles.BUILTIN_ROLE_IDS.PUBLIC, + level: PermissionLevel.READ, + resourceId: table._id!, + }) + await config.api.permission.add({ + roleId: roles.BUILTIN_ROLE_IDS.POWER, + level: PermissionLevel.READ, + resourceId: view.id, + }) + await config.publish() + + await config.api.viewV2.publicSearch(view.id, undefined, { + status: 403, + }) + }) + }) + }) }) From 6d7712fbdc15b74fa0387bd088eefb97a0bace0e Mon Sep 17 00:00:00 2001 From: Adria Navarro Date: Mon, 18 Mar 2024 10:18:45 +0100 Subject: [PATCH 2/7] Remove .only --- packages/server/src/api/routes/tests/viewV2.spec.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts index 9c53ade52e..c0b8b33a9a 100644 --- a/packages/server/src/api/routes/tests/viewV2.spec.ts +++ b/packages/server/src/api/routes/tests/viewV2.spec.ts @@ -544,7 +544,7 @@ describe.each([ }) }) - describe.only("row operations", () => { + describe("row operations", () => { let table: Table, view: ViewV2 beforeEach(async () => { table = await config.api.table.save( From 6da84d2941b87adcf1f8bfc6be4dd19f0bfa797b Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Wed, 20 Mar 2024 16:06:22 +0000 Subject: [PATCH 3/7] Fix lint errors. --- packages/server/src/api/routes/tests/row.spec.ts | 14 ++------------ .../server/src/api/routes/tests/viewV2.spec.ts | 7 ------- 2 files changed, 2 insertions(+), 19 deletions(-) diff --git a/packages/server/src/api/routes/tests/row.spec.ts b/packages/server/src/api/routes/tests/row.spec.ts index 64a156b15a..aff85b4d0e 100644 --- a/packages/server/src/api/routes/tests/row.spec.ts +++ b/packages/server/src/api/routes/tests/row.spec.ts @@ -3,7 +3,7 @@ import { databaseTestProviders } from "../../../integrations/tests/utils" import tk from "timekeeper" import { outputProcessing } from "../../../utilities/rowProcessor" import * as setup from "./utilities" -import { context, InternalTable, roles, tenancy } from "@budibase/backend-core" +import { context, InternalTable, tenancy } from "@budibase/backend-core" import { quotas } from "@budibase/pro" import { AutoFieldSubType, @@ -14,25 +14,15 @@ import { FieldTypeSubtypes, FormulaType, INTERNAL_TABLE_SOURCE_ID, - PermissionLevel, QuotaUsageType, RelationshipType, Row, SaveTableRequest, - SearchQueryOperators, - SortOrder, - SortType, StaticQuotaName, Table, TableSourceType, - ViewV2, } from "@budibase/types" -import { - expectAnyExternalColsAttributes, - expectAnyInternalColsAttributes, - generator, - mocks, -} from "@budibase/backend-core/tests" +import { generator, mocks } from "@budibase/backend-core/tests" import _, { merge } from "lodash" import * as uuid from "uuid" diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts index c0b8b33a9a..778d9d6e5a 100644 --- a/packages/server/src/api/routes/tests/viewV2.spec.ts +++ b/packages/server/src/api/routes/tests/viewV2.spec.ts @@ -962,13 +962,6 @@ describe.each([ }) }) - it("does not allow public users to fetch by default", async () => { - await config.publish() - await config.api.viewV2.publicSearch(view.id, undefined, { - status: 403, - }) - }) - it("allow public users to fetch when permissions are explicit", async () => { await config.api.permission.add({ roleId: roles.BUILTIN_ROLE_IDS.PUBLIC, From 545c67eac685e530b1cf41f6412580d676b358e2 Mon Sep 17 00:00:00 2001 From: Sam Rose Date: Wed, 20 Mar 2024 17:59:35 +0000 Subject: [PATCH 4/7] Remove mssql mock, unify SQL-based query tests. --- packages/server/__mocks__/mssql.ts | 17 - .../{mysql.spec.ts => generic-sql.spec.ts} | 384 +++++++++--------- .../api/routes/tests/queries/postgres.spec.ts | 243 ----------- .../tests/microsoftSqlServer.spec.ts | 57 --- .../src/integrations/tests/postgres.spec.ts | 83 ---- .../src/integrations/tests/utils/mssql.ts | 3 + 6 files changed, 206 insertions(+), 581 deletions(-) delete mode 100644 packages/server/__mocks__/mssql.ts rename packages/server/src/api/routes/tests/queries/{mysql.spec.ts => generic-sql.spec.ts} (64%) delete mode 100644 packages/server/src/api/routes/tests/queries/postgres.spec.ts delete mode 100644 packages/server/src/integrations/tests/microsoftSqlServer.spec.ts delete mode 100644 packages/server/src/integrations/tests/postgres.spec.ts diff --git a/packages/server/__mocks__/mssql.ts b/packages/server/__mocks__/mssql.ts deleted file mode 100644 index 6a34e1e9d7..0000000000 --- a/packages/server/__mocks__/mssql.ts +++ /dev/null @@ -1,17 +0,0 @@ -module.exports = { - ConnectionPool: jest.fn(() => ({ - connect: jest.fn(() => ({ - request: jest.fn(() => ({ - query: jest.fn(sql => ({ recordset: [sql] })), - })), - })), - })), - query: jest.fn(() => ({ - recordset: [ - { - a: "string", - b: 1, - }, - ], - })), -} diff --git a/packages/server/src/api/routes/tests/queries/mysql.spec.ts b/packages/server/src/api/routes/tests/queries/generic-sql.spec.ts similarity index 64% rename from packages/server/src/api/routes/tests/queries/mysql.spec.ts rename to packages/server/src/api/routes/tests/queries/generic-sql.spec.ts index d04e53971d..1fc0ecb382 100644 --- a/packages/server/src/api/routes/tests/queries/mysql.spec.ts +++ b/packages/server/src/api/routes/tests/queries/generic-sql.spec.ts @@ -1,26 +1,43 @@ -import { Datasource, Query } from "@budibase/types" +import { Datasource, Query, SourceName } from "@budibase/types" import * as setup from "../utilities" import { databaseTestProviders } from "../../../../integrations/tests/utils" +import pg from "pg" import mysql from "mysql2/promise" -import { generator } from "@budibase/backend-core/tests" +import mssql from "mssql" -const createTableSQL = ` -CREATE TABLE test_table ( - id INT AUTO_INCREMENT PRIMARY KEY, - name VARCHAR(50) NOT NULL -) -` +jest.unmock("pg") -const insertSQL = ` -INSERT INTO test_table (name) VALUES ('one'), ('two'), ('three'), ('four'), ('five') -` +const createTableSQL: Record = { + [SourceName.POSTGRES]: ` + CREATE TABLE test_table ( + id serial PRIMARY KEY, + name VARCHAR ( 50 ) NOT NULL, + birthday TIMESTAMP + );`, + [SourceName.MYSQL]: ` + CREATE TABLE test_table ( + id INT AUTO_INCREMENT PRIMARY KEY, + name VARCHAR(50) NOT NULL, + birthday TIMESTAMP + );`, + [SourceName.SQL_SERVER]: ` + CREATE TABLE test_table ( + id INT IDENTITY(1,1) PRIMARY KEY, + name NVARCHAR(50) NOT NULL, + birthday DATETIME + );`, +} -const dropTableSQL = ` -DROP TABLE test_table -` +const insertSQL = `INSERT INTO test_table (name) VALUES ('one'), ('two'), ('three'), ('four'), ('five')` +const dropTableSQL = `DROP TABLE test_table;` -describe("/queries", () => { - let config = setup.getConfig() +describe.each([ + ["postgres", databaseTestProviders.postgres], + ["mysql", databaseTestProviders.mysql], + ["mssql", databaseTestProviders.mssql], + ["mariadb", databaseTestProviders.mariadb], +])("queries (%s)", (__, dsProvider) => { + const config = setup.getConfig() let datasource: Datasource async function createQuery(query: Partial): Promise { @@ -37,124 +54,63 @@ describe("/queries", () => { return await config.api.query.create({ ...defaultQuery, ...query }) } - async function withConnection( - callback: (client: mysql.Connection) => Promise - ): Promise { - const ds = await databaseTestProviders.mysql.datasource() - const con = await mysql.createConnection(ds.config!) - try { - await callback(con) - } finally { - con.end() + async function rawQuery(sql: string): Promise { + // We re-fetch the datasource here because the one returned by + // config.api.datasource.create has the password field blanked out, and we + // need the password to connect to the database. + const ds = await dsProvider.datasource() + switch (ds.source) { + case SourceName.POSTGRES: { + const client = new pg.Client(ds.config!) + await client.connect() + try { + const { rows } = await client.query(sql) + return rows + } finally { + await client.end() + } + } + case SourceName.MYSQL: { + const con = await mysql.createConnection(ds.config!) + try { + const [rows] = await con.query(sql) + return rows + } finally { + con.end() + } + } + case SourceName.SQL_SERVER: { + const pool = new mssql.ConnectionPool(ds.config! as mssql.config) + const client = await pool.connect() + try { + const { recordset } = await client.query(sql) + return recordset + } finally { + await pool.close() + } + } } } - afterAll(async () => { - await databaseTestProviders.mysql.stop() - setup.afterAll() - }) - beforeAll(async () => { await config.init() datasource = await config.api.datasource.create( - await databaseTestProviders.mysql.datasource() + await dsProvider.datasource() ) }) beforeEach(async () => { - await withConnection(async connection => { - await connection.query(createTableSQL) - await connection.query(insertSQL) - }) + await rawQuery(createTableSQL[datasource.source]) + await rawQuery(insertSQL) }) afterEach(async () => { - await withConnection(async connection => { - await connection.query(dropTableSQL) - }) + await rawQuery(dropTableSQL) }) - describe("read", () => { - it("should execute a query", async () => { - const query = await createQuery({ - fields: { - sql: "SELECT * FROM test_table ORDER BY id", - }, - }) - - const result = await config.api.query.execute(query._id!) - - expect(result.data).toEqual([ - { - id: 1, - name: "one", - }, - { - id: 2, - name: "two", - }, - { - id: 3, - name: "three", - }, - { - id: 4, - name: "four", - }, - { - id: 5, - name: "five", - }, - ]) - }) - - it("should be able to transform a query", async () => { - const query = await createQuery({ - fields: { - sql: "SELECT * FROM test_table WHERE id = 1", - }, - transformer: ` - data[0].id = data[0].id + 1; - return data; - `, - }) - - const result = await config.api.query.execute(query._id!) - - expect(result.data).toEqual([ - { - id: 2, - name: "one", - }, - ]) - }) - - it("should coerce numeric bindings", async () => { - const query = await createQuery({ - fields: { - sql: "SELECT * FROM test_table WHERE id = {{ id }}", - }, - parameters: [ - { - name: "id", - default: "", - }, - ], - }) - - const result = await config.api.query.execute(query._id!, { - parameters: { - id: "1", - }, - }) - - expect(result.data).toEqual([ - { - id: 1, - name: "one", - }, - ]) - }) + afterAll(async () => { + await dsProvider.stop() + setup.afterAll() }) describe("create", () => { @@ -184,33 +140,21 @@ describe("/queries", () => { }, ]) - await withConnection(async connection => { - const [rows] = await connection.query( - "SELECT * FROM test_table WHERE name = 'baz'" - ) - expect(rows).toHaveLength(1) - }) + const rows = await rawQuery("SELECT * FROM test_table WHERE name = 'baz'") + expect(rows).toHaveLength(1) }) it.each(["2021-02-05T12:01:00.000Z", "2021-02-05"])( "should coerce %s into a date", - async dateStr => { - const date = new Date(dateStr) - const tableName = `\`${generator.guid()}\`` - await withConnection(async connection => { - await connection.query(`CREATE TABLE ${tableName} ( - id INT AUTO_INCREMENT PRIMARY KEY, - date DATETIME NOT NULL - )`) - }) - + async datetimeStr => { + const date = new Date(datetimeStr) const query = await createQuery({ fields: { - sql: `INSERT INTO ${tableName} (date) VALUES ({{ date }})`, + sql: `INSERT INTO test_table (name, birthday) VALUES ('foo', {{ birthday }})`, }, parameters: [ { - name: "date", + name: "birthday", default: "", }, ], @@ -218,23 +162,21 @@ describe("/queries", () => { }) const result = await config.api.query.execute(query._id!, { - parameters: { date: dateStr }, + parameters: { birthday: datetimeStr }, }) expect(result.data).toEqual([{ created: true }]) - await withConnection(async connection => { - const [rows] = await connection.query( - `SELECT * FROM ${tableName} WHERE date = '${date.toISOString()}'` - ) - expect(rows).toHaveLength(1) - }) + const rows = await rawQuery( + `SELECT * FROM test_table WHERE birthday = '${date.toISOString()}'` + ) + expect(rows).toHaveLength(1) } ) it.each(["2021,02,05", "202205-1500"])( "should not coerce %s as a date", - async date => { + async notDateStr => { const query = await createQuery({ fields: { sql: "INSERT INTO test_table (name) VALUES ({{ name }})", @@ -250,22 +192,110 @@ describe("/queries", () => { const result = await config.api.query.execute(query._id!, { parameters: { - name: date, + name: notDateStr, }, }) expect(result.data).toEqual([{ created: true }]) - await withConnection(async connection => { - const [rows] = await connection.query( - `SELECT * FROM test_table WHERE name = '${date}'` - ) - expect(rows).toHaveLength(1) - }) + const rows = await rawQuery( + `SELECT * FROM test_table WHERE name = '${notDateStr}'` + ) + expect(rows).toHaveLength(1) } ) }) + describe("read", () => { + it("should execute a query", async () => { + const query = await createQuery({ + fields: { + sql: "SELECT * FROM test_table ORDER BY id", + }, + }) + + const result = await config.api.query.execute(query._id!) + + expect(result.data).toEqual([ + { + id: 1, + name: "one", + birthday: null, + }, + { + id: 2, + name: "two", + birthday: null, + }, + { + id: 3, + name: "three", + birthday: null, + }, + { + id: 4, + name: "four", + birthday: null, + }, + { + id: 5, + name: "five", + birthday: null, + }, + ]) + }) + + it("should be able to transform a query", async () => { + const query = await createQuery({ + fields: { + sql: "SELECT * FROM test_table WHERE id = 1", + }, + transformer: ` + data[0].id = data[0].id + 1; + return data; + `, + }) + + const result = await config.api.query.execute(query._id!) + + expect(result.data).toEqual([ + { + id: 2, + name: "one", + birthday: null, + }, + ]) + }) + + it("should coerce numeric bindings", async () => { + const query = await createQuery({ + fields: { + sql: "SELECT * FROM test_table WHERE id = {{ id }}", + }, + parameters: [ + { + name: "id", + default: "", + }, + ], + }) + + const result = await config.api.query.execute(query._id!, { + parameters: { + id: "1", + }, + }) + + expect(result.data).toEqual([ + { + id: 1, + name: "one", + birthday: null, + }, + ]) + }) + }) + describe("update", () => { it("should be able to update rows", async () => { const query = await createQuery({ @@ -298,12 +328,8 @@ describe("/queries", () => { }, ]) - await withConnection(async connection => { - const [rows] = await connection.query( - "SELECT * FROM test_table WHERE id = 1" - ) - expect(rows).toEqual([{ id: 1, name: "foo" }]) - }) + const rows = await rawQuery("SELECT * FROM test_table WHERE id = 1") + expect(rows).toEqual([{ id: 1, name: "foo", birthday: null }]) }) it("should be able to execute an update that updates no rows", async () => { @@ -322,6 +348,23 @@ describe("/queries", () => { }, ]) }) + + it("should be able to execute a delete that deletes no rows", async () => { + const query = await createQuery({ + fields: { + sql: "DELETE FROM test_table WHERE id = 100", + }, + queryVerb: "delete", + }) + + const result = await config.api.query.execute(query._id!) + + expect(result.data).toEqual([ + { + deleted: true, + }, + ]) + }) }) describe("delete", () => { @@ -351,29 +394,8 @@ describe("/queries", () => { }, ]) - await withConnection(async connection => { - const [rows] = await connection.query( - "SELECT * FROM test_table WHERE id = 1" - ) - expect(rows).toHaveLength(0) - }) - }) - - it("should be able to execute a delete that deletes no rows", async () => { - const query = await createQuery({ - fields: { - sql: "DELETE FROM test_table WHERE id = 100", - }, - queryVerb: "delete", - }) - - const result = await config.api.query.execute(query._id!) - - expect(result.data).toEqual([ - { - deleted: true, - }, - ]) + const rows = await rawQuery("SELECT * FROM test_table WHERE id = 1") + expect(rows).toHaveLength(0) }) }) }) diff --git a/packages/server/src/api/routes/tests/queries/postgres.spec.ts b/packages/server/src/api/routes/tests/queries/postgres.spec.ts deleted file mode 100644 index fd6a2b7d3c..0000000000 --- a/packages/server/src/api/routes/tests/queries/postgres.spec.ts +++ /dev/null @@ -1,243 +0,0 @@ -import { Datasource, Query } from "@budibase/types" -import * as setup from "../utilities" -import { databaseTestProviders } from "../../../../integrations/tests/utils" -import { Client } from "pg" - -jest.unmock("pg") - -const createTableSQL = ` -CREATE TABLE test_table ( - id serial PRIMARY KEY, - name VARCHAR ( 50 ) NOT NULL -); -` - -const insertSQL = ` -INSERT INTO test_table (name) VALUES ('one'); -INSERT INTO test_table (name) VALUES ('two'); -INSERT INTO test_table (name) VALUES ('three'); -INSERT INTO test_table (name) VALUES ('four'); -INSERT INTO test_table (name) VALUES ('five'); -` - -const dropTableSQL = ` -DROP TABLE test_table; -` - -describe("/queries", () => { - let config = setup.getConfig() - let datasource: Datasource - - async function createQuery(query: Partial): Promise { - const defaultQuery: Query = { - datasourceId: datasource._id!, - name: "New Query", - parameters: [], - fields: {}, - schema: {}, - queryVerb: "read", - transformer: "return data", - readable: true, - } - return await config.api.query.create({ ...defaultQuery, ...query }) - } - - async function withClient( - callback: (client: Client) => Promise - ): Promise { - const ds = await databaseTestProviders.postgres.datasource() - const client = new Client(ds.config!) - await client.connect() - try { - await callback(client) - } finally { - await client.end() - } - } - - afterAll(async () => { - await databaseTestProviders.postgres.stop() - setup.afterAll() - }) - - beforeAll(async () => { - await config.init() - datasource = await config.api.datasource.create( - await databaseTestProviders.postgres.datasource() - ) - }) - - beforeEach(async () => { - await withClient(async client => { - await client.query(createTableSQL) - await client.query(insertSQL) - }) - }) - - afterEach(async () => { - await withClient(async client => { - await client.query(dropTableSQL) - }) - }) - - it("should execute a query", async () => { - const query = await createQuery({ - fields: { - sql: "SELECT * FROM test_table ORDER BY id", - }, - }) - - const result = await config.api.query.execute(query._id!) - - expect(result.data).toEqual([ - { - id: 1, - name: "one", - }, - { - id: 2, - name: "two", - }, - { - id: 3, - name: "three", - }, - { - id: 4, - name: "four", - }, - { - id: 5, - name: "five", - }, - ]) - }) - - it("should be able to transform a query", async () => { - const query = await createQuery({ - fields: { - sql: "SELECT * FROM test_table WHERE id = 1", - }, - transformer: ` - data[0].id = data[0].id + 1; - return data; - `, - }) - - const result = await config.api.query.execute(query._id!) - - expect(result.data).toEqual([ - { - id: 2, - name: "one", - }, - ]) - }) - - it("should be able to insert with bindings", async () => { - const query = await createQuery({ - fields: { - sql: "INSERT INTO test_table (name) VALUES ({{ foo }})", - }, - parameters: [ - { - name: "foo", - default: "bar", - }, - ], - queryVerb: "create", - }) - - const result = await config.api.query.execute(query._id!, { - parameters: { - foo: "baz", - }, - }) - - expect(result.data).toEqual([ - { - created: true, - }, - ]) - - await withClient(async client => { - const { rows } = await client.query( - "SELECT * FROM test_table WHERE name = 'baz'" - ) - expect(rows).toHaveLength(1) - }) - }) - - it("should be able to update rows", async () => { - const query = await createQuery({ - fields: { - sql: "UPDATE test_table SET name = {{ name }} WHERE id = {{ id }}", - }, - parameters: [ - { - name: "id", - default: "", - }, - { - name: "name", - default: "updated", - }, - ], - queryVerb: "update", - }) - - const result = await config.api.query.execute(query._id!, { - parameters: { - id: "1", - name: "foo", - }, - }) - - expect(result.data).toEqual([ - { - updated: true, - }, - ]) - - await withClient(async client => { - const { rows } = await client.query( - "SELECT * FROM test_table WHERE id = 1" - ) - expect(rows).toEqual([{ id: 1, name: "foo" }]) - }) - }) - - it("should be able to delete rows", async () => { - const query = await createQuery({ - fields: { - sql: "DELETE FROM test_table WHERE id = {{ id }}", - }, - parameters: [ - { - name: "id", - default: "", - }, - ], - queryVerb: "delete", - }) - - const result = await config.api.query.execute(query._id!, { - parameters: { - id: "1", - }, - }) - - expect(result.data).toEqual([ - { - deleted: true, - }, - ]) - - await withClient(async client => { - const { rows } = await client.query( - "SELECT * FROM test_table WHERE id = 1" - ) - expect(rows).toHaveLength(0) - }) - }) -}) diff --git a/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts b/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts deleted file mode 100644 index eaaa79f7c9..0000000000 --- a/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts +++ /dev/null @@ -1,57 +0,0 @@ -import { default as MSSQLIntegration } from "../microsoftSqlServer" - -jest.mock("mssql") - -class TestConfiguration { - integration: any - - constructor(config: any = {}) { - this.integration = new MSSQLIntegration.integration(config) - } -} - -describe("MS SQL Server Integration", () => { - let config: any - - beforeEach(async () => { - config = new TestConfiguration() - }) - - describe("check sql used", () => { - beforeEach(async () => { - await config.integration.connect() - }) - - it("calls the create method with the correct params", async () => { - const sql = "insert into users (name, age) values ('Joe', 123);" - const response = await config.integration.create({ - sql, - }) - expect(config.integration.client.request).toHaveBeenCalledWith() - expect(response[0]).toEqual(sql) - }) - - it("calls the read method with the correct params", async () => { - const sql = "select * from users;" - const response = await config.integration.read({ - sql, - }) - expect(config.integration.client.request).toHaveBeenCalledWith() - expect(response[0]).toEqual(sql) - }) - }) - - describe("no rows returned", () => { - beforeEach(async () => { - await config.integration.connect() - }) - - it("returns the correct response when the create response has no rows", async () => { - const sql = "insert into users (name, age) values ('Joe', 123);" - const response = await config.integration.create({ - sql, - }) - expect(response[0]).toEqual(sql) - }) - }) -}) diff --git a/packages/server/src/integrations/tests/postgres.spec.ts b/packages/server/src/integrations/tests/postgres.spec.ts deleted file mode 100644 index cbce86acd0..0000000000 --- a/packages/server/src/integrations/tests/postgres.spec.ts +++ /dev/null @@ -1,83 +0,0 @@ -const pg = require("pg") - -import { default as PostgresIntegration } from "../postgres" - -jest.mock("pg") - -class TestConfiguration { - integration: any - - constructor(config: any = {}) { - this.integration = new PostgresIntegration.integration(config) - } -} - -describe("Postgres Integration", () => { - let config: any - - beforeEach(() => { - config = new TestConfiguration() - }) - - it("calls the create method with the correct params", async () => { - const sql = "insert into users (name, age) values ('Joe', 123);" - await config.integration.create({ - sql, - }) - expect(pg.queryMock).toHaveBeenCalledWith(sql, []) - }) - - it("calls the read method with the correct params", async () => { - const sql = "select * from users;" - await config.integration.read({ - sql, - }) - expect(pg.queryMock).toHaveBeenCalledWith(sql, []) - }) - - it("calls the update method with the correct params", async () => { - const sql = "update table users set name = 'test';" - await config.integration.update({ - sql, - }) - expect(pg.queryMock).toHaveBeenCalledWith(sql, []) - }) - - it("calls the delete method with the correct params", async () => { - const sql = "delete from users where name = 'todelete';" - await config.integration.delete({ - sql, - }) - expect(pg.queryMock).toHaveBeenCalledWith(sql, []) - }) - - describe("no rows returned", () => { - beforeEach(() => { - pg.queryMock.mockImplementation(() => ({ rows: [] })) - }) - - it("returns the correct response when the create response has no rows", async () => { - const sql = "insert into users (name, age) values ('Joe', 123);" - const response = await config.integration.create({ - sql, - }) - expect(response).toEqual([{ created: true }]) - }) - - it("returns the correct response when the update response has no rows", async () => { - const sql = "update table users set name = 'test';" - const response = await config.integration.update({ - sql, - }) - expect(response).toEqual([{ updated: true }]) - }) - - it("returns the correct response when the delete response has no rows", async () => { - const sql = "delete from users where name = 'todelete';" - const response = await config.integration.delete({ - sql, - }) - expect(response).toEqual([{ deleted: true }]) - }) - }) -}) diff --git a/packages/server/src/integrations/tests/utils/mssql.ts b/packages/server/src/integrations/tests/utils/mssql.ts index f548f0c42c..6bd4290a90 100644 --- a/packages/server/src/integrations/tests/utils/mssql.ts +++ b/packages/server/src/integrations/tests/utils/mssql.ts @@ -41,6 +41,9 @@ export async function datasource(): Promise { port, user: "sa", password: "Password_123", + options: { + encrypt: false, + }, }, } } From a6d38401414953a72ee42b0bd40826ea7a256cfa Mon Sep 17 00:00:00 2001 From: Adria Navarro Date: Thu, 21 Mar 2024 11:28:06 +0100 Subject: [PATCH 5/7] Fix bundling --- packages/string-templates/src/helpers/list.ts | 39 ++++++++++++------- 1 file changed, 26 insertions(+), 13 deletions(-) diff --git a/packages/string-templates/src/helpers/list.ts b/packages/string-templates/src/helpers/list.ts index 361558e04d..082d0e255b 100644 --- a/packages/string-templates/src/helpers/list.ts +++ b/packages/string-templates/src/helpers/list.ts @@ -1,17 +1,30 @@ import { date, duration } from "./date" +import { + math, + array, + number, + url, + string, + comparison, + object, + regex, + uuid, + // @ts-expect-error +} from "@budibase/handlebars-helpers" + // https://github.com/evanw/esbuild/issues/56 -const getExternalCollections = (): Record any> => ({ - math: require("@budibase/handlebars-helpers/lib/math"), - array: require("@budibase/handlebars-helpers/lib/array"), - number: require("@budibase/handlebars-helpers/lib/number"), - url: require("@budibase/handlebars-helpers/lib/url"), - string: require("@budibase/handlebars-helpers/lib/string"), - comparison: require("@budibase/handlebars-helpers/lib/comparison"), - object: require("@budibase/handlebars-helpers/lib/object"), - regex: require("@budibase/handlebars-helpers/lib/regex"), - uuid: require("@budibase/handlebars-helpers/lib/uuid"), -}) +const externalCollections = { + math, + array, + number, + url, + string, + comparison, + object, + regex, + uuid, +} export const helpersToRemoveForJs = ["sortBy"] @@ -28,8 +41,8 @@ export function getJsHelperList() { } helpers = {} - for (let collection of Object.values(getExternalCollections())) { - for (let [key, func] of Object.entries(collection)) { + for (let collection of Object.values(externalCollections)) { + for (let [key, func] of Object.entries(collection)) { // Handlebars injects the hbs options to the helpers by default. We are adding an empty {} as a last parameter to simulate it helpers[key] = (...props: any) => func(...props, {}) } From 1a8510358b80835809eea3529c0519c51cc28690 Mon Sep 17 00:00:00 2001 From: Adria Navarro Date: Thu, 21 Mar 2024 11:43:50 +0100 Subject: [PATCH 6/7] Fix test --- packages/string-templates/src/helpers/list.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/string-templates/src/helpers/list.ts b/packages/string-templates/src/helpers/list.ts index 082d0e255b..5852bc9127 100644 --- a/packages/string-templates/src/helpers/list.ts +++ b/packages/string-templates/src/helpers/list.ts @@ -42,7 +42,7 @@ export function getJsHelperList() { helpers = {} for (let collection of Object.values(externalCollections)) { - for (let [key, func] of Object.entries(collection)) { + for (let [key, func] of Object.entries(collection())) { // Handlebars injects the hbs options to the helpers by default. We are adding an empty {} as a last parameter to simulate it helpers[key] = (...props: any) => func(...props, {}) } From 08cf877565ee8f46a62b538af7a9340e93460049 Mon Sep 17 00:00:00 2001 From: Budibase Staging Release Bot <> Date: Thu, 21 Mar 2024 11:02:04 +0000 Subject: [PATCH 7/7] Bump version to 2.22.8 --- lerna.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lerna.json b/lerna.json index 3a92bc6d9a..ec64523dff 100644 --- a/lerna.json +++ b/lerna.json @@ -1,5 +1,5 @@ { - "version": "2.22.7", + "version": "2.22.8", "npmClient": "yarn", "packages": [ "packages/*",