De-mock the environment variable tests.

packages/server/src/api/routes/tests/environmentVariables.spec.ts

@@ -1,153 +1,108 @@
 const pg = require("pg")
 
-jest.mock("pg", () => {
+import { structures } from "./utilities"
-  return {
-    Client: jest.fn().mockImplementation(() => ({
-      connect: jest.fn(),
-      query: jest.fn().mockImplementation(() => ({ rows: [] })),
-      end: jest.fn().mockImplementation((fn: any) => fn()),
-    })),
-    queryMock: jest.fn().mockImplementation(() => {}),
-    on: jest.fn(),
-  }
-})
-import * as setup from "./utilities"
 import { mocks } from "@budibase/backend-core/tests"
-import { env, events } from "@budibase/backend-core"
+import { setEnv } from "@budibase/backend-core"
-import { QueryPreview } from "@budibase/types"
+import { Datasource } from "@budibase/types"
+import TestConfiguration from "../../../tests/utilities/TestConfiguration"
+import {
+  DatabaseName,
+  datasourceDescribe,
+} from "../../../integrations/tests/utils"
 
-const structures = setup.structures
+const describes = datasourceDescribe({ only: [DatabaseName.POSTGRES] })
 
-env._set("ENCRYPTION_KEY", "budibase")
+if (describes.length > 0) {
-mocks.licenses.useEnvironmentVariables()
+  describe.each(describes)("/api/env/variables", ({ dsProvider }) => {
+    const config = new TestConfiguration()
 
-describe("/api/env/variables", () => {
+    let rawDatasource: Datasource
-  let request = setup.getRequest()
+    let restoreEnv: () => void
-  let config = setup.getConfig()
-
-  afterAll(setup.afterAll)
 
     beforeAll(async () => {
       await config.init()
+      restoreEnv = setEnv({ ENCRYPTION_KEY: "budibase" })
+      mocks.licenses.useEnvironmentVariables()
+
+      const ds = await dsProvider()
+      rawDatasource = ds.rawDatasource!
+    })
+
+    afterAll(() => {
+      restoreEnv()
+    })
+
+    beforeEach(async () => {
+      const { variables } = await config.api.environment.fetch()
+      for (const variable of variables) {
+        await config.api.environment.destroy(variable)
+      }
+
+      await config.api.environment.create({
+        name: "test",
+        production: rawDatasource.config!.password,
+        development: rawDatasource.config!.password,
+      })
     })
 
     it("should be able check the status of env var API", async () => {
-    const res = await request
+      const { encryptionKeyAvailable } = await config.api.environment.status()
-      .get(`/api/env/variables/status`)
+      expect(encryptionKeyAvailable).toEqual(true)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-
-    expect(res.body.encryptionKeyAvailable).toEqual(true)
-  })
-
-  it("should be able to create an environment variable", async () => {
-    await request
-      .post(`/api/env/variables`)
-      .send(structures.basicEnvironmentVariable("test", "test"))
-      .set(config.defaultHeaders())
-      .expect(200)
     })
 
     it("should be able to fetch the 'test' variable name", async () => {
-    const res = await request
+      const { variables } = await config.api.environment.fetch()
-      .get(`/api/env/variables`)
+      expect(variables.length).toEqual(1)
-      .set(config.defaultHeaders())
+      expect(variables[0]).toEqual("test")
-      .expect("Content-Type", /json/)
-      .expect(200)
-    expect(res.body.variables.length).toEqual(1)
-    expect(res.body.variables[0]).toEqual("test")
     })
 
     it("should be able to update the environment variable 'test'", async () => {
-    const varName = "test"
+      await config.api.environment.update("test", {
-    await request
+        production: "test1",
-      .patch(`/api/env/variables/${varName}`)
+        development: "test1",
-      .send(structures.basicEnvironmentVariable("test", "test1"))
+      })
-      .set(config.defaultHeaders())
-      .expect(200)
     })
 
     it("should be able to delete the environment variable 'test'", async () => {
-    const varName = "test"
+      await config.api.environment.destroy("test")
-    await request
-      .delete(`/api/env/variables/${varName}`)
-      .set(config.defaultHeaders())
-      .expect(200)
     })
 
     it("should create a datasource (using the environment variable) and query", async () => {
-    const datasourceBase = structures.basicDatasource()
+      const datasource = await config.api.datasource.create({
-    await request
+        ...structures.basicDatasource().datasource,
-      .post(`/api/env/variables`)
+        config: {
-      .send(structures.basicEnvironmentVariable("test", "test"))
+          ...rawDatasource.config,
-      .set(config.defaultHeaders())
-
-    datasourceBase.datasource.config = {
           password: "{{ env.test }}",
-    }
+        },
-    const response = await request
+      })
-      .post(`/api/datasources`)
-      .send(datasourceBase)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-    expect(response.body.datasource._id).toBeDefined()
 
-    const response2 = await request
+      const query = await config.api.query.save({
-      .post(`/api/queries`)
+        ...structures.basicQuery(datasource._id!),
-      .send(structures.basicQuery(response.body.datasource._id))
+        fields: { sql: "SELECT 1" },
-      .set(config.defaultHeaders())
+      })
-      .expect("Content-Type", /json/)
+      expect(query._id).toBeDefined()
-      .expect(200)
-    expect(response2.body._id).toBeDefined()
     })
 
     it("should run a query preview and check the mocked results", async () => {
-    const datasourceBase = structures.basicDatasource()
+      const datasource = await config.api.datasource.create({
-    await request
+        ...structures.basicDatasource().datasource,
-      .post(`/api/env/variables`)
+        config: {
-      .send(structures.basicEnvironmentVariable("test", "test"))
+          ...rawDatasource.config,
-      .set(config.defaultHeaders())
-
-    datasourceBase.datasource.config = {
           password: "{{ env.test }}",
-    }
+        },
-    const response = await request
+      })
-      .post(`/api/datasources`)
-      .send(datasourceBase)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-    expect(response.body.datasource._id).toBeDefined()
 
-    const queryPreview: QueryPreview = {
+      const query = await config.api.query.save({
-      datasourceId: response.body.datasource._id,
+        ...structures.basicQuery(datasource._id!),
-      parameters: [],
+        fields: { sql: "SELECT 1 as id" },
-      fields: {},
+      })
-      queryVerb: "read",
+
-      name: response.body.datasource.name,
+      const { rows } = await config.api.query.preview({
-      transformer: null,
+        ...query,
-      schema: {},
+        queryId: query._id!,
-      readable: true,
+      })
-    }
+
-    const res = await request
+      expect(rows).toEqual([{ id: 1 }])
-      .post(`/api/queries/preview`)
-      .send(queryPreview)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-    expect(res.body.rows.length).toEqual(0)
-    expect(events.query.previewed).toHaveBeenCalledTimes(1)
-    // API doesn't include config in response
-    delete response.body.datasource.config
-    expect(events.query.previewed).toHaveBeenCalledWith(
-      response.body.datasource,
-      {
-        ...queryPreview,
-        nullDefaultSupport: true,
-      }
-    )
-    expect(pg.Client).toHaveBeenCalledWith({ password: "test", ssl: undefined })
     })
   })
+}

packages/server/src/tests/utilities/api/environment.ts

@@ -0,0 +1,52 @@
+import { Expectations, TestAPI } from "./base"
+import {
+  CreateEnvironmentVariableRequest,
+  CreateEnvironmentVariableResponse,
+  GetEnvironmentVariablesResponse,
+  Row,
+  StatusEnvironmentVariableResponse,
+  UpdateEnvironmentVariableRequest,
+} from "@budibase/types"
+
+export class EnvironmentAPI extends TestAPI {
+  create = async (
+    body: CreateEnvironmentVariableRequest,
+    expectations?: Expectations
+  ) => {
+    return await this._post<CreateEnvironmentVariableResponse>(
+      `/api/env/variables`,
+      { body, expectations }
+    )
+  }
+
+  status = async (expectations?: Expectations) => {
+    return await this._get<StatusEnvironmentVariableResponse>(
+      `/api/env/variables/status`,
+      { expectations }
+    )
+  }
+
+  fetch = async (expectations?: Expectations) => {
+    return await this._get<GetEnvironmentVariablesResponse>(
+      `/api/env/variables`,
+      { expectations }
+    )
+  }
+
+  update = async (
+    varName: string,
+    body: UpdateEnvironmentVariableRequest,
+    expectations?: Expectations
+  ) => {
+    return await this._patch<void>(`/api/env/variables/${varName}`, {
+      body,
+      expectations,
+    })
+  }
+
+  destroy = async (varName: string, expectations?: Expectations) => {
+    return await this._delete<void>(`/api/env/variables/${varName}`, {
+      expectations,
+    })
+  }
+}

packages/server/src/tests/utilities/api/index.ts

@@ -17,6 +17,7 @@ import { RowActionAPI } from "./rowAction"
 import { AutomationAPI } from "./automation"
 import { PluginAPI } from "./plugin"
 import { WebhookAPI } from "./webhook"
+import { EnvironmentAPI } from "./environment"
 
 export default class API {
   application: ApplicationAPI
@@ -24,6 +25,7 @@ export default class API {
   automation: AutomationAPI
   backup: BackupAPI
   datasource: DatasourceAPI
+  environment: EnvironmentAPI
   legacyView: LegacyViewAPI
   permission: PermissionAPI
   plugin: PluginAPI
@@ -44,6 +46,7 @@ export default class API {
     this.automation = new AutomationAPI(config)
     this.backup = new BackupAPI(config)
     this.datasource = new DatasourceAPI(config)
+    this.environment = new EnvironmentAPI(config)
     this.legacyView = new LegacyViewAPI(config)
     this.permission = new PermissionAPI(config)
     this.plugin = new PluginAPI(config)

packages/server/src/tests/utilities/structures.ts

@@ -37,6 +37,9 @@ import {
   DeepPartial,
   FilterCondition,
   AutomationTriggerResult,
+  EnvironmentVariablesDoc,
+  EnvironmentVariableValue,
+  CreateEnvironmentVariableRequest,
 } from "@budibase/types"
 import { LoopInput } from "../../definitions/automations"
 import { merge } from "lodash"
@@ -574,7 +577,7 @@ export function basicEnvironmentVariable(
   name: string,
   prod: string,
   dev?: string
-) {
+): CreateEnvironmentVariableRequest {
   return {
     name,
     production: prod,