@budibase/worker 1.2.58 → 1.3.1

package/src/tests/TestConfiguration.ts

@@ -0,0 +1,273 @@
+import "./mocks"
+import dbConfig from "../db"
+dbConfig.init()
+import env from "../environment"
+import controllers from "./controllers"
+const supertest = require("supertest")
+import { Configs } from "../constants"
+import {
+  users,
+  tenancy,
+  Cookies,
+  Headers,
+  sessions,
+  auth,
+} from "@budibase/backend-core"
+import { TENANT_ID, TENANT_1, CSRF_TOKEN } from "./structures"
+import structures from "./structures"
+import { CreateUserResponse, User, AuthToken } from "@budibase/types"
+
+enum Mode {
+  ACCOUNT = "account",
+  SELF = "self",
+}
+
+class TestConfiguration {
+  server: any
+  request: any
+  defaultUser?: User
+  tenant1User?: User
+
+  constructor(
+    opts: { openServer: boolean; mode: Mode } = {
+      openServer: true,
+      mode: Mode.ACCOUNT,
+    }
+  ) {
+    if (opts.mode === Mode.ACCOUNT) {
+      this.modeAccount()
+    } else if (opts.mode === Mode.SELF) {
+      this.modeSelf()
+    }
+
+    if (opts.openServer) {
+      env.PORT = "0" // random port
+      this.server = require("../index")
+      // we need the request for logging in, involves cookies, hard to fake
+      this.request = supertest(this.server)
+    }
+  }
+
+  getRequest() {
+    return this.request
+  }
+
+  // MODES
+
+  modeAccount = () => {
+    env.SELF_HOSTED = false
+    // @ts-ignore
+    env.MULTI_TENANCY = true
+    // @ts-ignore
+    env.DISABLE_ACCOUNT_PORTAL = false
+  }
+
+  modeSelf = () => {
+    env.SELF_HOSTED = true
+    // @ts-ignore
+    env.MULTI_TENANCY = false
+    // @ts-ignore
+    env.DISABLE_ACCOUNT_PORTAL = true
+  }
+
+  // UTILS
+
+  async _req(config: any, params: any, controlFunc: any) {
+    const request: any = {}
+    // fake cookies, we don't need them
+    request.cookies = { set: () => {}, get: () => {} }
+    request.config = { jwtSecret: env.JWT_SECRET }
+    request.user = { tenantId: this.getTenantId() }
+    request.query = {}
+    request.request = {
+      body: config,
+    }
+    request.throw = (status: any, err: any) => {
+      throw { status, message: err }
+    }
+    if (params) {
+      request.params = params
+    }
+    await tenancy.doInTenant(this.getTenantId(), () => {
+      return controlFunc(request)
+    })
+    return request.body
+  }
+
+  // SETUP / TEARDOWN
+
+  async beforeAll() {
+    await this.createDefaultUser()
+    await this.createSession(this.defaultUser!)
+
+    await tenancy.doInTenant(TENANT_1, async () => {
+      await this.createTenant1User()
+      await this.createSession(this.tenant1User!)
+    })
+  }
+
+  async afterAll() {
+    if (this.server) {
+      await this.server.close()
+    }
+  }
+
+  // TENANCY
+
+  getTenantId() {
+    try {
+      return tenancy.getTenantId()
+    } catch (e: any) {
+      return TENANT_ID
+    }
+  }
+
+  // USER / 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",
+    })
+    this.tenant1User = await this.createUser(user)
+  }
+
+  async createSession(user: User) {
+    await sessions.createASession(user._id!, {
+      sessionId: "sessionid",
+      tenantId: user.tenantId,
+      csrfToken: CSRF_TOKEN,
+    })
+  }
+
+  cookieHeader(cookies: any) {
+    return {
+      Cookie: [cookies],
+    }
+  }
+
+  authHeaders(user: User) {
+    const authToken: AuthToken = {
+      userId: user._id!,
+      sessionId: "sessionid",
+      tenantId: user.tenantId,
+    }
+    const authCookie = auth.jwt.sign(authToken, env.JWT_SECRET)
+    return {
+      Accept: "application/json",
+      ...this.cookieHeader([`${Cookies.Auth}=${authCookie}`]),
+      [Headers.CSRF_TOKEN]: CSRF_TOKEN,
+    }
+  }
+
+  defaultHeaders() {
+    const tenantId = this.getTenantId()
+    if (tenantId === TENANT_ID) {
+      return this.authHeaders(this.defaultUser!)
+    } else if (tenantId === TENANT_1) {
+      return this.authHeaders(this.tenant1User!)
+    } else {
+      throw new Error("could not determine auth headers to use")
+    }
+  }
+
+  async getUser(email: string): Promise<User> {
+    return tenancy.doInTenant(this.getTenantId(), () => {
+      return users.getGlobalUserByEmail(email)
+    })
+  }
+
+  async createUser(user?: User) {
+    if (!user) {
+      user = structures.users.user()
+    }
+    const response = await this._req(user, null, controllers.users.save)
+    const body = response as CreateUserResponse
+    return this.getUser(body.email)
+  }
+
+  // CONFIGS
+
+  async deleteConfig(type: any) {
+    try {
+      const cfg = await this._req(
+        null,
+        {
+          type,
+        },
+        controllers.config.find
+      )
+      if (cfg) {
+        await this._req(
+          null,
+          {
+            id: cfg._id,
+            rev: cfg._rev,
+          },
+          controllers.config.destroy
+        )
+      }
+    } catch (err) {
+      // don't need to handle error
+    }
+  }
+
+  // CONFIGS - SETTINGS
+
+  async saveSettingsConfig() {
+    await this.deleteConfig(Configs.SETTINGS)
+    await this._req(
+      structures.configs.settings(),
+      null,
+      controllers.config.save
+    )
+  }
+
+  // CONFIGS - GOOGLE
+
+  async saveGoogleConfig() {
+    await this.deleteConfig(Configs.GOOGLE)
+    await this._req(structures.configs.google(), null, controllers.config.save)
+  }
+
+  // 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()
+
+    await this._req(config, null, controllers.config.save)
+    return config
+  }
+
+  // CONFIGS - SMTP
+
+  async saveSmtpConfig() {
+    await this.deleteConfig(Configs.SMTP)
+    await this._req(structures.configs.smtp(), null, controllers.config.save)
+  }
+
+  async saveEtherealSmtpConfig() {
+    await this.deleteConfig(Configs.SMTP)
+    await this._req(
+      structures.configs.smtpEthereal(),
+      null,
+      controllers.config.save
+    )
+  }
+}
+
+export = TestConfiguration

