@budibase/worker 2.3.17-alpha.4 → 2.3.17-alpha.5

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

@@ -2,7 +2,7 @@
 jest.mock("nodemailer")
 import { TestConfiguration, structures, mocks } from "../../../../tests"
 mocks.email.mock()
-import { Config, context, events } from "@budibase/backend-core"
+import { Config, events } from "@budibase/backend-core"
 
 describe("configs", () => {
   const config = new TestConfiguration()
@@ -113,64 +113,56 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create activated OIDC config", async () => {
-          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)
-          })
+          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 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)
-          })
+          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 () => {
-          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)
-          })
+          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 () => {
-          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)
-          })
+          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)
         })
       })
     })
@@ -187,26 +179,22 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create SMTP config", async () => {
-          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)
-          })
+          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 () => {
-          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)
-          })
+          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)
         })
       })
     })
@@ -223,73 +211,65 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create settings config with default settings", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, async () => {
-            await config.deleteConfig(Config.SETTINGS)
+          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 () => {
-          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()
-          })
+          config.selfHosted()
+          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.cloudHosted()
         })
       })
 
       describe("update", () => {
         it("should update settings config", async () => {
-          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()
-          })
+          config.selfHosted()
+          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.cloudHosted()
         })
       })
     })
   })
 
   it("should return the correct checklist status based on the state of the budibase installation", async () => {
-    await context.doInTenant(config.tenant1User!.tenantId, async () => {
-      await config.saveSmtpConfig()
+    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

@@ -32,6 +32,7 @@ async function addAppMetadata() {
 
 describe("/api/global/roles", () => {
   const config = new TestConfiguration()
+
   const role = new roles.Role(
     db.generateRoleID("newRole"),
     roles.BUILTIN_ROLE_IDS.BASIC,
@@ -43,13 +44,13 @@ describe("/api/global/roles", () => {
   })
 
   beforeEach(async () => {
-    appId = db.generateAppID()
+    appId = db.generateAppID(config.tenantId)
     appDb = db.getDB(appId)
     const mockAppDB = context.getAppDB as Mock
     mockAppDB.mockReturnValue(appDb)
 
     await addAppMetadata()
-    appDb.put(role)
+    await appDb.put(role)
   })
 
   afterAll(async () => {

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

@@ -30,7 +30,7 @@ describe("/api/global/self", () => {
       user.dayPassRecordedAt = mocks.date.MOCK_DATE.toISOString()
       expect(res.body._id).toBe(user._id)
       expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.user.updated).toBeCalledWith(user)
+      expect(events.user.updated).toBeCalledWith(dbUser)
       expect(events.user.passwordUpdated).not.toBeCalled()
     })
 
@@ -44,12 +44,11 @@ describe("/api/global/self", () => {
       const dbUser = await config.getUser(user.email)
       user._rev = dbUser._rev
       user.dayPassRecordedAt = mocks.date.MOCK_DATE.toISOString()
-      delete user.password
       expect(res.body._id).toBe(user._id)
       expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.user.updated).toBeCalledWith(user)
+      expect(events.user.updated).toBeCalledWith(dbUser)
       expect(events.user.passwordUpdated).toBeCalledTimes(1)
-      expect(events.user.passwordUpdated).toBeCalledWith(user)
+      expect(events.user.passwordUpdated).toBeCalledWith(dbUser)
     })
   })
 })

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

@@ -3,7 +3,9 @@ import { InviteUsersResponse, User } from "@budibase/types"
 jest.mock("nodemailer")
 import { TestConfiguration, mocks, structures } from "../../../../tests"
 const sendMailMock = mocks.email.mock()
-import { context, events, tenancy } from "@budibase/backend-core"
+import { events, tenancy, accounts as _accounts } from "@budibase/backend-core"
+
+const accounts = jest.mocked(_accounts)
 
 describe("/api/global/users", () => {
   const config = new TestConfiguration()
@@ -20,26 +22,24 @@ describe("/api/global/users", () => {
     jest.clearAllMocks()
   })
 
-  describe("invite", () => {
+  describe("POST /api/global/users/invite", () => {
     it("should be able to generate an invitation", async () => {
-      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)
-      })
+      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 () => {
       const { code, res } = await config.api.users.sendUserInvite(
         sendMailMock,
-        config.defaultUser!.email,
+        config.user!.email,
         400
       )
 
@@ -50,26 +50,24 @@ describe("/api/global/users", () => {
     })
 
     it("should be able to create new user from invite", async () => {
-      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)
-      })
+      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)
     })
   })
 
-  describe("inviteMultiple", () => {
+  describe("POST /api/global/users/multi/invite", () => {
     it("should be able to generate an invitation", async () => {
       const newUserInvite = () => ({
         email: structures.users.newEmail(),
@@ -87,7 +85,7 @@ describe("/api/global/users", () => {
     })
 
     it("should not be able to generate an invitation for existing user", async () => {
-      const request = [{ email: config.defaultUser!.email, userInfo: {} }]
+      const request = [{ email: config.user!.email, userInfo: {} }]
 
       const res = await config.api.users.sendMultiUserInvite(request)
 
@@ -100,7 +98,7 @@ describe("/api/global/users", () => {
     })
   })
 
-  describe("bulk (create)", () => {
+  describe("POST /api/global/users/bulk", () => {
     it("should ignore users existing in the same tenant", async () => {
       const user = await config.createUser()
       jest.clearAllMocks()
@@ -163,7 +161,7 @@ describe("/api/global/users", () => {
     })
   })
 
-  describe("create", () => {
+  describe("POST /api/global/users", () => {
     it("should be able to create a basic user", async () => {
       const user = structures.users.user()
 
@@ -242,7 +240,7 @@ describe("/api/global/users", () => {
     it("should not be able to create user with the same email as an account", async () => {
       const user = structures.users.user()
       const account = structures.accounts.cloudAccount()
-      mocks.accounts.getAccount.mockReturnValueOnce(account)
+      accounts.getAccount.mockReturnValueOnce(Promise.resolve(account))
 
       const response = await config.api.users.saveUser(user, 400)
 
@@ -283,7 +281,7 @@ describe("/api/global/users", () => {
     })
   })
 
-  describe("update", () => {
+  describe("POST /api/global/users (update)", () => {
     it("should be able to update a basic user", async () => {
       const user = await config.createUser()
       jest.clearAllMocks()
@@ -298,7 +296,7 @@ describe("/api/global/users", () => {
     })
 
     it("should not allow a user to update their own admin/builder status", async () => {
-      const user = (await config.api.users.getUser(config.defaultUser?._id!))
+      const user = (await config.api.users.getUser(config.user?._id!))
         .body as User
       await config.api.users.saveUser({
         ...user,
@@ -468,9 +466,9 @@ describe("/api/global/users", () => {
     })
   })
 
-  describe("bulk (delete)", () => {
+  describe("POST /api/global/users/bulk (delete)", () => {
     it("should not be able to bulk delete current user", async () => {
-      const user = await config.defaultUser!
+      const user = await config.user!
 
       const response = await config.api.users.bulkDeleteUsers([user._id!], 400)
 
@@ -482,7 +480,7 @@ describe("/api/global/users", () => {
       const user = await config.createUser()
       const account = structures.accounts.cloudAccount()
       account.budibaseUserId = user._id!
-      mocks.accounts.getAccountByTenantId.mockReturnValue(account)
+      accounts.getAccountByTenantId.mockReturnValue(Promise.resolve(account))
 
       const response = await config.api.users.bulkDeleteUsers([user._id!])
 
@@ -497,7 +495,7 @@ describe("/api/global/users", () => {
 
     it("should be able to bulk delete users", async () => {
       const account = structures.accounts.cloudAccount()
-      mocks.accounts.getAccountByTenantId.mockReturnValue(account)
+      accounts.getAccountByTenantId.mockReturnValue(Promise.resolve(account))
 
       const builder = structures.users.builderUser()
       const admin = structures.users.adminUser()
@@ -521,7 +519,7 @@ describe("/api/global/users", () => {
     })
   })
 
-  describe("destroy", () => {
+  describe("DELETE /api/global/users/:userId", () => {
     it("should be able to destroy a basic user", async () => {
       const user = await config.createUser()
       jest.clearAllMocks()
@@ -558,7 +556,7 @@ describe("/api/global/users", () => {
     it("should not be able to destroy account owner", async () => {
       const user = await config.createUser()
       const account = structures.accounts.cloudAccount()
-      mocks.accounts.getAccount.mockReturnValueOnce(account)
+      accounts.getAccount.mockReturnValueOnce(Promise.resolve(account))
 
       const response = await config.api.users.deleteUser(user._id!, 400)
 
@@ -566,10 +564,10 @@ describe("/api/global/users", () => {
     })
 
     it("should not be able to destroy account owner as account owner", async () => {
-      const user = await config.defaultUser!
+      const user = await config.user!
       const account = structures.accounts.cloudAccount()
       account.email = user.email
-      mocks.accounts.getAccount.mockReturnValueOnce(account)
+      accounts.getAccount.mockReturnValueOnce(Promise.resolve(account))
 
       const response = await config.api.users.deleteUser(user._id!, 400)
 

package/src/api/routes/system/tenants.ts

@@ -7,7 +7,7 @@ const router: Router = new Router()
 router.delete(
   "/api/system/tenants/:tenantId",
   middleware.adminOnly,
-  controller.delete
+  controller.destroy
 )
 
 export default router

package/src/api/routes/system/tests/accounts.spec.ts

@@ -1,4 +1,4 @@
-import sdk from "../../../../sdk"
+import * as accounts from "../../../../sdk/accounts"
 import { TestConfiguration, structures } from "../../../../tests"
 import { v4 as uuid } from "uuid"
 
@@ -24,8 +24,8 @@ describe("accounts", () => {
 
         const response = await config.api.accounts.saveMetadata(account)
 
-        const id = sdk.accounts.formatAccountMetadataId(account.accountId)
-        const metadata = await sdk.accounts.getMetadata(id)
+        const id = accounts.metadata.formatAccountMetadataId(account.accountId)
+        const metadata = await accounts.metadata.getMetadata(id)
         expect(response).toStrictEqual(metadata)
       })
     })
@@ -37,7 +37,7 @@ describe("accounts", () => {
 
         await config.api.accounts.destroyMetadata(account.accountId)
 
-        const deleted = await sdk.accounts.getMetadata(account.accountId)
+        const deleted = await accounts.metadata.getMetadata(account.accountId)
         expect(deleted).toBe(undefined)
       })
 

package/src/api/routes/system/tests/migrations.spec.ts

@@ -30,7 +30,7 @@ describe("/api/system/migrations", () => {
         headers: {},
         status: 403,
       })
-      expect(res.text).toBe("Unauthorized - no public worker access")
+      expect(res.body).toEqual({ message: "Unauthorized", status: 403 })
       expect(migrateFn).toBeCalledTimes(0)
     })
 
@@ -47,7 +47,7 @@ describe("/api/system/migrations", () => {
         headers: {},
         status: 403,
       })
-      expect(res.text).toBe("Unauthorized - no public worker access")
+      expect(res.body).toEqual({ message: "Unauthorized", status: 403 })
     })
 
     it("returns definitions", async () => {

package/src/api/routes/system/tests/restore.spec.ts

@@ -25,12 +25,12 @@ describe("/api/system/restore", () => {
     })
 
     it("restores in self host", async () => {
-      config.modeSelf()
+      config.selfHosted()
       const res = await config.api.restore.restored()
       expect(res.body).toEqual({
         message: "System prepared after restore.",
       })
-      config.modeCloud()
+      config.cloudHosted()
     })
   })
 })

package/src/api/routes/system/tests/status.spec.ts

@@ -1,6 +1,6 @@
 import { TestConfiguration } from "../../../../tests"
-import { accounts } from "@budibase/backend-core"
-import { mocks } from "@budibase/backend-core/tests"
+import { accounts as _accounts } from "@budibase/backend-core"
+const accounts = jest.mocked(_accounts)
 
 describe("/api/system/status", () => {
   const config = new TestConfiguration()
@@ -19,7 +19,7 @@ describe("/api/system/status", () => {
 
   describe("GET /api/system/status", () => {
     it("returns status in self host", async () => {
-      config.modeSelf()
+      config.selfHosted()
       const res = await config.api.status.getStatus()
       expect(res.body).toEqual({
         health: {
@@ -27,7 +27,7 @@ describe("/api/system/status", () => {
         },
       })
       expect(accounts.getStatus).toBeCalledTimes(0)
-      config.modeCloud()
+      config.cloudHosted()
     })
 
     it("returns status in cloud", async () => {
@@ -37,7 +37,7 @@ describe("/api/system/status", () => {
         },
       }
 
-      mocks.accounts.getStatus.mockReturnValueOnce(value)
+      accounts.getStatus.mockReturnValueOnce(Promise.resolve(value))
 
       const res = await config.api.status.getStatus()