@budibase/backend-core 3.2.4 → 3.2.6

package/tests/core/utilities/structures/quotas.ts

@@ -1,72 +0,0 @@
-import { MonthlyQuotaName, QuotaUsage } from "@budibase/types"
-
-export const usage = (users: number = 0, creators: number = 0): QuotaUsage => {
-  return {
-    _id: "usage_quota",
-    quotaReset: new Date().toISOString(),
-    apps: {
-      app_1: {
-        // @ts-ignore - the apps definition doesn't match up to actual usage
-        usageQuota: {
-          rows: 0,
-        },
-      },
-    },
-    monthly: {
-      "01-2023": {
-        automations: 0,
-        dayPasses: 0,
-        queries: 0,
-        budibaseAICredits: 0,
-        triggers: {},
-        breakdown: {
-          rowQueries: {
-            parent: MonthlyQuotaName.QUERIES,
-            values: {
-              row_1: 0,
-              row_2: 0,
-            },
-          },
-          datasourceQueries: {
-            parent: MonthlyQuotaName.QUERIES,
-            values: {
-              ds_1: 0,
-              ds_2: 0,
-            },
-          },
-          automations: {
-            parent: MonthlyQuotaName.AUTOMATIONS,
-            values: {
-              auto_1: 0,
-              auto_2: 0,
-            },
-          },
-        },
-      },
-      "02-2023": {
-        automations: 0,
-        dayPasses: 0,
-        queries: 0,
-        budibaseAICredits: 0,
-        triggers: {},
-      },
-      current: {
-        automations: 0,
-        dayPasses: 0,
-        queries: 0,
-        budibaseAICredits: 0,
-        triggers: {},
-      },
-    },
-    usageQuota: {
-      apps: 0,
-      plugins: 0,
-      users,
-      creators,
-      userGroups: 0,
-      rows: 0,
-      aiCustomConfigs: 0,
-      triggers: {},
-    },
-  }
-}

package/tests/core/utilities/structures/scim.ts

@@ -1,80 +0,0 @@
-import { ScimCreateGroupRequest, ScimCreateUserRequest } from "@budibase/types"
-import { uuid } from "./common"
-import { generator } from "./generator"
-
-interface CreateUserRequestFields {
-  externalId: string
-  email: string
-  firstName: string
-  lastName: string
-  username: string
-}
-
-export function createUserRequest(userData?: Partial<CreateUserRequestFields>) {
-  const defaultValues = {
-    externalId: uuid(),
-    email: `${uuid()}@example.com`,
-    firstName: generator.first(),
-    lastName: generator.last(),
-    username: generator.name(),
-  }
-
-  const { externalId, email, firstName, lastName, username } = {
-    ...defaultValues,
-    ...userData,
-  }
-
-  let user: ScimCreateUserRequest = {
-    schemas: [
-      "urn:ietf:params:scim:schemas:core:2.0:User",
-      "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User",
-    ],
-    externalId,
-    userName: username,
-    active: true,
-    emails: [
-      {
-        primary: true,
-        type: "work",
-        value: email,
-      },
-    ],
-    meta: {
-      resourceType: "User",
-    },
-    roles: [],
-  }
-
-  if (firstName || lastName) {
-    user.name = {
-      formatted: [firstName, lastName].filter(s => s).join(" "),
-      familyName: lastName,
-      givenName: firstName,
-    }
-  }
-
-  return user
-}
-
-export function createGroupRequest(groupData?: {
-  externalId?: string
-  displayName?: string
-}) {
-  const { externalId = uuid(), displayName = generator.word() } =
-    groupData || {}
-
-  const group: ScimCreateGroupRequest = {
-    schemas: [
-      "urn:ietf:params:scim:schemas:core:2.0:Group",
-      "http://schemas.microsoft.com/2006/11/ResourceManagement/ADSCIM/2.0/Group",
-    ],
-    externalId: externalId,
-    displayName: displayName,
-    meta: {
-      resourceType: "Group",
-      created: new Date(),
-      lastModified: new Date(),
-    },
-  }
-  return group
-}

package/tests/core/utilities/structures/sso.ts

