@budibase/worker 2.3.16 → 2.3.17-alpha.1

package/__mocks__/node-fetch.ts

@@ -0,0 +1,23 @@
+import fs from "fs"
+module FetchMock {
+  const fetch = jest.requireActual("node-fetch")
+
+  const func = async (url: any, opts: any) => {
+    if (url.includes("http://someconfigurl")) {
+      return {
+        ok: true,
+        json: () => ({
+          issuer: "test",
+          authorization_endpoint: "http://localhost/auth",
+          token_endpoint: "http://localhost/token",
+          userinfo_endpoint: "http://localhost/userinfo",
+        }),
+      }
+    }
+    return fetch(url, opts)
+  }
+
+  func.Headers = fetch.Headers
+
+  module.exports = func
+}

package/jest-testcontainers-config.js

@@ -0,0 +1,8 @@
+const { join } = require("path")
+require("dotenv").config({
+  path: join(__dirname, "..", "..", "hosting", ".env"),
+})
+
+const jestTestcontainersConfigGenerator = require("../../jestTestcontainersConfigGenerator")
+
+module.exports = jestTestcontainersConfigGenerator()

package/jest.config.ts

@@ -1,8 +1,10 @@
 import { Config } from "@jest/types"
 import * as fs from "fs"
+const preset = require("ts-jest/jest-preset")
 
 const config: Config.InitialOptions = {
-  testEnvironment: "node",
+  ...preset,
+  preset: "@trendyol/jest-testcontainers",
   setupFiles: ["./src/tests/jestEnv.ts"],
   setupFilesAfterEnv: ["./src/tests/jestSetup.ts"],
   collectCoverageFrom: ["src/**/*.{js,ts}"],
@@ -18,7 +20,6 @@ if (!process.env.CI) {
     "@budibase/backend-core/(.*)": "<rootDir>/../backend-core/$1",
     "@budibase/backend-core": "<rootDir>/../backend-core/src",
     "@budibase/types": "<rootDir>/../types/src",
-    "^axios.*$": "<rootDir>/node_modules/axios/lib/axios.js",
   }
   // add pro sources if they exist
   if (fs.existsSync("../../../budibase-pro")) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "2.3.16",
+  "version": "2.3.17-alpha.1",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -36,16 +36,17 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "^2.3.16",
-    "@budibase/pro": "2.3.15",
-    "@budibase/string-templates": "^2.3.16",
-    "@budibase/types": "^2.3.16",
+    "@budibase/backend-core": "2.3.17-alpha.1",
+    "@budibase/pro": "2.3.17-alpha.0",
+    "@budibase/string-templates": "2.3.17-alpha.1",
+    "@budibase/types": "2.3.17-alpha.1",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
     "@types/global-agent": "2.1.1",
     "aws-sdk": "2.1030.0",
     "bcryptjs": "2.4.3",
+    "dd-trace": "3.13.2",
     "dotenv": "8.6.0",
     "elastic-apm-node": "3.38.0",
     "global-agent": "3.0.0",
@@ -72,6 +73,7 @@
   "devDependencies": {
     "@swc/core": "^1.3.25",
     "@swc/jest": "^0.2.24",
+    "@trendyol/jest-testcontainers": "^2.1.1",
     "@types/jest": "26.0.23",
     "@types/jsonwebtoken": "8.5.1",
     "@types/koa": "2.13.4",
@@ -97,5 +99,5 @@
     "typescript": "4.7.3",
     "update-dotenv": "1.1.1"
   },
-  "gitHead": "0840e8897bc36ba5bc09c9d8d1a73a7de6498305"
+  "gitHead": "5c22c75429f742b3e0e64c01fc3ad41b5fd55000"
 }

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

@@ -1,7 +1,8 @@
 jest.mock("nodemailer")
 import { TestConfiguration, mocks } from "../../../../tests"
 const sendMailMock = mocks.email.mock()
