@quenty/nevermore-cli 4.49.0 → 4.50.1

package/src/utils/batch/changed-packages-utils.ts

@@ -10,6 +10,11 @@ import {
   toManifestPlaceInfo,
 } from '@quenty/nevermore-deploy';
 
+export interface WorkspacePackageInfo {
+  name: string;
+  path: string;
+}
+
 export interface TargetPackage {
   name: string;
   path: string;
@@ -50,16 +55,19 @@ export interface BatchTarget {
 export async function discoverAllTargetPackagesAsync(
   targetName: string
 ): Promise<TargetPackage[]> {
-  const { stdout } = await execa('pnpm', [
-    'ls',
-    '--json',
-    '-r',
-    '--depth',
-    '-1',
-  ]);
+  return filterByTargetAsync(await listWorkspacePackagesAsync(), targetName);
+}
 
-  const packages = JSON.parse(stdout) as Array<{ name: string; path: string }>;
-  return _filterByTargetAsync(packages, targetName);
+/** Every package in the pnpm workspace, with absolute paths. */
+export async function listWorkspacePackagesAsync(
+  cwd?: string
+): Promise<WorkspacePackageInfo[]> {
+  const { stdout } = await execa(
+    'pnpm',
+    ['ls', '--json', '-r', '--depth', '-1'],
+    { cwd }
+  );
+  return JSON.parse(stdout) as WorkspacePackageInfo[];
 }
 
 /**
@@ -92,7 +100,7 @@ export async function discoverChangedTargetPackagesAsync(
     return [];
   }
 
-  return _filterByTargetAsync(packages, targetName);
+  return filterByTargetAsync(packages, targetName);
 }
 
 /**
@@ -181,8 +189,9 @@ function _requireScriptTemplate(targets: BatchTarget[]): BatchTarget[] {
   return withTemplate;
 }
 
-async function _filterByTargetAsync(
-  packages: Array<{ name: string; path: string }>,
+/** Keep the packages whose deploy config has `targetName`, with its places. */
+export async function filterByTargetAsync(
+  packages: WorkspacePackageInfo[],
   targetName: string
 ): Promise<TargetPackage[]> {
   const results: TargetPackage[] = [];

package/src/utils/testing/batch-run.e2e.test.ts

@@ -485,8 +485,12 @@ describe('an aggregated batch run, end to end', () => {
       '/tmp/batch-2.rbxl',
     ]);
     expect(transport.runCount).toBe(2);
-    expect(transport.scriptContents[0]).toContain('["alpha"]');
-    expect(transport.scriptContents[1]).toContain('["beta"]');
+    // The places run in parallel, so their scripts arrive in either order
+    expect(
+      transport.scriptContents.map((script) =>
+        script.includes('["alpha"]') ? 'alpha' : 'beta'
+      )
+    ).toEqual(expect.arrayContaining(['alpha', 'beta']));
 
     expect(alpha.success).toBe(true);
     expect(alpha.testResults).toMatchObject({ passed: 68, total: 68 });

package/src/utils/testing/parsers/annotation-workspace.ts

@@ -0,0 +1,74 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import {
+  filterByTargetAsync,
+  listWorkspacePackagesAsync,
+} from '../../batch/changed-packages-utils.js';
+import {
+  type TestRojoProject,
+  findTestProjectSlug,
+} from '../runner/test-project-slug.js';
+
+export interface AnnotationWorkspacePackage {
+  /** Repo-relative POSIX directory, e.g. `src/player-mock` */
+  dir: string;
+  /** Rojo project name, which the sourcemap uses */
+  projectName?: string;
+  /** Instance names the package gets in its test places */
+  testSlugs: string[];
+}
+
+export interface AnnotationWorkspace {
+  packagesByName: Map<string, AnnotationWorkspacePackage>;
+}
+
+/**
+ * Index the pnpm workspace for mapping test output back to files. Returns
+ * `undefined` when the workspace can't be listed.
+ */
+export async function tryLoadAnnotationWorkspaceAsync(
+  repoRoot: string
+): Promise<AnnotationWorkspace | undefined> {
+  let packages;
+  try {
+    packages = await listWorkspacePackagesAsync(repoRoot);
+  } catch {
+    return undefined;
+  }
+
+  const packagesByName = new Map<string, AnnotationWorkspacePackage>();
+  await Promise.all(
+    packages.map(async (pkg) => {
+      const project = await _tryReadJsonAsync<{ name?: string }>(
+        path.join(pkg.path, 'default.project.json')
+      );
+      packagesByName.set(pkg.name, {
+        dir: path.relative(repoRoot, pkg.path).replace(/\\/g, '/'),
+        projectName: project?.name,
+        testSlugs: [],
+      });
+    })
+  );
+
+  for (const testPackage of await filterByTargetAsync(packages, 'test')) {
+    const entry = packagesByName.get(testPackage.name);
+    if (!entry) continue;
+    for (const target of testPackage.activeTargets) {
+      const project = await _tryReadJsonAsync<TestRojoProject>(
+        path.resolve(testPackage.path, target.project)
+      );
+      const slug = project && findTestProjectSlug(project);
+      if (slug && !entry.testSlugs.includes(slug)) entry.testSlugs.push(slug);
+    }
+  }
+
+  return { packagesByName };
+}
+
+async function _tryReadJsonAsync<T>(filePath: string): Promise<T | undefined> {
+  try {
+    return JSON.parse(await fs.readFile(filePath, 'utf-8')) as T;
+  } catch {
+    return undefined;
+  }
+}

package/src/utils/testing/parsers/index.ts

@@ -1,2 +1 @@
-export { resolveRobloxTestPath } from './roblox-path-resolver.js';
 export { parseJestLuaOutput } from './jest-lua-parser.js';