package/src/tests/api/accounts.ts

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

package/src/tests/api/auth.ts

@@ -0,0 +1,48 @@
+import TestConfiguration from "../TestConfiguration"
+
+export class AuthAPI {
+  config: TestConfiguration
+  request: any
+
+  constructor(config: TestConfiguration) {
+    this.config = config
+    this.request = config.request
+  }
+
+  updatePassword = (code: string) => {
+    return this.request
+      .post(`/api/global/auth/${this.config.getTenantId()}/reset/update`)
+      .send({
+        password: "newpassword",
+        resetCode: code,
+      })
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
+
+  logout = () => {
+    return this.request
+      .post("/api/global/auth/logout")
+      .set(this.config.defaultHeaders())
+      .expect(200)
+  }
+
+  requestPasswordReset = async (sendMailMock: any) => {
+    await this.config.saveSmtpConfig()
+    await this.config.saveSettingsConfig()
+    await this.config.createUser()
+    const res = await this.request
+      .post(`/api/global/auth/${this.config.getTenantId()}/reset`)
+      .send({
+        email: "test@test.com",
+      })
+      .expect("Content-Type", /json/)
+      .expect(200)
+    const emailCall = sendMailMock.mock.calls[0][0]
+    const parts = emailCall.html.split(
+      `http://localhost:10000/builder/auth/reset?code=`
+    )
+    const code = parts[1].split('"')[0].split("&")[0]
+    return { code, res }
+  }
+}

package/src/tests/api/configs.ts

@@ -0,0 +1,40 @@
+import TestConfiguration from "../TestConfiguration"
+
+export class ConfigAPI {
+  config: TestConfiguration
+  request: any
+
+  constructor(config: TestConfiguration) {
+    this.config = config
+    this.request = config.request
+  }
+
+  getConfigChecklist = () => {
+    return this.request
+      .get(`/api/global/configs/checklist`)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
+
+  saveConfig = (data: any) => {
+    return this.request
+      .post(`/api/global/configs`)
+      .send(data)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
+
+  OIDCCallback = (configId: string) => {
+    return this.request
+      .get(`/api/global/auth/${this.config.getTenantId()}/oidc/callback`)
+      .set(this.config.getOIDConfigCookie(configId))
+  }
+
+  getOIDCConfig = (configId: string) => {
+    return this.request.get(
+      `/api/global/auth/${this.config.getTenantId()}/oidc/configs/${configId}`
+    )
+  }
+}

package/src/tests/api/email.ts

@@ -0,0 +1,24 @@
+import TestConfiguration from "../TestConfiguration"
+
+export class EmailAPI {
+  config: TestConfiguration
+  request: any
+
+  constructor(config: TestConfiguration) {
+    this.config = config
+    this.request = config.request
+  }
+
+  sendEmail = (purpose: string) => {
+    return this.request
+      .post(`/api/global/email/send`)
+      .send({
+        email: "test@test.com",
+        purpose,
+        tenantId: this.config.getTenantId(),
+      })
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
+}

package/src/tests/api/index.ts

@@ -0,0 +1,25 @@
+import TestConfiguration from "../TestConfiguration"
+import { AccountAPI } from "./accounts"
+import { AuthAPI } from "./auth"
+import { ConfigAPI } from "./configs"
+import { EmailAPI } from "./email"
+import { SelfAPI } from "./self"
+import { UserAPI } from "./users"
+
+export default class API {
+  accounts: AccountAPI
+  auth: AuthAPI
+  configs: ConfigAPI
+  emails: EmailAPI
+  self: SelfAPI
+  users: UserAPI
+
+  constructor(config: TestConfiguration) {
+    this.accounts = new AccountAPI(config)
+    this.auth = new AuthAPI(config)
+    this.configs = new ConfigAPI(config)
+    this.emails = new EmailAPI(config)
+    this.self = new SelfAPI(config)
+    this.users = new UserAPI(config)
+  }
+}

package/src/tests/api/self.ts

@@ -0,0 +1,21 @@
+import TestConfiguration from "../TestConfiguration"
+import { User } from "@budibase/types"
+
+export class SelfAPI {
+  config: TestConfiguration
+  request: any
+
+  constructor(config: TestConfiguration) {
+    this.config = config
+    this.request = config.request
+  }
+
+  updateSelf = (user: User) => {
+    return this.request
+      .post(`/api/global/self`)
+      .send(user)
+      .set(this.config.authHeaders(user))
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
+}

package/src/tests/api/users.ts

@@ -0,0 +1,111 @@
+import {
+  BulkCreateUsersRequest,
+  BulkCreateUsersResponse,
+  BulkDeleteUsersRequest,
+  CreateUserResponse,
+  InviteUsersRequest,
+  User,
+  UserDetails,
+} from "@budibase/types"
+import TestConfiguration from "../TestConfiguration"
+
+export class UserAPI {
+  config: TestConfiguration
+  request: any
+
+  constructor(config: TestConfiguration) {
+    this.config = config
+    this.request = config.request
+  }
+
+  // INVITE
+
+  sendUserInvite = async (sendMailMock: any, email: string, status = 200) => {
+    await this.config.saveSmtpConfig()
+    await this.config.saveSettingsConfig()
+    const res = await this.request
+      .post(`/api/global/users/invite`)
+      .send({
+        email,
+      })
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(status)
+
+    if (status !== 200) {
+      return { code: undefined, res }
+    }
+
+    const emailCall = sendMailMock.mock.calls[0][0]
+    // after this URL there should be a code
+    const parts = emailCall.html.split(
+      "http://localhost:10000/builder/invite?code="
+    )
+    const code = parts[1].split('"')[0].split("&")[0]
+    return { code, res }
+  }
+
+  acceptInvite = (code: string) => {
+    return this.request
+      .post(`/api/global/users/invite/accept`)
+      .send({
+        password: "newpassword",
+        inviteCode: code,
+      })
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
+
+  sendMultiUserInvite = async (request: InviteUsersRequest, status = 200) => {
+    await this.config.saveSmtpConfig()
+    await this.config.saveSettingsConfig()
+    return this.request
+      .post(`/api/global/users/multi/invite`)
+      .send(request)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(status)
+  }
+
+  // BULK
+
+  bulkCreateUsers = async (users: User[], groups: any[] = []) => {
+    const body: BulkCreateUsersRequest = { users, groups }
+    const res = await this.request
+      .post(`/api/global/users/bulkCreate`)
+      .send(body)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+
+    return res.body as BulkCreateUsersResponse
+  }
+
+  bulkDeleteUsers = (body: BulkDeleteUsersRequest, status?: number) => {
+    return this.request
+      .post(`/api/global/users/bulkDelete`)
+      .send(body)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(status ? status : 200)
+  }
+
+  // USER
+
+  saveUser = (user: User, status?: number) => {
+    return this.request
+      .post(`/api/global/users`)
+      .send(user)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(status ? status : 200)
+  }
+
+  deleteUser = (userId: string, status?: number) => {
+    return this.request
+      .delete(`/api/global/users/${userId}`)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(status ? status : 200)
+  }
+}

package/src/tests/index.ts

@@ -0,0 +1,14 @@
+import TestConfiguration from "./TestConfiguration"
+import structures from "./structures"
+import mocks from "./mocks"
+import API from "./api"
+
+const pkg = {
+  structures,
+  TENANT_1: structures.TENANT_1,
+  mocks,
+  TestConfiguration,
+  API,
+}
+
+export = pkg

package/src/tests/mocks/index.ts

@@ -0,0 +1,7 @@
+const email = require("./email")
+import { mocks as coreMocks } from "@budibase/backend-core/tests"
+
+export = {
+  email,
+  ...coreMocks,
+}

package/src/tests/structures/accounts.ts

@@ -0,0 +1,24 @@
+import { Account, AuthType, Hosting, CloudAccount } from "@budibase/types"
+import { v4 as uuid } from "uuid"
+import { utils } from "@budibase/backend-core"
+
+export const account = (): Account => {
+  return {
+    email: `${uuid()}@test.com`,
+    tenantId: utils.newid(),
+    hosting: Hosting.SELF,
+    authType: AuthType.SSO,
+    accountId: uuid(),
+    createdAt: Date.now(),
+    verified: true,
+    verificationSent: true,
+    tier: "FREE",
+  }
+}
+
+export const cloudAccount = (): CloudAccount => {
+  return {
+    ...account(),
+    budibaseUserId: uuid(),
+  }
+}

package/src/tests/structures/index.ts

@@ -0,0 +1,20 @@
+import configs from "./configs"
+import * as users from "./users"
+import * as groups from "./groups"
+import * as accounts from "./accounts"
+
+const TENANT_ID = "default"
+const TENANT_1 = "tenant1"
+const CSRF_TOKEN = "e3727778-7af0-4226-b5eb-f43cbe60a306"
+
+const pkg = {
+  configs,
+  users,
+  accounts,
+  TENANT_ID,
+  TENANT_1,
+  CSRF_TOKEN,
+  groups,
+}
+
+export = pkg

package/src/tests/structures/users.ts

@@ -1,24 +1,32 @@
 export const email = "test@test.com"
+import { AdminUser, BuilderUser, User } from "@budibase/types"
+import { v4 as uuid } from "uuid"
 
-export const user = (userProps: any) => {
+export const newEmail = () => {
+  return `${uuid()}@test.com`
+}
+export const user = (userProps?: any): User => {
   return {
-    email: "test@test.com",
+    email: newEmail(),
     password: "test",
     roles: {},
     ...userProps,
   }
 }
 
-export const adminUser = (userProps: any) => {
+export const adminUser = (userProps?: any): AdminUser => {
   return {
     ...user(userProps),
     admin: {
       global: true,
     },
+    builder: {
+      global: true,
+    },
   }
 }
 
-export const builderUser = (userProps: any) => {
+export const builderUser = (userProps?: any): BuilderUser => {
   return {
     ...user(userProps),
     builder: {

package/src/utilities/redis.js

@@ -55,6 +55,7 @@ exports.init = async () => {
 exports.shutdown = async () => {
   if (pwResetClient) await pwResetClient.finish()
   if (invitationClient) await invitationClient.finish()
+  console.log("Redis shutdown")
 }
 
 /**