feat(integration): switch long-running test apps from dev to build+serve

Author: jacekradko

integration/models/application.ts

@@ -144,25 +144,48 @@ export const application = (
     get serveOutput() {
       return serveOutput;
     },
-    serve: async (opts: { port?: number; manualStart?: boolean } = {}) => {
+    serve: async (opts: { port?: number; manualStart?: boolean; detached?: boolean; serverUrl?: string } = {}) => {
       const log = logger.child({ prefix: 'serve' }).info;
       const port = opts.port || (await getPort());
-      // TODO: get serverUrl as in dev()
-      const serverUrl = `http://localhost:${port}`;
-      // If this is ever used as a background process, we need to make sure
-      // it's not using the log function. See the dev() method above
+      const getServerUrl = () => {
+        if (opts.serverUrl) {
+          return opts.serverUrl.includes(':') ? opts.serverUrl : `${opts.serverUrl}:${port}`;
+        }
+        return serverUrl || `http://localhost:${port}`;
+      };
+      const runtimeServerUrl = getServerUrl();
+      log(`Will try to serve app at ${runtimeServerUrl}`);
+
+      if (opts.manualStart) {
+        state.serverUrl = runtimeServerUrl;
+        return { port, serverUrl: runtimeServerUrl };
+      }
+
       const proc = run(scripts.serve, {
         cwd: appDirPath,
         env: { PORT: port.toString() },
-        log: (msg: string) => {
-          serveOutput += `\n${msg}`;
-          log(msg);
-        },
+        detached: opts.detached,
+        stdout: opts.detached ? fs.openSync(stdoutFilePath, 'a') : undefined,
+        stderr: opts.detached ? fs.openSync(stderrFilePath, 'a') : undefined,
+        log: opts.detached
+          ? undefined
+          : (msg: string) => {
+              serveOutput += `\n${msg}`;
+              log(msg);
+            },
       });
+
+      if (opts.detached) {
+        const shouldExit = () => !!proc.exitCode && proc.exitCode !== 0;
+        await waitForServer(runtimeServerUrl, { log, maxAttempts: Infinity, shouldExit });
+      } else {
+        await waitForIdleProcess(proc);
+      }
+
+      log(`Server started at ${runtimeServerUrl}, pid: ${proc.pid}`);
       cleanupFns.push(() => awaitableTreekill(proc.pid, 'SIGKILL'));
-      await waitForIdleProcess(proc);
-      state.serverUrl = serverUrl;
-      return { port, serverUrl, pid: proc };
+      state.serverUrl = runtimeServerUrl;
+      return { port, serverUrl: runtimeServerUrl, pid: proc.pid };
     },
     stop: async () => {
       logger.info('Stopping...');

integration/models/longRunningApplication.ts

@@ -100,10 +100,16 @@ export const longRunningApplication = (params: LongRunningApplicationParams) =>
           throw error;
         }
         try {
-          const { port, serverUrl, pid } = await app.dev({ detached: true });
+          await app.build();
+        } catch (error) {
+          console.error('Error during app build:', error);
+          throw error;
+        }
+        try {
+          const { port, serverUrl, pid } = await app.serve({ detached: true });
           stateFile.addLongRunningApp({ port, serverUrl, pid, id, appDir: app.appDir, env: params.env.toJson() });
         } catch (error) {
-          console.error('Error during app dev:', error);
+          console.error('Error during app serve:', error);
           throw error;
         }
       },
@@ -126,9 +132,7 @@ export const longRunningApplication = (params: LongRunningApplicationParams) =>
       setup: () => Promise.resolve(),
       withEnv: () => Promise.resolve(),
       teardown: () => Promise.resolve(),
-      build: () => {
-        throw new Error('build for long running apps is not supported yet');
-      },
+      build: () => Promise.resolve(),
       get name() {
         return name;
       },

integration/tests/global.setup.ts

@@ -5,7 +5,7 @@ import { appConfigs } from '../presets';
 import { fs, parseEnvOptions, startClerkJsHttpServer, startClerkUiHttpServer } from '../scripts';
 
 setup('start long running apps', async () => {
-  setup.setTimeout(90_000);
+  setup.setTimeout(300_000);
 
   await fs.ensureDir(constants.TMP_DIR);