-import { events } from "@budibase/backend-core"
+import { events, tenancy } from "@budibase/backend-core"
+import { structures } from "@budibase/backend-core/tests"
 
 const expectSetAuthCookie = (res: any) => {
   expect(
@@ -40,36 +41,43 @@ describe("/api/global/auth", () => {
 
     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")
+        await tenancy.doInTenant(config.tenant1User!.tenantId, async () => {
+          const userEmail = structures.email()
+          const { res, code } = await config.api.auth.requestPasswordReset(
+            sendMailMock,
+            userEmail
+          )
+          const user = await config.getUser(userEmail)
 
-        expect(res.body).toEqual({
-          message: "Please check your email for a reset link.",
-        })
-        expect(sendMailMock).toHaveBeenCalled()
+          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)
+          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)
+        await tenancy.doInTenant(config.tenant1User!.tenantId, async () => {
+          const userEmail = structures.email()
+          const { code } = await config.api.auth.requestPasswordReset(
+            sendMailMock,
+            userEmail
+          )
+          const user = await config.getUser(userEmail)
+          delete user.password
 
-        expect(res.body).toEqual({ message: "password reset successfully." })
-        expect(events.user.passwordReset).toBeCalledTimes(1)
-        expect(events.user.passwordReset).toBeCalledWith(user)
+          const res = await config.api.auth.updatePassword(code)
 
+          expect(res.body).toEqual({ message: "password reset successfully." })
+          expect(events.user.passwordReset).toBeCalledTimes(1)
+          expect(events.user.passwordReset).toBeCalledWith(user)
+        })
         // TODO: Login using new password
       })
     })

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

@@ -2,12 +2,12 @@
 jest.mock("nodemailer")
 import { TestConfiguration, structures, mocks } from "../../../../tests"
 mocks.email.mock()
-import { Config, events } from "@budibase/backend-core"
+import { Config, context, events } from "@budibase/backend-core"
 
 describe("configs", () => {
   const config = new TestConfiguration()
 
-  beforeAll(async () => {
+  beforeEach(async () => {
     await config.beforeAll()
   })
 
@@ -113,56 +113,64 @@ describe("configs", () => {
 
       describe("create", () => {
         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.SSODeactivated).not.toBeCalled()
-          expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
-          await config.deleteConfig(Config.OIDC)
+          await context.doInTenant(config.tenant1User!.tenantId, async () => {
+            await saveOIDCConfig()
+            expect(events.auth.SSOCreated).toBeCalledTimes(1)
+            expect(events.auth.SSOCreated).toBeCalledWith(Config.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)
+          })
         })
 
         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.SSOActivated).not.toBeCalled()
-          expect(events.auth.SSODeactivated).not.toBeCalled()
-          await config.deleteConfig(Config.OIDC)
+          await context.doInTenant(config.tenant1User!.tenantId, async () => {
+            await saveOIDCConfig({ activated: false })
+            expect(events.auth.SSOCreated).toBeCalledTimes(1)
+            expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
+            expect(events.auth.SSOActivated).not.toBeCalled()
+            expect(events.auth.SSODeactivated).not.toBeCalled()
+            await config.deleteConfig(Config.OIDC)
+          })
         })
       })
 
       describe("update", () => {
         it("should update OIDC config to deactivated", async () => {
-          const oidcConf = await saveOIDCConfig()
-          jest.clearAllMocks()
-          await saveOIDCConfig(
-            { ...oidcConf.config.configs[0], activated: false },
-            oidcConf._id,
-            oidcConf._rev
-          )
-          expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Config.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)
+          await context.doInTenant(config.tenant1User!.tenantId, async () => {
+            const oidcConf = await saveOIDCConfig()
+            jest.clearAllMocks()
+            await saveOIDCConfig(
+              { ...oidcConf.config.configs[0], activated: false },
+              oidcConf._id,
+              oidcConf._rev
+            )
+            expect(events.auth.SSOUpdated).toBeCalledTimes(1)
+            expect(events.auth.SSOUpdated).toBeCalledWith(Config.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)
+          })
         })
 
         it("should update OIDC config to activated", async () => {
-          const oidcConf = await saveOIDCConfig({ activated: false })
-          jest.clearAllMocks()
-          await saveOIDCConfig(
-            { ...oidcConf.config.configs[0], activated: true },
-            oidcConf._id,
-            oidcConf._rev
-          )
-          expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Config.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)
+          await context.doInTenant(config.tenant1User!.tenantId, async () => {
+            const oidcConf = await saveOIDCConfig({ activated: false })
+            jest.clearAllMocks()
+            await saveOIDCConfig(
+              { ...oidcConf.config.configs[0], activated: true },
+              oidcConf._id,
+              oidcConf._rev
+            )
+            expect(events.auth.SSOUpdated).toBeCalledTimes(1)
+            expect(events.auth.SSOUpdated).toBeCalledWith(Config.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)
+          })
         })
       })
     })
