@budibase/server 2.1.46-alpha.0 → 2.1.46-alpha.10

package/src/automations/tests/bash.spec.js

@@ -0,0 +1,34 @@
+const setup = require("./utilities")
+
+describe("test the bash action", () => {
+    let config = setup.getConfig()
+
+    beforeEach(async () => {
+        await config.init()
+    })
+    afterAll(setup.afterAll)
+
+    it("should be able to execute a script", async () => {
+
+        let res = await setup.runStep("EXECUTE_BASH",
+            inputs = {
+                code: "echo 'test'"
+            }
+
+        )
+        expect(res.stdout).toEqual("test\n")
+        expect(res.success).toEqual(true)
+    })
+
+    it("should handle a null value", async () => {
+
+        let res = await setup.runStep("EXECUTE_BASH",
+            inputs = {
+                code: null
+            }
+
+
+        )
+        expect(res.stdout).toEqual("Budibase bash automation failed: Invalid inputs")
+    })
+})

package/src/automations/tests/discord.spec.js

@@ -0,0 +1,27 @@
+const setup = require("./utilities")
+const fetch = require("node-fetch")
+
+jest.mock("node-fetch")
+
+describe("test the outgoing webhook action", () => {
+    let inputs
+    let config = setup.getConfig()
+
+    beforeEach(async () => {
+        await config.init()
+        inputs = {
+            username: "joe_bloggs",
+            url: "http://www.test.com",
+        }
+    })
+
+    afterAll(setup.afterAll)
+
+    it("should be able to run the action", async () => {
+        const res = await setup.runStep(setup.actions.discord.stepId, inputs)
+        expect(res.response.url).toEqual("http://www.test.com")
+        expect(res.response.method).toEqual("post")
+        expect(res.success).toEqual(true)
+    })
+
+})

package/src/automations/tests/executeQuery.spec.js

@@ -0,0 +1,49 @@
+const setup = require("./utilities")
+
+describe("test the execute query action", () => {
+    let datasource
+    let config = setup.getConfig()
+
+    beforeEach(async () => {
+        await config.init()
+
+        await config.createDatasource()
+        query = await config.createQuery()
+
+    })
+
+    afterAll(setup.afterAll)
+
+    it("should be able to execute a query", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: { queryId: query._id }
+            }
+        )
+        expect(res.response).toEqual([{ a: 'string', b: 1 }])
+        expect(res.success).toEqual(true)
+    })
+
+    it("should handle a null query value", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: null
+            }
+        )
+        expect(res.response.message).toEqual("Invalid inputs")
+        expect(res.success).toEqual(false)
+    })
+
+
+    it("should handle an error executing a query", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: { queryId: "wrong_id" }
+            }
+        )
+        expect(res.response).toEqual('{"status":404,"name":"not_found","message":"missing","reason":"missing"}')
+        expect(res.success).toEqual(false)
+    })
+
+
+})

package/src/automations/tests/executeScript.spec.js

@@ -0,0 +1,48 @@
+const setup = require("./utilities")
+
+describe("test the execute script action", () => {
+    let config = setup.getConfig()
+
+    beforeEach(async () => {
+        await config.init()
+    })
+    afterAll(setup.afterAll)
+
+    it("should be able to execute a script", async () => {
+
+        let res = await setup.runStep(setup.actions.EXECUTE_SCRIPT.stepId,
+            inputs = {
+                code: "return 1 + 1"
+            }
+
+        )
+        expect(res.value).toEqual(2)
+        expect(res.success).toEqual(true)
+    })
+
+    it("should handle a null value", async () => {
+
+        let res = await setup.runStep(setup.actions.EXECUTE_SCRIPT.stepId,
+            inputs = {
+                code: null
+            }
+
+
+        )
+        expect(res.response.message).toEqual("Invalid inputs")
+        expect(res.success).toEqual(false)
+    })
+
+    it("should be able to handle an error gracefully", async () => {
+
+        let res = await setup.runStep(setup.actions.EXECUTE_SCRIPT.stepId,
+            inputs = {
+                code: "return something.map(x => x.name)"
+            }
+
+        )
+        expect(res.response).toEqual("ReferenceError: something is not defined")
+        expect(res.success).toEqual(false)
+    })
+
+})

