@typespec/http-client-python 0.28.3 → 0.29.0

package/eng/scripts/ci/regenerate.ts

@@ -2,24 +2,32 @@
 /**
  * Regenerates Python SDK code from TypeSpec definitions.
  *
- * Uses in-process TypeSpec compilation to avoid subprocess spawning overhead.
- * This is significantly faster than spawning `tsp compile` for each spec.
+ * Two-phase pipeline:
+ *   1. TypeSpec compile (in-process, parallel) -> emits per-spec YAML only.
+ *   2. Single batched Python subprocess reads all YAMLs and writes the
+ *      final `.py` files. Amortizes Python-startup cost across many specs.
+ *
+ * Shared helpers/data live in `regenerate-common.ts` (kept identical with the
+ * `@azure-tools/typespec-python` wrapper copy).
  */
 
-import { compile, NodeHost } from "@typespec/compiler";
-import { promises, rmSync } from "fs";
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { access, readdir } from "fs/promises";
 import { platform } from "os";
-import { dirname, join, relative, resolve } from "path";
+import { dirname, join, resolve } from "path";
 import pc from "picocolors";
 import { fileURLToPath } from "url";
 import { parseArgs } from "util";
+
 import {
-  BASE_AZURE_EMITTER_OPTIONS,
-  BASE_EMITTER_OPTIONS,
+  buildTaskGroups,
   getSubdirectories,
-  SpecialFlags,
-  toPosix,
-  type RegenerateFlags,
+  prepareBaselineOfGeneratedCode,
+  preprocess,
+  RegenerateContext,
+  RegenerateFlags,
+  runParallel,
 } from "./regenerate-common.js";
 
 // Parse arguments
@@ -93,193 +101,66 @@ const GENERATED_FOLDER = argv.values.generatedFolder
   : resolve(PLUGIN_DIR, "generator");
 const EMITTER_NAME = argv.values.emitterName || "@typespec/http-client-python";
 