@@ -179,22 +187,26 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create SMTP config", async () => {
-          await config.deleteConfig(Config.SMTP)
-          await saveSMTPConfig()
-          expect(events.email.SMTPUpdated).not.toBeCalled()
-          expect(events.email.SMTPCreated).toBeCalledTimes(1)
-          await config.deleteConfig(Config.SMTP)
+          await context.doInTenant(config.tenant1User!.tenantId, async () => {
+            await config.deleteConfig(Config.SMTP)
+            await saveSMTPConfig()
+            expect(events.email.SMTPUpdated).not.toBeCalled()
+            expect(events.email.SMTPCreated).toBeCalledTimes(1)
+            await config.deleteConfig(Config.SMTP)
+          })
         })
       })
 
       describe("update", () => {
         it("should update SMTP config", async () => {
-          const smtpConf = await saveSMTPConfig()
-          jest.clearAllMocks()
-          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 context.doInTenant(config.tenant1User!.tenantId, async () => {
+            const smtpConf = await saveSMTPConfig()
+            jest.clearAllMocks()
+            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)
+          })
         })
       })
     })
@@ -211,65 +223,73 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create settings config with default settings", async () => {
-          await config.deleteConfig(Config.SETTINGS)
+          await context.doInTenant(config.tenant1User!.tenantId, async () => {
+            await config.deleteConfig(Config.SETTINGS)
 
-          await saveSettingsConfig()
+            await saveSettingsConfig()
 
-          expect(events.org.nameUpdated).not.toBeCalled()
-          expect(events.org.logoUpdated).not.toBeCalled()
-          expect(events.org.platformURLUpdated).not.toBeCalled()
+            expect(events.org.nameUpdated).not.toBeCalled()
+            expect(events.org.logoUpdated).not.toBeCalled()
+            expect(events.org.platformURLUpdated).not.toBeCalled()
+          })
         })
 
         it("should create settings config with non-default settings", async () => {
-          config.modeSelf()
-          await config.deleteConfig(Config.SETTINGS)
-          const conf = {
-            company: "acme",
-            logoUrl: "http://example.com",
-            platformUrl: "http://example.com",
-          }
-
-          await saveSettingsConfig(conf)
-
-          expect(events.org.nameUpdated).toBeCalledTimes(1)
-          expect(events.org.logoUpdated).toBeCalledTimes(1)
-          expect(events.org.platformURLUpdated).toBeCalledTimes(1)
-          config.modeCloud()
+          await context.doInTenant(config.tenant1User!.tenantId, async () => {
+            config.modeSelf()
+            await config.deleteConfig(Config.SETTINGS)
+            const conf = {
+              company: "acme",
+              logoUrl: "http://example.com",
+              platformUrl: "http://example.com",
+            }
+
+            await saveSettingsConfig(conf)
+
+            expect(events.org.nameUpdated).toBeCalledTimes(1)
+            expect(events.org.logoUpdated).toBeCalledTimes(1)
+            expect(events.org.platformURLUpdated).toBeCalledTimes(1)
+            config.modeCloud()
+          })
         })
       })
 
       describe("update", () => {
         it("should update settings config", async () => {
-          config.modeSelf()
-          await config.deleteConfig(Config.SETTINGS)
-          const settingsConfig = await saveSettingsConfig()
-          settingsConfig.config.company = "acme"
-          settingsConfig.config.logoUrl = "http://example.com"
-          settingsConfig.config.platformUrl = "http://example.com"
-
-          await saveSettingsConfig(
-            settingsConfig.config,
-            settingsConfig._id,
-            settingsConfig._rev
-          )
-
-          expect(events.org.nameUpdated).toBeCalledTimes(1)
-          expect(events.org.logoUpdated).toBeCalledTimes(1)
-          expect(events.org.platformURLUpdated).toBeCalledTimes(1)
-          config.modeCloud()
+          await context.doInTenant(config.tenant1User!.tenantId, async () => {
+            config.modeSelf()
+            await config.deleteConfig(Config.SETTINGS)
+            const settingsConfig = await saveSettingsConfig()
+            settingsConfig.config.company = "acme"
+            settingsConfig.config.logoUrl = "http://example.com"
+            settingsConfig.config.platformUrl = "http://example.com"
+
+            await saveSettingsConfig(
+              settingsConfig.config,
+              settingsConfig._id,
+              settingsConfig._rev
+            )
+
+            expect(events.org.nameUpdated).toBeCalledTimes(1)
+            expect(events.org.logoUpdated).toBeCalledTimes(1)
+            expect(events.org.platformURLUpdated).toBeCalledTimes(1)
+            config.modeCloud()
+          })
         })
       })
     })
   })
 
   it("should return the correct checklist status based on the state of the budibase installation", async () => {
-    await config.saveSmtpConfig()
+    await context.doInTenant(config.tenant1User!.tenantId, async () => {
+      await config.saveSmtpConfig()
 
-    const res = await config.api.configs.getConfigChecklist()
-    const checklist = res.body
+      const res = await config.api.configs.getConfigChecklist()
+      const checklist = res.body
 
-    expect(checklist.apps.checked).toBeFalsy()
-    expect(checklist.smtp.checked).toBeTruthy()
-    expect(checklist.adminUser.checked).toBeTruthy()
+      expect(checklist.apps.checked).toBeFalsy()
+      expect(checklist.smtp.checked).toBeTruthy()
+      expect(checklist.adminUser.checked).toBeTruthy()
+    })
   })
 })

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

