@budibase/worker 2.1.32-alpha.8 → 2.1.33

package/src/api/routes/global/auth.js

@@ -2,6 +2,7 @@ const Router = require("@koa/router")
 const authController = require("../../controllers/global/auth")
 const { joiValidator } = require("@budibase/backend-core/auth")
 const Joi = require("joi")
+const { updateTenantId } = require("@budibase/backend-core/tenancy")
 
 const router = new Router()
 
@@ -28,61 +29,77 @@ function buildResetUpdateValidation() {
   }).required().unknown(false))
 }
 
+function updateTenant(ctx, next) {
+  if (ctx.params) {
+    updateTenantId(ctx.params.tenantId)
+  }
+  return next()
+}
+
 router
-  // PASSWORD
   .post(
     "/api/global/auth/:tenantId/login",
     buildAuthValidation(),
+    updateTenant,
     authController.authenticate
   )
-  .post("/api/global/auth/logout", authController.logout)
   .post(
     "/api/global/auth/:tenantId/reset",
     buildResetValidation(),
+    updateTenant,
     authController.reset
   )
   .post(
     "/api/global/auth/:tenantId/reset/update",
     buildResetUpdateValidation(),
+    updateTenant,
     authController.resetUpdate
   )
-  // INIT
+  .post("/api/global/auth/logout", authController.logout)
   .post("/api/global/auth/init", authController.setInitInfo)
   .get("/api/global/auth/init", authController.getInitInfo)
-
-  // DATASOURCE - MULTI TENANT
+  .get(
+    "/api/global/auth/:tenantId/google",
+    updateTenant,
+    authController.googlePreAuth
+  )
   .get(
     "/api/global/auth/:tenantId/datasource/:provider",
+    updateTenant,
     authController.datasourcePreAuth
   )
+  // single tenancy endpoint
+  .get("/api/global/auth/google/callback", authController.googleAuth)
   .get(
-    "/api/global/auth/:tenantId/datasource/:provider/callback",
+    "/api/global/auth/datasource/:provider/callback",
     authController.datasourceAuth
   )
-
-  // DATASOURCE - SINGLE TENANT - DEPRECATED
+  // multi-tenancy endpoint
   .get(
-    "/api/global/auth/datasource/:provider/callback",
+    "/api/global/auth/:tenantId/google/callback",
+    updateTenant,
+    authController.googleAuth
+  )
+  .get(
+    "/api/global/auth/:tenantId/datasource/:provider/callback",
+    updateTenant,
     authController.datasourceAuth
   )
-
-  // GOOGLE - MULTI TENANT
-  .get("/api/global/auth/:tenantId/google", authController.googlePreAuth)
-  .get("/api/global/auth/:tenantId/google/callback", authController.googleAuth)
-
-  // GOOGLE - SINGLE TENANT - DEPRECATED
-  .get("/api/global/auth/google/callback", authController.googleAuth)
-  .get("/api/admin/auth/google/callback", authController.googleAuth)
-
-  // OIDC - MULTI TENANT
   .get(
     "/api/global/auth/:tenantId/oidc/configs/:configId",
+    updateTenant,
     authController.oidcPreAuth
   )
-  .get("/api/global/auth/:tenantId/oidc/callback", authController.oidcAuth)
-
-  // OIDC - SINGLE TENANT - DEPRECATED
+  // single tenancy endpoint
   .get("/api/global/auth/oidc/callback", authController.oidcAuth)
+  // multi-tenancy endpoint
+  .get(
+    "/api/global/auth/:tenantId/oidc/callback",
+    updateTenant,
+    authController.oidcAuth
+  )
+  // deprecated - used by the default system before tenancy
+  .get("/api/admin/auth/google/callback", authController.googleAuth)
   .get("/api/admin/auth/oidc/callback", authController.oidcAuth)
 
 module.exports = router

package/src/api/routes/global/configs.js

@@ -3,7 +3,7 @@ const controller = require("../../controllers/global/configs")
 const { joiValidator } = require("@budibase/backend-core/auth")
 const { adminOnly } = require("@budibase/backend-core/auth")
 const Joi = require("joi")
-const { Config } = require("@budibase/backend-core/constants")
+const { Configs } = require("../../../constants")
 
 const router = new Router()
 
