@budibase/server 2.3.19 → 2.3.21-alpha.0

package/src/tests/jestEnv.ts

@@ -1,13 +1,11 @@
-import env from "../environment"
 import { tmpdir } from "os"
 
-env._set("SELF_HOSTED", "1")
-env._set("NODE_ENV", "jest")
-env._set("JWT_SECRET", "test-jwtsecret")
-env._set("CLIENT_ID", "test-client-id")
-env._set("BUDIBASE_DIR", tmpdir("budibase-unittests"))
-env._set("LOG_LEVEL", "silent")
-env._set("PORT", 0)
-env._set("MINIO_URL", "http://localhost")
-env._set("MINIO_ACCESS_KEY", "test")
-env._set("MINIO_SECRET_KEY", "test")
+process.env.SELF_HOSTED = "1"
+process.env.NODE_ENV = "jest"
+process.env.MULTI_TENANCY = "1"
+// @ts-ignore
+process.env.BUDIBASE_DIR = tmpdir("budibase-unittests")
+process.env.LOG_LEVEL = process.env.LOG_LEVEL || "error"
+process.env.ENABLE_4XX_HTTP_LOGGING = "0"
+process.env.MOCK_REDIS = "1"
+process.env.PLATFORM_URL = "http://localhost:10000"

package/src/tests/jestSetup.ts

