@budibase/server 0.0.32 → 0.0.999-alpha.30

package/src/api/routes/tests/screen.spec.js

@@ -0,0 +1,103 @@
+const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
+const setup = require("./utilities")
+const { basicScreen } = setup.structures
+const { events } = require("@budibase/backend-core")
+
+describe("/screens", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+  let screen
+
+  afterAll(setup.afterAll)
+
+  beforeAll(async () => {
+    await config.init()
+    screen = await config.createScreen()
+  })
+
+  describe("fetch", () => {
+    it("should be able to create a layout", async () => {
+      const res = await request
+        .get(`/api/screens`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body.length).toEqual(1)
+      expect(res.body.some(s => s._id === screen._id)).toEqual(true)
+    })
+
+    it("should apply authorization to endpoint", async () => {
+      await checkBuilderEndpoint({
+        config,
+        method: "GET",
+        url: `/api/screens`,
+      })
+    })
+  })
+
+  describe("save", () => {
+    const saveScreen = async (screen) => {
+      const res = await request
+        .post(`/api/screens`)
+        .send(screen)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      return res
+    }
+
+    it("should be able to create a screen", async () => {
+      jest.clearAllMocks()
+
+      const screen = basicScreen()
+      const res = await saveScreen(screen)
+
+      expect(res.body._rev).toBeDefined()
+      expect(res.body.name).toEqual(screen.name)
+      expect(events.screen.created).toBeCalledTimes(1)
+    })
+
+    it("should be able to update a screen", async () => {
+      const screen = basicScreen()
+      let res = await saveScreen(screen)
+      screen._id = res.body._id
+      screen._rev = res.body._rev
+      screen.name = "edit"
+      jest.clearAllMocks()
+
+      res = await saveScreen(screen)
+
+      expect(res.body._rev).toBeDefined()
+      expect(res.body.name).toEqual(screen.name)
+      expect(events.screen.created).not.toBeCalled()
+    })
+
+    it("should apply authorization to endpoint", async () => {
+      await checkBuilderEndpoint({
+        config,
+        method: "POST",
+        url: `/api/screens`,
+      })
+    })
+  })
+
+  describe("destroy", () => {
+    it("should be able to delete the screen", async () => {
+      const res = await request
+        .delete(`/api/screens/${screen._id}/${screen._rev}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body.message).toBeDefined()
+      expect(events.screen.deleted).toBeCalledTimes(1)
+    })
+
+    it("should apply authorization to endpoint", async () => {
+      await checkBuilderEndpoint({
+        config,
+        method: "DELETE",
+        url: `/api/screens/${screen._id}/${screen._rev}`,
+      })
+    })
+  })
+})

package/src/api/routes/tests/static.spec.js

@@ -0,0 +1,140 @@
+const setup = require("./utilities")
+const { constants } = require("@budibase/backend-core")
+
+describe("/static", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+  let app
+
+  afterAll(setup.afterAll)
+
+  beforeAll(async () => {
+    config.modeSelf()
+    app = await config.init()
+  })
+
+  describe("/app", () => {
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    it("should serve the app by id", async () => {
+      const headers = config.defaultHeaders()
+      delete headers[constants.Header.APP_ID]
+
+      const res = await request
+        .get(`/${config.prodAppId}`)
+        .set(headers)
+        .expect(200)
+
+      expect(res.body.appId).toBe(config.prodAppId)
+    })
+
+    it("should serve the app by url", async () => {
+      const headers = config.defaultHeaders()
+      delete headers[constants.Header.APP_ID]
+
+      const res = await request
+        .get(`/app${config.prodApp.url}`)
+        .set(headers)
+        .expect(200)
+
+      expect(res.body.appId).toBe(config.prodAppId)
+    })
+
+    it("should serve the app preview by id", async () => {
+      const res = await request
+        .get(`/${config.appId}`)
+        .set(config.defaultHeaders())
+        .expect(200)
+
+      expect(res.body.appId).toBe(config.appId)
+    })
+  })
+
+  describe("/attachments", () => {
+    describe("generateSignedUrls", () => {
+      let datasource
+
+      beforeEach(async () => {
+        datasource = await config.createDatasource({
+          datasource: {
+            type: "datasource",
+            name: "Test",
+            source: "S3",
+            config: {},
+          },
+        })
+      })
+
+      it("should be able to generate a signed upload URL", async () => {
+        const bucket = "foo"
+        const key = "bar"
+        const res = await request
+          .post(`/api/attachments/${datasource._id}/url`)
+          .send({ bucket, key })
+          .set(config.defaultHeaders())
+          .expect("Content-Type", /json/)
+          .expect(200)
+        expect(res.body.signedUrl).toEqual("http://test.com/foo/bar")
+        expect(res.body.publicUrl).toEqual(
+          `https://${bucket}.s3.eu-west-1.amazonaws.com/${key}`
+        )
+      })
+
+      it("should handle an invalid datasource ID", async () => {
+        const res = await request
+          .post(`/api/attachments/foo/url`)
+          .send({
+            bucket: "foo",
+            key: "bar",
+          })
+          .set(config.defaultHeaders())
+          .expect("Content-Type", /json/)
+          .expect(400)
+        expect(res.body.message).toEqual(
+          "The specified datasource could not be found"
+        )
+      })
+
+      it("should require a bucket parameter", async () => {
+        const res = await request
+          .post(`/api/attachments/${datasource._id}/url`)
+          .send({
+            bucket: undefined,
+            key: "bar",
+          })
+          .set(config.defaultHeaders())
+          .expect("Content-Type", /json/)
+          .expect(400)
+        expect(res.body.message).toEqual("bucket and key values are required")
+      })
+
+      it("should require a key parameter", async () => {
+        const res = await request
+          .post(`/api/attachments/${datasource._id}/url`)
+          .send({
+            bucket: "foo",
+          })
+          .set(config.defaultHeaders())
+          .expect("Content-Type", /json/)
+          .expect(400)
+        expect(res.body.message).toEqual("bucket and key values are required")
+      })
+    })
+  })
+
+  describe("/app/preview", () => {
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    it("should serve the builder preview", async () => {
+      const headers = config.defaultHeaders()
+      const res = await request.get(`/app/preview`).set(headers).expect(200)
+
+      expect(res.body.appId).toBe(config.appId)
+      expect(res.body.builderPreview).toBe(true)
+    })
+  })
+})

