@budibase/worker 2.1.22-alpha.4 → 2.1.22-alpha.6

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

@@ -1,10 +1,9 @@
 import sdk from "../../../../sdk"
-import { TestConfiguration, structures, API } from "../../../../tests"
+import { TestConfiguration, structures } from "../../../../tests"
 import { v4 as uuid } from "uuid"
 
 describe("accounts", () => {
   const config = new TestConfiguration()
-  const api = new API(config)
 
   beforeAll(async () => {
     await config.beforeAll()
@@ -23,7 +22,7 @@ describe("accounts", () => {
       it("saves account metadata", async () => {
         let account = structures.accounts.account()
 
-        const response = await api.accounts.saveMetadata(account)
+        const response = await config.api.accounts.saveMetadata(account)
 
         const id = sdk.accounts.formatAccountMetadataId(account.accountId)
         const metadata = await sdk.accounts.getMetadata(id)
@@ -34,9 +33,9 @@ describe("accounts", () => {
     describe("destroyMetadata", () => {
       it("destroys account metadata", async () => {
         const account = structures.accounts.account()
-        await api.accounts.saveMetadata(account)
+        await config.api.accounts.saveMetadata(account)
 
-        await api.accounts.destroyMetadata(account.accountId)
+        await config.api.accounts.destroyMetadata(account.accountId)
 
         const deleted = await sdk.accounts.getMetadata(account.accountId)
         expect(deleted).toBe(undefined)
@@ -45,7 +44,7 @@ describe("accounts", () => {
       it("destroys account metadata that does not exist", async () => {
         const id = uuid()
 
-        const response = await api.accounts.destroyMetadata(id)
+        const response = await config.api.accounts.destroyMetadata(id)
 
         expect(response.status).toBe(204)
       })

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

@@ -0,0 +1,29 @@
+import { TestConfiguration } from "../../../../tests"
+
+describe("/api/system/environment", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("GET /api/system/environment", () => {
+    it("returns the expected environment", async () => {
+      const env = await config.api.environment.getEnvironment()
+      expect(env.body).toEqual({
+        cloud: true,
+        disableAccountPortal: false,
+        isDev: false,
+        multiTenancy: true,
+      })
+    })
+  })
+})

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

@@ -0,0 +1,63 @@
+const migrateFn = jest.fn()
+
+import { TestConfiguration } from "../../../../tests"
+
+jest.mock("../../../../migrations", () => {
+  return {
+    ...jest.requireActual("../../../../migrations"),
+    migrate: migrateFn,
+  }
+})
+
+describe("/api/system/migrations", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("POST /api/system/migrations/run", () => {
+    it("fails with no internal api key", async () => {
+      const res = await config.api.migrations.runMigrations({
+        headers: {},
+        status: 403,
+      })
+      expect(res.text).toBe("Unauthorized - no public worker access")
+      expect(migrateFn).toBeCalledTimes(0)
+    })
+
+    it("runs migrations", async () => {
+      const res = await config.api.migrations.runMigrations()
+      expect(res.text).toBe("OK")
+      expect(migrateFn).toBeCalledTimes(1)
+    })
+  })
+
+  describe("DELETE /api/system/migrations/definitions", () => {
+    it("fails with no internal api key", async () => {
+      const res = await config.api.migrations.getMigrationDefinitions({
+        headers: {},
+        status: 403,
+      })
+      expect(res.text).toBe("Unauthorized - no public worker access")
+    })
+
+    it("returns definitions", async () => {
+      const res = await config.api.migrations.getMigrationDefinitions()
+      expect(res.body).toEqual([
+        {
+          name: "global_info_sync_users",
+          type: "global",
+        },
+      ])
+    })
+  })
+})

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

@@ -0,0 +1,36 @@
+import { TestConfiguration } from "../../../../tests"
+
+describe("/api/system/restore", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("POST /api/global/restore", () => {
+    it("doesn't allow restore in cloud", async () => {
+      const res = await config.api.restore.restored({ status: 405 })
+      expect(res.body).toEqual({
+        message: "This operation is not allowed in cloud.",
+        status: 405,
+      })
+    })
+
+    it("restores in self host", async () => {
+      config.modeSelf()
+      const res = await config.api.restore.restored()
+      expect(res.body).toEqual({
+        message: "System prepared after restore.",
+      })
+      config.modeCloud()
+    })
+  })
+})

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

@@ -0,0 +1,48 @@
+import { TestConfiguration } from "../../../../tests"
+import { accounts } from "@budibase/backend-core"
+import { mocks } from "@budibase/backend-core/tests"
+
+describe("/api/system/status", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("GET /api/system/status", () => {
+    it("returns status in self host", async () => {
+      config.modeSelf()
+      const res = await config.api.status.getStatus()
+      expect(res.body).toEqual({
+        health: {
+          passing: true,
+        },
+      })
+      expect(accounts.getStatus).toBeCalledTimes(0)
+      config.modeCloud()
+    })
+
+    it("returns status in cloud", async () => {
+      const value = {
+        health: {
+          passing: false,
+        },
+      }
+
+      mocks.accounts.getStatus.mockReturnValueOnce(value)
+
+      const res = await config.api.status.getStatus()
+
+      expect(accounts.getStatus).toBeCalledTimes(1)
+      expect(res.body).toEqual(value)
+    })
+  })
+})

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

@@ -0,0 +1,61 @@
+import { TestConfiguration } from "../../../../tests"
+import { tenancy } from "@budibase/backend-core"
+
+describe("/api/global/tenants", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("DELETE /api/system/tenants/:tenantId", () => {
+    it("allows deleting the current tenant", async () => {
+      const user = await config.createTenant()
+
+      await config.api.tenants.delete(user.tenantId, {
+        headers: config.authHeaders(user),
+      })
+    })
+
+    it("rejects deleting another tenant", async () => {
+      const user1 = await config.createTenant()
+      // create a second user in another tenant
+      const user2 = await config.createTenant()
+
+      const status = 403
+      const res = await config.api.tenants.delete(user1.tenantId, {
+        status,
+        headers: config.authHeaders(user2),
+      })
+
+      expect(res.body).toEqual({
+        message: "Tenant ID does not match current user",
+        status,
+      })
+    })
+
+    it("rejects non-admin", async () => {
+      const user1 = await config.createTenant()
+      // create an internal non-admin user
+      const user2 = await tenancy.doInTenant(user1.tenantId, () => {
+        return config.createUser()
+      })
+      await config.createSession(user2)
+
+      const res = await config.api.tenants.delete(user1.tenantId, {
+        status: 403,
+        headers: config.authHeaders(user2),
+      })
+
+      expect(res.body).toEqual(config.adminOnlyResponse())
+    })
+  })
+})

package/src/middleware/tests/tenancy.spec.ts

@@ -0,0 +1,73 @@
+import { TestConfiguration, structures } from "../../tests"
+import { constants } from "@budibase/backend-core"
+
+describe("tenancy middleware", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it("should get tenant id from user", async () => {
+    const user = await config.createTenant()
+    await config.createSession(user)
+    const res = await config.api.self.getSelf(user)
+    expect(res.headers[constants.Headers.TENANT_ID]).toBe(user.tenantId)
+  })
+
+  it("should get tenant id from header", async () => {
+    const tenantId = structures.uuid()
+    const headers = {
+      [constants.Headers.TENANT_ID]: tenantId,
+    }
+    const res = await config.request
+      .get(`/api/global/configs/checklist`)
+      .set(headers)
+    expect(res.headers[constants.Headers.TENANT_ID]).toBe(tenantId)
+  })
+
+  it("should get tenant id from query param", async () => {
+    const tenantId = structures.uuid()
+    const res = await config.request.get(
+      `/api/global/configs/checklist?tenantId=${tenantId}`
+    )
+    expect(res.headers[constants.Headers.TENANT_ID]).toBe(tenantId)
+  })
+
+  it("should get tenant id from subdomain", async () => {
+    const tenantId = structures.uuid()
+    const headers = {
+      host: `${tenantId}.localhost:10000`,
+    }
+    const res = await config.request
+      .get(`/api/global/configs/checklist`)
+      .set(headers)
+    expect(res.headers[constants.Headers.TENANT_ID]).toBe(tenantId)
+  })
+
+  it("should get tenant id from path variable", async () => {
+    const user = await config.createTenant()
+    const res = await config.request
+      .post(`/api/global/auth/${user.tenantId}/login`)
+      .send({
+        username: user.email,
+        password: user.password,
+      })
+    expect(res.headers[constants.Headers.TENANT_ID]).toBe(user.tenantId)
+  })
+
+  it("should throw when no tenant id is found", async () => {
+    const res = await config.request.get(`/api/global/configs/checklist`)
+    expect(res.status).toBe(403)
+    expect(res.text).toBe("Tenant id not set")
+    expect(res.headers[constants.Headers.TENANT_ID]).toBe(undefined)
+  })
+})

package/src/tests/TestConfiguration.ts

@@ -12,30 +12,33 @@ import {
   Headers,
   sessions,
   auth,
+  constants,
+  env as coreEnv,
 } from "@budibase/backend-core"
-import { TENANT_ID, TENANT_1, CSRF_TOKEN } from "./structures"
-import structures from "./structures"
+import structures, { TENANT_ID, TENANT_1, CSRF_TOKEN } from "./structures"
 import { CreateUserResponse, User, AuthToken } from "@budibase/types"
+import API from "./api"
 
 enum Mode {
-  ACCOUNT = "account",
+  CLOUD = "cloud",
   SELF = "self",
 }
 
 class TestConfiguration {
   server: any
   request: any
+  api: API
   defaultUser?: User
   tenant1User?: User
 
   constructor(
     opts: { openServer: boolean; mode: Mode } = {
       openServer: true,
-      mode: Mode.ACCOUNT,
+      mode: Mode.CLOUD,
     }
   ) {
-    if (opts.mode === Mode.ACCOUNT) {
-      this.modeAccount()
+    if (opts.mode === Mode.CLOUD) {
+      this.modeCloud()
     } else if (opts.mode === Mode.SELF) {
       this.modeSelf()
     }
@@ -46,6 +49,8 @@ class TestConfiguration {
       // we need the request for logging in, involves cookies, hard to fake
       this.request = supertest(this.server)
     }
+
+    this.api = new API(this)
   }
 
   getRequest() {
@@ -54,20 +59,24 @@ class TestConfiguration {
 
   // MODES
 
-  modeAccount = () => {
-    env.SELF_HOSTED = false
-    // @ts-ignore
-    env.MULTI_TENANCY = true
-    // @ts-ignore
-    env.DISABLE_ACCOUNT_PORTAL = false
+  setMultiTenancy = (value: boolean) => {
+    env._set("MULTI_TENANCY", value)
+    coreEnv._set("MULTI_TENANCY", value)
+  }
+
+  setSelfHosted = (value: boolean) => {
+    env._set("SELF_HOSTED", value)
+    coreEnv._set("SELF_HOSTED", value)
+  }
+
+  modeCloud = () => {
+    this.setSelfHosted(false)
+    this.setMultiTenancy(true)
   }
 
   modeSelf = () => {
-    env.SELF_HOSTED = true
-    // @ts-ignore
-    env.MULTI_TENANCY = false
-    // @ts-ignore
-    env.DISABLE_ACCOUNT_PORTAL = true
+    this.setSelfHosted(true)
+    this.setMultiTenancy(false)
   }
 
   // UTILS
@@ -114,6 +123,25 @@ class TestConfiguration {
 
   // TENANCY
 
+  createTenant = async (): Promise<User> => {
+    // create user / new tenant
+    const res = await this.api.users.createAdminUser()
+
+    // return the created user
+    const userRes = await this.api.users.getUser(res.userId, {
+      headers: {
+        ...this.internalAPIHeaders(),
+        [constants.Headers.TENANT_ID]: res.tenantId,
+      },
+    })
+
+    // create a session for the new user
+    const user = userRes.body
+    await this.createSession(user)
+
+    return user
+  }
+
   getTenantId() {
     try {
       return tenancy.getTenantId()
@@ -122,35 +150,32 @@ class TestConfiguration {
     }
   }
 
-  // USER / AUTH
+  // AUTH
 
-  async createDefaultUser() {
-    const user = structures.users.adminUser({
-      email: "test@test.com",
-      password: "test",
-    })
-    this.defaultUser = await this.createUser(user)
-  }
-
-  async createTenant1User() {
-    const user = structures.users.adminUser({
-      email: "tenant1@test.com",
-      password: "test",
+  async _createSession({
+    userId,
+    tenantId,
+  }: {
+    userId: string
+    tenantId: string
+  }) {
+    await sessions.createASession(userId!, {
+      sessionId: "sessionid",
+      tenantId: tenantId,
+      csrfToken: CSRF_TOKEN,
     })
-    this.tenant1User = await this.createUser(user)
   }
 
   async createSession(user: User) {
-    await sessions.createASession(user._id!, {
-      sessionId: "sessionid",
-      tenantId: user.tenantId,
-      csrfToken: CSRF_TOKEN,
-    })
+    return this._createSession({ userId: user._id!, tenantId: user.tenantId })
   }
 
   cookieHeader(cookies: any) {
+    if (!Array.isArray(cookies)) {
+      cookies = [cookies]
+    }
     return {
-      Cookie: [cookies],
+      Cookie: cookies,
     }
   }
 
@@ -179,6 +204,32 @@ class TestConfiguration {
     }
   }
 
+  internalAPIHeaders() {
+    return { [constants.Headers.API_KEY]: env.INTERNAL_API_KEY }
+  }
+
+  adminOnlyResponse = () => {
+    return { message: "Admin user only endpoint.", status: 403 }
+  }
+
+  // USERS
+
+  async createDefaultUser() {
+    const user = structures.users.adminUser({
+      email: "test@test.com",
+      password: "test",
+    })
+    this.defaultUser = await this.createUser(user)
+  }
+
+  async createTenant1User() {
+    const user = structures.users.adminUser({
+      email: "tenant1@test.com",
+      password: "test",
+    })
+    this.tenant1User = await this.createUser(user)
+  }
+
   async getUser(email: string): Promise<User> {
     return tenancy.doInTenant(this.getTenantId(), () => {
       return users.getGlobalUserByEmail(email)
@@ -240,11 +291,6 @@ class TestConfiguration {
 
   // CONFIGS - OIDC
 
-  getOIDConfigCookie(configId: string) {
-    const token = auth.jwt.sign(configId, env.JWT_SECRET)
-    return this.cookieHeader([[`${Cookies.OIDC_CONFIG}=${token}`]])
-  }
-
   async saveOIDCConfig() {
     await this.deleteConfig(Configs.OIDC)
     const config = structures.configs.oidc()

package/src/tests/api/accounts.ts

@@ -1,20 +1,17 @@
 import { Account, AccountMetadata } from "@budibase/types"
 import TestConfiguration from "../TestConfiguration"
+import { TestAPI } from "./base"
 
-export class AccountAPI {
-  config: TestConfiguration
-  request: any
-
+export class AccountAPI extends TestAPI {
   constructor(config: TestConfiguration) {
-    this.config = config
-    this.request = config.request
+    super(config)
   }
 
   saveMetadata = async (account: Account) => {
     const res = await this.request
       .put(`/api/system/accounts/${account.accountId}/metadata`)
       .send(account)
-      .set(this.config.defaultHeaders())
+      .set(this.config.internalAPIHeaders())
       .expect("Content-Type", /json/)
       .expect(200)
     return res.body as AccountMetadata
@@ -23,6 +20,6 @@ export class AccountAPI {
   destroyMetadata = (accountId: string) => {
     return this.request
       .del(`/api/system/accounts/${accountId}/metadata`)
-      .set(this.config.defaultHeaders())
+      .set(this.config.internalAPIHeaders())
   }
 }

package/src/tests/api/auth.ts

@@ -1,12 +1,9 @@
 import TestConfiguration from "../TestConfiguration"
+import { TestAPI } from "./base"
 
-export class AuthAPI {
-  config: TestConfiguration
-  request: any
-
+export class AuthAPI extends TestAPI {
   constructor(config: TestConfiguration) {
-    this.config = config
-    this.request = config.request
+    super(config)
   }
 
   updatePassword = (code: string) => {

package/src/tests/api/base.ts

@@ -0,0 +1,16 @@
+import TestConfiguration from "../TestConfiguration"
+
+export interface TestAPIOpts {
+  headers?: any
+  status?: number
+}
+
+export abstract class TestAPI {
+  config: TestConfiguration
+  request: any
+
+  protected constructor(config: TestConfiguration) {
+    this.config = config
+    this.request = config.request
+  }
+}

package/src/tests/api/configs.ts

@@ -1,12 +1,9 @@
 import TestConfiguration from "../TestConfiguration"
+import { TestAPI } from "./base"
 
-export class ConfigAPI {
-  config: TestConfiguration
-  request: any
-
+export class ConfigAPI extends TestAPI {
   constructor(config: TestConfiguration) {
-    this.config = config
-    this.request = config.request
+    super(config)
   }
 
   getConfigChecklist = () => {
@@ -26,10 +23,20 @@ export class ConfigAPI {
       .expect(200)
   }
 
-  OIDCCallback = (configId: string) => {
+  OIDCCallback = (configId: string, preAuthRes: any) => {
+    const cookie = this.config.cookieHeader(preAuthRes.get("set-cookie"))
+    const setKoaSession = cookie.Cookie.find((c: string) =>
+      c.includes("koa:sess")
+    )
+    const koaSession = setKoaSession.split("=")[1] + "=="
+    const sessionContent = JSON.parse(
+      Buffer.from(koaSession, "base64").toString("utf-8")
+    )
+    const handle = sessionContent["openidconnect:localhost"].state.handle
     return this.request
       .get(`/api/global/auth/${this.config.getTenantId()}/oidc/callback`)
-      .set(this.config.getOIDConfigCookie(configId))
+      .query({ code: "test", state: handle })
+      .set(cookie)
   }
 
   getOIDCConfig = (configId: string) => {

package/src/tests/api/email.ts

@@ -1,12 +1,9 @@
 import TestConfiguration from "../TestConfiguration"
+import { TestAPI } from "./base"
 
-export class EmailAPI {
-  config: TestConfiguration
-  request: any
-
+export class EmailAPI extends TestAPI {
   constructor(config: TestConfiguration) {
-    this.config = config
-    this.request = config.request
+    super(config)
   }
 
   sendEmail = (purpose: string) => {