@@ -65,17 +65,17 @@ function buildConfigSaveValidation() {
     _id: Joi.string().optional(),
     _rev: Joi.string().optional(),
     workspace: Joi.string().optional(),
-    type: Joi.string().valid(...Object.values(Config)).required(),
+    type: Joi.string().valid(...Object.values(Configs)).required(),
     createdAt: Joi.string().optional(),
     updatedAt: Joi.string().optional(),
     config: Joi.alternatives()
       .conditional("type", {
         switch: [
-          { is: Config.SMTP, then: smtpValidation() },
-          { is: Config.SETTINGS, then: settingValidation() },
-          { is: Config.ACCOUNT, then: Joi.object().unknown(true) },
-          { is: Config.GOOGLE, then: googleValidation() },
-          { is: Config.OIDC, then: oidcValidation() }
+          { is: Configs.SMTP, then: smtpValidation() },
+          { is: Configs.SETTINGS, then: settingValidation() },
+          { is: Configs.ACCOUNT, then: Joi.object().unknown(true) },
+          { is: Configs.GOOGLE, then: googleValidation() },
+          { is: Configs.OIDC, then: oidcValidation() }
         ],
       }),
   }).required().unknown(true),
@@ -85,7 +85,7 @@ function buildConfigSaveValidation() {
 function buildUploadValidation() {
   // prettier-ignore
   return joiValidator.params(Joi.object({
-    type: Joi.string().valid(...Object.values(Config)).required(),
+    type: Joi.string().valid(...Object.values(Configs)).required(),
     name: Joi.string().required(),
   }).required().unknown(true))
 }
@@ -93,7 +93,7 @@ function buildUploadValidation() {
 function buildConfigGetValidation() {
   // prettier-ignore
   return joiValidator.params(Joi.object({
-    type: Joi.string().valid(...Object.values(Config)).required()
+    type: Joi.string().valid(...Object.values(Configs)).required()
   }).required().unknown(true))
 }
 

package/src/api/routes/global/templates.ts

@@ -1,6 +1,6 @@
 import Router from "@koa/router"
 import * as controller from "../../controllers/global/templates"
-import { TemplatePurpose, TemplateType } from "../../../constants"
+import { TemplatePurpose, TemplateTypes } from "../../../constants"
 import { auth as authCore } from "@budibase/backend-core"
 import Joi from "joi"
 const { adminOnly, joiValidator } = authCore
@@ -16,7 +16,7 @@ function buildTemplateSaveValidation() {
     name: Joi.string().allow(null, ""),
     contents: Joi.string().required(),
     purpose: Joi.string().required().valid(...Object.values(TemplatePurpose)),
-    type: Joi.string().required().valid(...Object.values(TemplateType)),
+    type: Joi.string().required().valid(...Object.values(TemplateTypes)),
   }).required().unknown(true).optional())
 }
 

package/src/api/routes/global/tests/auth.spec.ts

@@ -1,16 +1,11 @@
 jest.mock("nodemailer")
-import { TestConfiguration, mocks } from "../../../../tests"
+import { TestConfiguration, mocks, API } from "../../../../tests"
 const sendMailMock = mocks.email.mock()
 import { events } from "@budibase/backend-core"
 