package/src/automations/tests/sendSmtpEmail.spec.js

@@ -0,0 +1,71 @@
+
+function generateResponse(to, from) {
+    return {
+        "success": true,
+        "response": {
+            "accepted": [
+                to
+            ],
+            "envelope": {
+                "from": from,
+                "to": [
+                    to
+                ]
+            },
+            "message": `Email sent to ${to}.`
+        }
+
+    }
+}
+
+const mockFetch = jest.fn(() => ({
+    headers: {
+        raw: () => {
+            return { "content-type": ["application/json"] }
+        },
+        get: () => ["application/json"],
+    },
+    json: jest.fn(() => response),
+    status: 200,
+    text: jest.fn(),
+}))
+jest.mock("node-fetch", () => mockFetch)
+const setup = require("./utilities")
+
+
+describe("test the outgoing webhook action", () => {
+    let inputs
+    let config = setup.getConfig()
+    beforeEach(async () => {
+        await config.init()
+    })
+
+    afterAll(setup.afterAll)
+
+    it("should be able to run the action", async () => {
+        inputs = {
+            to: "user1@test.com",
+            from: "admin@test.com",
+            subject: "hello",
+            contents: "testing",
+        }
+        let resp = generateResponse(inputs.to, inputs.from)
+        mockFetch.mockImplementationOnce(() => ({
+            headers: {
+                raw: () => {
+                    return { "content-type": ["application/json"] }
+                },
+                get: () => ["application/json"],
+            },
+            json: jest.fn(() => resp),
+            status: 200,
+            text: jest.fn(),
+        }))
+        const res = await setup.runStep(setup.actions.SEND_EMAIL_SMTP.stepId, inputs)
+        expect(res.response).toEqual(resp)
+        expect(res.success).toEqual(true)
+
+    })
+
+
+})

package/src/automations/tests/serverLog.spec.js

@@ -0,0 +1,22 @@
+const setup = require("./utilities")
+
+describe("test the server log action", () => {
+    let config = setup.getConfig()
+
+    beforeEach(async () => {
+        await config.init()
+        inputs = {
+            text: "log message",
+        }
+    })
+    afterAll(setup.afterAll)
+
+    it("should be able to log the text", async () => {
+
+        let res = await setup.runStep(setup.actions.SERVER_LOG.stepId,
+            inputs
+        )
+        expect(res.message).toEqual(`App ${config.getAppId()} - ${inputs.text}`)
+        expect(res.success).toEqual(true)
+    })
+})

package/src/automations/tests/utilities/index.ts

@@ -31,7 +31,7 @@ export async function runInProd(fn: any) {
   }
 }
 