package/src/api/routes/tests/table.spec.js

@@ -0,0 +1,302 @@
+const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
+const setup = require("./utilities")
+const { basicTable } = setup.structures
+const { events, context } = require("@budibase/backend-core")
+
+describe("/tables", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+  let appId
+
+  afterAll(setup.afterAll)
+
+  beforeAll(async () => {
+    const app = await config.init()
+    appId = app.appId
+  })
+
+  describe("create", () => {
+
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    const createTable = (table) => {
+      if (!table) {
+        table = basicTable()
+      }
+      return request
+        .post(`/api/tables`)
+        .send(table)
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+
+    }
+
+    it("returns a success message when the table is successfully created", async () => {
+      const res = await createTable()
+
+      expect(res.res.statusMessage).toEqual("Table TestTable saved successfully.")
+      expect(res.body.name).toEqual("TestTable")
+      expect(events.table.created).toBeCalledTimes(1)
+      expect(events.table.created).toBeCalledWith(res.body)
+    })
+
+    it("creates a table via data import", async () => {
+      const table = basicTable()
+      table.rows = [{ name: 'test-name', description: 'test-desc' }]
+
+      const res = await createTable(table)
+
+      expect(events.table.created).toBeCalledTimes(1)
+      expect(events.table.created).toBeCalledWith(res.body)
+      expect(events.table.imported).toBeCalledTimes(1)
+      expect(events.table.imported).toBeCalledWith(res.body)
+      expect(events.rows.imported).toBeCalledTimes(1)
+      expect(events.rows.imported).toBeCalledWith(res.body, 1)
+    })
+
+    it("should apply authorization to endpoint", async () => {
+      await checkBuilderEndpoint({
+        config,
+        method: "POST",
+        url: `/api/tables`,
+        body: basicTable()
+      })
+    })
+  })
+
+  describe("update", () => {
+    it("updates a table", async () => {
+      const testTable = await config.createTable()
+
+      const res = await request
+        .post(`/api/tables`)
+        .send(testTable)
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+
+      expect(events.table.updated).toBeCalledTimes(1)
+      expect(events.table.updated).toBeCalledWith(res.body)
+    })
+
+    it("updates all the row fields for a table when a schema key is renamed", async () => {
+      const testTable = await config.createTable()
+      await config.createView({
+        name: "TestView",
+        field: "Price",
+        calculation: "stats",
+        tableId: testTable._id,
+      })
+
+      const testRow = await request
+        .post(`/api/${testTable._id}/rows`)
+        .send({
+          name: "test"
+        })
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+
+      const updatedTable = await request
+        .post(`/api/tables`)
+        .send({
+          _id: testTable._id,
+          _rev: testTable._rev,
+          name: "TestTable",
+          key: "name",
+          _rename: {
+            old: "name",
+            updated: "updatedName"
+          },
+          schema: {
+            updatedName: { type: "string" }
+          }
+        })
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+      expect(updatedTable.res.statusMessage).toEqual("Table TestTable saved successfully.")
+      expect(updatedTable.body.name).toEqual("TestTable")
+
+      const res = await request
+        .get(`/api/${testTable._id}/rows/${testRow.body._id}`)
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+
+      expect(res.body.updatedName).toEqual("test")
+      expect(res.body.name).toBeUndefined()
+    })
+
+    describe("user table", () => {
+      it("should add roleId and email field when adjusting user table schema", async () => {
+        const res = await request
+          .post(`/api/tables`)
+          .send({
+            ...basicTable(),
+            _id: "ta_users",
+          })
+          .set(config.defaultHeaders())
+          .expect('Content-Type', /json/)
+          .expect(200)
+        expect(res.body.schema.email).toBeDefined()
+        expect(res.body.schema.roleId).toBeDefined()
+      })
+    })
+  })
+
+  describe("import", () => {
+    it("imports rows successfully", async () => {
+      const table = await config.createTable()
+      const importRequest = {
+        schema: table.schema,
+        rows: [{ name: 'test-name', description: 'test-desc' }]
+      }
+
+      jest.clearAllMocks()
+
+      await request
+        .post(`/api/tables/${table._id}/import`)
+        .send(importRequest)
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+
+      expect(events.table.created).not.toHaveBeenCalled()
+      expect(events.rows.imported).toBeCalledTimes(1)
+      expect(events.rows.imported).toBeCalledWith(table, 1)
+    })
+  })
+
+  describe("fetch", () => {
+    let testTable
+
+    beforeEach(async () => {
+      testTable = await config.createTable(testTable)
+    })
+
+    afterEach(() => {
+      delete testTable._rev
+    })
+
+    it("returns all the tables for that instance in the response body", async () => {
+      const res = await request
+        .get(`/api/tables`)
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+      const fetchedTable = res.body[0]
+      expect(fetchedTable.name).toEqual(testTable.name)
+      expect(fetchedTable.type).toEqual("internal")
+    })
+
+    it("should apply authorization to endpoint", async () => {
+      await checkBuilderEndpoint({
+        config,
+        method: "GET",
+        url: `/api/tables`,
+      })
+    })
+  })
+
+  describe("indexing", () => {
+    it("should be able to create a table with indexes", async () => {
+      await context.doInAppContext(appId, async () => {
+        const db = context.getAppDB()
+        const indexCount = (await db.getIndexes()).total_rows
+        const table = basicTable()
+        table.indexes = ["name"]
+        const res = await request
+          .post(`/api/tables`)
+          .send(table)
+          .set(config.defaultHeaders())
+          .expect('Content-Type', /json/)
+          .expect(200)
+        expect(res.body._id).toBeDefined()
+        expect(res.body._rev).toBeDefined()
+        expect((await db.getIndexes()).total_rows).toEqual(indexCount + 1)
+        // update index to see what happens
+        table.indexes = ["name", "description"]
+        await request
+          .post(`/api/tables`)
+          .send({
+            ...table,
+            _id: res.body._id,
+            _rev: res.body._rev,
+          })
+          .set(config.defaultHeaders())
+          .expect('Content-Type', /json/)
+          .expect(200)
+        // shouldn't have created a new index
+        expect((await db.getIndexes()).total_rows).toEqual(indexCount + 1)
+      })
+    })
+  })
+
+  describe("destroy", () => {
+    let testTable
+
+    beforeEach(async () => {
+      testTable = await config.createTable(testTable)
+    })
+
+    afterEach(() => {
+      delete testTable._rev
+    })
+
+    it("returns a success response when a table is deleted.", async () => {
+      const res = await request
+        .delete(`/api/tables/${testTable._id}/${testTable._rev}`)
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+      expect(res.body.message).toEqual(`Table ${testTable._id} deleted.`)
+      expect(events.table.deleted).toBeCalledTimes(1)
+      expect(events.table.deleted).toBeCalledWith({ ...testTable, tableId: testTable._id })
+    })
+
+    it("deletes linked references to the table after deletion", async () => {
+      const linkedTable = await config.createTable({
+        name: "LinkedTable",
+        type: "table",
+        key: "name",
+        schema: {
+          name: {
+            type: "string",
+            constraints: {
+              type: "string",
+            },
+          },
+          TestTable: {
+            type: "link",
+            fieldName: "TestTable",
+            tableId: testTable._id,
+            constraints: {
+              type: "array"
+            }
+          }
+        },
+      })
+
+      const res = await request
+        .delete(`/api/tables/${testTable._id}/${testTable._rev}`)
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+      expect(res.body.message).toEqual(`Table ${testTable._id} deleted.`)
+      const dependentTable = await config.getTable(linkedTable._id)
+      expect(dependentTable.schema.TestTable).not.toBeDefined()
+    })
+
+    it("should apply authorization to endpoint", async () => {
+      await checkBuilderEndpoint({
+        config,
+        method: "DELETE",
+        url: `/api/tables/${testTable._id}/${testTable._rev}`,
+      })
+    })
+  })
+})

package/src/api/routes/tests/templates.spec.js

@@ -0,0 +1,24 @@
+const setup = require("./utilities")
+
+describe("/templates", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+
+  afterAll(setup.afterAll)
+
+  beforeAll(async () => {
+    await config.init()
+  })
+
+  describe("fetch", () => {
+    it("should be able to fetch templates", async () => {
+      const res = await request
+        .get(`/api/templates`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      // this test is quite light right now, templates aren't heavily utilised yet
+      expect(Array.isArray(res.body)).toEqual(true)
+    })
+  })
+})