@quenty/nevermore-cli 4.50.0 → 4.51.0

package/src/utils/testing/parsers/roblox-path-resolver.ts

@@ -1,82 +1,143 @@
 /**
- * Converts Roblox instance paths from Jest-lua output back to
- * repo-relative local filesystem paths.
+ * Maps Roblox instance paths from Jest-lua output to existing repo-relative
+ * source files, through `sourcemap.json` or else the `<package dir>/src/`
+ * layout.
  *
- * Two strategies:
- *
- * 1. **Sourcemap** (preferred) — Uses the authoritative `sourcemap.json`
- *    mapping from `rojo sourcemap --absolute`. Exact and handles all
- *    project layouts.
- *
- * 2. **Heuristic** (fallback) — Assumes `src/{slug}/src/` layout and
- *    hard-codes `.spec`/`.story` as known dotted suffixes. Works when no
- *    sourcemap is available.
+ * A package's npm name (`@quenty/playermock`), directory (`src/player-mock`),
+ * Rojo project name (`playermock`) and test-place slug (`gameproduct` for
+ * `src/gameproductservice`) can all differ; see `AnnotationWorkspace`.
  */
 
+import * as fs from 'fs';
+import * as path from 'path';
 import type { SourcemapResolver } from '../../sourcemap/index.js';
+import type {
+  AnnotationWorkspace,
+  AnnotationWorkspacePackage,
+} from './annotation-workspace.js';
 
 const SERVER_SCRIPT_SERVICE_PREFIX = 'ServerScriptService.';
+const NODE_MODULES_SEGMENT = '.node_modules.';
+const QUENTY_SCOPE = '@quenty/';
+const QUENTY_SCOPE_SEGMENT = '@quenty.';
+const CHUNK_NAME_PATTERN = /^\[string "(.*)"\]$/;
+// Rojo strips `.server`/`.client` from script instance names.
+const SOURCE_EXTENSIONS = ['', '.server', '.client'].flatMap((kind) => [
+  `${kind}.lua`,
+  `${kind}.luau`,
+  `/init${kind}.lua`,
+  `/init${kind}.luau`,
+]);
+
+export interface RobloxSourceResolveOptions {
+  sourcemapResolver?: SourcemapResolver;
+  workspace?: AnnotationWorkspace;
+  /** npm name of the package under test, e.g. `@quenty/gameproductservice` */
+  packageName?: string;
+  /** Repo root that holds the workspace. Defaults to cwd. */
+  repoRoot?: string;
+}
+
+export interface ResolvedSourceFile {
+  file: string;
+  /** False for dependency copies and sibling packages. */
+  isPackageUnderTest: boolean;
+}
 
 /**
- * Resolve a Roblox instance path (from Jest-lua or a stack trace) to a
- * repo-relative filesystem path.
- *
- * When a `sourcemapResolver` is provided, it is tried first. Falls back to
- * the heuristic if the resolver doesn't have a mapping.
+ * Resolve an instance path (no `:LINE` suffix) to an existing repo-relative
+ * source file, or `undefined` when none matches.
  */