@@ -1,6 +1,7 @@
 import { structures, TestConfiguration } from "../../../../tests"
 import { context, db, permissions, roles } from "@budibase/backend-core"
 import { Mock } from "jest-mock"
+import { Database } from "@budibase/types"
 
 jest.mock("@budibase/backend-core", () => {
   const core = jest.requireActual("@budibase/backend-core")
@@ -16,14 +17,13 @@ jest.mock("@budibase/backend-core", () => {
   }
 })
 
-const appDb = db.getDB("app_test")
-const mockAppDB = context.getAppDB as Mock
-mockAppDB.mockReturnValue(appDb)
+let appId: string
+let appDb: Database
 
 async function addAppMetadata() {
   await appDb.put({
     _id: "app_metadata",
-    appId: "app_test",
+    appId: appId,
     name: "New App",
     version: "version",
     url: "url",
@@ -39,12 +39,19 @@ describe("/api/global/roles", () => {
   )
 
   beforeAll(async () => {
-    console.debug(role)
-    appDb.put(role)
-    await addAppMetadata()
     await config.beforeAll()
   })
 
+  beforeEach(async () => {
+    appId = db.generateAppID()
+    appDb = db.getDB(appId)
+    const mockAppDB = context.getAppDB as Mock
+    mockAppDB.mockReturnValue(appDb)
+
+    await addAppMetadata()
+    appDb.put(role)
+  })
+
   afterAll(async () => {
     await config.afterAll()
   })
@@ -57,16 +64,14 @@ describe("/api/global/roles", () => {
     it("retrieves roles", async () => {
       const res = await config.api.roles.get()
       expect(res.body).toBeDefined()
-      expect(res.body["app_test"].roles.length).toEqual(5)
-      expect(res.body["app_test"].roles.map((r: any) => r._id)).toContain(
-        role._id
-      )
+      expect(res.body[appId].roles.length).toEqual(5)
+      expect(res.body[appId].roles.map((r: any) => r._id)).toContain(role._id)
     })
   })
 
   describe("GET api/global/roles/:appId", () => {
     it("finds a role by appId", async () => {
-      const res = await config.api.roles.find("app_test")
+      const res = await config.api.roles.find(appId)
       expect(res.body).toBeDefined()
       expect(res.body.name).toEqual("New App")
     })
@@ -79,9 +84,9 @@ describe("/api/global/roles", () => {
         app_test: "role1",
       }
       const userResponse = await config.createUser(user)
-      const res = await config.api.roles.remove("app_test")
+      const res = await config.api.roles.remove(appId)
       const updatedUser = await config.api.users.getUser(userResponse._id!)
-      expect(updatedUser.body.roles).not.toHaveProperty("app_test")
+      expect(updatedUser.body.roles).not.toHaveProperty(appId)
       expect(res.body.message).toEqual("App role removed from all users")
     })
   })

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

@@ -1,14 +1,9 @@
 import { InviteUsersResponse, User } from "@budibase/types"
 
 jest.mock("nodemailer")
-import {
-  TestConfiguration,
-  mocks,
-  structures,
-  TENANT_1,
-} from "../../../../tests"
+import { TestConfiguration, mocks, structures } from "../../../../tests"
 const sendMailMock = mocks.email.mock()
-import { events, tenancy } from "@budibase/backend-core"
+import { context, events, tenancy } from "@budibase/backend-core"
 
 describe("/api/global/users", () => {
   const config = new TestConfiguration()
@@ -27,16 +22,18 @@ describe("/api/global/users", () => {
 
   describe("invite", () => {
     it("should be able to generate an invitation", async () => {
-      const email = structures.users.newEmail()
-      const { code, res } = await config.api.users.sendUserInvite(
-        sendMailMock,
-        email
-      )
-
-      expect(res.body).toEqual({ message: "Invitation has been sent." })
-      expect(sendMailMock).toHaveBeenCalled()
-      expect(code).toBeDefined()
-      expect(events.user.invited).toBeCalledTimes(1)
+      await context.doInTenant(config.tenant1User!.tenantId, async () => {
+        const email = structures.users.newEmail()
+        const { code, res } = await config.api.users.sendUserInvite(
+          sendMailMock,
+          email
+        )
+
+        expect(res.body).toEqual({ message: "Invitation has been sent." })
+        expect(sendMailMock).toHaveBeenCalled()
+        expect(code).toBeDefined()
+        expect(events.user.invited).toBeCalledTimes(1)
+      })
     })
 
     it("should not be able to generate an invitation for existing user", async () => {
@@ -53,20 +50,22 @@ describe("/api/global/users", () => {
     })
 
     it("should be able to create new user from invite", async () => {
-      const email = structures.users.newEmail()
-      const { code } = await config.api.users.sendUserInvite(
-        sendMailMock,
-        email
-      )
-
-      const res = await config.api.users.acceptInvite(code)
-
-      expect(res.body._id).toBeDefined()
-      const user = await config.getUser(email)
-      expect(user).toBeDefined()
-      expect(user._id).toEqual(res.body._id)
-      expect(events.user.inviteAccepted).toBeCalledTimes(1)
-      expect(events.user.inviteAccepted).toBeCalledWith(user)
+      await context.doInTenant(config.tenant1User!.tenantId, async () => {
+        const email = structures.users.newEmail()
+        const { code } = await config.api.users.sendUserInvite(
+          sendMailMock,
+          email
+        )
+
+        const res = await config.api.users.acceptInvite(code)
+
+        expect(res.body._id).toBeDefined()
+        const user = await config.getUser(email)
+        expect(user).toBeDefined()
+        expect(user._id).toEqual(res.body._id)
+        expect(events.user.inviteAccepted).toBeCalledTimes(1)
+        expect(events.user.inviteAccepted).toBeCalledWith(user)
+      })
     })
   })
 
@@ -118,7 +117,7 @@ describe("/api/global/users", () => {
       const user = await config.createUser()
       jest.clearAllMocks()
 
-      await tenancy.doInTenant(TENANT_1, async () => {
+      await tenancy.doInTenant(config.getTenantId(), async () => {
         const response = await config.api.users.bulkCreateUsers([user])
 
         expect(response.created?.successful.length).toBe(0)
@@ -231,7 +230,7 @@ describe("/api/global/users", () => {
       const user = await config.createUser()
       jest.clearAllMocks()
 
-      await tenancy.doInTenant(TENANT_1, async () => {
+      await tenancy.doInTenant(config.getTenantId(), async () => {
         delete user._id
         const response = await config.api.users.saveUser(user, 400)
 
@@ -444,7 +443,7 @@ describe("/api/global/users", () => {
     })
 
     it("should not be able to update email address", async () => {
-      const email = "email@test.com"
+      const email = structures.email()
       const user = await config.createUser(structures.users.user({ email }))
       user.email = "new@test.com"
 

package/src/ddApm.ts

@@ -0,0 +1,7 @@
+import apm from "dd-trace"
+
+// enable APM if configured
+if (process.env.DD_APM_ENABLED) {
+  console.log("Starting dd-trace")
+  apm.init()
+}