@typespec/http-client-python 0.28.2 → 0.29.0

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

@@ -0,0 +1,507 @@
+/* eslint-disable no-console */
+import { ChildProcess, spawn } from "child_process";
+import fs from "fs";
+import { cpus } from "os";
+import { dirname, join } from "path";
+import pc from "picocolors";
+import { fileURLToPath } from "url";
+import { parseArgs } from "util";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "../../../");
+const monorepoRoot = join(root, "../../");
+const testsDir = join(root, "tests");
+
+const argv = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    emitter: { type: "boolean", short: "e" },
+    generator: { type: "boolean", short: "g" },
+    flavor: { type: "string", short: "f", default: "all" },
+    env: { type: "string" },
+    jobs: { type: "string", short: "j" },
+    name: { type: "string", short: "n" },
+    quiet: { type: "boolean", short: "q", default: false },
+    help: { type: "boolean", short: "h", default: false },
+  },
+});
+
+if (argv.values.help) {
+  console.log(`
+Usage: run-tests.ts [options]
+
+Options:
+  -e, --emitter                   Run TypeScript emitter tests (vitest)
+  -g, --generator                 Run Python generator tests (tox)
+  -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, 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)
+  -h, --help                      Show this help message
+
+Environments (for --generator):
+  test       Run pytest tests for generated packages
+  lint       Run pylint on generated packages
+  mypy       Run mypy type checking on generated packages
+  pyright    Run pyright type checking on generated packages
+  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:
+  run-tests.ts                                 # Run all tests (emitter + generator)
+  run-tests.ts --emitter                       # Run only emitter tests
+  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=lint                   # Run pylint for all flavors
+  run-tests.ts -g -f unbranded --env=mypy      # Run mypy for unbranded only
+`);
+  process.exit(0);
+}
+
+// Get Python venv path
+function getVenvPython(): string {
+  const venvPath = join(root, "venv");
+  if (fs.existsSync(join(venvPath, "bin"))) {
+    return join(venvPath, "bin", "python");
+  } else if (fs.existsSync(join(venvPath, "Scripts"))) {
+    return join(venvPath, "Scripts", "python.exe");
+  }
+  throw new Error("Virtual environment not found. Run 'npm run install' first.");
+}
+
+interface ToxResult {
+  env: string;
+  success: boolean;
+  duration: number;
+  error?: string;
+  failedTests?: string[];
+}
+
+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");
+
+  // Build command
+  const args = ["-m", "tox", "-c", toxIniPath, "-e", env];
+  if (name) {
+    args.push("--", "-k", name);
+  }
+
+  console.log(`${pc.blue("[START]")} ${env}`);
+
+  const proc: ChildProcess = spawn(pythonPath, args, {
+    cwd: testsDir,
+    stdio: "pipe",
+    env: { ...process.env, FOLDER: env.split("-")[1] || "azure" },
+  });
+
+  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;
+
+      if (success) {
+        console.log(`${pc.green("[PASS]")} ${env} (${duration.toFixed(1)}s)`);
+      } else {
+        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,
+      });
+    });
+
+    proc.on("error", (err) => {
+      const duration = (Date.now() - startTime) / 1000;
+      console.log(`${pc.red("[ERROR]")} ${env}: ${err.message}`);
+      resolve({
+        env,
+        success: false,
+        duration,
+        error: err.message,
+      });
+    });
+  });
+
+  return { env, proc, promise };
+}
+
+function killTask(task: RunningTask): void {
+  try {
+    task.proc.kill("SIGTERM");
+  } catch {
+    // Process may have already exited
+  }
+}
+
+async function runParallel(
+  envs: string[],
+  pythonPath: string,
+  maxJobs: number,
+  name?: string,
+): Promise<ToxResult[]> {
+  const results: ToxResult[] = [];
+  const running: Map<string, RunningTask> = new Map();
+
+  for (const env of envs) {
+    // Wait if we're at max capacity
+    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 = startToxEnv(env, pythonPath, name);
+    running.set(env, task);
+  }
+
+  // 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;
+}
+
+async function _runSequential(
+  envs: string[],
+  pythonPath: string,
+  name?: string,
+): Promise<ToxResult[]> {
+  const results: ToxResult[] = [];
+  for (const env of envs) {
+    const task = startToxEnv(env, pythonPath, name);
+    const result = await task.promise;
+    results.push(result);
+  }
+  return results;
+}
+
+function printSummary(results: ToxResult[]): void {
+  console.log("\n" + pc.bold("═".repeat(60)));
+  console.log(pc.bold(" Test Results Summary"));
+  console.log(pc.bold("═".repeat(60)) + "\n");
+
+  const passed = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+  const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+
+  for (const result of results) {
+    const status = result.success ? pc.green("PASS") : pc.red("FAIL");
+    console.log(`  ${status}  ${result.env} (${result.duration.toFixed(1)}s)`);
+  }
+
+  console.log("\n" + "─".repeat(60));
+  console.log(
+    `  ${pc.green(`Passed: ${passed.length}`)}  ` +
+      `${pc.red(`Failed: ${failed.length}`)}  ` +
+      `Total: ${results.length}  ` +
+      `Duration: ${totalDuration.toFixed(1)}s`,
+  );
+  console.log("─".repeat(60) + "\n");
+
+  if (failed.length > 0) {
+    console.log(pc.red("Failed environments:"));
+    for (const result of failed) {
+      console.log(`  - ${result.env}`);
+      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    ")}`);
+      }
+    }
+    console.log();
+  }
+}
+
+async function runEmitterTests(): Promise<ToxResult> {
+  const startTime = Date.now();
+  console.log(`${pc.blue("[START]")} emitter (vitest)`);
+
+  // Add node_modules/.bin directories to PATH so vitest can be found
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const binPaths = [
+    join(root, "node_modules", ".bin"),
+    join(monorepoRoot, "node_modules", ".bin"),
+  ].join(pathSep);
+  const env = {
+    ...process.env,
+    PATH: `${binPaths}${pathSep}${process.env.PATH}`,
+  };
+
+  return new Promise((resolve) => {
+    const proc: ChildProcess = spawn("vitest", ["run", "-c", "./emitter/vitest.config.ts"], {
+      cwd: root,
+      stdio: !argv.values.quiet ? "inherit" : "pipe",
+      shell: true,
+      env,
+    });
+
+    let stderr = "";
+    if (argv.values.quiet && proc.stderr) {
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+
+    proc.on("close", (code) => {
+      const duration = (Date.now() - startTime) / 1000;
+      const success = code === 0;
+
+      if (success) {
+        console.log(`${pc.green("[PASS]")} emitter (vitest) (${duration.toFixed(1)}s)`);
+      } else {
+        console.log(`${pc.red("[FAIL]")} emitter (vitest) (${duration.toFixed(1)}s)`);
+      }
+
+      resolve({
+        env: "emitter (vitest)",
+        success,
+        duration,
+        error: success ? undefined : stderr || `Exit code: ${code}`,
+      });
+    });
+
+    proc.on("error", (err) => {
+      const duration = (Date.now() - startTime) / 1000;
+      console.log(`${pc.red("[ERROR]")} emitter (vitest): ${err.message}`);
+      resolve({
+        env: "emitter (vitest)",
+        success: false,
+        duration,
+        error: err.message,
+      });
+    });
+  });
+}
+
+async function main(): Promise<void> {
+  const startTime = Date.now();
+
+  const runEmitter = argv.values.emitter;
+  const runGenerator = argv.values.generator;
+  const runBoth = !runEmitter && !runGenerator;
+
+  const allResults: ToxResult[] = [];
+
+  // Header
+  console.log(pc.cyan("\n╔══════════════════════════════════════════════════════════╗"));
+  console.log(
+    pc.cyan("║") +
+      pc.bold("           TypeSpec Python SDK Generator Tests            ") +
+      pc.cyan("║"),
+  );
+  console.log(pc.cyan("╚══════════════════════════════════════════════════════════╝") + "\n");
+
+  // Run emitter tests if requested
+  if (runEmitter || runBoth) {
+    console.log(`${pc.bold("=== Emitter Tests (TypeScript) ===")}\n`);
+    const emitterResult = await runEmitterTests();
+    allResults.push(emitterResult);
+  }
+
+  // Run generator tests if requested
+  if (runGenerator || runBoth) {
+    console.log(`\n${pc.bold("=== Generator Tests (Python) ===")}\n`);
+
+    // Determine flavors
+    const flavors = argv.values.flavor === "all" ? ["azure", "unbranded"] : [argv.values.flavor!];
+
+    // Determine environments
+    let baseEnvs: string[];
+    if (argv.values.env) {
+      baseEnvs = argv.values.env.split(",").map((e) => e.trim());
+    } else {
+      // Default: run test environments
+      baseEnvs = ["test"];
+    }
+
+    // Expand 'ci' and 'docs' into component environments for parallel execution
+    const expandedEnvs: string[] = [];
+    for (const env of baseEnvs) {
+      if (env === "ci") {
+        // 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);
+      }
+    }
+
+    // Build full environment list
+    const envs: string[] = [];
+    for (const env of expandedEnvs) {
+      if (env === "unittest") {
+        envs.push("unittest");
+      } else {
+        for (const flavor of flavors) {
+          envs.push(`${env}-${flavor}`);
+        }
+      }
+    }
+
+    // Get Python path
+    let pythonPath: string;
+    try {
+      pythonPath = getVenvPython();
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+
+    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}`);
+    if (argv.values.name) {
+      console.log(`  Filter:       ${argv.values.name}`);
+    }
+    console.log();
+
+    // 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 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);
+  }
+
+  // Print summary
+  printSummary(allResults);
+
+  const totalDuration = (Date.now() - startTime) / 1000;
+  console.log(`Total execution time: ${totalDuration.toFixed(1)}s\n`);
+
+  // Exit with appropriate code
+  const failed = allResults.filter((r) => !r.success);
+  if (failed.length > 0) {
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error(`${pc.red("Unexpected error:")}`, error);
+  process.exit(1);
+});

package/eng/scripts/ci/run_apiview.py

@@ -10,32 +10,38 @@
 
 import os
 import sys
-from subprocess import check_call, CalledProcessError
+from subprocess import run, TimeoutExpired
 import logging
 from util import run_check
 
 logging.getLogger().setLevel(logging.INFO)
 
+# Timeout for each apiview generation (seconds)
+APIVIEW_TIMEOUT = 30
+
 
 def _single_dir_apiview(mod):
-    loop = 0
-    while True:
+    for attempt in range(2):
         try:
-            check_call(
-                [
-                    "apistubgen",
-                    "--pkg-path",
-                    str(mod.absolute()),
-                ]
+            result = run(
+                ["apistubgen", "--pkg-path", str(mod.absolute())],
+                capture_output=True,
+                timeout=APIVIEW_TIMEOUT,
             )
-        except CalledProcessError as e:
-            if loop >= 2:  # retry for maximum 3 times because sometimes the apistubgen has transient failure.
-                logging.error("{} exited with apiview generation error {}".format(mod.stem, e.returncode))
+            if result.returncode == 0:
+                return True
+            if attempt == 1:
+                logging.error(f"{mod.stem} failed: {result.stderr.decode()[:200]}")
+                return False
+        except TimeoutExpired:
+            if attempt == 1:
+                logging.error(f"{mod.stem} timed out after {APIVIEW_TIMEOUT}s")
+                return False
+        except Exception as e:
+            if attempt == 1:
+                logging.error(f"{mod.stem} error: {e}")
                 return False
-            else:
-                loop += 1
-                continue
-        return True
+    return False
 
 
 if __name__ == "__main__":

package/eng/scripts/ci/run_mypy.py

@@ -12,37 +12,48 @@ from subprocess import check_call, CalledProcessError
 import os
 import logging
 import sys
-from util import run_check
+from util import run_check, get_package_namespace_dir
 
 logging.getLogger().setLevel(logging.INFO)
 
 
 def get_config_file_location():
-    mypy_ini_path = os.path.join(os.getcwd(), "../../eng/scripts/ci/mypy.ini")
+    # When running from tests/ directory via tox
+    mypy_ini_path = os.path.join(os.getcwd(), "../eng/scripts/ci/config/mypy.ini")
     if os.path.exists(mypy_ini_path):
         return mypy_ini_path
-    else:
-        return os.path.join(os.getcwd(), "../../../eng/scripts/ci/mypy.ini")
-
-
-def _single_dir_mypy(mod):
-    inner_class = next(d for d in mod.iterdir() if d.is_dir() and not str(d).endswith("egg-info"))
-    try:
-        check_call(
-            [
-                sys.executable,
-                "-m",
-                "mypy",
-                "--config-file",
-                get_config_file_location(),
-                "--ignore-missing",
-                str(inner_class.absolute()),
-            ]
-        )
+    # Fallback for running from different directories
+    return os.path.join(os.path.dirname(__file__), "config/mypy.ini")
+
+
+def _single_dir_mypy(mod, retries=2):
+    inner_class = get_package_namespace_dir(mod)
+    if not inner_class:
+        logging.info(f"No package directory found in {mod}, skipping")
         return True
-    except CalledProcessError as e:
-        logging.error("{} exited with mypy error {}".format(inner_class.stem, e.returncode))
-        return False
+    for attempt in range(1, retries + 2):
+        try:
+            check_call(
+                [
+                    sys.executable,
+                    "-m",
+                    "mypy",
+                    "--config-file",
+                    get_config_file_location(),
+                    "--ignore-missing",
+                    str(inner_class.absolute()),
+                ]
+            )
+            return True
+        except CalledProcessError as e:
+            if attempt <= retries:
+                logging.warning(
+                    "{} mypy attempt {} failed (exit {}), retrying...".format(inner_class.stem, attempt, e.returncode)
+                )
+            else:
+                logging.error("{} exited with mypy error {}".format(inner_class.stem, e.returncode))
+                return False
+    return False
 
 
 if __name__ == "__main__":

package/eng/scripts/ci/run_pylint.py

@@ -12,36 +12,44 @@ from subprocess import check_call, CalledProcessError
 import os
 import logging
 import sys
-from util import run_check
+from util import run_check, get_package_namespace_dir
 
 logging.getLogger().setLevel(logging.INFO)
 
 
 def get_rfc_file_location():
-    rfc_file_location = os.path.join(os.getcwd(), "../../../eng/scripts/ci/pylintrc")
+    # When running from tests/ directory via tox
+    rfc_file_location = os.path.join(os.getcwd(), "../eng/scripts/ci/config/pylintrc")
     if os.path.exists(rfc_file_location):
         return rfc_file_location
-    else:
-        return os.path.join(os.getcwd(), "../../../../eng/scripts/ci/pylintrc")
+    # Fallback for running from different directories
+    return os.path.join(os.path.dirname(__file__), "config/pylintrc")
 
 
 def _single_dir_pylint(mod):
-    inner_class = next(d for d in mod.iterdir() if d.is_dir() and not str(d).endswith("egg-info"))
+    inner_class = get_package_namespace_dir(mod)
+    if not inner_class:
+        logging.info(f"No package directory found in {mod}, skipping")
+        return True
+    # Only load the Azure pylint guidelines checker plugin for azure packages.
+    # The plugin (azure-pylint-guidelines-checker) is only installed in the
+    # lint-azure tox environment and is not available for unbranded packages.
+    is_azure = "azure" in mod.parts
+    pylint_args = [
+        sys.executable,
+        "-m",
+        "pylint",
+        "--rcfile={}".format(get_rfc_file_location()),
+        "--evaluation=(max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention + info)/ statement) * 10)))",
+        "--output-format=parseable",
+        "--recursive=y",
+        "--py-version=3.10",
+    ]
+    if is_azure:
+        pylint_args.append("--load-plugins=pylint_guidelines_checker")
+    pylint_args.append(str(inner_class.absolute()))
     try:
-        check_call(
-            [
-                sys.executable,
-                "-m",
-                "pylint",
-                "--rcfile={}".format(get_rfc_file_location()),
-                "--evaluation=(max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention + info)/ statement) * 10)))",
-                "--load-plugins=pylint_guidelines_checker",
-                "--output-format=parseable",
-                "--recursive=y",
-                "--py-version=3.9",
-                str(inner_class.absolute()),
-            ]
-        )
+        check_call(pylint_args)
         return True
     except CalledProcessError as e:
         logging.error("{} exited with linting error {}".format(str(inner_class.absolute()), e.returncode))