@@ -1,118 +0,0 @@
-import {
-  ConfigType,
-  GoogleConfig,
-  GoogleInnerConfig,
-  JwtClaims,
-  OAuth2,
-  OIDCInnerConfig,
-  OIDCWellKnownConfig,
-  SSOAuthDetails,
-  SSOProfile,
-  SSOProviderType,
-  User,
-} from "@budibase/types"
-import { generator } from "./generator"
-import { email, uuid } from "./common"
-import * as users from "./users"
-import sample from "lodash/sample"
-
-export function OAuth(): OAuth2 {
-  return {
-    refreshToken: generator.string(),
-    accessToken: generator.string(),
-  }
-}
-
-export function authDetails(userDoc?: User): SSOAuthDetails {
-  if (!userDoc) {
-    userDoc = users.user()
-  }
-
-  const userId = userDoc._id || uuid()
-  const provider = generator.string()
-
-  const profile = ssoProfile(userDoc)
-  profile.provider = provider
-  profile.id = userId
-
-  return {
-    email: userDoc.email,
-    oauth2: OAuth(),
-    profile,
-    provider,
-    providerType: providerType(),
-    userId,
-  }
-}
-
-export function providerType(): SSOProviderType {
-  return sample(Object.values(SSOProviderType)) as SSOProviderType
-}
-
-export function ssoProfile(user?: User): SSOProfile {
-  if (!user) {
-    user = users.user()
-  }
-  return {
-    id: user._id!,
-    name: {
-      givenName: user.firstName,
-      familyName: user.lastName,
-    },
-    _json: {
-      email: user.email,
-      picture: "http://example.com",
-    },
-    provider: generator.string(),
-  }
-}
-
-// OIDC
-
-export function oidcConfig(): OIDCInnerConfig {
-  return {
-    uuid: uuid(),
-    activated: true,
-    logo: "",
-    name: generator.string(),
-    configUrl: "http://someconfigurl",
-    clientID: generator.string(),
-    clientSecret: generator.string(),
-    scopes: [],
-  }
-}
-
-// response from .well-known/openid-configuration
-export function oidcWellKnownConfig(): OIDCWellKnownConfig {
-  return {
-    issuer: generator.string(),
-    authorization_endpoint: generator.url(),
-    token_endpoint: generator.url(),
-    userinfo_endpoint: generator.url(),
-  }
-}
-
-export function jwtClaims(): JwtClaims {
-  return {
-    email: email(),
-    preferred_username: email(),
-  }
-}
-
-// GOOGLE
-
-export function googleConfig(): GoogleInnerConfig {
-  return {
-    activated: true,
-    clientID: generator.string(),
-    clientSecret: generator.string(),
-  }
-}
-
-export function googleConfigDoc(): GoogleConfig {
-  return {
-    _id: "config_google",
-    type: ConfigType.GOOGLE,
-    config: googleConfig(),
-  }
-}

package/tests/core/utilities/structures/tenants.ts

@@ -1,5 +0,0 @@
-import { newid } from "../../../../src/docIds/newid"
-
-export function id() {
-  return `tenant-${newid()}`
-}

package/tests/core/utilities/structures/userGroups.ts

@@ -1,10 +0,0 @@
-import { UserGroup } from "@budibase/types"
-import { generator } from "./generator"
-
-export function userGroup(): UserGroup {
-  return {
-    name: generator.guid(),
-    icon: generator.word(),
-    color: generator.word(),
-  }
-}

package/tests/core/utilities/structures/users.ts

@@ -1,89 +0,0 @@
-import {
-  AdminUser,
-  AdminOnlyUser,
-  BuilderUser,
-  SSOAuthDetails,
-  SSOUser,
-  User,
-} from "@budibase/types"
-import { authDetails } from "./sso"
-import { uuid } from "./common"
-import { generator } from "./generator"
-import { tenant } from "."
-
-export const newEmail = () => {
-  return `${uuid()}@example.com`
-}
-
-export const user = (userProps?: Partial<Omit<User, "userId">>): User => {
-  const userId = userProps?._id
-  return {
-    _id: userId,
-    userId,
-    email: newEmail(),
-    password: "password123!",
-    roles: { app_test: "admin" },
-    firstName: generator.first(),
-    lastName: generator.last(),
-    tenantId: tenant.id(),
-    ...userProps,
-  }
-}
-
-export const adminUser = (userProps?: any): AdminUser => {
-  return {
-    ...user(userProps),
-    admin: {
-      global: true,
-    },
-    builder: {
-      global: true,
-    },
-  }
-}
-
-export const adminOnlyUser = (userProps?: any): AdminOnlyUser => {
-  return {
-    ...user(userProps),
-    admin: {
-      global: true,
-    },
-  }
-}
-
-export const builderUser = (userProps?: Partial<User>): BuilderUser => {
-  return {
-    ...user(userProps),
-    builder: {
-      global: true,
-    },
-  }
-}
-
-export const appBuilderUser = (appId: string, userProps?: any): BuilderUser => {
-  return {
-    ...user(userProps),
-    builder: {
-      apps: [appId],
-    },
-  }
-}
-
-export function ssoUser(
-  opts: { user?: any; details?: SSOAuthDetails } = {}
-): SSOUser {
-  const base = user(opts.user)
-  delete base.password
-
-  if (!opts.details) {
-    opts.details = authDetails(base)
-  }
-
-  return {
-    ...base,
-    forceResetPassword: false,
-    oauth2: opts.details?.oauth2,
-    provider: opts.details?.provider!,
-    providerType: opts.details?.providerType!,
-  }
-}

