Some fixtures will only use 1 package manager

Author: codenem

packages/cli-v3/e2e/fixtures/dep-to-add-scope-parsing/yarn.lock

@@ -1,17 +1,21 @@
 import { execa, execaNode } from "execa";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, rename, rm } from "node:fs/promises";
 import { join, resolve } from "node:path";
 
 import { typecheckProject } from "../src/commands/deploy";
 import { readConfig, ReadConfigFileResult } from "../src/utilities/configFiles";
-import { PackageManager } from "../src/utilities/getUserPackageManager";
+import {
+  detectPackageManagerFromArtifacts,
+  LOCKFILES,
+  PackageManager,
+} from "../src/utilities/getUserPackageManager";
 import { logger } from "../src/utilities/logger";
 import { compile } from "./compile";
 import { createContainerFile } from "./createContainerFile";
 import { createDeployHash } from "./createDeployHash";
 import { handleDependencies } from "./handleDependencies";
-import { Loglevel, LogLevelSchema, PackageManagerSchema } from "./schemas";
+import { E2EOptions, E2EOptionsSchema } from "./schemas";
 import allTestCases from "./testCases.json";
 
 type TestCase = {
@@ -31,36 +35,36 @@ const testCases: TestCase[] = process.env.MOD
   ? allTestCases.filter(({ name }) => process.env.MOD === name)
   : allTestCases;
 
-let logLevel: Loglevel = "log";
-let packageManager: PackageManager = "npm";
+let options: E2EOptions;
 
 try {
-  logLevel = LogLevelSchema.parse(process.env.LOG);
+  options = E2EOptionsSchema.parse({
+    logLevel: process.env.LOG,
+    packageManager: process.env.PM,
+  });
 } catch (e) {
-  console.error(e);
-  console.log("Using default log level 'log'");
+  options = {
+    logLevel: "log",
+  };
 }
 
-logger.loggerLevel = logLevel;
-
-try {
-  packageManager = PackageManagerSchema.parse(process.env.PM);
-} catch (e) {
-  console.error(e);
-  console.log("Using default package manager 'npm'");
-}
+logger.loggerLevel = options.logLevel;
 
 if (testCases.length > 0) {
-  console.log(`Using ${packageManager}`);
-
-  describe.concurrent("bundling", () => {
+  describe.concurrent("bundling", async () => {
     beforeAll(async () => {
       for (let testCase of testCases) {
         const { name } = testCase;
         const fixtureDir = resolve(join(process.cwd(), "e2e/fixtures", name));
         await rm(resolve(join(fixtureDir, ".trigger")), { force: true, recursive: true });
         await rm(resolve(join(fixtureDir, "node_modules")), { force: true, recursive: true });
-        if (packageManager === "npm") {
+        const packageManager: PackageManager = await parsepackageManager(options, fixtureDir);
+
+        if (
+          packageManager === "npm" &&
+          (existsSync(resolve(join(fixtureDir, "yarn.lock"))) ||
+            existsSync(resolve(join(fixtureDir, "yarn.lock.copy"))))
+        ) {
           // `npm ci` & `npm install` will update an existing yarn.lock
           try {
             await rename(
@@ -90,10 +94,12 @@ if (testCases.length > 0) {
     });
 
     afterAll(async () => {
-      if (packageManager === "npm") {
-        for (let testCase of testCases) {
-          const { name } = testCase;
-          const fixtureDir = resolve(join(process.cwd(), "e2e/fixtures", name));
+      for (let testCase of testCases) {
+        const { name } = testCase;
+        const fixtureDir = resolve(join(process.cwd(), "e2e/fixtures", name));
+        const packageManager: PackageManager = await parsepackageManager(options, fixtureDir);
+
+        if (packageManager === "npm") {
           try {
             await rename(
               resolve(join(fixtureDir, "yarn.lock.copy")),
@@ -116,8 +122,13 @@ if (testCases.length > 0) {
         wantInstallationError,
       } = testCase;
       const fixtureDir = resolve(join(process.cwd(), "e2e/fixtures", name));
+      let shouldSkipFixture: boolean = false;
+      const packageManager: PackageManager = await parsepackageManager(options, fixtureDir);
 
-      test(
+      if (options.packageManager)
+        shouldSkipFixture = !existsSync(resolve(fixtureDir, LOCKFILES[options.packageManager]));
+
+      test.skipIf(shouldSkipFixture)(
         `fixture '${name}'`,
         async () => {
           await expect(
@@ -316,3 +327,18 @@ function installArgs(packageManager: string) {
       throw new Error(`Unknown package manager '${packageManager}'`);
   }
 }
+
+async function parsepackageManager(
+  options: E2EOptions,
+  fixtureDir: string
+): Promise<PackageManager> {
+  let packageManager: PackageManager;
+
+  if (options.packageManager) {
+    packageManager = options.packageManager;
+  } else {
+    packageManager = await detectPackageManagerFromArtifacts(fixtureDir);
+  }
+
+  return packageManager;
+}

packages/cli-v3/e2e/index.test.ts

@@ -1,7 +1,9 @@
 import { z } from "zod";
 
-export const LogLevelSchema = z
-  .enum(["debug", "info", "log", "warn", "error", "none"])
-  .default("log");
-export type Loglevel = z.infer<typeof LogLevelSchema>;
-export const PackageManagerSchema = z.enum(["npm", "pnpm", "yarn"]).default("npm");
+const LogLevelSchema = z.enum(["debug", "info", "log", "warn", "error", "none"]).default("log");
+const PackageManagerSchema = z.enum(["npm", "pnpm", "yarn"]);
+export const E2EOptionsSchema = z.object({
+  logLevel: LogLevelSchema,
+  packageManager: PackageManagerSchema.optional(),
+});
+export type E2EOptions = z.infer<typeof E2EOptionsSchema>;

packages/cli-v3/e2e/schemas.ts

@@ -3,6 +3,12 @@ import { basename } from "path";
 import { logger } from "./logger";
 
 export type PackageManager = "npm" | "pnpm" | "yarn";
+export const LOCKFILES = {
+  yarn: "yarn.lock",
+  pnpm: "pnpm-lock.yaml",
+  npm: "package-lock.json",
+  npmShrinkwrap: "npm-shrinkwrap.json",
+};
 
 export async function getUserPackageManager(path: string): Promise<PackageManager> {
   const packageManager = await detectPackageManager(path);
@@ -36,15 +42,8 @@ function detectPackageManagerFromCurrentCommand(): PackageManager {
   }
 }
 
-async function detectPackageManagerFromArtifacts(path: string): Promise<PackageManager> {
-  const artifacts = {
-    yarn: "yarn.lock",
-    pnpm: "pnpm-lock.yaml",
-    npm: "package-lock.json",
-    npmShrinkwrap: "npm-shrinkwrap.json",
-  };
-
-  const foundPath = await findUp(Object.values(artifacts), { cwd: path });
+export async function detectPackageManagerFromArtifacts(path: string): Promise<PackageManager> {
+  const foundPath = await findUp(Object.values(LOCKFILES), { cwd: path });
 
   if (!foundPath) {
     throw new Error("Could not detect package manager from artifacts");
@@ -53,12 +52,12 @@ async function detectPackageManagerFromArtifacts(path: string): Promise<PackageM
   logger.debug("Found path from package manager artifacts", { foundPath });
 
   switch (basename(foundPath)) {
-    case artifacts.yarn:
+    case LOCKFILES.yarn:
       return "yarn";
-    case artifacts.pnpm:
+    case LOCKFILES.pnpm:
       return "pnpm";
-    case artifacts.npm:
-    case artifacts.npmShrinkwrap:
+    case LOCKFILES.npm:
+    case LOCKFILES.npmShrinkwrap:
       return "npm";
     default:
       throw new Error(`Unhandled package manager detection path: ${foundPath}`);