-const expectSetAuthCookie = (res: any) => {
-  expect(
-    res.get("Set-Cookie").find((c: string) => c.startsWith("budibase:auth"))
-  ).toBeDefined()
-}
-
 describe("/api/global/auth", () => {
   const config = new TestConfiguration()
+  const api = new API(config)
 
   beforeAll(async () => {
     await config.beforeAll()
@@ -24,155 +19,90 @@ describe("/api/global/auth", () => {
     jest.clearAllMocks()
   })
 
-  describe("password", () => {
-    describe("POST /api/global/auth/:tenantId/login", () => {
-      it("should login", () => {})
-    })
-
-    describe("POST /api/global/auth/logout", () => {
-      it("should logout", async () => {
-        await config.api.auth.logout()
-        expect(events.auth.logout).toBeCalledTimes(1)
-
-        // TODO: Verify sessions deleted
-      })
-    })
-
-    describe("POST /api/global/auth/:tenantId/reset", () => {
-      it("should generate password reset email", async () => {
-        const { res, code } = await config.api.auth.requestPasswordReset(
-          sendMailMock
-        )
-        const user = await config.getUser("test@test.com")
-
-        expect(res.body).toEqual({
-          message: "Please check your email for a reset link.",
-        })
-        expect(sendMailMock).toHaveBeenCalled()
-
-        expect(code).toBeDefined()
-        expect(events.user.passwordResetRequested).toBeCalledTimes(1)
-        expect(events.user.passwordResetRequested).toBeCalledWith(user)
-      })
-    })
-
-    describe("POST /api/global/auth/:tenantId/reset/update", () => {
-      it("should reset password", async () => {
-        const { code } = await config.api.auth.requestPasswordReset(
-          sendMailMock
-        )
-        const user = await config.getUser("test@test.com")
-        delete user.password
-
-        const res = await config.api.auth.updatePassword(code)
+  it("should logout", async () => {
+    await api.auth.logout()
+    expect(events.auth.logout).toBeCalledTimes(1)
+  })
 
-        expect(res.body).toEqual({ message: "password reset successfully." })
-        expect(events.user.passwordReset).toBeCalledTimes(1)
-        expect(events.user.passwordReset).toBeCalledWith(user)
+  it("should be able to generate password reset email", async () => {
+    const { res, code } = await api.auth.requestPasswordReset(sendMailMock)
+    const user = await config.getUser("test@test.com")
 
-        // TODO: Login using new password
-      })
+    expect(res.body).toEqual({
+      message: "Please check your email for a reset link.",
     })
-  })
+    expect(sendMailMock).toHaveBeenCalled()
 
-  describe("init", () => {
-    describe("POST /api/global/auth/init", () => {})
-
-    describe("GET /api/global/auth/init", () => {})
+    expect(code).toBeDefined()
+    expect(events.user.passwordResetRequested).toBeCalledTimes(1)
+    expect(events.user.passwordResetRequested).toBeCalledWith(user)
   })
 
-  describe("datasource", () => {
-    // MULTI TENANT
-
-    describe("GET /api/global/auth/:tenantId/datasource/:provider", () => {})
-
-    describe("GET /api/global/auth/:tenantId/datasource/:provider/callback", () => {})
+  it("should allow resetting user password with code", async () => {
+    const { code } = await api.auth.requestPasswordReset(sendMailMock)
+    const user = await config.getUser("test@test.com")
+    delete user.password
 
-    // SINGLE TENANT
+    const res = await api.auth.updatePassword(code)
 
-    describe("GET /api/global/auth/datasource/:provider/callback", () => {})
+    expect(res.body).toEqual({ message: "password reset successfully." })
+    expect(events.user.passwordReset).toBeCalledTimes(1)
+    expect(events.user.passwordReset).toBeCalledWith(user)
   })
 
-  describe("google", () => {
-    // MULTI TENANT
-
-    describe("GET /api/global/auth/:tenantId/google", () => {})
-
-    describe("GET /api/global/auth/:tenantId/google/callback", () => {})
+  describe("oidc", () => {
+    const auth = require("@budibase/backend-core/auth")
 
-    // SINGLE TENANT
+    const passportSpy = jest.spyOn(auth.passport, "authenticate")
+    let oidcConf
+    let chosenConfig: any
+    let configId: string
 
-    describe("GET /api/global/auth/google/callback", () => {})
+    // mock the oidc strategy implementation and return value
+    let strategyFactory = jest.fn()
+    let mockStrategyReturn = jest.fn()
+    let mockStrategyConfig = jest.fn()
+    auth.oidc.fetchStrategyConfig = mockStrategyConfig
 
-    describe("GET /api/admin/auth/google/callback", () => {})
-  })
+    strategyFactory.mockReturnValue(mockStrategyReturn)
+    auth.oidc.strategyFactory = strategyFactory
 
-  describe("oidc", () => {
     beforeEach(async () => {
-      jest.clearAllMocks()
-      mockGetWellKnownConfig()
-
-      // see: __mocks__/oauth
-      // for associated mocking inside passport
+      oidcConf = await config.saveOIDCConfig()
+      chosenConfig = oidcConf.config.configs[0]
+      configId = chosenConfig.uuid
+      mockStrategyConfig.mockReturnValue(chosenConfig)
     })
 
-    const generateOidcConfig = async () => {
-      const oidcConf = await config.saveOIDCConfig()
-      const chosenConfig = oidcConf.config.configs[0]
-      return chosenConfig.uuid
-    }
-
-    const mockGetWellKnownConfig = () => {
-      mocks.fetch.mockReturnValue({
-        ok: true,
-        json: () => ({
-          issuer: "test",
-          authorization_endpoint: "http://localhost/auth",
-          token_endpoint: "http://localhost/token",
-          userinfo_endpoint: "http://localhost/userinfo",
-        }),
-      })
-    }
-
-    // MULTI TENANT
-    describe("GET /api/global/auth/:tenantId/oidc/configs/:configId", () => {
-      it("redirects to auth provider", async () => {
-        const configId = await generateOidcConfig()
-
-        const res = await config.api.configs.getOIDCConfig(configId)
-
-        expect(res.status).toBe(302)
-        const location: string = res.get("location")
-        expect(
-          location.startsWith(
-            "http://localhost/auth?response_type=code&client_id=clientId&redirect_uri=http%3A%2F%2Flocalhost%3A10000%2Fapi%2Fglobal%2Fauth%2Fdefault%2Foidc%2Fcallback&scope=openid%20profile%20email%20offline_access"
-          )
-        ).toBe(true)
-      })
+    afterEach(() => {
+      expect(strategyFactory).toBeCalledWith(chosenConfig, expect.any(Function))
     })
 
-    describe("GET /api/global/auth/:tenantId/oidc/callback", () => {
-      it("logs in", async () => {
-        const configId = await generateOidcConfig()
-        const preAuthRes = await config.api.configs.getOIDCConfig(configId)
-
-        const res = await config.api.configs.OIDCCallback(configId, preAuthRes)
+    describe("oidc configs", () => {
+      it("should load strategy and delegate to passport", async () => {
+        await api.configs.getOIDCConfig(configId)
 
-        expect(events.auth.login).toBeCalledWith("oidc")
-        expect(events.auth.login).toBeCalledTimes(1)
-        expect(res.status).toBe(302)
-        const location: string = res.get("location")
-        expect(location).toBe("/")
-        expectSetAuthCookie(res)
+        expect(passportSpy).toBeCalledWith(mockStrategyReturn, {
+          scope: ["profile", "email", "offline_access"],
+        })
+        expect(passportSpy.mock.calls.length).toBe(1)
       })
     })
 
-    // SINGLE TENANT
-
-    describe("GET /api/global/auth/oidc/callback", () => {})
-
-    describe("GET /api/global/auth/oidc/callback", () => {})
-
-    describe("GET /api/admin/auth/oidc/callback", () => {})
+    describe("oidc callback", () => {
+      it("should load strategy and delegate to passport", async () => {
+        await api.configs.OIDCCallback(configId)
+
+        expect(passportSpy).toBeCalledWith(
+          mockStrategyReturn,
+          {
+            successRedirect: "/",
+            failureRedirect: "/error",
+          },
+          expect.anything()
+        )
+        expect(passportSpy.mock.calls.length).toBe(1)
+      })
+    })
   })
 })

package/src/api/routes/global/tests/configs.spec.ts

@@ -1,11 +1,12 @@
 // mock the email system
 jest.mock("nodemailer")
-import { TestConfiguration, structures, mocks } from "../../../../tests"
+import { TestConfiguration, structures, mocks, API } from "../../../../tests"
 mocks.email.mock()
-import { Config, events } from "@budibase/backend-core"
+import { Configs, events } from "@budibase/backend-core"
 
 describe("configs", () => {
   const config = new TestConfiguration()
+  const api = new API(config)
 
   beforeAll(async () => {
     await config.beforeAll()
@@ -27,7 +28,7 @@ describe("configs", () => {
         _rev,
       }
 
-      const res = await config.api.configs.saveConfig(data)
+      const res = await api.configs.saveConfig(data)
 
       return {
         ...data,
@@ -49,20 +50,20 @@ describe("configs", () => {
         it("should create activated google config", async () => {
           await saveGoogleConfig()
           expect(events.auth.SSOCreated).toBeCalledTimes(1)
-          expect(events.auth.SSOCreated).toBeCalledWith(Config.GOOGLE)
+          expect(events.auth.SSOCreated).toBeCalledWith(Configs.GOOGLE)
           expect(events.auth.SSODeactivated).not.toBeCalled()
           expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Config.GOOGLE)
-          await config.deleteConfig(Config.GOOGLE)
+          expect(events.auth.SSOActivated).toBeCalledWith(Configs.GOOGLE)
+          await config.deleteConfig(Configs.GOOGLE)
         })
 
         it("should create deactivated google config", async () => {
           await saveGoogleConfig({ activated: false })
           expect(events.auth.SSOCreated).toBeCalledTimes(1)
-          expect(events.auth.SSOCreated).toBeCalledWith(Config.GOOGLE)
+          expect(events.auth.SSOCreated).toBeCalledWith(Configs.GOOGLE)
           expect(events.auth.SSOActivated).not.toBeCalled()
           expect(events.auth.SSODeactivated).not.toBeCalled()
-          await config.deleteConfig(Config.GOOGLE)
+          await config.deleteConfig(Configs.GOOGLE)
         })
       })
 
@@ -76,11 +77,11 @@ describe("configs", () => {
             googleConf._rev
           )
           expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Config.GOOGLE)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.GOOGLE)
           expect(events.auth.SSOActivated).not.toBeCalled()
           expect(events.auth.SSODeactivated).toBeCalledTimes(1)
-          expect(events.auth.SSODeactivated).toBeCalledWith(Config.GOOGLE)
-          await config.deleteConfig(Config.GOOGLE)
+          expect(events.auth.SSODeactivated).toBeCalledWith(Configs.GOOGLE)
+          await config.deleteConfig(Configs.GOOGLE)
         })
 
         it("should update google config to activated", async () => {
@@ -92,11 +93,11 @@ describe("configs", () => {
             googleConf._rev
           )
           expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Config.GOOGLE)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.GOOGLE)
           expect(events.auth.SSODeactivated).not.toBeCalled()
           expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Config.GOOGLE)
-          await config.deleteConfig(Config.GOOGLE)
+          expect(events.auth.SSOActivated).toBeCalledWith(Configs.GOOGLE)
+          await config.deleteConfig(Configs.GOOGLE)
         })
       })
     })
@@ -115,20 +116,20 @@ describe("configs", () => {
         it("should create activated OIDC config", async () => {
           await saveOIDCConfig()
           expect(events.auth.SSOCreated).toBeCalledTimes(1)
-          expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
+          expect(events.auth.SSOCreated).toBeCalledWith(Configs.OIDC)
           expect(events.auth.SSODeactivated).not.toBeCalled()
           expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
-          await config.deleteConfig(Config.OIDC)
+          expect(events.auth.SSOActivated).toBeCalledWith(Configs.OIDC)
+          await config.deleteConfig(Configs.OIDC)
         })
 
         it("should create deactivated OIDC config", async () => {
           await saveOIDCConfig({ activated: false })
           expect(events.auth.SSOCreated).toBeCalledTimes(1)
-          expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
+          expect(events.auth.SSOCreated).toBeCalledWith(Configs.OIDC)
           expect(events.auth.SSOActivated).not.toBeCalled()
           expect(events.auth.SSODeactivated).not.toBeCalled()
-          await config.deleteConfig(Config.OIDC)
+          await config.deleteConfig(Configs.OIDC)
         })
       })
 
@@ -142,11 +143,11 @@ describe("configs", () => {
             oidcConf._rev
           )
           expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Config.OIDC)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.OIDC)
           expect(events.auth.SSOActivated).not.toBeCalled()
           expect(events.auth.SSODeactivated).toBeCalledTimes(1)
-          expect(events.auth.SSODeactivated).toBeCalledWith(Config.OIDC)
-          await config.deleteConfig(Config.OIDC)
+          expect(events.auth.SSODeactivated).toBeCalledWith(Configs.OIDC)
+          await config.deleteConfig(Configs.OIDC)
         })
 
         it("should update OIDC config to activated", async () => {
@@ -158,11 +159,11 @@ describe("configs", () => {
             oidcConf._rev
           )
           expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Config.OIDC)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.OIDC)
           expect(events.auth.SSODeactivated).not.toBeCalled()
           expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
-          await config.deleteConfig(Config.OIDC)
+          expect(events.auth.SSOActivated).toBeCalledWith(Configs.OIDC)
+          await config.deleteConfig(Configs.OIDC)
         })
       })
     })
@@ -179,11 +180,11 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create SMTP config", async () => {
-          await config.deleteConfig(Config.SMTP)
+          await config.deleteConfig(Configs.SMTP)
           await saveSMTPConfig()
           expect(events.email.SMTPUpdated).not.toBeCalled()
           expect(events.email.SMTPCreated).toBeCalledTimes(1)
-          await config.deleteConfig(Config.SMTP)
+          await config.deleteConfig(Configs.SMTP)
         })
       })
 
