feature: show initialize message only when needed

Author: SimonSiefke

packages/test-coordinator/src/parts/RunTestsWithCallback/RunTestsWithCallback.ts

@@ -9,6 +9,7 @@ import * as Id from '../Id/Id.ts'
 import * as MemoryLeakFinder from '../MemoryLeakFinder/MemoryLeakFinder.ts'
 import * as MemoryLeakResultsPath from '../MemoryLeakResultsPath/MemoryLeakResultsPath.ts'
 import * as PrepareTestsOrAttach from '../PrepareTestsOrAttach/PrepareTestsOrAttach.ts'
+import * as ShouldShowInitializingMessage from '../ShouldShowInitializingMessage/ShouldShowInitializingMessage.ts'
 import * as TestWorkerEventType from '../TestWorkerEventType/TestWorkerEventType.ts'
 import * as TestWorkerRunTests from '../TestWorkerRunTests/TestWorkerRunTests.ts'
 import * as TestWorkerSetupTest from '../TestWorkerSetupTest/TestWorkerSetupTest.ts'
@@ -225,20 +226,26 @@ export const runTestsWithCallback = async ({
     }
     const initialStart = Time.now()
     const first = formattedPaths[0]
-    await callback(TestWorkerEventType.HandleInitializing)
+    const showInitializingMessage = await ShouldShowInitializingMessage.shouldShowInitializingMessage({
+      arch,
+      commit,
+      ide,
+      insidersCommit,
+      platform,
+      vscodePath,
+      vscodeVersion,
+    })
 
     const context = {
       runs,
     }
 
-    const intializeEnd = performance.now()
-    const intializeTime = intializeEnd - initialStart
-
-    await callback(TestWorkerEventType.HandleInitialized, intializeTime)
-
-    const testStart = performance.now()
-    await callback(TestWorkerEventType.TestsStarting, total)
-    await callback(TestWorkerEventType.TestRunning, first.absolutePath, first.relativeDirname, first.dirent, /* isFirst */ true)
+    let testStart = 0
+    if (!showInitializingMessage) {
+      testStart = performance.now()
+      await callback(TestWorkerEventType.TestsStarting, total)
+      await callback(TestWorkerEventType.TestRunning, first.absolutePath, first.relativeDirname, first.dirent, true)
+    }
 
     let workers = {
       functionTrackerRpc: emptyRpc,
@@ -247,6 +254,7 @@ export const runTestsWithCallback = async ({
       testWorkerRpc: emptyRpc,
       videoRpc: emptyRpc,
     }
+    let hasHandledInitializing = false
 
     for (let i = 0; i < formattedPaths.length; i++) {
       const formattedPath = formattedPaths[i]
@@ -256,6 +264,10 @@ export const runTestsWithCallback = async ({
       const needsSetup = i === 0 || restartBetween
 
       if (needsSetup) {
+        const initializeStart = Time.now()
+        if (showInitializingMessage && !hasHandledInitializing) {
+          await callback(TestWorkerEventType.HandleInitializing)
+        }
         await disposeWorkers(workers)
         PrepareTestsOrAttach.state.promise = undefined
         const { functionTrackerRpc, initializationWorkerRpc, memoryRpc, testWorkerRpc, videoRpc } =
@@ -295,6 +307,11 @@ export const runTestsWithCallback = async ({
             vscodePath,
             vscodeVersion,
           })
+        if (showInitializingMessage && !hasHandledInitializing) {
+          const intializeTime = performance.now() - initializeStart
+          await callback(TestWorkerEventType.HandleInitialized, intializeTime)
+          hasHandledInitializing = true
+        }
         workers = {
           functionTrackerRpc: functionTrackerRpc || emptyRpc,
           initializationWorkerRpc: initializationWorkerRpc || emptyRpc,
@@ -307,11 +324,16 @@ export const runTestsWithCallback = async ({
 
       const { memoryRpc, testWorkerRpc, videoRpc } = workers
 
-      let wasOriginallySkipped = false
-      if (i !== 0) {
-        await callback(TestWorkerEventType.TestRunning, absolutePath, relativeDirname, dirent, /* isFirst */ true)
+      if (i === 0 && showInitializingMessage) {
+        testStart = performance.now()
+        await callback(TestWorkerEventType.TestsStarting, total)
+        await callback(TestWorkerEventType.TestRunning, absolutePath, relativeDirname, dirent, true)
+      } else if (i !== 0) {
+        await callback(TestWorkerEventType.TestRunning, absolutePath, relativeDirname, dirent, false)
       }
 
+      let wasOriginallySkipped = false
+
       try {
         const start = i === 0 ? initialStart : Time.now()
         const testResult = await TestWorkerSetupTest.testWorkerSetupTest(

packages/test-coordinator/src/parts/ShouldShowInitializingMessage/ShouldShowInitializingMessage.ts

@@ -0,0 +1,58 @@
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import * as Ide from '../Ide/Ide.ts'
+import * as Root from '../Root/Root.ts'
+
+export interface ShouldShowInitializingMessageOptions {
+  readonly arch: string
+  readonly commit: string
+  readonly ide: string
+  readonly insidersCommit: string
+  readonly platform: string
+  readonly vscodePath: string
+  readonly vscodeVersion: string
+}
+
+const getCacheFilePath = (cacheKey: string, platform: string, arch: string): string => {
+  return join(Root.root, '.vscode-runtime-paths', `${cacheKey}-${platform}-${arch}.json`)
+}
+
+const isRuntimeCached = async (cacheKey: string, platform: string, arch: string): Promise<boolean> => {
+  if (!cacheKey) {
+    return false
+  }
+  const cacheFilePath = getCacheFilePath(cacheKey, platform, arch)
+  if (!existsSync(cacheFilePath)) {
+    return false
+  }
+  try {
+    const cacheContent = await readFile(cacheFilePath, 'utf8')
+    const cache = JSON.parse(cacheContent)
+    const pathUri = cache.uri || cache.path
+    if (typeof pathUri !== 'string' || pathUri === '') {
+      return false
+    }
+    const binaryPath = pathUri.startsWith('file://') ? fileURLToPath(pathUri) : pathUri
+    return existsSync(binaryPath)
+  } catch {
+    return false
+  }
+}
+
+export const shouldShowInitializingMessage = async (options: ShouldShowInitializingMessageOptions): Promise<boolean> => {
+  const { arch, commit, ide, insidersCommit, platform, vscodePath, vscodeVersion } = options
+  if (ide !== Ide.VsCode) {
+    return false
+  }
+  if (vscodePath || process.env.VSCODE_PATH) {
+    return false
+  }
+  if (commit) {
+    return false
+  }
+  const cacheKey = insidersCommit || vscodeVersion
+  const isDownloaded = await isRuntimeCached(cacheKey, platform, arch)
+  return !isDownloaded
+}