feat: e2e test output now colored and interleaved

.gitignore

@@ -2,6 +2,7 @@ frontend/build
 deployToGCP.sh
 certs
 backend/data
+backend/dist
 backend/instant-mock.db
 backend/src/migrations/**/*.snapshot*
 minikube*

backend/src/graphql/client.ts

@@ -34,7 +34,6 @@ import {GET_VARIANT} from './queries/getVariant';
 import {PROPOSAL_LAUNCHES} from './queries/proposalLaunches';
 import {logger} from '../utilities/logger';
 import {SchemaLoader} from '../utilities/schemaLoader';
-import {printSchema} from 'graphql';
 
 export default class Client {
   private apolloClient!: ApolloClient<unknown>;
@@ -129,7 +128,7 @@ export default class Client {
           const operationMatchArguments = operation.variables;
           const seedResponse = response;
 
-          const apiUrl = `http://instant-mock-e2e-play:${process.env.PLAY_PORT}/api/seeds`;
+          const apiUrl = `http://localhost:${process.env.PLAY_PORT}/api/seeds`;
 
           if (operationName === 'IntrospectionQuery') {
             return response;
@@ -316,7 +315,7 @@ export default class Client {
         latestPublication: {
           publishedAt: new Date().toISOString(),
           schema: {
-            document: printSchema(schema.schema),
+            document: schema.schema,
           },
         },
       };
@@ -348,7 +347,7 @@ export default class Client {
             latestPublication: {
               publishedAt: new Date().toISOString(),
               schema: {
-                document: printSchema(schema.schema),
+                document: schema.schema,
               },
             },
           },

backend/src/routes/graphql.ts

@@ -13,7 +13,7 @@ const mutex = new Mutex();
 export const getOrStartNewMockServer = async (
   graphId: string,
   variantName: string
-): Promise<MockServer> => {
+): Promise<MockServer | undefined> => {
   const release = await mutex.acquire();
   try {
     let mockInstance = mockInstances[graphId]?.[variantName];
@@ -25,6 +25,8 @@ export const getOrStartNewMockServer = async (
       mockInstance = await startNewMockServer(graphId, variantName);
     }
     return mockInstance;
+  } catch (error) {
+    logger.error('Error getting or starting new mock server', {error});
   } finally {
     release();
   }
@@ -37,6 +39,7 @@ const startNewMockServer = async (
   logger.debug('Starting new mock server', {graphId, variantName});
   const schema = await DI.apolloClient.getSchema(graphId, variantName);
 
+  if (!schema) throw new Error('Schema not found');
   const mockServer = new MockServer(schema, {
     subgraph: false,
     fakerConfig: {},
@@ -103,6 +106,11 @@ const handleGraphQLRequest = async (
   }
 
   const mockServer = await getOrStartNewMockServer(graphId, variantName);
+  if (!mockServer) {
+    console.error('Could not start mock server', {graphId, variantName});
+    return res.status(422).json({message: 'Could not start mock server'});
+  }
+
   const queryWithoutFragments = mockServer.expandFragments(query);
   const typenamedQuery = mockServer.addTypenameFieldsToQuery(
     queryWithoutFragments

backend/src/routes/seeds.ts

@@ -149,6 +149,10 @@ router.post('/seeds', async (req: Request, res: Response) => {
   logger.debug('Attempting to add a new seed', {graphId, variantName});
 
   const mockServer = await getOrStartNewMockServer(graphId, variantName);
+  if (!mockServer) {
+    console.error('Could not start mock server', {graphId, variantName});
+    return res.status(422).json({message: 'Could not start mock server'});
+  }
   const seedGroup = DI.em.getReference(SeedGroup, seedGroupId);
 
   const seed = DI.seeds.create({

scripts/run-e2e-tests.ts

@@ -8,24 +8,44 @@ dotenv.config();
 
 const FIXTURE_BASE_PATH = path.join("test", "e2e", "fixtures");
 
-async function waitForServerReady(containerName: string): Promise<boolean> {
+const colors = {
+  play: "\x1b[34m", // Blue for play server logs
+  record: "\x1b[35m", // Magenta for record server logs
+  test: "\x1b[36m", // Cyan for test server logs
+  cypress: "\x1b[32m", // Green for Cypress output
+  reset: "\x1b[0m", // Reset color
+};
+
+function addPrefixAndColor(prefix: string, color: string, message: string) {
+  const timestamp = format(new Date(), "yyyy-MM-dd HH:mm:ss");
+  return `${color}[${prefix} - ${timestamp}] ${message}${colors.reset}`;
+}
+
+async function waitForServerReady(
+  containerName: string,
+  color: string,
+): Promise<boolean> {
   return new Promise((resolve) => {
     const logs = spawn("docker", ["logs", "-f", containerName]);
+    let serverReady = false;
 
     logs.stdout.on("data", (data) => {
       const output = data.toString();
-      console.log(output);
-      if (output.includes("Server running")) {
-        logs.kill();
+      console.log(addPrefixAndColor(containerName, color, output));
+      if (output.includes("Server running") && !serverReady) {
+        serverReady = true;
         resolve(true);
       }
     });
 
-    logs.stderr.on("data", (data) => console.error(data.toString()));
+    logs.stderr.on("data", (data) => {
+      console.error(addPrefixAndColor(containerName, color, data.toString()));
+    });
 
     setTimeout(() => {
-      logs.kill();
-      resolve(false);
+      if (!serverReady) {
+        resolve(false);
+      }
     }, 30000);
   });
 }
@@ -80,41 +100,60 @@ function startDockerService(service: string, envVars: NodeJS.ProcessEnv) {
 async function runTests(mode: string, timestamp: string) {
   const baseEnvVars = { FIXTURE_TIMESTAMP: timestamp };
 
-  // Start the play server in both modes, with additional APOLLO_API_KEY in record mode
   const playEnvVars =
     mode === "record" && process.env.APOLLO_API_KEY
       ? { ...baseEnvVars, APOLLO_API_KEY: process.env.APOLLO_API_KEY }
       : baseEnvVars;
 
   startDockerService("instant-mock-e2e-play", playEnvVars);
-  const playHealthy = await waitForServerReady("instant-mock-e2e-play");
+  const playHealthy = await waitForServerReady(
+    "instant-mock-e2e-play",
+    colors.play,
+  );
   if (!playHealthy) {
     throw new Error("Play server failed to start properly");
   }
 
-  // Additional setup for 'record' and 'test' modes
   if (mode === "record") {
     startDockerService("instant-mock-e2e-record", baseEnvVars);
-    const recordHealthy = await waitForServerReady("instant-mock-e2e-record");
+    const recordHealthy = await waitForServerReady(
+      "instant-mock-e2e-record",
+      colors.record,
+    );
     if (!recordHealthy) {
       throw new Error("Record server failed to start properly");
     }
   } else if (mode === "test") {
     startDockerService("instant-mock-e2e-test", baseEnvVars);
-    const testHealthy = await waitForServerReady("instant-mock-e2e-test");
+    const testHealthy = await waitForServerReady(
+      "instant-mock-e2e-test",
+      colors.test,
+    );
     if (!testHealthy) {
       throw new Error("Test server failed to start properly");
     }
   }
 
-  // Determine Cypress base URL based on mode
   const baseUrl =
     mode === "record" ? process.env.RECORD_PORT : process.env.TEST_PORT;
   console.log(`Running Cypress tests against port ${baseUrl}...`);
-  execSync(
+
+  const cypressOutput = spawn(
     `CYPRESS_BASE_URL=http://localhost:${baseUrl} npx cypress run --spec 'cypress/e2e/basic-functionality.cy.ts'`,
-    { stdio: "inherit", env: { ...process.env, ...baseEnvVars } },
+    { shell: true, env: { ...process.env, ...baseEnvVars } },
   );
+
+  cypressOutput.stdout.on("data", (data) => {
+    console.log(addPrefixAndColor("Cypress", colors.cypress, data.toString()));
+  });
+
+  cypressOutput.stderr.on("data", (data) => {
+    console.error(
+      addPrefixAndColor("Cypress", colors.cypress, data.toString()),
+    );
+  });
+
+  await new Promise((resolve) => cypressOutput.on("close", resolve));
 }
 
 function shutdownDocker() {