Add Playwright tests for async execution

browser_tests/tests/subgraphExecutionProgress.spec.ts

@@ -0,0 +1,237 @@
+import { expect, mergeTests } from '@playwright/test'
+
+import { comfyPageFixture } from '../fixtures/ComfyPage'
+import { webSocketFixture } from '../fixtures/ws'
+import {
+  ExecutionTestHelper,
+  SubgraphTestHelper
+} from '../helpers/ExecutionTestHelper'
+
+const test = mergeTests(comfyPageFixture, webSocketFixture)
+
+test.describe('Subgraph Execution Progress', () => {
+  test.describe.configure({ mode: 'serial' })
+  test.setTimeout(30000) // Increase timeout for subgraph tests
+
+  let executionHelper: ExecutionTestHelper
+  let subgraphHelper: SubgraphTestHelper
+
+  test.beforeEach(async ({ comfyPage }) => {
+    executionHelper = new ExecutionTestHelper(comfyPage.page)
+    subgraphHelper = new SubgraphTestHelper(comfyPage.page)
+    // Share the same test ID to access the same window properties
+    subgraphHelper.setTestId(executionHelper.getTestId())
+  })
+
+  test.afterEach(async () => {
+    if (executionHelper) {
+      await executionHelper.cleanup()
+    }
+  })
+
+  test('Shows progress for nodes inside subgraphs', async ({
+    comfyPage,
+    ws
+  }) => {
+    await comfyPage.loadWorkflow('execution/nested-subgraph-test')
+
+    // Get reference to the subgraph node
+    const subgraphNode = await comfyPage.getNodeRefById(10)
+    expect(subgraphNode).toBeDefined()
+
+    // Set up tracking for progress events
+    await executionHelper.setupEventTracking()
+
+    // Start real execution using command to avoid click issues
+    await comfyPage.executeCommand('Comfy.QueuePrompt')
+
+    // Wait for execution to start
+    await executionHelper.waitForExecutionStart()
+
+    // Wait for real progress events from subgraph execution
+    await subgraphHelper.waitForNestedNodeProgress(1)
+
+    // Wait for progress to be applied to the subgraph node
+    await executionHelper.waitForGraphNodeProgress([10])
+
+    // Check that the subgraph node shows aggregated progress
+    const subgraphProgress = await subgraphNode.getProperty('progress')
+
+    // The progress should be aggregated from child nodes
+    expect(subgraphProgress).toBeDefined()
+    expect(subgraphProgress).toBeGreaterThan(0)
+    expect(subgraphProgress).toBeLessThanOrEqual(1)
+
+    // Wait for stroke style to be applied
+    await comfyPage.page.waitForFunction(
+      (nodeId) => {
+        const node = window['app'].graph.getNodeById(nodeId)
+        if (!node?.strokeStyles?.['running']) return false
+        const style = node.strokeStyles['running'].call(node)
+        return style?.color === '#0f0'
+      },
+      10,
+      { timeout: 5000 }
+    )
+
+    // Check stroke style
+    const strokeStyle = await comfyPage.page.evaluate((nodeId) => {
+      const node = window['app'].graph.getNodeById(nodeId)
+      if (!node || !node.strokeStyles || !node.strokeStyles['running']) {
+        return null
+      }
+      return node.strokeStyles['running'].call(node)
+    }, 10)
+
+    expect(strokeStyle).toEqual({ color: '#0f0' })
+  })
+
+  test('Handles deeply nested subgraph execution', async ({
+    comfyPage,
+    ws
+  }) => {
+    await comfyPage.loadWorkflow('execution/nested-subgraph-test')
+
+    // Set up tracking for progress events
+    await executionHelper.setupEventTracking()
+
+    // Start real execution using command to avoid click issues
+    await comfyPage.executeCommand('Comfy.QueuePrompt')
+
+    // Wait for execution to start
+    await executionHelper.waitForExecutionStart()
+
+    // Wait for real progress events from deeply nested subgraph execution
+    await subgraphHelper.waitForNestedNodeProgress(2)
+
+    // Wait for progress to be applied to the top-level subgraph node
+    await executionHelper.waitForGraphNodeProgress([10])
+
+    // Check that top-level subgraph shows progress
+    const subgraphNode = await comfyPage.getNodeRefById(10)
+    const progress = await subgraphNode.getProperty('progress')
+
+    expect(progress).toBeDefined()
+    expect(progress).toBeGreaterThan(0)
+    expect(progress).toBeLessThanOrEqual(1)
+  })
+
+  test('Shows running state for parent nodes when child executes', async ({
+    comfyPage,
+    ws
+  }) => {
+    await comfyPage.loadWorkflow('execution/nested-subgraph-test')
+
+    // Track which nodes have running stroke style
+    const getRunningNodes = async () => {
+      return await comfyPage.page.evaluate(() => {
+        const runningNodes: number[] = []
+        const nodes = window['app'].graph.nodes
+
+        for (const node of nodes) {
+          if (
+            node.strokeStyles?.['running'] &&
+            node.strokeStyles['running'].call(node)?.color === '#0f0'
+          ) {
+            runningNodes.push(node.id)
+          }
+        }
+
+        return runningNodes
+      })
+    }
+
+    // Wait for any existing execution to complete
+    await comfyPage.page
+      .waitForFunction(
+        () => {
+          const nodes = window['app'].graph.nodes
+          for (const node of nodes) {
+            if (
+              node.strokeStyles?.['running'] &&
+              node.strokeStyles['running'].call(node)?.color === '#0f0'
+            ) {
+              return false
+            }
+          }
+          return true
+        },
+        { timeout: 10000 }
+      )
+      .catch(() => {
+        // If timeout, continue anyway
+      })
+
+    // Initially no nodes should be running
+    let runningNodes = await getRunningNodes()
+    expect(runningNodes).toHaveLength(0)
+
+    // Set up tracking for progress events
+    await executionHelper.setupEventTracking()
+
+    // Start real execution using command to avoid click issues
+    await comfyPage.executeCommand('Comfy.QueuePrompt')
+
+    // Wait for execution to start
+    await executionHelper.waitForExecutionStart()
+
+    // Wait for real nested node execution progress
+    await subgraphHelper.waitForNestedNodeProgress(1)
+
+    // Wait for parent subgraph to show as running
+    await comfyPage.page.waitForFunction(
+      (nodeId) => {
+        const node = window['app'].graph.getNodeById(nodeId)
+        if (!node?.strokeStyles?.['running']) return false
+        const style = node.strokeStyles['running'].call(node)
+        return style?.color === '#0f0'
+      },
+      10,
+      { timeout: 5000 }
+    )
+
+    // Parent subgraph should show as running
+    runningNodes = await getRunningNodes()
+    expect(runningNodes).toContain(10)
+
+    // Wait for the execution to complete naturally
+    const testId = executionHelper.getTestId()
+    await comfyPage.page.waitForFunction(
+      (testId) => {
+        const states = window[`__progressStates_${testId}`]
+        if (!states || states.length === 0) return false
+
+        // Check if execution is finished (no more running nodes)
+        const latestState = states[states.length - 1]
+        if (!latestState.nodes) return false
+
+        const runningNodes = Object.values(latestState.nodes).filter(
+          (node: any) => node.state === 'running'
+        ).length
+
+        return runningNodes === 0
+      },
+      testId,
+      { timeout: 10000 }
+    )
+
+    // Add a small delay to ensure UI updates
+    await comfyPage.page.waitForTimeout(500)
+
+    // Wait for parent subgraph to no longer be running
+    await comfyPage.page.waitForFunction(
+      (nodeId) => {
+        const node = window['app'].graph.getNodeById(nodeId)
+        if (!node?.strokeStyles?.['running']) return true
+        const style = node.strokeStyles['running'].call(node)
+        return style?.color !== '#0f0'
+      },
+      10,
+      { timeout: 5000 }
+    )
+
+    // Parent should no longer be running
+    runningNodes = await getRunningNodes()
+    expect(runningNodes).not.toContain(10)
+  })
+})