-export async function runStep(stepId: string, inputs: any) {
+export async function runStep(stepId: string, inputs: any, stepContext?: any) {
   async function run() {
     let step = await getAction(stepId)
     expect(step).toBeDefined()
@@ -39,7 +39,7 @@ export async function runStep(stepId: string, inputs: any) {
       throw new Error("No step found")
     }
     return step({
-      context: {},
+      context: stepContext || {},
       inputs,
       appId: config ? config.getAppId() : null,
       // don't really need an API key, mocked out usage quota, not being tested here

package/src/automations/tests/zapier.spec.js

@@ -0,0 +1,27 @@
+const setup = require("./utilities")
+const fetch = require("node-fetch")
+
+jest.mock("node-fetch")
+
+describe("test the outgoing webhook action", () => {
+    let inputs
+    let config = setup.getConfig()
+
+    beforeEach(async () => {
+        await config.init()
+        inputs = {
+            value1: "test",
+            url: "http://www.test.com",
+        }
+    })
+
+    afterAll(setup.afterAll)
+
+    it("should be able to run the action", async () => {
+        const res = await setup.runStep(setup.actions.zapier.stepId, inputs)
+        expect(res.response.url).toEqual("http://www.test.com")
+        expect(res.response.method).toEqual("post")
+        expect(res.success).toEqual(true)
+    })
+
+})

package/src/automations/unitTests/automationUtils.spec.ts

@@ -0,0 +1,65 @@
+const automationUtils = require("../automationUtils")
+
+describe("automationUtils", () => {
+  describe("substituteLoopStep", () => {
+    it("should allow multiple loop binding substitutes", () => {
+      expect(
+        automationUtils.substituteLoopStep(
+          `{{ loop.currentItem._id }} {{ loop.currentItem._id }} {{ loop.currentItem._id }}`,
+          "step.2"
+        )
+      ).toBe(
+        `{{ step.2.currentItem._id }} {{ step.2.currentItem._id }} {{ step.2.currentItem._id }}`
+      )
+    })
+
+    it("should handle not subsituting outside of curly braces", () => {
+      expect(
+        automationUtils.substituteLoopStep(
+          `loop {{ loop.currentItem._id }}loop loop{{ loop.currentItem._id }}loop`,
+          "step.2"
+        )
+      ).toBe(
+        `loop {{ step.2.currentItem._id }}loop loop{{ step.2.currentItem._id }}loop`
+      )
+    })
+  })
+
+  describe("typeCastForLooping", () => {
+    it("should parse to correct type", () => {
+      expect(
+        automationUtils.typecastForLooping(
+          { inputs: { option: "Array" } },
+          { binding: [1, 2, 3] }
+        )
+      ).toEqual([1, 2, 3])
+      expect(
+        automationUtils.typecastForLooping(
+          { inputs: { option: "Array" } },
+          { binding: "[1, 2, 3]" }
+        )
+      ).toEqual([1, 2, 3])
+      expect(
+        automationUtils.typecastForLooping(
+          { inputs: { option: "String" } },
+          { binding: [1, 2, 3] }
+        )
+      ).toEqual("1,2,3")
+    })
+    it("should handle null values", () => {
+      // expect it to handle where the binding is null
+      expect(
+        automationUtils.typecastForLooping(
+          { inputs: { option: "Array" } },
+          { binding: null }
+        )
+      ).toEqual(null)
+      expect(() =>
+        automationUtils.typecastForLooping(
+          { inputs: { option: "Array" } },
+          { binding: "test" }
+        )
+      ).toThrow()
+    })
+  })
+})

package/src/tests/utilities/TestConfiguration.ts

@@ -1,3 +1,12 @@
+import { mocks } from "@budibase/backend-core/tests"
+
+// init the licensing mock
+import * as pro from "@budibase/pro"
+mocks.licenses.init(pro)
+
+// use unlimited license by default
+mocks.licenses.useUnlimited()
+
 import { init as dbInit } from "../../db"
 dbInit()
 import env from "../../environment"

package/src/threads/automation.ts

@@ -32,31 +32,8 @@ const LOOP_STEP_ID = actions.ACTION_DEFINITIONS.LOOP.stepId
 const CRON_STEP_ID = triggerDefs.CRON.stepId
 const STOPPED_STATUS = { success: true, status: AutomationStatus.STOPPED }
 
-function typecastForLooping(loopStep: LoopStep, input: LoopInput) {
-  if (!input || !input.binding) {
-    return null
-  }
-  try {
-    switch (loopStep.inputs.option) {
-      case LoopStepType.ARRAY:
-        if (typeof input.binding === "string") {
-          return JSON.parse(input.binding)
-        }
-        break
-      case LoopStepType.STRING:
-        if (Array.isArray(input.binding)) {
-          return input.binding.join(",")
-        }
-        break
-    }
-  } catch (err) {
-    throw new Error("Unable to cast to correct type")
-  }
-  return input.binding
-}
-
 function getLoopIterations(loopStep: LoopStep, input: LoopInput) {
-  const binding = typecastForLooping(loopStep, input)
+  const binding = automationUtils.typecastForLooping(loopStep, input)
   if (!loopStep || !binding) {
     return 1
   }
@@ -289,7 +266,7 @@ class Orchestrator {
 
           let tempOutput = { items: loopSteps, iterations: iterationCount }
           try {
-            newInput.binding = typecastForLooping(
+            newInput.binding = automationUtils.typecastForLooping(
               loopStep as LoopStep,
               newInput
             )

package/src/utilities/rowProcessor/tests/utils.spec.ts

@@ -0,0 +1,57 @@
+import { fixAutoColumnSubType } from "../utils"
+import { AutoFieldDefaultNames, AutoFieldSubTypes } from "../../../constants"
+
+describe("rowProcessor utility", () => {
+  describe("fixAutoColumnSubType", () => {
+    let schema = {
+      name: "",
+      type: "link",
+      subtype: "", // missing subtype
+      icon: "ri-magic-line",
+      autocolumn: true,
+      constraints: { type: "array", presence: false },
+      tableId: "ta_users",
+      fieldName: "test-Updated By",
+      relationshipType: "many-to-many",
+      sortable: false,
+    }
+
+    it("updates the schema with the correct subtype", async () => {
+      schema.name = AutoFieldDefaultNames.CREATED_BY
+      expect(fixAutoColumnSubType(schema).subtype).toEqual(
+        AutoFieldSubTypes.CREATED_BY
+      )
+      schema.subtype = ""
+
+      schema.name = AutoFieldDefaultNames.UPDATED_BY
+      expect(fixAutoColumnSubType(schema).subtype).toEqual(
+        AutoFieldSubTypes.UPDATED_BY
+      )
+      schema.subtype = ""
+
+      schema.name = AutoFieldDefaultNames.CREATED_AT
+      expect(fixAutoColumnSubType(schema).subtype).toEqual(
+        AutoFieldSubTypes.CREATED_AT
+      )
+      schema.subtype = ""
+
+      schema.name = AutoFieldDefaultNames.UPDATED_AT
+      expect(fixAutoColumnSubType(schema).subtype).toEqual(
+        AutoFieldSubTypes.UPDATED_AT
+      )
+      schema.subtype = ""
+
+      schema.name = AutoFieldDefaultNames.AUTO_ID
+      expect(fixAutoColumnSubType(schema).subtype).toEqual(
+        AutoFieldSubTypes.AUTO_ID
+      )
+      schema.subtype = ""
+    })
+
+    it("returns the column if subtype exists", async () => {
+      schema.subtype = AutoFieldSubTypes.CREATED_BY
+      schema.name = AutoFieldDefaultNames.CREATED_AT
+      expect(fixAutoColumnSubType(schema)).toEqual(schema)
+    })
+  })
+})

package/src/utilities/tests/plugins.spec.ts

@@ -0,0 +1,23 @@
+import { enrichPluginURLs } from "../plugins"
+const env = require("../../environment")
+jest.mock("../../environment")
+
+describe("plugins utility", () => {
+  let pluginsArray: any = [
+    {
+      name: "test-plugin",
+    },
+  ]
+  it("enriches the plugins url self-hosted", async () => {
+    let result = enrichPluginURLs(pluginsArray)
+    expect(result[0].jsUrl).toEqual("/plugins/test-plugin/plugin.min.js")
+  })
+
+  it("enriches the plugins url cloud", async () => {
+    env.SELF_HOSTED = 0
+    let result = enrichPluginURLs(pluginsArray)
+    expect(result[0].jsUrl).toEqual(
+      "https://cdn.budi.live/test-plugin/plugin.min.js"
+    )
+  })
+})

package/tsconfig.build.json

@@ -19,6 +19,8 @@
     "node_modules",
     "dist",
     "src/tests",
+    "src/api/routes/tests/utilities",
+    "src/automations/tests/utilities",
     "**/*.spec.ts",
     "**/*.spec.js"
   ]