More progress on modernising application tests.

packages/backend-core/src/objectStore/buckets/plugins.ts

@@ -6,7 +6,7 @@ import { Plugin } from "@budibase/types"
 
 // URLS
 
-export function enrichPluginURLs(plugins: Plugin[]) {
+export function enrichPluginURLs(plugins: Plugin[]): Plugin[] {
   if (!plugins || !plugins.length) {
     return []
   }

packages/server/scripts/test.sh

@@ -3,12 +3,12 @@ set -e
 
 if [[ -n $CI ]]
 then
-  export NODE_OPTIONS="--max-old-space-size=4096 --no-node-snapshot"
+  export NODE_OPTIONS="--max-old-space-size=4096 --no-node-snapshot $NODE_OPTIONS"
   echo "jest --coverage --maxWorkers=2 --forceExit --workerIdleMemoryLimit=2000MB --bail $@"
   jest --coverage --maxWorkers=2 --forceExit --workerIdleMemoryLimit=2000MB --bail $@
 else
   # --maxWorkers performs better in development
-  export NODE_OPTIONS="--no-node-snapshot"
+  export NODE_OPTIONS="--no-node-snapshot $NODE_OPTIONS"
   echo "jest --coverage --maxWorkers=2 --forceExit $@"
   jest --coverage --maxWorkers=2 --forceExit $@
 fi

packages/server/src/api/controllers/application.ts

@@ -48,6 +48,8 @@ import {
   Screen,
   UserCtx,
   CreateAppRequest,
+  FetchAppDefinitionResponse,
+  type FetchAppPackageResponse,
 } from "@budibase/types"
 import { BASE_LAYOUT_PROP_IDS } from "../../constants/layouts"
 import sdk from "../../sdk"
@@ -59,23 +61,23 @@ import * as appMigrations from "../../appMigrations"
 async function getLayouts() {
   const db = context.getAppDB()
   return (
-    await db.allDocs(
+    await db.allDocs<Layout>(
       getLayoutParams(null, {
         include_docs: true,
       })
     )
-  ).rows.map((row: any) => row.doc)
+  ).rows.map(row => row.doc!)
 }
 
 async function getScreens() {
   const db = context.getAppDB()
   return (
-    await db.allDocs(
+    await db.allDocs<Screen>(
       getScreenParams(null, {
         include_docs: true,
       })
     )
-  ).rows.map((row: any) => row.doc)
+  ).rows.map(row => row.doc!)
 }
 
 function getUserRoleId(ctx: UserCtx) {
@@ -175,14 +177,16 @@ export const addSampleData = async (ctx: UserCtx) => {
   ctx.status = 200
 }
 
-export async function fetch(ctx: UserCtx) {
+export async function fetch(ctx: UserCtx<null, App[]>) {
   ctx.body = await sdk.applications.fetch(
     ctx.query.status as AppStatus,
     ctx.user
   )
 }
 
-export async function fetchAppDefinition(ctx: UserCtx) {
+export async function fetchAppDefinition(
+  ctx: UserCtx<null, FetchAppDefinitionResponse>
+) {
   const layouts = await getLayouts()
   const userRoleId = getUserRoleId(ctx)
   const accessController = new roles.AccessController()
@@ -197,17 +201,19 @@ export async function fetchAppDefinition(ctx: UserCtx) {
   }
 }
 
-export async function fetchAppPackage(ctx: UserCtx) {
+export async function fetchAppPackage(
+  ctx: UserCtx<null, FetchAppPackageResponse>
+) {
   const db = context.getAppDB()
   const appId = context.getAppId()
-  let application = await db.get<any>(DocumentType.APP_METADATA)
+  let application = await db.get<App>(DocumentType.APP_METADATA)
   const layouts = await getLayouts()
   let screens = await getScreens()
   const license = await licensing.cache.getCachedLicense()
 
   // Enrich plugin URLs
   application.usedPlugins = objectStore.enrichPluginURLs(
-    application.usedPlugins
+    application.usedPlugins || []
   )
 
   // Only filter screens if the user is not a builder
@@ -425,7 +431,9 @@ export async function create(ctx: UserCtx) {
 
 // This endpoint currently operates as a PATCH rather than a PUT
 // Thus name and url fields are handled only if present
-export async function update(ctx: UserCtx) {
+export async function update(
+  ctx: UserCtx<{ name?: string; url?: string }, App>
+) {
   const apps = (await dbCore.getAllApps({ dev: true })) as App[]
   // validation
   const name = ctx.request.body.name,
@@ -498,7 +506,7 @@ export async function revertClient(ctx: UserCtx) {
   const revertedToVersion = application.revertableVersion
   const appPackageUpdates = {
     version: revertedToVersion,
-    revertableVersion: null,
+    revertableVersion: undefined,
   }
   const app = await updateAppPackage(appPackageUpdates, ctx.params.appId)
   await events.app.versionReverted(app, currentVersion, revertedToVersion)
@@ -618,12 +626,15 @@ export async function importToApp(ctx: UserCtx) {
   ctx.body = { message: "app updated" }
 }
 
-export async function updateAppPackage(appPackage: any, appId: any) {
+export async function updateAppPackage(
+  appPackage: Partial<App>,
+  appId: string
+) {
   return context.doInAppContext(appId, async () => {
     const db = context.getAppDB()
     const application = await db.get<App>(DocumentType.APP_METADATA)
 
-    const newAppPackage = { ...application, ...appPackage }
+    const newAppPackage: App = { ...application, ...appPackage }
     if (appPackage._rev !== application._rev) {
       newAppPackage._rev = application._rev
     }

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

@@ -11,25 +11,27 @@ jest.mock("../../../utilities/redis", () => ({
   checkDebounce: jest.fn(),
   shutdown: jest.fn(),
 }))
-import { clearAllApps, checkBuilderEndpoint } from "./utilities/TestFunctions"
+import { checkBuilderEndpoint } from "./utilities/TestFunctions"
 import * as setup from "./utilities"
 import { AppStatus } from "../../../db/utils"
 import { events, utils, context } from "@budibase/backend-core"
 import env from "../../../environment"
+import type { App } from "@budibase/types"
 
-jest.setTimeout(15000)
+jest.setTimeout(150000000)
 
 describe("/applications", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
+  let app: App
 
   afterAll(setup.afterAll)
-
-  beforeAll(async () => {
-    await config.init()
-  })
+  beforeAll(async () => await config.init())
 
   beforeEach(async () => {
+    app = await config.api.application.create({ name: utils.newid() })
+    const deployment = await config.api.application.publish(app.appId)
+    expect(deployment.status).toBe("SUCCESS")
     jest.clearAllMocks()
   })
 
@@ -74,7 +76,7 @@ describe("/applications", () => {
 
     it("migrates navigation settings from old apps", async () => {
       const app = await config.api.application.create({
-        name: "Old App",
+        name: utils.newid(),
         useTemplate: "true",
         templateFile: "src/api/routes/tests/data/old-app.txt",
       })
@@ -96,77 +98,45 @@ describe("/applications", () => {
   })
 
   describe("fetch", () => {
-    beforeEach(async () => {
-      // Clean all apps but the onde from config
-      await clearAllApps(config.getTenantId(), [config.getAppId()!])
-    })
-
     it("lists all applications", async () => {
-      await config.createApp("app1")
-      await config.createApp("app2")
       const apps = await config.api.application.fetch({ status: AppStatus.DEV })
-
-      // two created apps + the inited app
-      expect(apps.length).toBe(3)
+      expect(apps.length).toBeGreaterThan(0)
     })
   })
 
   describe("fetchAppDefinition", () => {
     it("should be able to get an apps definition", async () => {
-      const res = await request
-        .get(`/api/applications/${config.getAppId()}/definition`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
-      expect(res.body.libraries.length).toEqual(1)
+      const res = await config.api.application.getDefinition(app.appId)
+      expect(res.libraries.length).toEqual(1)
     })
   })
 
   describe("fetchAppPackage", () => {
     it("should be able to fetch the app package", async () => {
-      const res = await request
-        .get(`/api/applications/${config.getAppId()}/appPackage`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
-      expect(res.body.application).toBeDefined()
-      expect(res.body.application.appId).toEqual(config.getAppId())
+      const res = await config.api.application.getAppPackage(app.appId)
+      expect(res.application).toBeDefined()
+      expect(res.application.appId).toEqual(config.getAppId())
     })
   })
 
   describe("update", () => {
     it("should be able to update the app package", async () => {
-      const res = await request
-        .put(`/api/applications/${config.getAppId()}`)
-        .send({
-          name: "TEST_APP",
-        })
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
-      expect(res.body._rev).toBeDefined()
+      const updatedApp = await config.api.application.update(app.appId, {
+        name: "TEST_APP",
+      })
+      expect(updatedApp._rev).toBeDefined()
       expect(events.app.updated).toBeCalledTimes(1)
     })
   })
 
   describe("publish", () => {
     it("should publish app with dev app ID", async () => {
-      const appId = config.getAppId()
-      await request
-        .post(`/api/applications/${appId}/publish`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
+      await config.api.application.publish(app.appId)
       expect(events.app.published).toBeCalledTimes(1)
     })
 
     it("should publish app with prod app ID", async () => {
-      const appId = config.getProdAppId()
-      await request
-        .post(`/api/applications/${appId}/publish`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
+      await config.api.application.publish(app.appId.replace("_dev", ""))
       expect(events.app.published).toBeCalledTimes(1)
     })
   })
@@ -222,33 +192,25 @@ describe("/applications", () => {
 
   describe("sync", () => {
     it("app should sync correctly", async () => {
-      const res = await request
-        .post(`/api/applications/${config.getAppId()}/sync`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
-      expect(res.body.message).toEqual("App sync completed successfully.")
+      const { message } = await config.api.application.sync(app.appId)
+      expect(message).toEqual("App sync completed successfully.")
     })
 
     it("app should not sync if production", async () => {
-      const res = await request
-        .post(`/api/applications/app_123456/sync`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(400)
-      expect(res.body.message).toEqual(
+      const { message } = await config.api.application.sync(
+        app.appId.replace("_dev", ""),
+        { statusCode: 400 }
+      )
+
+      expect(message).toEqual(
         "This action cannot be performed for production apps"
       )
     })
 
     it("app should not sync if sync is disabled", async () => {
       env._set("DISABLE_AUTO_PROD_APP_SYNC", true)
-      const res = await request
-        .post(`/api/applications/${config.getAppId()}/sync`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
-      expect(res.body.message).toEqual(
+      const { message } = await config.api.application.sync(app.appId)
+      expect(message).toEqual(
         "App sync disabled. You can reenable with the DISABLE_AUTO_PROD_APP_SYNC environment variable."
       )
       env._set("DISABLE_AUTO_PROD_APP_SYNC", false)
@@ -256,51 +218,26 @@ describe("/applications", () => {
   })
 
   describe("unpublish", () => {
-    beforeEach(async () => {
-      // We want to republish as the unpublish will delete the prod app
-      await config.publish()
-    })
-
     it("should unpublish app with dev app ID", async () => {
-      const appId = config.getAppId()
-      await request
-        .post(`/api/applications/${appId}/unpublish`)
-        .set(config.defaultHeaders())
-        .expect(204)
+      await config.api.application.unpublish(app.appId)
       expect(events.app.unpublished).toBeCalledTimes(1)
     })
 
     it("should unpublish app with prod app ID", async () => {
-      const appId = config.getProdAppId()
-      await request
-        .post(`/api/applications/${appId}/unpublish`)
-        .set(config.defaultHeaders())
-        .expect(204)
+      await config.api.application.unpublish(app.appId.replace("_dev", ""))
       expect(events.app.unpublished).toBeCalledTimes(1)
     })
   })
 
   describe("delete", () => {
     it("should delete published app and dev apps with dev app ID", async () => {
-      await config.createApp("to-delete")
-      const appId = config.getAppId()
-      await request
-        .delete(`/api/applications/${appId}`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
+      await config.api.application.delete(app.appId)
       expect(events.app.deleted).toBeCalledTimes(1)
       expect(events.app.unpublished).toBeCalledTimes(1)
     })
 
     it("should delete published app and dev app with prod app ID", async () => {
-      await config.createApp("to-delete")
-      const appId = config.getProdAppId()
-      await request
-        .delete(`/api/applications/${appId}`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
+      await config.api.application.delete(app.appId.replace("_dev", ""))
       expect(events.app.deleted).toBeCalledTimes(1)
       expect(events.app.unpublished).toBeCalledTimes(1)
     })
@@ -308,28 +245,18 @@ describe("/applications", () => {
 
   describe("POST /api/applications/:appId/sync", () => {
     it("should not sync automation logs", async () => {
-      // setup the apps
-      await config.createApp("testing-auto-logs")
       const automation = await config.createAutomation()
-      await config.publish()
-      await context.doInAppContext(config.getProdAppId(), () => {
-        return config.createAutomationLog(automation)
-      })
+      await context.doInAppContext(app.appId, () =>
+        config.createAutomationLog(automation)
+      )
 
-      // do the sync
-      const appId = config.getAppId()
-      await request
-        .post(`/api/applications/${appId}/sync`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
+      await config.api.application.sync(app.appId)
 
       // does exist in prod
       const prodLogs = await config.getAutomationLogs()
       expect(prodLogs.data.length).toBe(1)
 
-      // delete prod app so we revert to dev log search
-      await config.unpublish()
+      await config.api.application.unpublish(app.appId)
 
       // doesn't exist in dev
       const devLogs = await config.getAutomationLogs()

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

@@ -1,9 +1,14 @@
 import { Response } from "supertest"
-import { App, type CreateAppRequest } from "@budibase/types"
+import {
+  App,
+  type CreateAppRequest,
+  type FetchAppDefinitionResponse,
+  type FetchAppPackageResponse,
+} from "@budibase/types"
 import TestConfiguration from "../TestConfiguration"
 import { TestAPI } from "./base"
 import { AppStatus } from "../../../db/utils"
-import { dbObjectAsPojo } from "oracledb"
+import { constants } from "@budibase/backend-core"
 
 export class ApplicationAPI extends TestAPI {
   constructor(config: TestConfiguration) {
@@ -27,12 +32,55 @@ export class ApplicationAPI extends TestAPI {
     const result = await request
 
     if (result.statusCode !== 200) {
-      fail(JSON.stringify(result.body))
+      throw new Error(JSON.stringify(result.body))
     }
 
     return result.body as App
   }
 
+  delete = async (appId: string): Promise<void> => {
+    await this.request
+      .delete(`/api/applications/${appId}`)
+      .set(this.config.defaultHeaders())
+      .expect(200)
+  }
+
+  publish = async (
+    appId: string
+  ): Promise<{ _id: string; status: string; appUrl: string }> => {
+    // While the publsih endpoint does take an :appId parameter, it doesn't
+    // use it. It uses the appId from the context.
+    let headers = {
+      ...this.config.defaultHeaders(),
+      [constants.Header.APP_ID]: appId,
+    }
+    const result = await this.request
+      .post(`/api/applications/${appId}/publish`)
+      .set(headers)
+      .expect("Content-Type", /json/)
+      .expect(200)
+    return result.body as { _id: string; status: string; appUrl: string }
+  }
+
+  unpublish = async (appId: string): Promise<void> => {
+    await this.request
+      .post(`/api/applications/${appId}/unpublish`)
+      .set(this.config.defaultHeaders())
+      .expect(204)
+  }
+
+  sync = async (
+    appId: string,
+    { statusCode }: { statusCode: number } = { statusCode: 200 }
+  ): Promise<{ message: string }> => {
+    const result = await this.request
+      .post(`/api/applications/${appId}/sync`)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(statusCode)
+    return result.body
+  }
+
   getRaw = async (appId: string): Promise<Response> => {
     const result = await this.request
       .get(`/api/applications/${appId}/appPackage`)
@@ -47,6 +95,48 @@ export class ApplicationAPI extends TestAPI {
     return result.body.application as App
   }
 
+  getDefinition = async (
+    appId: string
+  ): Promise<FetchAppDefinitionResponse> => {
+    const result = await this.request
+      .get(`/api/applications/${appId}/definition`)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    return result.body as FetchAppDefinitionResponse
+  }
+
+  getAppPackage = async (appId: string): Promise<FetchAppPackageResponse> => {
+    const result = await this.request
+      .get(`/api/applications/${appId}/appPackage`)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    return result.body
+  }
+
+  update = async (
+    appId: string,
+    app: { name?: string; url?: string }
+  ): Promise<App> => {
+    const request = this.request
+      .put(`/api/applications/${appId}`)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+
+    for (const key of Object.keys(app)) {
+      request.field(key, (app as any)[key])
+    }
+
+    const result = await request
+
+    if (result.statusCode !== 200) {
+      throw new Error(JSON.stringify(result.body))
+    }
+
+    return result.body as App
+  }
+
   fetch = async ({ status }: { status?: AppStatus } = {}): Promise<App[]> => {
     let query = []
     if (status) {

packages/types/src/documents/app/app.ts

@@ -1,5 +1,5 @@
-import { User, Document } from "../"
-import { SocketSession } from "../../sdk"
+import { User, Document, Layout, Screen, Plugin } from "../"
+import { SocketSession, PlanType } from "../../sdk"
 
 export type AppMetadataErrors = { [key: string]: string[] }
 
@@ -24,6 +24,8 @@ export interface App extends Document {
   icon?: AppIcon
   features?: AppFeatures
   automations?: AutomationSettings
+  usedPlugins?: Plugin[]
+  upgradableVersion?: string
 }
 
 export interface AppInstance {
@@ -85,3 +87,18 @@ export interface CreateAppRequest {
   encryptionPassword?: string
   templateString?: string
 }
+
+export interface FetchAppDefinitionResponse {
+  layouts: Layout[]
+  screens: Screen[]
+  libraries: string[]
+}
+
+export interface FetchAppPackageResponse {
+  application: App
+  licenseType: PlanType
+  screens: Screen[]
+  layouts: Layout[]
+  clientLibPath: string
+  hasLock: boolean
+}