-// Emitter options
-const AZURE_EMITTER_OPTIONS: Record<string, Record<string, string> | Record<string, string>[]> = {
-  ...BASE_AZURE_EMITTER_OPTIONS,
-  "client/structure/client-operation-group": {
-    "package-name": "client-structure-clientoperationgroup",
-    namespace: "client.structure.clientoperationgroup",
-  },
-};
-
-const EMITTER_OPTIONS: Record<string, Record<string, string> | Record<string, string>[]> = {
-  ...BASE_EMITTER_OPTIONS,
-  "type/array": {
-    "package-name": "typetest-array",
-    namespace: "typetest.array",
-  },
-  "type/model/inheritance/recursive": {
-    "package-name": "typetest-model-recursive",
-    namespace: "typetest.model.recursive",
-  },
+const ctx: RegenerateContext = {
+  pluginDir: PLUGIN_DIR,
+  azureHttpSpecs: AZURE_HTTP_SPECS,
+  httpSpecs: HTTP_SPECS,
+  generatedFolder: GENERATED_FOLDER,
+  emitterName: EMITTER_NAME,
 };
 
-interface CompileTask {
-  spec: string;
-  outputDir: string;
-  options: Record<string, unknown>;
-}
-
-// Group of tasks for the same spec that must run sequentially
-interface TaskGroup {
-  spec: string;
-  tasks: CompileTask[];
-}
-
-function defaultPackageName(spec: string): string {
-  const specDir = spec.includes("azure") ? AZURE_HTTP_SPECS : HTTP_SPECS;
-  return toPosix(relative(specDir, dirname(spec)))
-    .replace(/\//g, "-")
-    .toLowerCase();
-}
-
-function getEmitterOptions(spec: string, flavor: string): Record<string, string>[] {
-  const specDir = spec.includes("azure") ? AZURE_HTTP_SPECS : HTTP_SPECS;
-  const relativeSpec = toPosix(relative(specDir, spec));
-  const key = relativeSpec.includes("resiliency/srv-driven/old.tsp")
-    ? relativeSpec
-    : dirname(relativeSpec);
-  const emitterOpts = EMITTER_OPTIONS[key] ||
-    (flavor === "azure" ? AZURE_EMITTER_OPTIONS[key] : [{}]) || [{}];
-  return Array.isArray(emitterOpts) ? emitterOpts : [emitterOpts];
-}
-
-function buildTaskGroups(specs: string[], flags: RegenerateFlags): TaskGroup[] {
-  const groups: TaskGroup[] = [];
-
-  for (const spec of specs) {
-    const tasks: CompileTask[] = [];
-
-    for (const emitterConfig of getEmitterOptions(spec, flags.flavor)) {
-      const options: Record<string, unknown> = { ...emitterConfig };
-
-      // Add flavor-specific options
-      options["flavor"] = flags.flavor;
-      for (const [k, v] of Object.entries(SpecialFlags[flags.flavor] ?? {})) {
-        options[k] = v;
-      }
-
-      // Set output directory - use tests/generated/<flavor>/<package> structure
-      const packageName = (options["package-name"] as string) || defaultPackageName(spec);
-      const outputDir =
-        (options["emitter-output-dir"] as string) ||
-        toPosix(`${GENERATED_FOLDER}/../tests/generated/${flags.flavor}/${packageName}`);
-      options["emitter-output-dir"] = outputDir;
-
-      // Debug mode
-      if (flags.debug) {
-        options["debug"] = true;
-      }
-
-      // Examples directory
-      options["examples-dir"] = toPosix(join(dirname(spec), "examples"));
-
-      tasks.push({ spec, outputDir, options });
-    }
-
-    groups.push({ spec, tasks });
-  }
-
-  return groups;
-}
-
-async function compileSpec(task: CompileTask): Promise<{ success: boolean; error?: string }> {
-  const { spec, outputDir, options } = task;
-
+async function collectConfigFiles(generatedDir: string, flavor: string): Promise<string[]> {
+  const flavorDir = join(generatedDir, "..", "tests", "generated", flavor);
   try {
-    // Build compiler options
-    const compilerOptions = {
-      emit: [PLUGIN_DIR],
-      options: {
-        [EMITTER_NAME]: options,
-      },
-    };
-
-    // Compile using TypeSpec compiler directly (no subprocess)
-    const program = await compile(NodeHost, spec, compilerOptions);
-
-    if (program.hasError()) {
-      const errors = program.diagnostics
-        .filter((d) => d.severity === "error")
-        .map((d) => d.message)
-        .join("\n");
-      return { success: false, error: errors };
-    }
-
-    return { success: true };
-  } catch (err) {
-    // Clean up on error
-    rmSync(outputDir, { recursive: true, force: true });
-    return { success: false, error: String(err) };
+    await access(flavorDir);
+  } catch {
+    return [];
   }
-}
-
-async function runParallel(groups: TaskGroup[], maxJobs: number): Promise<Map<string, boolean>> {
-  const results = new Map<string, boolean>();
-  const executing: Set<Promise<void>> = new Set();
 
-  // Count total tasks for progress
-  const totalTasks = groups.reduce((sum, g) => sum + g.tasks.length, 0);
-  let completed = 0;
-
-  for (const group of groups) {
-    // Each group runs as a unit - tasks within a group run sequentially
-    // But different groups can run in parallel
-    const runGroup = async () => {
-      const specDir = group.spec.includes("azure") ? AZURE_HTTP_SPECS : HTTP_SPECS;
-      const shortName = toPosix(relative(specDir, dirname(group.spec)));
-
-      // Run all tasks in this group sequentially to avoid state pollution
-      let groupSuccess = true;
-      for (const task of group.tasks) {
-        const packageName = (task.options["package-name"] as string) || shortName;
-        console.log(pc.blue(`[${completed + 1}/${totalTasks}] Compiling ${packageName}...`));
-
-        const result = await compileSpec(task);
-        completed++;
-
-        if (result.success) {
-          console.log(pc.green(`[${completed}/${totalTasks}] ${packageName} succeeded`));
-        } else {
-          console.log(
-            pc.red(`[${completed}/${totalTasks}] ${packageName} failed: ${result.error}`),
-          );
-          groupSuccess = false;
+  const configFiles: string[] = [];
+  for (const pkg of await readdir(flavorDir, { withFileTypes: true })) {
+    if (pkg.isDirectory()) {
+      const pkgDir = join(flavorDir, pkg.name);
+      for (const file of await readdir(pkgDir)) {
+        if (file.startsWith(".tsp-codegen-") && file.endsWith(".json")) {
+          configFiles.push(join(pkgDir, file));
         }
       }
+    }
+  }
+  return configFiles;
+}
 
-      results.set(group.spec, groupSuccess);
-    };
+function runBatchPythonProcessing(flavor: string, configCount: number, jobs: number): boolean {
+  if (configCount === 0) return true;
 
-    const p = runGroup().finally(() => executing.delete(p));
-    executing.add(p);
+  console.log(pc.cyan(`\nRunning batch Python processing on ${configCount} specs...`));
 
-    if (executing.size >= maxJobs) {
-      await Promise.race(executing);
-    }
+  // Find Python venv
+  let venvPath = join(PLUGIN_DIR, "venv");
+  if (existsSync(join(venvPath, "bin"))) {
+    venvPath = join(venvPath, "bin", "python");
+  } else if (existsSync(join(venvPath, "Scripts"))) {
+    venvPath = join(venvPath, "Scripts", "python.exe");
+  } else {
+    console.error(pc.red("Python venv not found"));
+    return false;
   }
 
-  await Promise.all(executing);
-  return results;
-}
+  const batchScript = join(PLUGIN_DIR, "eng", "scripts", "setup", "run_batch.py");
 
-// Preprocess: create files that should be deleted after regeneration (for testing)
-async function preprocess(flavor: string): Promise<void> {
-  if (flavor === "azure") {
-    // Use tests/generated/<flavor>/<package> structure (same as output)
-    const testsGeneratedDir = resolve(GENERATED_FOLDER, "../tests/generated");
-    const folderParts = [
-      "azure",
-      "authentication-api-key",
-      "authentication",
-      "apikey",
-      "_operations",
-    ];
-    await promises.mkdir(join(testsGeneratedDir, ...folderParts), { recursive: true });
-    await promises.writeFile(
-      join(testsGeneratedDir, ...folderParts, "to_be_deleted.py"),
-      "# This file is to be deleted after regeneration",
+  try {
+    // Pass directory and flavor instead of individual config files to avoid command line length limits on Windows
+    execSync(
+      `"${venvPath}" "${batchScript}" --generated-dir "${PLUGIN_DIR}" --flavor ${flavor} --jobs ${jobs}`,
+      {
+        stdio: "inherit",
+        cwd: PLUGIN_DIR,
+      },
     );
+    return true;
+  } catch {
+    return false;
   }
 }
 
@@ -296,35 +177,61 @@ async function regenerateFlavor(
   const flags: RegenerateFlags = { flavor, debug, name };
 
   // Preprocess
-  await preprocess(flavor);
+  await preprocess(flavor, GENERATED_FOLDER);
 
   // Collect specs
   const azureSpecs = flavor === "azure" ? await getSubdirectories(AZURE_HTTP_SPECS, flags) : [];
   const standardSpecs = await getSubdirectories(HTTP_SPECS, flags);
   const allSpecs = [...azureSpecs, ...standardSpecs];
 
-  // Build task groups (tasks for same spec run sequentially to avoid state pollution)
-  const groups = buildTaskGroups(allSpecs, flags);
+  // Build task groups (tasks for same spec run sequentially to avoid state pollution).
+  // emitYamlOnly: true -> phase 1 emits YAML only; phase 2 (runBatchPythonProcessing) writes .py files.
+  const groups = buildTaskGroups(allSpecs, flags, ctx, { emitYamlOnly: true });
   const totalTasks = groups.reduce((sum, g) => sum + g.tasks.length, 0);
 
   console.log(pc.cyan(`Found ${allSpecs.length} specs (${totalTasks} total tasks) to compile`));
   console.log(pc.cyan(`Using ${jobs} parallel jobs\n`));
 
-  // Run compilation
+  // Run compilation (emits YAML only)
   const startTime = performance.now();
-  const results = await runParallel(groups, jobs);
-  const duration = (performance.now() - startTime) / 1000;
+  const results = await runParallel(groups, jobs, ctx);
+  const compileTime = (performance.now() - startTime) / 1000;
 
-  // Summary
+  // Summary for TypeSpec compilation
   const succeeded = Array.from(results.values()).filter((v) => v).length;
-  const failed = results.size - succeeded;
+  const compileFailed = results.size - succeeded;
+
+  console.log(
+    pc.cyan(
+      `\nTypeSpec compilation: ${succeeded} succeeded, ${compileFailed} failed (${compileTime.toFixed(1)}s)`,
+    ),
+  );
+
+  if (compileFailed > 0) {
+    console.log(pc.red(`Skipping Python processing due to compilation failures`));
+    return false;
+  }
+
+  // Batch process all specs with Python
+  const pyStartTime = performance.now();
+  const configCount = (await collectConfigFiles(GENERATED_FOLDER, flavor)).length;
+  // Use fewer Python jobs since Python processing is heavier
+  const pyJobs = Math.max(4, jobs);
+  const pySuccess = runBatchPythonProcessing(flavor, configCount, pyJobs);
+  const pyTime = (performance.now() - pyStartTime) / 1000;
+
+  const totalTime = (performance.now() - startTime) / 1000;
 
   console.log(pc.cyan(`\n${"=".repeat(60)}`));
-  console.log(pc.cyan(`Results: ${succeeded} succeeded, ${failed} failed`));
-  console.log(pc.cyan(`Time: ${duration.toFixed(1)}s`));
+  console.log(pc.cyan(`Results: ${succeeded} specs processed`));
+  console.log(
+    pc.cyan(
+      `  TypeSpec: ${compileTime.toFixed(1)}s | Python: ${pyTime.toFixed(1)}s | Total: ${totalTime.toFixed(1)}s`,
+    ),
+  );
   console.log(pc.cyan(`${"=".repeat(60)}\n`));
 
-  return failed === 0;
+  return pySuccess;
 }
 
 async function main() {
@@ -349,6 +256,8 @@ async function main() {
   const startTime = performance.now();
   let success: boolean;
 
+  await prepareBaselineOfGeneratedCode(GENERATED_FOLDER);
+
   if (flavor) {
     success = await regenerateFlavor(flavor, name, debug, jobs);
   } else {

package/eng/scripts/ci/run-tests.ts

@@ -35,7 +35,7 @@ Options:
   -f, --flavor <azure|unbranded>  SDK flavor to test (only applies to --generator)
                                   If not specified, tests both flavors
   --env <env1,env2,...>           Specific tox environments to run
-                                  Available: test, lint, mypy, pyright, docs, ci, unittest
+                                  Available: test, lint, mypy, pyright, apiview, sphinx, docs, ci, unittest
   -j, --jobs <n>                  Number of parallel jobs (default: CPU cores - 2)
   -n, --name <pattern>            Filter tests by name pattern
   -q, --quiet                     Suppress test output (only show pass/fail summary)
@@ -46,8 +46,10 @@ Environments (for --generator):
   lint       Run pylint on generated packages
   mypy       Run mypy type checking on generated packages
   pyright    Run pyright type checking on generated packages
-  docs       Run documentation validation (apiview, sphinx)
-  ci         Run all checks (test + lint + mypy + pyright)
+  apiview    Run apiview validation on generated packages
+  sphinx     Run sphinx docstring validation on generated packages
+  docs       Run apiview + sphinx (split into parallel envs)
+  ci         Run all checks (test + lint + mypy + pyright + apiview + sphinx)
   unittest   Run unit tests for pygen internals
 
 Examples:
@@ -56,8 +58,8 @@ Examples:
   run-tests.ts --generator                     # Run generator tests for all flavors
   run-tests.ts --generator --flavor=azure      # Run generator tests for azure only
   run-tests.ts -g -f azure --env=test          # Run pytest for azure only
-  run-tests.ts -g --env=mypy                   # Run mypy for all flavors
-  run-tests.ts -g -f unbranded --env=lint      # Run pylint for unbranded only
+  run-tests.ts -g --env=lint                   # Run pylint for all flavors
+  run-tests.ts -g -f unbranded --env=mypy      # Run mypy for unbranded only
 `);
   process.exit(0);
 }
@@ -78,9 +80,39 @@ interface ToxResult {
   success: boolean;
   duration: number;
   error?: string;
+  failedTests?: string[];
 }
 
-async function runToxEnv(env: string, pythonPath: string, name?: string): Promise<ToxResult> {
+interface RunningTask {
+  env: string;
+  proc: ChildProcess;
+  promise: Promise<ToxResult>;
+}
+
+function extractFailedTests(output: string): string[] {
+  const lines = output.split("\n");
+  const failedTests: string[] = [];
+  let inSummary = false;
+
+  for (const line of lines) {
+    if (line.includes("short test summary info")) {
+      inSummary = true;
+      continue;
+    }
+    if (inSummary) {
+      const match = line.match(/^FAILED\s+(.+)/);
+      if (match) {
+        failedTests.push(match[1].trim());
+      } else if (line.match(/^={3,}/) || line.match(/^\d+ failed/)) {
+        break;
+      }
+    }
+  }
+
+  return failedTests;
+}
+
+function startToxEnv(env: string, pythonPath: string, name?: string): RunningTask {
   const startTime = Date.now();
   const toxIniPath = join(testsDir, "tox.ini");
 
@@ -92,20 +124,34 @@ async function runToxEnv(env: string, pythonPath: string, name?: string): Promis
 
   console.log(`${pc.blue("[START]")} ${env}`);
 
-  return new Promise((resolve) => {
-    const proc: ChildProcess = spawn(pythonPath, args, {
-      cwd: testsDir,
-      stdio: !argv.values.quiet ? "inherit" : "pipe",
-      env: { ...process.env, FOLDER: env.split("-")[1] || "azure" },
-    });
+  const proc: ChildProcess = spawn(pythonPath, args, {
+    cwd: testsDir,
+    stdio: "pipe",
+    env: { ...process.env, FOLDER: env.split("-")[1] || "azure" },
+  });
 
-    let stderr = "";
-    if (argv.values.quiet && proc.stderr) {
-      proc.stderr.on("data", (data) => {
-        stderr += data.toString();
-      });
-    }
+  let stderr = "";
+  let stdout = "";
+  if (proc.stdout) {
+    proc.stdout.on("data", (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+      if (!argv.values.quiet) {
+        process.stdout.write(chunk);
+      }
+    });
+  }
+  if (proc.stderr) {
+    proc.stderr.on("data", (data) => {
+      const chunk = data.toString();
+      stderr += chunk;
+      if (!argv.values.quiet) {
+        process.stderr.write(chunk);
+      }
+    });
+  }
 
+  const promise = new Promise<ToxResult>((resolve) => {
     proc.on("close", (code) => {
       const duration = (Date.now() - startTime) / 1000;
       const success = code === 0;
@@ -116,11 +162,14 @@ async function runToxEnv(env: string, pythonPath: string, name?: string): Promis
         console.log(`${pc.red("[FAIL]")} ${env} (${duration.toFixed(1)}s)`);
       }
 
+      const failedTests = extractFailedTests(stdout);
+
       resolve({
         env,
         success,
         duration,
         error: success ? undefined : stderr || `Exit code: ${code}`,
+        failedTests: failedTests.length > 0 ? failedTests : undefined,
       });
     });
 
@@ -135,6 +184,16 @@ async function runToxEnv(env: string, pythonPath: string, name?: string): Promis
       });
     });
   });
+
+  return { env, proc, promise };
+}
+
+function killTask(task: RunningTask): void {
+  try {
+    task.proc.kill("SIGTERM");
+  } catch {
+    // Process may have already exited
+  }
 }
 
 async function runParallel(
@@ -144,24 +203,51 @@ async function runParallel(
   name?: string,
 ): Promise<ToxResult[]> {
   const results: ToxResult[] = [];
-  const running: Map<string, Promise<ToxResult>> = new Map();
+  const running: Map<string, RunningTask> = new Map();
 
   for (const env of envs) {
     // Wait if we're at max capacity
-    if (running.size >= maxJobs) {
-      const completed = await Promise.race(running.values());
+    while (running.size >= maxJobs) {
+      const promises = Array.from(running.values()).map((t) => t.promise);
+      const completed = await Promise.race(promises);
       results.push(completed);
       running.delete(completed.env);
+
+      // Fail-fast: kill all running tasks and exit
+      if (!completed.success) {
+        console.log(pc.red(`\n[FAIL-FAST] ${completed.env} failed, killing remaining tasks...`));
+        for (const task of running.values()) {
+          killTask(task);
+        }
+        // Wait briefly for processes to terminate
+        await Promise.all(Array.from(running.values()).map((t) => t.promise));
+        return results;
+      }
     }
 
     // Start new task
-    const task = runToxEnv(env, pythonPath, name);
+    const task = startToxEnv(env, pythonPath, name);
     running.set(env, task);
   }
 
-  // Wait for remaining tasks
-  const remaining = await Promise.all(running.values());
-  results.push(...remaining);
+  // Wait for remaining tasks, checking for failures
+  while (running.size > 0) {
+    const promises = Array.from(running.values()).map((t) => t.promise);
+    const completed = await Promise.race(promises);
+    results.push(completed);
+    running.delete(completed.env);
+
+    // Fail-fast: kill all running tasks and exit
+    if (!completed.success) {
+      console.log(pc.red(`\n[FAIL-FAST] ${completed.env} failed, killing remaining tasks...`));
+      for (const task of running.values()) {
+        killTask(task);
+      }
+      // Wait briefly for processes to terminate
+      await Promise.all(Array.from(running.values()).map((t) => t.promise));
+      return results;
+    }
+  }
 
   return results;
 }
@@ -173,7 +259,8 @@ async function _runSequential(
 ): Promise<ToxResult[]> {
   const results: ToxResult[] = [];
   for (const env of envs) {
-    const result = await runToxEnv(env, pythonPath, name);
+    const task = startToxEnv(env, pythonPath, name);
+    const result = await task.promise;
     results.push(result);
   }
   return results;
@@ -206,7 +293,11 @@ function printSummary(results: ToxResult[]): void {
     console.log(pc.red("Failed environments:"));
     for (const result of failed) {
       console.log(`  - ${result.env}`);
-      if (result.error && !argv.values.quiet) {
+      if (result.failedTests && result.failedTests.length > 0) {
+        for (const test of result.failedTests) {
+          console.log(`    ${pc.red("FAILED")} ${test}`);
+        }
+      } else if (result.error && !argv.values.quiet) {
         console.log(`    ${result.error.split("\n").slice(0, 5).join("\n    ")}`);
       }
     }
@@ -316,12 +407,15 @@ async function main(): Promise<void> {
       baseEnvs = ["test"];
     }
 
-    // Expand 'ci' into its component environments for parallel execution
+    // Expand 'ci' and 'docs' into component environments for parallel execution
     const expandedEnvs: string[] = [];
     for (const env of baseEnvs) {
       if (env === "ci") {
-        // Run test first (sequential), then lint/mypy/pyright/docs in parallel
-        expandedEnvs.push("test", "lint", "mypy", "pyright", "docs");
+        // All envs run in parallel — pre-built wheels make installs cheap
+        expandedEnvs.push("test", "lint", "mypy", "pyright", "apiview", "sphinx");
+      } else if (env === "docs") {
+        // Split docs into apiview + sphinx for parallelism
+        expandedEnvs.push("apiview", "sphinx");
       } else {
         expandedEnvs.push(env);
       }
@@ -348,37 +442,48 @@ async function main(): Promise<void> {
       process.exit(1);
     }
 
-    // Separate test environments from other environments
-    // Test environments must run sequentially (they share port 3000)
-    // Other environments (lint, mypy, pyright, docs) can run in parallel
-    const testEnvs = envs.filter((e) => e.startsWith("test-") || e === "unittest");
-    const otherEnvs = envs.filter((e) => !e.startsWith("test-") && e !== "unittest");
-
     const maxJobs = argv.values.jobs
       ? parseInt(argv.values.jobs, 10)
       : Math.max(2, cpus().length - 2);
 
     console.log(`  Flavors:      ${flavors.join(", ")}`);
     console.log(`  Environments: ${envs.join(", ")}`);
-    console.log(`  Jobs:         ${maxJobs} (test envs run sequentially, others in parallel)`);
+    console.log(`  Jobs:         ${maxJobs}`);
     if (argv.values.name) {
       console.log(`  Filter:       ${argv.values.name}`);
     }
     console.log();
 
-    // Run test environments first (sequentially)
-    let results: ToxResult[] = [];
-    if (testEnvs.length > 0) {
-      console.log(pc.cyan("Running test environments (sequential)..."));
-      results = await runParallel(testEnvs, pythonPath, 1, argv.values.name);
+    // Pre-build wheels for each flavor so tox envs install from pre-built
+    // wheels instead of rebuilding from source (~2min build once vs ~2min × N envs)
+    console.log(pc.cyan("Pre-building wheels for all flavors..."));
+    const installScript = join(testsDir, "install_packages.py");
+    for (const flavor of flavors) {
+      const startTime = Date.now();
+      const proc = spawn(pythonPath, [installScript, "build", flavor, testsDir], {
+        cwd: testsDir,
+        stdio: "inherit",
+      });
+      await new Promise<void>((resolve) => {
+        proc.on("close", (code) => {
+          const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+          if (code === 0) {
+            console.log(`${pc.green("[PASS]")} wheel build ${flavor} (${duration}s)`);
+          } else {
+            console.log(
+              `${pc.yellow("[WARN]")} wheel build ${flavor} failed (${duration}s), tox envs will build from source`,
+            );
+          }
+          resolve();
+        });
+      });
     }
+    console.log();
 
-    // Run other environments in parallel
-    if (otherEnvs.length > 0) {
-      console.log(pc.cyan("\nRunning lint/typecheck environments (parallel)..."));
-      const otherResults = await runParallel(otherEnvs, pythonPath, maxJobs, argv.values.name);
-      results = results.concat(otherResults);
-    }
+    // Run all environments in parallel
+    // The mock server serves both azure and unbranded specs, so all tests can run together
+    console.log(pc.cyan("Running all environments in parallel..."));
+    const results = await runParallel(envs, pythonPath, maxJobs, argv.values.name);
 
     allResults.push(...results);
   }