-export function resolveRobloxTestPath(
+export function tryResolveRobloxSourceFile(
   instancePath: string,
-  sourcemapResolver?: SourcemapResolver
-): string {
-  if (sourcemapResolver) {
-    const resolved = sourcemapResolver.resolve(instancePath);
-    if (resolved) return resolved;
+  options: RobloxSourceResolveOptions = {}
+): ResolvedSourceFile | undefined {
+  let unwrapped = _unwrapChunkName(instancePath);
+
+  // Roblox truncates long chunk names: `...@quenty.servic..."]`
+  if (unwrapped.endsWith('...')) return undefined;
+
+  if (unwrapped.startsWith(SERVER_SCRIPT_SERVICE_PREFIX)) {
+    unwrapped = unwrapped.slice(SERVER_SCRIPT_SERVICE_PREFIX.length);
   }
 
-  return _resolveHeuristic(instancePath);
-}
+  const packagesByName = options.workspace?.packagesByName;
 
-/**
- * Heuristic fallback: assumes `src/{slug}/src/` layout.
- *
- * Handles optional `:LINE` suffixes and missing `ServerScriptService.` prefix.
- */
-function _resolveHeuristic(instancePath: string): string {
-  // Strip :LINE suffix if present
-  let path = instancePath.replace(/:\d+$/, '');
+  let workspacePackage: AnnotationWorkspacePackage | undefined;
+  let packageInstanceName: string;
+  let rest: string;
+  let isPackageUnderTest = false;
 
-  // Strip ServerScriptService. prefix
-  if (path.startsWith(SERVER_SCRIPT_SERVICE_PREFIX)) {
-    path = path.slice(SERVER_SCRIPT_SERVICE_PREFIX.length);
+  const nodeModulesIndex = unwrapped.lastIndexOf(NODE_MODULES_SEGMENT);
+  if (nodeModulesIndex !== -1) {
+    const dependencyPath = unwrapped.slice(
+      nodeModulesIndex + NODE_MODULES_SEGMENT.length
+    );
+    if (!dependencyPath.startsWith(QUENTY_SCOPE_SEGMENT)) return undefined;
+    [packageInstanceName, rest] = _splitFirstSegment(
+      dependencyPath.slice(QUENTY_SCOPE_SEGMENT.length)
+    );
+    workspacePackage = packagesByName?.get(QUENTY_SCOPE + packageInstanceName);
+  } else {
+    [packageInstanceName, rest] = _splitFirstSegment(unwrapped);
+    const packageUnderTest = options.packageName
+      ? packagesByName?.get(options.packageName)
+      : undefined;
+    if (packageUnderTest?.testSlugs.includes(packageInstanceName)) {
+      workspacePackage = packageUnderTest;
+      isPackageUnderTest = true;
+    }
   }
 
-  // First dot-separated segment is the package slug
-  const dotIndex = path.indexOf('.');
-  if (dotIndex === -1) {
-    // Just a package name with no sub-path — return the src dir
-    return `src/${path}/src`;
+  const dir = workspacePackage?.dir ?? `src/${packageInstanceName}`;
+  // The sourcemap names packages by Rojo project name, not folder.
+  const sourcemapNames = new Set([
+    workspacePackage?.projectName ?? packageInstanceName,
+    path.posix.basename(dir),
+  ]);
+  for (const name of sourcemapNames) {
+    const mapped = options.sourcemapResolver?.resolve(
+      SERVER_SCRIPT_SERVICE_PREFIX + name + (rest ? `.${rest}` : '')
+    );
+    if (mapped) return { file: mapped, isPackageUnderTest };
   }
 
-  const packageSlug = path.slice(0, dotIndex);
-  const remaining = path.slice(dotIndex + 1);
+  const repoRoot = options.repoRoot ?? process.cwd();
+  const base = _resolveHeuristic(dir, rest);
+  for (const extension of SOURCE_EXTENSIONS) {
+    const file = `${base}${extension}`;
+    if (fs.existsSync(path.join(repoRoot, file))) {
+      return { file, isPackageUnderTest };
+    }
+  }
 
-  // Split into segments. In Rojo, dots in filenames (e.g. "Maid.spec.lua"
-  // becomes instance "Maid.spec") are ambiguous with the hierarchy separator.
-  // Rejoin known filename suffixes like ".spec" and ".story" with a dot
-  // instead of a slash.
-  const segments = remaining.split('.');
-  const rejoined: string[] = [];
+  return undefined;
+}
 
-  for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i];
-    // If this segment is a known file suffix, merge it with the previous
-    if (i > 0 && (seg === 'spec' || seg === 'story')) {
-      rejoined[rejoined.length - 1] += `.${seg}`;
+function _unwrapChunkName(name: string): string {
+  const match = name.trim().match(CHUNK_NAME_PATTERN);
+  return match ? match[1] : name.trim();
+}
+
+function _splitFirstSegment(dottedPath: string): [string, string] {
+  const dotIndex = dottedPath.indexOf('.');
+  return dotIndex === -1
+    ? [dottedPath, '']
+    : [dottedPath.slice(0, dotIndex), dottedPath.slice(dotIndex + 1)];
+}
+
+function _resolveHeuristic(dir: string, rest: string): string {
+  if (!rest) return `${dir}/src`;
+
+  // Rojo turns `Maid.spec.lua` into instance `Maid.spec`, so rejoin suffixes.
+  const rejoined: string[] = [];
+  for (const segment of rest.split('.')) {
+    if (rejoined.length > 0 && (segment === 'spec' || segment === 'story')) {
+      rejoined[rejoined.length - 1] += `.${segment}`;
     } else {
-      rejoined.push(seg);
+      rejoined.push(segment);
     }
   }
 
-  const subPath = rejoined.join('/');
-  return `src/${packageSlug}/src/${subPath}.lua`;
+  return `${dir}/src/${rejoined.join('/')}`;
 }

package/src/utils/testing/runner/combined-project-generator.ts

@@ -8,6 +8,10 @@ import { OutputHelper } from '@quenty/cli-output-helpers';
 import { type DeployTarget } from '@quenty/nevermore-deploy';
 import { type BatchTarget } from '../../batch/changed-packages-utils.js';
 import { recompressPlace } from '../../build/place-recompression.js';
+import {
+  type TestRojoProject,
+  findTestProjectSlug,
+} from './test-project-slug.js';
 
 /**
  * Budget for one combined place, as uploaded (recompressed). Under the upload
@@ -40,10 +44,6 @@ export interface CombinedProjectResult {
   buildContext: BuildContext;
 }
 
-interface RojoNode {
-  [key: string]: unknown;
-}
-
 import { type StepProgress } from '@quenty/cli-output-helpers/reporting';
 
 /** Progress callbacks for granular phase reporting during combined builds. */
@@ -345,20 +345,16 @@ async function _extractSlugAsync(
     );
   }
 
-  const project = JSON.parse(content) as {
-    tree: { ServerScriptService?: RojoNode };
-  };
-  const serverScriptService = project.tree?.ServerScriptService;
-  if (!serverScriptService) {
+  const project = JSON.parse(content) as TestRojoProject;
+  if (!project.tree?.ServerScriptService) {
     throw new Error(
       `Test project for ${batchTargetName} is missing ServerScriptService in tree`
     );
   }
 
-  for (const key of Object.keys(serverScriptService)) {
-    if (!key.startsWith('$') && key !== 'Script') {
-      return key;
-    }
+  const slug = findTestProjectSlug(project);
+  if (slug) {
+    return slug;
   }
 
   throw new Error(

package/src/utils/testing/runner/prebuilt-batch-bundle.test.ts

@@ -0,0 +1,252 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { Header } from 'tar';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  type PrebuiltBatchBundle,
+  readPrebuiltBatchBundleAsync,
+  writePrebuiltBatchBundleAsync,
+} from './prebuilt-batch-bundle.js';
+
+interface RawEntry {
+  path: string;
+  body?: string;
+  type?: 'File' | 'SymbolicLink' | 'Directory';
+  linkpath?: string;
+}
+
+function rawTar(entries: RawEntry[]): Buffer {
+  const blocks: Buffer[] = [];
+  for (const entry of entries) {
+    const body = Buffer.from(entry.body ?? '');
+    const header = new Header({
+      path: entry.path,
+      type: entry.type ?? 'File',
+      linkpath: entry.linkpath,
+      size: entry.type && entry.type !== 'File' ? 0 : body.length,
+      mode: 0o644,
+      mtime: new Date(0),
+    });
+    header.encode();
+    blocks.push(header.block!);
+    if (!entry.type || entry.type === 'File') {
+      const padded = Buffer.alloc(Math.ceil(body.length / 512) * 512);
+      body.copy(padded);
+      blocks.push(padded);
+    }
+  }
+  blocks.push(Buffer.alloc(1024));
+  return Buffer.concat(blocks);
+}
+
+function validManifest(): any {
+  return {
+    formatVersion: 1,
+    chunks: [
+      {
+        file: 'place-1.rbxl',
+        packages: [
+          { name: '@quenty/rx', slug: 'rx', hasJestConfig: true },
+          { name: '@quenty/maid', slug: 'maid', hasJestConfig: false },
+        ],
+      },
+    ],
+  };
+}
+
+describe('prebuilt batch bundle', () => {
+  let workDir: string;
+  const opened: PrebuiltBatchBundle[] = [];
+
+  beforeEach(async () => {
+    workDir = await fs.mkdtemp(path.join(os.tmpdir(), 'prebuilt-bundle-'));
+  });
+
+  afterEach(async () => {
+    for (const bundle of opened.splice(0)) {
+      await bundle.buildContext.cleanupAsync();
+    }
+    await fs.rm(workDir, { recursive: true, force: true });
+  });
+
+  async function readAsync(file: string) {
+    const bundle = await readPrebuiltBatchBundleAsync(file);
+    opened.push(bundle);
+    return bundle;
+  }
+
+  async function writeRawAsync(entries: RawEntry[]): Promise<string> {
+    const file = path.join(workDir, 'raw.nevermore.tests.tar');
+    await fs.writeFile(file, rawTar(entries));
+    return file;
+  }
+
+  async function writeManifestAsync(manifest: any): Promise<string> {
+    return writeRawAsync([
+      { path: 'manifest.json', body: JSON.stringify(manifest) },
+      { path: 'place-1.rbxl', body: 'place bytes' },
+    ]);
+  }
+
+  it('round-trips places, slugs and jest.config flags through one file', async () => {
+    const source = path.join(workDir, 'source.rbxl');
+    await fs.writeFile(source, 'place bytes');
+    const file = path.join(workDir, 'out', 'pr-1.nevermore.tests.tar');
+    await writePrebuiltBatchBundleAsync(
+      file,
+      [
+        {
+          rbxlPath: source,
+          slugMap: new Map([
+            ['@quenty/rx', 'rx'],
+            ['@quenty/maid', 'maid'],
+          ]),
+          sizeBytes: 11,
+        },
+      ],
+      new Map([['@quenty/rx', true]])
+    );
+
+    const bundle = await readAsync(file);
+
+    expect(bundle.packages).toEqual([
+      { name: '@quenty/rx', hasJestConfig: true },
+      { name: '@quenty/maid', hasJestConfig: false },
+    ]);
+    expect(bundle.chunks).toHaveLength(1);
+    expect(bundle.chunks[0]!.sizeBytes).toBe(11);
+    expect([...bundle.chunks[0]!.slugMap]).toEqual([
+      ['@quenty/rx', 'rx'],
+      ['@quenty/maid', 'maid'],
+    ]);
+    expect(await fs.readFile(bundle.chunks[0]!.rbxlPath, 'utf-8')).toBe(
+      'place bytes'
+    );
+  });
+
+  it('reads an empty bundle as no packages', async () => {
+    const file = path.join(workDir, 'empty.nevermore.tests.tar');
+    await writePrebuiltBatchBundleAsync(file, [], new Map());
+
+    const bundle = await readAsync(file);
+
+    expect(bundle.packages).toEqual([]);
+    expect(bundle.chunks).toEqual([]);
+  });
+
+  it('removes the unpacked places on cleanup', async () => {
+    const bundle = await readPrebuiltBatchBundleAsync(
+      await writeManifestAsync(validManifest())
+    );
+    const placePath = bundle.chunks[0]!.rbxlPath;
+
+    await bundle.buildContext.cleanupAsync();
+
+    await expect(fs.stat(placePath)).rejects.toThrow();
+  });
+
+  it('never writes outside its own directory for an entry that escapes', async () => {
+    const file = await writeRawAsync([
+      { path: 'manifest.json', body: JSON.stringify(validManifest()) },
+      { path: 'place-1.rbxl', body: 'place bytes' },
+      { path: '../escaped.rbxl', body: 'evil' },
+    ]);
+
+    await expect(readAsync(file)).rejects.toThrow('unexpected entry');
+    await expect(
+      fs.stat(path.join(os.tmpdir(), 'escaped.rbxl'))
+    ).rejects.toThrow();
+  });
+
+  it('rejects a symlink entry', async () => {
+    const file = await writeRawAsync([
+      { path: 'manifest.json', body: JSON.stringify(validManifest()) },
+      { path: 'place-1.rbxl', type: 'SymbolicLink', linkpath: '/etc/passwd' },
+    ]);
+
+    await expect(readAsync(file)).rejects.toThrow('not a regular file');
+  });
+
+  it('rejects a place the manifest does not list', async () => {
+    const file = await writeRawAsync([
+      { path: 'manifest.json', body: JSON.stringify(validManifest()) },
+      { path: 'place-1.rbxl', body: 'place bytes' },
+      { path: 'place-2.rbxl', body: 'extra' },
+    ]);
+
+    await expect(readAsync(file)).rejects.toThrow('every place it holds');
+  });
+
+  it('rejects a manifest that lists a place the bundle does not hold', async () => {
+    const manifest = validManifest();
+    manifest.chunks[0].file = 'place-2.rbxl';
+
+    await expect(readAsync(await writeManifestAsync(manifest))).rejects.toThrow(
+      'invalid place file'
+    );
+  });
+
+  it('rejects a file that is not a tar', async () => {
+    const file = path.join(workDir, 'junk.nevermore.tests.tar');
+    await fs.writeFile(file, 'not a tar at all');
+
+    await expect(readAsync(file)).rejects.toThrow();
+  });
+
+  it('rejects a slug that could break out of the batch script', async () => {
+    const manifest = validManifest();
+    manifest.chunks[0].packages[0].slug = 'rx"]] print("hi") --';
+
+    await expect(readAsync(await writeManifestAsync(manifest))).rejects.toThrow(
+      'invalid slug'
+    );
+  });
+
+  it('accepts a multi-place target name with a free-form place name', async () => {
+    const manifest = validManifest();
+    manifest.chunks[0].packages[0].name = '@quenty/rx - Hub (Test) + Lobby é';
+
+    const bundle = await readAsync(await writeManifestAsync(manifest));
+
+    expect(bundle.packages[0]!.name).toBe('@quenty/rx - Hub (Test) + Lobby é');
+  });
+
+  it.each([
+    '@quenty/rx | injected',
+    '@quenty/rx<img>',
+    '@quenty/rx\nline',
+    '@quenty/rx [Approved](https://evil.example)',
+    '@quenty/rx ![x](p.png)',
+    '@quenty/rx cc @someuser',
+    '@quenty/rx https://evil.example',
+  ])(
+    'rejects a package name that could break the PR comment: %j',
+    async (name) => {
+      const manifest = validManifest();
+      manifest.chunks[0].packages[0].name = name;
+
+      await expect(
+        readAsync(await writeManifestAsync(manifest))
+      ).rejects.toThrow('invalid package name');
+    }
+  );
+
+  it('rejects a package listed twice', async () => {
+    const manifest = validManifest();
+    manifest.chunks[0].packages[1].name = '@quenty/rx';
+
+    await expect(readAsync(await writeManifestAsync(manifest))).rejects.toThrow(
+      'more than once'
+    );
+  });
+
+  it('rejects an unknown format version', async () => {
+    const manifest = validManifest();
+    manifest.formatVersion = 2;
+
+    await expect(readAsync(await writeManifestAsync(manifest))).rejects.toThrow(
+      'Unsupported bundle format'
+    );
+  });
+});