feat: [KSBP-101776] - Additional work on parallelisation of test app with other components

Author: kindredjcharters

k8s-deployer/src/dependency-resolver.ts

@@ -210,24 +210,44 @@ const reconstructCyclePath = (startId: string, parent: Map<string, string>): Arr
 }
 
 /**
- * Print the dependency graph in a visually grouped format.
- * Components that can be deployed in parallel are shown together and annotated.
+ * Print the full deployment graph including testApp placement.
+ *
+ * - Components are shown in topological stages.
+ * - If testApp.parallel === true it is shown in a separate concurrent section
+ *   (it runs alongside all component stages).
+ * - Otherwise testApp is shown as the final sequential stage after all components.
  */
-export const printDependencyGraph = (components: Array<Schema.DeployableComponent>): void => {
+export const printDependencyGraph = (graph: Schema.Graph): void => {
+  const { components, testApp } = graph
   const { levels } = topologicalSort(components)
   const sep = "─".repeat(40)
+  const label = (c: Schema.DeployableComponent) => c.parallel ? `${c.id} 🔀` : c.id
   const edges = components.flatMap(c => (c.dependsOn ?? []).map(dep => `  ${dep} ──▶ ${c.id}`))
+  const anyConcurrent = components.some(c => c.parallel) || testApp.parallel === true
 
   console.log("Dependency Graph")
   console.log(sep)
-  levels.forEach((level, idx) =>
-    console.log(`  Stage ${idx + 1} │  ${level.map(c => c.parallel ? `${c.id} 🔀` : c.id).join("  ")}`)
-  )
+
+  if (testApp.parallel === true) {
+    // testApp runs concurrently with the entire component chain — show it in a separate section
+    levels.forEach((level, idx) =>
+      console.log(`  Stage ${idx + 1} │  ${level.map(label).join("  ")}`)
+    )
+    console.log(sep)
+    console.log(`  ${label(testApp)}  (concurrent with component stages)`)
+  } else {
+    // testApp runs after all components — append it as the final stage
+    levels.forEach((level, idx) =>
+      console.log(`  Stage ${idx + 1} │  ${level.map(label).join("  ")}`)
+    )
+    console.log(`  Stage ${levels.length + 1} │  ${testApp.id}`)
+  }
+
   if (edges.length > 0) {
     console.log(sep)
     edges.forEach(e => console.log(e))
   }
-  if (components.some(c => c.parallel)) {
+  if (anyConcurrent) {
     console.log(sep)
     console.log("  🔀 = concurrent deployment")
   }

k8s-deployer/src/test-suite-handler.ts

@@ -46,7 +46,7 @@ export const deployGraph = async (config: Config, workspace: string, testSuiteId
 
   logger.info("")
   logger.info("Dependency Graph for %s:", testSuiteId)
-  printDependencyGraph(graph.components)
+  printDependencyGraph(graph)
   logger.info("")
 
   if (testAppDirForRemoteTestSuite) {

k8s-deployer/test/dependency-resolver.spec.ts

@@ -395,6 +395,11 @@ describe("Dependency Resolver", () => {
   describe("printDependencyGraph", () => {
     let logOutput: string[]
     let originalLog: typeof console.log
+    const testApp: Schema.DeployableComponent = {
+      name: "test-app", id: "test-app",
+      location: { type: Schema.LocationType.Local },
+      deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" }
+    }
     beforeEach(() => {
       logOutput = []
       originalLog = console.log
@@ -410,9 +415,10 @@ describe("Dependency Resolver", () => {
         { name: "B", id: "b", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" } },
         { name: "C", id: "c", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" } }
       ]
-      printDependencyGraph(components)
+      printDependencyGraph({ testApp, components })
       expect(logOutput[0]).to.equal("Dependency Graph")
       expect(logOutput).to.include("  Stage 1 │  a  b  c")
+      expect(logOutput).to.include("  Stage 2 │  test-app")
     })
 
     it("prints graph for components with dependencies at multiple stages", () => {
@@ -421,10 +427,11 @@ describe("Dependency Resolver", () => {
         { name: "API", id: "api", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" }, dependsOn: ["db"] },
         { name: "Cache", id: "cache", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" }, dependsOn: ["db"] }
       ]
-      printDependencyGraph(components)
+      printDependencyGraph({ testApp, components })
       expect(logOutput[0]).to.equal("Dependency Graph")
       expect(logOutput).to.include("  Stage 1 │  db")
       expect(logOutput).to.include("  Stage 2 │  api  cache")
+      expect(logOutput).to.include("  Stage 3 │  test-app")
       expect(logOutput).to.include("  db ──▶ api")
       expect(logOutput).to.include("  db ──▶ cache")
     })
@@ -435,11 +442,12 @@ describe("Dependency Resolver", () => {
         { name: "B", id: "b", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" }, dependsOn: ["a"] },
         { name: "C", id: "c", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" }, dependsOn: ["b"] }
       ]
-      printDependencyGraph(components)
+      printDependencyGraph({ testApp, components })
       expect(logOutput[0]).to.equal("Dependency Graph")
       expect(logOutput).to.include("  Stage 1 │  a")
       expect(logOutput).to.include("  Stage 2 │  b")
       expect(logOutput).to.include("  Stage 3 │  c")
+      expect(logOutput).to.include("  Stage 4 │  test-app")
       expect(logOutput).to.include("  a ──▶ b")
       expect(logOutput).to.include("  b ──▶ c")
     })
@@ -450,13 +458,29 @@ describe("Dependency Resolver", () => {
         { name: "B", id: "b", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" }, dependsOn: ["a"], parallel: true },
         { name: "C", id: "c", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" }, dependsOn: ["a"], parallel: true }
       ]
-      printDependencyGraph(components)
+      printDependencyGraph({ testApp, components })
       expect(logOutput[0]).to.equal("Dependency Graph")
       expect(logOutput).to.include("  Stage 1 │  a")
       expect(logOutput).to.include("  Stage 2 │  b 🔀  c 🔀")
+      expect(logOutput).to.include("  Stage 3 │  test-app")
       expect(logOutput).to.include("  a ──▶ b")
       expect(logOutput).to.include("  a ──▶ c")
       expect(logOutput).to.include("  🔀 = concurrent deployment")
     })
+
+    it("shows testApp in a concurrent section when testApp.parallel is true", () => {
+      const parallelTestApp: Schema.DeployableComponent = { ...testApp, id: "my-test-app", parallel: true }
+      const components: Array<Schema.DeployableComponent> = [
+        { name: "A", id: "a", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" } },
+        { name: "B", id: "b", location: { type: Schema.LocationType.Local }, deploy: { command: "deploy.sh" }, undeploy: { command: "undeploy.sh" }, dependsOn: ["a"] }
+      ]
+      printDependencyGraph({ testApp: parallelTestApp, components })
+      expect(logOutput[0]).to.equal("Dependency Graph")
+      expect(logOutput).to.include("  Stage 1 │  a")
+      expect(logOutput).to.include("  Stage 2 │  b")
+      expect(logOutput).to.include("  my-test-app 🔀  (concurrent with component stages)")
+      expect(logOutput).to.not.include("  Stage 3 │  my-test-app")
+      expect(logOutput).to.include("  🔀 = concurrent deployment")
+    })
   })
 })