@@ -194,7 +195,7 @@ describe("configs", () => {
           await saveSMTPConfig(smtpConf.config, smtpConf._id, smtpConf._rev)
           expect(events.email.SMTPCreated).not.toBeCalled()
           expect(events.email.SMTPUpdated).toBeCalledTimes(1)
-          await config.deleteConfig(Config.SMTP)
+          await config.deleteConfig(Configs.SMTP)
         })
       })
     })
@@ -211,7 +212,7 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create settings config with default settings", async () => {
-          await config.deleteConfig(Config.SETTINGS)
+          await config.deleteConfig(Configs.SETTINGS)
 
           await saveSettingsConfig()
 
@@ -222,7 +223,7 @@ describe("configs", () => {
 
         it("should create settings config with non-default settings", async () => {
           config.modeSelf()
-          await config.deleteConfig(Config.SETTINGS)
+          await config.deleteConfig(Configs.SETTINGS)
           const conf = {
             company: "acme",
             logoUrl: "http://example.com",
@@ -234,14 +235,14 @@ describe("configs", () => {
           expect(events.org.nameUpdated).toBeCalledTimes(1)
           expect(events.org.logoUpdated).toBeCalledTimes(1)
           expect(events.org.platformURLUpdated).toBeCalledTimes(1)
-          config.modeCloud()
+          config.modeAccount()
         })
       })
 
       describe("update", () => {
         it("should update settings config", async () => {
           config.modeSelf()
-          await config.deleteConfig(Config.SETTINGS)
+          await config.deleteConfig(Configs.SETTINGS)
           const settingsConfig = await saveSettingsConfig()
           settingsConfig.config.company = "acme"
           settingsConfig.config.logoUrl = "http://example.com"
@@ -256,7 +257,7 @@ describe("configs", () => {
           expect(events.org.nameUpdated).toBeCalledTimes(1)
           expect(events.org.logoUpdated).toBeCalledTimes(1)
           expect(events.org.platformURLUpdated).toBeCalledTimes(1)
-          config.modeCloud()
+          config.modeAccount()
         })
       })
     })
@@ -265,7 +266,7 @@ describe("configs", () => {
   it("should return the correct checklist status based on the state of the budibase installation", async () => {
     await config.saveSmtpConfig()
 
-    const res = await config.api.configs.getConfigChecklist()
+    const res = await api.configs.getConfigChecklist()
     const checklist = res.body
 
     expect(checklist.apps.checked).toBeFalsy()

package/src/api/routes/global/tests/email.spec.ts

@@ -1,10 +1,11 @@
 jest.mock("nodemailer")
-import { TestConfiguration, mocks } from "../../../../tests"
+import { TestConfiguration, mocks, API } from "../../../../tests"
 const sendMailMock = mocks.email.mock()
 import { EmailTemplatePurpose } from "../../../../constants"
 
 describe("/api/global/email", () => {
   const config = new TestConfiguration()
+  const api = new API(config)
 
   beforeAll(async () => {
     await config.beforeAll()
@@ -19,9 +20,7 @@ describe("/api/global/email", () => {
     await config.saveSmtpConfig()
     await config.saveSettingsConfig()
 
-    const res = await config.api.emails.sendEmail(
-      EmailTemplatePurpose.INVITATION
-    )
+    const res = await api.emails.sendEmail(EmailTemplatePurpose.INVITATION)
 
     expect(res.body.message).toBeDefined()
     expect(sendMailMock).toHaveBeenCalled()

package/src/api/routes/global/tests/realEmail.spec.ts

@@ -1,4 +1,4 @@
-import { TestConfiguration } from "../../../../tests"
+import { TestConfiguration, API } from "../../../../tests"
 import { EmailTemplatePurpose } from "../../../../constants"
 const nodemailer = require("nodemailer")
 const fetch = require("node-fetch")
@@ -8,6 +8,7 @@ jest.setTimeout(30000)
 
 describe("/api/global/email", () => {
   const config = new TestConfiguration()
+  const api = new API(config)
 
   beforeAll(async () => {
     await config.beforeAll()
@@ -34,7 +35,7 @@ describe("/api/global/email", () => {
       await Promise.race([config.saveEtherealSmtpConfig(), timeout()])
       await Promise.race([config.saveSettingsConfig(), timeout()])
 
-      const res = await config.api.emails.sendEmail(purpose).timeout(20000)
+      const res = await api.emails.sendEmail(purpose).timeout(20000)
       // ethereal hiccup, can't test right now
       if (res.status >= 300) {
         return