package/tests/core/utilities/testContainerUtils.ts

@@ -1,165 +0,0 @@
-import { execSync } from "child_process"
-import { cloneDeep } from "lodash"
-import { GenericContainer, StartedTestContainer } from "testcontainers"
-
-const IPV4_PORT_REGEX = new RegExp(`0\\.0\\.0\\.0:(\\d+)->(\\d+)/tcp`, "g")
-
-interface ContainerInfo {
-  Command: string
-  CreatedAt: string
-  ID: string
-  Image: string
-  Labels: string
-  LocalVolumes: string
-  Mounts: string
-  Names: string
-  Networks: string
-  Ports: string
-  RunningFor: string
-  Size: string
-  State: string
-  Status: string
-}
-
-function getTestcontainers(): ContainerInfo[] {
-  // We use --format json to make sure the output is nice and machine-readable,
-  // and we use --no-trunc so that the command returns full container IDs so we
-  // can filter on them correctly.
-  return execSync("docker ps --format json --no-trunc")
-    .toString()
-    .split("\n")
-    .filter(x => x.length > 0)
-    .map(x => JSON.parse(x) as ContainerInfo)
-    .filter(
-      x =>
-        x.Labels.includes("org.testcontainers=true") &&
-        x.Labels.includes("com.budibase=true")
-    )
-}
-
-export function getContainerByImage(image: string) {
-  const containers = getTestcontainers().filter(x => x.Image.startsWith(image))
-  if (containers.length > 1) {
-    let errorMessage = `Multiple containers found starting with image: "${image}"\n\n`
-    for (const container of containers) {
-      errorMessage += JSON.stringify(container, null, 2)
-    }
-    throw new Error(errorMessage)
-  }
-  return containers[0]
-}
-
-export function getContainerById(id: string) {
-  return getTestcontainers().find(x => x.ID === id)
-}
-
-export interface Port {
-  host: number
-  container: number
-}
-
-export function getExposedV4Ports(container: ContainerInfo): Port[] {
-  let ports: Port[] = []
-  for (const match of container.Ports.matchAll(IPV4_PORT_REGEX)) {
-    ports.push({ host: parseInt(match[1]), container: parseInt(match[2]) })
-  }
-  return ports
-}
-
-export function getExposedV4Port(container: ContainerInfo, port: number) {
-  return getExposedV4Ports(container).find(x => x.container === port)?.host
-}
-
-export function setupEnv(...envs: any[]) {
-  // We start couchdb in globalSetup.ts, in the root of the monorepo, so it
-  // should be relatively safe to look for it by its image name.
-  const couch = getContainerByImage("budibase/couchdb")
-  if (!couch) {
-    throw new Error("CouchDB container not found")
-  }
-
-  const couchPort = getExposedV4Port(couch, 5984)
-  if (!couchPort) {
-    throw new Error("CouchDB port not found")
-  }
-
-  const couchSqlPort = getExposedV4Port(couch, 4984)
-  if (!couchSqlPort) {
-    throw new Error("CouchDB SQL port not found")
-  }
-
-  const minio = getContainerByImage("minio/minio")
-
-  const minioPort = getExposedV4Port(minio, 9000)
-  if (!minioPort) {
-    throw new Error("Minio port not found")
-  }
-
-  const configs = [
-    { key: "COUCH_DB_PORT", value: `${couchPort}` },
-    { key: "COUCH_DB_URL", value: `http://127.0.0.1:${couchPort}` },
-    { key: "COUCH_DB_SQL_URL", value: `http://127.0.0.1:${couchSqlPort}` },
-    { key: "MINIO_URL", value: `http://127.0.0.1:${minioPort}` },
-  ]
-
-  for (const config of configs.filter(x => !!x.value)) {
-    for (const env of envs) {
-      env._set(config.key, config.value)
-    }
-  }
-}
-
-export async function startContainer(container: GenericContainer) {
-  const imageName = (container as any).imageName.string as string
-  let key: string = imageName
-  if (imageName.includes("@sha256")) {
-    key = imageName.split("@")[0]
-  }
-  key = key.replace(/\//g, "-").replace(/:/g, "-")
-
-  container = container
-    .withReuse()
-    .withLabels({ "com.budibase": "true" })
-    .withName(`${key}_testcontainer`)
-
-  let startedContainer: StartedTestContainer | undefined = undefined
-  let lastError = undefined
-  for (let i = 0; i < 10; i++) {
-    try {
-      // container.start() is not an idempotent operation, calling `start`
-      // modifies the internal state of a GenericContainer instance such that
-      // the hash it uses to determine reuse changes. We need to clone the
-      // container before calling start to ensure that we're using the same
-      // reuse hash every time.
-      const containerCopy = cloneDeep(container)
-      startedContainer = await containerCopy.start()
-      lastError = undefined
-      break
-    } catch (e: any) {
-      lastError = e
-      await new Promise(resolve => setTimeout(resolve, 1000))
-    }
-  }
-
-  if (!startedContainer) {
-    if (lastError) {
-      throw lastError
-    }
-    throw new Error(`failed to start container: ${imageName}`)
-  }
-
-  const info = getContainerById(startedContainer.getId())
-  if (!info) {
-    throw new Error("Container not found")
-  }
-
-  // Some Docker runtimes, when you expose a port, will bind it to both
-  // 127.0.0.1 and ::1, so ipv4 and ipv6. The port spaces of ipv4 and ipv6
-  // addresses are not shared, and testcontainers will sometimes give you back
-  // the ipv6 port. There's no way to know that this has happened, and if you
-  // try to then connect to `localhost:port` you may attempt to bind to the v4
-  // address which could be unbound or even an entirely different container. For
-  // that reason, we don't use testcontainers' `getExposedPort` function,
-  // preferring instead our own method that guaranteed v4 ports.
-  return getExposedV4Ports(info)
-}

package/tests/core/utilities/utils/index.ts

@@ -1,2 +0,0 @@
-export * as time from "./time"
-export * as queue from "./queue"

package/tests/core/utilities/utils/queue.ts

@@ -1,27 +0,0 @@
-import { Queue } from "bull"
-import { GenericContainer, Wait } from "testcontainers"
-import { startContainer } from "../testContainerUtils"
-
-export async function useRealQueues() {
-  const ports = await startContainer(
-    new GenericContainer("redis")
-      .withExposedPorts(6379)
-      .withWaitStrategy(
-        Wait.forSuccessfulCommand(`redis-cli`).withStartupTimeout(10000)
-      )
-  )
-
-  const port = ports.find(x => x.container === 6379)?.host
-  if (!port) {
-    throw new Error("Redis port not found")
-  }
-  process.env.BULL_TEST_REDIS_PORT = port.toString()
-}
-
-export async function processMessages(queue: Queue) {
-  do {
-    await queue.whenCurrentJobsFinished()
-  } while (await queue.count())
-
-  await queue.whenCurrentJobsFinished()
-}

package/tests/core/utilities/utils/time.ts

@@ -1,3 +0,0 @@
-export function addDaysToDate(date: Date, days: number) {
-  return new Date(date.getTime() + days * 24 * 60 * 60 * 1000)
-}

package/tests/extra/DBTestConfiguration.ts

@@ -1,36 +0,0 @@
-import "../core/utilities/mocks"
-import * as structures from "../core/utilities/structures"
-import * as testEnv from "./testEnv"
-import * as context from "../../src/context"
-
-class DBTestConfiguration {
-  tenantId: string
-
-  constructor() {
-    // db tests need to be multi tenant to prevent conflicts
-    testEnv.multiTenant()
-    this.tenantId = structures.tenant.id()
-  }
-
-  newTenant() {
-    this.tenantId = structures.tenant.id()
-  }
-
-  // TENANCY
-
-  doInTenant<T>(task: () => Promise<T>) {
-    return context.doInTenant(this.tenantId, () => {
-      return task()
-    })
-  }
-
-  getTenantId() {
-    try {
-      return context.getTenantId()
-    } catch (e) {
-      return this.tenantId!
-    }
-  }
-}
-
-export default DBTestConfiguration

package/tests/extra/index.ts

@@ -1,2 +0,0 @@
-export * as testEnv from "./testEnv"
-export { default as DBTestConfiguration } from "./DBTestConfiguration"