@quenty/nevermore-cli 4.50.0 → 4.51.0

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

@@ -142,6 +142,7 @@ class FakeTransport implements JobContext {
   public scriptContent?: string;
   public scriptContents: string[] = [];
   public deployedPaths: string[] = [];
+  public deployedTargets: unknown[] = [];
   public deployCount = 0;
   public runCount = 0;
   public messagesFor?: (script: string) => TaskLogMessage[];
@@ -160,6 +161,7 @@ class FakeTransport implements JobContext {
   ): Promise<Deployment> {
     this.deployCount++;
     this.deployedPaths.push(options.builtPlace.rbxlPath);
+    this.deployedTargets.push(options.builtPlace.target);
     return {};
   }
 
@@ -506,4 +508,44 @@ describe('an aggregated batch run, end to end', () => {
       ])
     );
   });
+
+  it('runs prebuilt places on the target it was given, without building', async () => {
+    const generate = vi.mocked(
+      (await import('./runner/combined-project-generator.js'))
+        .generateCombinedProjectAsync
+    );
+    generate.mockClear();
+    const { targets } = createBatch();
+    const transport = new FakeTransport(TASK_MESSAGES);
+    const cleanupAsync = vi.fn(async () => {});
+    const batch = new BatchScriptJobContext(transport, targets, {
+      repoRoot: '/repo',
+      batchPlaceId: 900,
+      batchUniverseId: 901,
+      prebuilt: {
+        chunks: [
+          {
+            rbxlPath: '/bundle/place-1.rbxl',
+            slugMap: SLUG_MAP,
+            sizeBytes: 1024,
+          },
+        ],
+        buildContext: { cleanupAsync } as any,
+      },
+    });
+
+    const alpha = await runPackageAsync(batch, '@quenty/alpha');
+    const beta = await runPackageAsync(batch, '@quenty/beta');
+
+    expect(generate).not.toHaveBeenCalled();
+    expect(transport.deployedPaths).toEqual(['/bundle/place-1.rbxl']);
+    expect(transport.deployedTargets).toEqual([
+      { placeId: 900, universeId: 901, project: '' },
+    ]);
+    expect(alpha.success).toBe(true);
+    expect(beta.success).toBe(false);
+
+    await batch.disposeAsync();
+    expect(cleanupAsync).toHaveBeenCalledOnce();
+  });
 });

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';