@@ -1,9 +1,7 @@
-import { mocks } from "@budibase/backend-core/tests"
-
-// mock all dates to 2020-01-01T00:00:00.000Z
-// use tk.reset() to use real dates in individual tests
-const tk = require("timekeeper")
-tk.freeze(mocks.date.MOCK_DATE)
+import "./logging"
+import env from "../environment"
+import { env as coreEnv } from "@budibase/backend-core"
+import { testContainerUtils } from "@budibase/backend-core/tests"
 
 if (!process.env.DEBUG) {
   global.console.log = jest.fn() // console.log are ignored in tests
@@ -13,5 +11,9 @@ if (!process.env.DEBUG) {
 if (!process.env.CI) {
   // set a longer timeout in dev for debugging
   // 100 seconds
-  jest.setTimeout(100000)
+  jest.setTimeout(100 * 1000)
+} else {
+  jest.setTimeout(10 * 1000)
 }
+
+testContainerUtils.setupEnv(env, coreEnv)

package/src/tests/logging.ts

@@ -0,0 +1,34 @@
+export enum LogLevel {
+  TRACE = "trace",
+  DEBUG = "debug",
+  INFO = "info",
+  WARN = "warn",
+  ERROR = "error",
+}
+
+const LOG_INDEX: { [key in LogLevel]: number } = {
+  [LogLevel.TRACE]: 1,
+  [LogLevel.DEBUG]: 2,
+  [LogLevel.INFO]: 3,
+  [LogLevel.WARN]: 4,
+  [LogLevel.ERROR]: 5,
+}
+
+const setIndex = LOG_INDEX[process.env.LOG_LEVEL as LogLevel]
+
+if (setIndex > LOG_INDEX.trace) {
+  global.console.trace = jest.fn()
+}
+
+if (setIndex > LOG_INDEX.debug) {
+  global.console.debug = jest.fn()
+}
+
+if (setIndex > LOG_INDEX.info) {
+  global.console.info = jest.fn()
+  global.console.log = jest.fn()
+}
+
+if (setIndex > LOG_INDEX.warn) {
+  global.console.warn = jest.fn()
+}

package/src/tests/utilities/TestConfiguration.ts

@@ -1,4 +1,4 @@
-import { mocks } from "@budibase/backend-core/tests"
+import { generator, mocks, structures } from "@budibase/backend-core/tests"
 
 // init the licensing mock
 import * as pro from "@budibase/pro"
@@ -10,6 +10,7 @@ mocks.licenses.useUnlimited()
 import { init as dbInit } from "../../db"
 dbInit()
 import env from "../../environment"
+import { env as coreEnv } from "@budibase/backend-core"
 import {
   basicTable,
   basicRow,
@@ -20,7 +21,6 @@ import {
   basicScreen,
   basicLayout,
   basicWebhook,
-  TENANT_ID,
 } from "./structures"
 import {
   constants,
@@ -38,21 +38,31 @@ import { cleanup } from "../../utilities/fileSystem"
 import newid from "../../db/newid"
 import { generateUserMetadataID } from "../../db/utils"
 import { startup } from "../../startup"
-const supertest = require("supertest")
-
-const GLOBAL_USER_ID = "us_uuid1"
-const EMAIL = "babs@babs.com"
-const FIRSTNAME = "Barbara"
-const LASTNAME = "Barbington"
-const CSRF_TOKEN = "e3727778-7af0-4226-b5eb-f43cbe60a306"
+import supertest from "supertest"
+import {
+  App,
+  AuthToken,
+  Datasource,
+  Row,
+  SourceName,
+  Table,
+} from "@budibase/types"
+
+type DefaultUserValues = {
+  globalUserId: string
+  email: string
+  firstName: string
+  lastName: string
+  csrfToken: string
+}
 
 class TestConfiguration {
   server: any
-  request: any
+  request: supertest.SuperTest<supertest.Test> | undefined
   started: boolean
   appId: string | null
   allApps: any[]
-  app: any
+  app?: App
   prodApp: any
   prodAppId: any
   user: any
@@ -62,6 +72,8 @@ class TestConfiguration {
   linkedTable: any
   automation: any
   datasource: any
+  tenantId?: string
+  defaultUserValues: DefaultUserValues
 
   constructor(openServer = true) {
     if (openServer) {
@@ -76,6 +88,17 @@ class TestConfiguration {
     }
     this.appId = null
     this.allApps = []
+    this.defaultUserValues = this.populateDefaultUserValues()
+  }
+
+  populateDefaultUserValues(): DefaultUserValues {
+    return {
+      globalUserId: `us_${newid()}`,
+      email: generator.email(),
+      firstName: generator.first(),
+      lastName: generator.last(),
+      csrfToken: generator.hash(),
+    }
   }
 
   getRequest() {
@@ -100,10 +123,10 @@ class TestConfiguration {
 
   getUserDetails() {
     return {
-      globalId: GLOBAL_USER_ID,
-      email: EMAIL,
-      firstName: FIRSTNAME,
-      lastName: LASTNAME,
+      globalId: this.defaultUserValues.globalUserId,
+      email: this.defaultUserValues.email,
+      firstName: this.defaultUserValues.firstName,
+      lastName: this.defaultUserValues.lastName,
     }
   }
 
@@ -111,7 +134,9 @@ class TestConfiguration {
     if (!appId) {
       appId = this.appId
     }
-    return tenancy.doInTenant(TENANT_ID, () => {
+
+    const tenant = this.getTenantId()
+    return tenancy.doInTenant(tenant, () => {
       // check if already in a context
       if (context.getAppId() == null && appId !== null) {
         return context.doInAppContext(appId, async () => {
@@ -130,11 +155,7 @@ class TestConfiguration {
     if (!this.started) {
       await startup()
     }
-    this.user = await this.globalUser()
-    this.globalUserId = this.user._id
-    this.userMetadataId = generateUserMetadataID(this.globalUserId)
-
-    return this.createApp(appName)
+    return this.newTenant(appName)
   }
 
   end() {
@@ -149,9 +170,28 @@ class TestConfiguration {
     }
   }
 
+  // MODES
+  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)
+  }
+
+  modeSelf = () => {
+    this.setSelfHosted(true)
+  }
+
   // UTILS
 
-  async _req(body: any, params: any, controlFunc: any) {
+  _req(body: any, params: any, controlFunc: any) {
     // create a fake request ctx
     const request: any = {}
     const appId = this.appId
@@ -159,7 +199,7 @@ class TestConfiguration {
     // fake cookies, we don't need them
     request.cookies = { set: () => {}, get: () => {} }
     request.config = { jwtSecret: env.JWT_SECRET }
-    request.user = { appId, tenantId: TENANT_ID }
+    request.user = { appId, tenantId: this.getTenantId() }
     request.query = {}
     request.request = {
       body,
@@ -175,61 +215,70 @@ class TestConfiguration {
 
   // USER / AUTH
   async globalUser({
-    id = GLOBAL_USER_ID,
-    firstName = FIRSTNAME,
-    lastName = LASTNAME,
+    id = this.defaultUserValues.globalUserId,
+    firstName = this.defaultUserValues.firstName,
+    lastName = this.defaultUserValues.lastName,
     builder = true,
     admin = false,
-    email = EMAIL,
+    email = this.defaultUserValues.email,
     roles,
   }: any = {}) {
-    return tenancy.doWithGlobalDB(TENANT_ID, async (db: any) => {
-      let existing
-      try {
-        existing = await db.get(id)
-      } catch (err) {
-        existing = { email }
-      }
-      const user = {
-        _id: id,
-        ...existing,
-        roles: roles || {},
-        tenantId: TENANT_ID,
-        firstName,
-        lastName,
-      }
-      await sessions.createASession(id, {
-        sessionId: "sessionid",
-        tenantId: TENANT_ID,
-        csrfToken: CSRF_TOKEN,
-      })
-      if (builder) {
-        user.builder = { global: true }
-      } else {
-        user.builder = { global: false }
-      }
-      if (admin) {
-        user.admin = { global: true }
-      } else {
-        user.admin = { global: false }
-      }
-      const resp = await db.put(user)
-      return {
-        _rev: resp._rev,
-        ...user,
-      }
+    const db = tenancy.getTenantDB(this.getTenantId())
+    let existing
+    try {
+      existing = await db.get(id)
+    } catch (err) {
+      existing = { email }
+    }
+    const user = {
+      _id: id,
+      ...existing,
+      roles: roles || {},
+      tenantId: this.getTenantId(),
+      firstName,
+      lastName,
+    }
+    await sessions.createASession(id, {
+      sessionId: "sessionid",
+      tenantId: this.getTenantId(),
+      csrfToken: this.defaultUserValues.csrfToken,
     })
+    if (builder) {
+      user.builder = { global: true }
+    } else {
+      user.builder = { global: false }
+    }
+    if (admin) {
+      user.admin = { global: true }
+    } else {
+      user.admin = { global: false }
+    }
+    const resp = await db.put(user)
+    return {
+      _rev: resp.rev,
+      ...user,
+    }
   }
 
   async createUser(
-    id = null,
-    firstName = FIRSTNAME,
-    lastName = LASTNAME,
-    email = EMAIL,
-    builder = true,
-    admin = false,
-    roles = {}
+    user: {
+      id?: string
+      firstName?: string
+      lastName?: string
+      email?: string
+      builder?: boolean
+      admin?: boolean
+      roles?: any
+    } = {}
   ) {
+    let { id, firstName, lastName, email, builder, admin, roles } = user
+    firstName = firstName || this.defaultUserValues.firstName
+    lastName = lastName || this.defaultUserValues.lastName
+    email = email || this.defaultUserValues.email
+    roles = roles || {}
+    if (builder == null) {
+      builder = true
+    }
     const globalId = !id ? `us_${Math.random()}` : `us_${id}`
     const resp = await this.globalUser({
       id: globalId,
@@ -264,13 +313,13 @@ class TestConfiguration {
       }
       await sessions.createASession(userId, {
         sessionId: "sessionid",
-        tenantId: TENANT_ID,
+        tenantId: this.getTenantId(),
       })
       // have to fake this
       const authObj = {
         userId,
         sessionId: "sessionid",
-        tenantId: TENANT_ID,
+        tenantId: this.getTenantId(),
       }
       const app = {
         roleId: roleId,
@@ -292,11 +341,14 @@ class TestConfiguration {
     })
   }
 
+  // HEADERS
+
   defaultHeaders(extras = {}) {
-    const authObj = {
-      userId: GLOBAL_USER_ID,
+    const tenantId = this.getTenantId()
+    const authObj: AuthToken = {
+      userId: this.defaultUserValues.globalUserId,
       sessionId: "sessionid",
-      tenantId: TENANT_ID,
+      tenantId,
     }
     const app = {
       roleId: roles.BUILTIN_ROLE_IDS.ADMIN,
@@ -310,9 +362,11 @@ class TestConfiguration {
         `${constants.Cookie.Auth}=${authToken}`,
         `${constants.Cookie.CurrentApp}=${appToken}`,
       ],
-      [constants.Header.CSRF_TOKEN]: CSRF_TOKEN,
+      [constants.Header.CSRF_TOKEN]: this.defaultUserValues.csrfToken,
+      Host: this.tenantHost(),
       ...extras,
     }
+
     if (this.appId) {
       headers[constants.Header.APP_ID] = this.appId
     }
@@ -328,11 +382,14 @@ class TestConfiguration {
     if (appId) {
       headers[constants.Header.APP_ID] = appId
     }
+
+    headers[constants.Header.TENANT_ID] = this.getTenantId()
+
     return headers
   }
 
   async roleHeaders({
-    email = EMAIL,
+    email = this.defaultUserValues.email,
     roleId = roles.BUILTIN_ROLE_IDS.ADMIN,
     builder = false,
     prodApp = true,
@@ -340,27 +397,54 @@ class TestConfiguration {
     return this.login({ email, roleId, builder, prodApp })
   }
 
+  // TENANCY
+
+  tenantHost() {
+    const tenantId = this.getTenantId()
+    const platformHost = new URL(coreEnv.PLATFORM_URL).host.split(":")[0]
+    return `${tenantId}.${platformHost}`
+  }
+
+  getTenantId() {
+    if (!this.tenantId) {
+      throw new Error("no test tenant id - init has not been called")
+    }
+    return this.tenantId
+  }
+
+  async newTenant(appName = newid()): Promise<App> {
+    this.defaultUserValues = this.populateDefaultUserValues()
+    this.tenantId = structures.tenant.id()
+    this.user = await this.globalUser()
+    this.globalUserId = this.user._id
+    this.userMetadataId = generateUserMetadataID(this.globalUserId)
+    return this.createApp(appName)
+  }
+
+  doInTenant(task: any) {
+    return context.doInTenant(this.getTenantId(), task)
+  }
+
   // API
 
-  async generateApiKey(userId = GLOBAL_USER_ID) {
-    return tenancy.doWithGlobalDB(TENANT_ID, async (db: any) => {
-      const id = dbCore.generateDevInfoID(userId)
-      let devInfo
-      try {
-        devInfo = await db.get(id)
-      } catch (err) {
-        devInfo = { _id: id, userId }
-      }
-      devInfo.apiKey = encryption.encrypt(
-        `${TENANT_ID}${dbCore.SEPARATOR}${newid()}`
-      )
-      await db.put(devInfo)
-      return devInfo.apiKey
-    })
+  async generateApiKey(userId = this.defaultUserValues.globalUserId) {
+    const db = tenancy.getTenantDB(this.getTenantId())
+    const id = dbCore.generateDevInfoID(userId)
+    let devInfo
+    try {
+      devInfo = await db.get(id)
+    } catch (err) {
+      devInfo = { _id: id, userId }
+    }
+    devInfo.apiKey = encryption.encrypt(
+      `${this.getTenantId()}${dbCore.SEPARATOR}${newid()}`
+    )
+    await db.put(devInfo)
+    return devInfo.apiKey
   }
 
   // APP
-  async createApp(appName: string) {
+  async createApp(appName: string): Promise<App> {
     // create dev app
     // clear any old app
     this.appId = null
@@ -370,7 +454,7 @@ class TestConfiguration {
         null,
         controllers.app.create
       )
-      this.appId = this.app.appId
+      this.appId = this.app?.appId!
     })
     return await context.doInAppContext(this.appId, async () => {
       // create production app
@@ -408,13 +492,13 @@ class TestConfiguration {
 
   // TABLE
 
-  async updateTable(config?: any) {
+  async updateTable(config?: any): Promise<Table> {
     config = config || basicTable()
     this.table = await this._req(config, null, controllers.table.save)
     return this.table
   }
 
-  async createTable(config?: any) {
+  async createTable(config?: Table) {
     if (config != null && config._id) {
       delete config._id
     }
@@ -458,7 +542,7 @@ class TestConfiguration {
 
   // ROW
 
-  async createRow(config: any = null) {
+  async createRow(config?: Row): Promise<Row> {
     if (!this.table) {
       throw "Test requires table to be configured."
     }
@@ -467,7 +551,7 @@ class TestConfiguration {
     return this._req(config, { tableId }, controllers.row.save)
   }
 
-  async getRow(tableId: string, rowId: string) {
+  async getRow(tableId: string, rowId: string): Promise<Row> {
     return this._req(null, { tableId, rowId }, controllers.row.find)
   }
 
@@ -549,7 +633,9 @@ class TestConfiguration {
 
   // DATASOURCE
 
-  async createDatasource(config?: any) {
+  async createDatasource(config?: {
+    datasource: Datasource
+  }): Promise<Datasource> {
     config = config || basicDatasource()
     const response = await this._req(config, null, controllers.datasource.save)
     this.datasource = response.datasource
@@ -570,7 +656,7 @@ class TestConfiguration {
     return this.createDatasource({
       datasource: {
         ...basicDatasource().datasource,
-        source: "REST",
+        source: SourceName.REST,
         config: cfg || {},
       },
     })
@@ -579,7 +665,7 @@ class TestConfiguration {
   async dynamicVariableDatasource() {
     let datasource = await this.restDatasource()
     const basedOnQuery = await this.createQuery({
-      ...basicQuery(datasource._id),
+      ...basicQuery(datasource._id!),
       fields: {
         path: "www.google.com",
       },
@@ -607,7 +693,7 @@ class TestConfiguration {
     datasource: any,
     fields: any,
     params: any,
-    verb: string
+    verb?: string
   ) {
     return request
       .post(`/api/queries/preview`)

package/src/tests/utilities/structures.ts

@@ -7,12 +7,12 @@ import {
   Automation,
   AutomationActionStepId,
   AutomationTriggerStepId,
+  Datasource,
+  SourceName,
 } from "@budibase/types"
 
 const { v4: uuidv4 } = require("uuid")
 
-export const TENANT_ID = "default"
-
 export function basicTable() {
   return {
     name: "TestTable",
@@ -207,12 +207,12 @@ export function basicRole() {
   }
 }
 
-export function basicDatasource() {
+export function basicDatasource(): { datasource: Datasource } {
   return {
     datasource: {
       type: "datasource",
       name: "Test",
-      source: "POSTGRES",
+      source: SourceName.POSTGRES,
       config: {},
     },
   }
@@ -255,3 +255,15 @@ export function basicWebhook(automationId: string) {
     },
   }
 }
+
+export function basicEnvironmentVariable(
+  name: string,
+  prod: string,
+  dev?: string
+) {
+  return {
+    name,
+    production: prod,
+    development: dev || prod,
+  }
+}

package/src/utilities/redis.ts

@@ -21,6 +21,8 @@ export async function shutdown() {
   if (devAppClient) await devAppClient.finish()
   if (debounceClient) await debounceClient.finish()
   if (flagClient) await flagClient.finish()
+  // shutdown core clients
+  await redis.clients.shutdown()
   console.log("Redis shutdown")
 }
 

package/src/utilities/retry.ts

@@ -0,0 +1,18 @@
+export async function retry<T extends (...arg0: any[]) => any>(
+  fn: T,
+  maxTry: number = 5,
+  retryCount = 1
+): Promise<Awaited<ReturnType<T>>> {
+  const currRetry = typeof retryCount === "number" ? retryCount : 1
+  try {
+    const result = await fn()
+    return result
+  } catch (e) {
+    console.log(`Retry ${currRetry} failed.`)
+    if (currRetry > maxTry) {
+      console.log(`All ${maxTry} retry attempts exhausted`)
+      throw e
+    }
+    return retry(fn, maxTry, currRetry + 1)
+  }
+}

package/tsconfig.build.json

@@ -20,6 +20,7 @@
     "dist",
     "src/tests",
     "src/api/routes/tests/utilities",
+    "src/api/routes/public/tests/utils.ts",
     "src/automations/tests/utilities",
     "**/*.spec.ts",
     "**/*.spec.js"