@quenty/nevermore-cli 4.18.0 → 4.19.0

package/src/utils/testing/parsers/jest-lua-parser.test.ts

@@ -0,0 +1,350 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { parseJestLuaOutput } from './jest-lua-parser.js';
+import { SourcemapResolver } from '../../sourcemap/index.js';
+import type { SourcemapNode } from '../../sourcemap/index.js';
+
+// Mock fs.readFileSync for _findTestLineInFile
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(() => {
+    throw new Error('ENOENT');
+  }),
+}));
+
+describe('parseJestLuaOutput', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('parses a single assertion failure with at location', () => {
+    const input = [
+      '  ● ObservableList > add and remove > should track count',
+      '',
+      '    expect(received).toEqual(expected)',
+      '',
+      '    Expected: 3',
+      '    Received: 2',
+      '',
+      '      at ServerScriptService.observablecollection.Shared.ObservableList.spec:45',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, {
+      packageName: 'observablecollection',
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({
+      file: 'src/observablecollection/src/Shared/ObservableList.spec.lua',
+      line: 45,
+      severity: 'error',
+      title: 'ObservableList > add and remove > should track count',
+      message: expect.stringContaining('expect(received).toEqual(expected)'),
+      source: 'jest-lua',
+    });
+    expect(result[0].message).toContain('Expected: 3');
+    expect(result[0].message).toContain('Received: 2');
+  });
+
+  it('parses multiple failures in one log', () => {
+    const input = [
+      '  ● Suite > test one',
+      '',
+      '    Expected: 1',
+      '    Received: 2',
+      '',
+      '      at ServerScriptService.mypkg.Shared.Foo.spec:10',
+      '',
+      '  ● Suite > test two',
+      '',
+      '    Expected: true',
+      '    Received: false',
+      '',
+      '      at ServerScriptService.mypkg.Shared.Bar.spec:20',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'mypkg' });
+
+    expect(result).toHaveLength(2);
+    expect(result[0].title).toBe('Suite > test one');
+    expect(result[0].line).toBe(10);
+    expect(result[1].title).toBe('Suite > test two');
+    expect(result[1].line).toBe(20);
+  });
+
+  it('parses nested 3+ level test hierarchy', () => {
+    const input = [
+      '  ● Level1 > Level2 > Level3 > Level4 > deep test',
+      '',
+      '    failure message',
+      '',
+      '      at ServerScriptService.pkg.Shared.Deep.spec:99',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'pkg' });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe(
+      'Level1 > Level2 > Level3 > Level4 > deep test'
+    );
+  });
+
+  it('falls back to line 1 when no at location and file not found', () => {
+    const input = [
+      '  ● Suite > test without location',
+      '',
+      '    some error happened',
+      '',
+      'Test Suites: 1 failed, 1 total',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'mypkg' });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].line).toBe(1);
+    expect(result[0].file).toBe('src/mypkg/src');
+  });
+
+  it('searches spec file for it() call when at location has no line number', async () => {
+    const { readFileSync } = await import('fs');
+    const mockedReadFileSync = vi.mocked(readFileSync);
+    mockedReadFileSync.mockReturnValue(
+      [
+        'local require = require(script.Parent.loader).load(script)',
+        '',
+        'describe("Suite", function()',
+        '  it("my test name", function()',
+        '    -- test body',
+        '  end)',
+        'end)',
+      ].join('\n')
+    );
+
+    const input = [
+      '  ● Suite > my test name',
+      '',
+      '    assertion failed',
+      '',
+      '      at ServerScriptService.mypkg.Shared.Foo.spec',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'mypkg' });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].file).toBe('src/mypkg/src/Shared/Foo.spec.lua');
+    expect(result[0].line).toBe(4);
+  });
+
+  it('parses a runtime error with Stack Begin/Stack End', () => {
+    const input = [
+      'Error: attempt to index nil with "Connect"',
+      'Stack Begin',
+      "Script 'ServerScriptService.maid.Shared.Maid.spec', Line 23",
+      'Stack End',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'maid' });
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({
+      file: 'src/maid/src/Shared/Maid.spec.lua',
+      line: 23,
+      severity: 'error',
+      title: 'Runtime error',
+      message: 'Error: attempt to index nil with "Connect"',
+      source: 'jest-lua',
+    });
+  });
+
+  it('parses mixed Jest failures and runtime errors', () => {
+    const input = [
+      '  ● Suite > assertion test',
+      '',
+      '    Expected: 1',
+      '    Received: 2',
+      '',
+      '      at ServerScriptService.pkg.Shared.Foo.spec:10',
+      '',
+      'Error: attempt to call nil value',
+      'Stack Begin',
+      "Script 'ServerScriptService.pkg.Shared.Bar.spec', Line 5",
+      'Stack End',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'pkg' });
+
+    expect(result).toHaveLength(2);
+    expect(result[0].title).toBe('Suite > assertion test');
+    expect(result[0].source).toBe('jest-lua');
+    expect(result[1].title).toBe('Runtime error');
+    expect(result[1].line).toBe(5);
+  });
+
+  it('returns empty array for all-passing output', () => {
+    const input = [
+      'PASS  ServerScriptService.maid',
+      '  Maid',
+      '    ✓ should create (5 ms)',
+      '    ✓ should destroy (2 ms)',
+      '',
+      'Test Suites: 1 passed, 1 total',
+      'Tests:       2 passed, 2 total',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'maid' });
+
+    expect(result).toEqual([]);
+  });
+
+  it('strips ANSI escape codes cleanly', () => {
+    const input = [
+      '  \x1b[31m●\x1b[39m \x1b[1mSuite > test\x1b[22m',
+      '',
+      '    \x1b[31mExpected: 1\x1b[39m',
+      '    \x1b[32mReceived: 2\x1b[39m',
+      '',
+      '      at ServerScriptService.pkg.Shared.Foo.spec:10',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'pkg' });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe('Suite > test');
+    expect(result[0].line).toBe(10);
+    // Ensure no ANSI codes leaked into the message
+    expect(result[0].message).not.toMatch(/\x1b/);
+  });
+
+  it('handles truncated/incomplete output without crashing', () => {
+    const input = [
+      '  ● Suite > incomplete test',
+      '',
+      '    partial error message',
+      // No at-line, no Stack Begin, just ends
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'pkg' });
+
+    // Should still emit a diagnostic with fallback location
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe('Suite > incomplete test');
+    expect(result[0].line).toBe(1);
+  });
+
+  it('handles empty input', () => {
+    const result = parseJestLuaOutput('', { packageName: 'pkg' });
+    expect(result).toEqual([]);
+  });
+
+  it('uses last stack frame for location in multi-frame stack', () => {
+    const input = [
+      'Error: bad argument',
+      'Stack Begin',
+      "Script 'ServerScriptService.pkg.Shared.Inner', Line 10",
+      "Script 'ServerScriptService.pkg.Shared.Outer.spec', Line 30",
+      'Stack End',
+    ].join('\n');
+
+    const result = parseJestLuaOutput(input, { packageName: 'pkg' });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].file).toBe('src/pkg/src/Shared/Outer.spec.lua');
+    expect(result[0].line).toBe(30);
+  });
+
+  describe('with sourcemap resolver', () => {
+    const repoRoot = '/repo';
+
+    const sourcemap: SourcemapNode = {
+      name: 'Nevermore',
+      className: 'DataModel',
+      children: [
+        {
+          name: 'mypkg',
+          className: 'Folder',
+          filePaths: [`${repoRoot}/src/mypkg/default.project.json`],
+          children: [
+            {
+              name: 'Shared',
+              className: 'Folder',
+              children: [
+                {
+                  name: 'Foo',
+                  className: 'ModuleScript',
+                  filePaths: [`${repoRoot}/src/mypkg/src/Shared/Foo.lua`],
+                  children: [
+                    {
+                      name: 'Foo.spec',
+                      className: 'ModuleScript',
+                      filePaths: [
+                        `${repoRoot}/src/mypkg/src/Shared/Foo.spec.lua`,
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+    const resolver = SourcemapResolver.fromSourcemap(sourcemap, repoRoot);
+
+    it('uses sourcemap resolver for assertion failure paths', () => {
+      const input = [
+        '  ● Suite > test one',
+        '',
+        '    Expected: 1',
+        '    Received: 2',
+        '',
+        '      at ServerScriptService.mypkg.Shared.Foo.Foo.spec:10',
+      ].join('\n');
+
+      const result = parseJestLuaOutput(input, {
+        packageName: 'mypkg',
+        sourcemapResolver: resolver,
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].file).toBe('src/mypkg/src/Shared/Foo.spec.lua');
+      expect(result[0].line).toBe(10);
+    });
+
+    it('uses sourcemap resolver for runtime error paths', () => {
+      const input = [
+        'Error: attempt to index nil',
+        'Stack Begin',
+        "Script 'ServerScriptService.mypkg.Shared.Foo.Foo.spec', Line 5",
+        'Stack End',
+      ].join('\n');
+
+      const result = parseJestLuaOutput(input, {
+        packageName: 'mypkg',
+        sourcemapResolver: resolver,
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].file).toBe('src/mypkg/src/Shared/Foo.spec.lua');
+      expect(result[0].line).toBe(5);
+    });
+
+    it('falls back to heuristic when sourcemap has no mapping', () => {
+      const input = [
+        '  ● Suite > test one',
+        '',
+        '    Expected: 1',
+        '    Received: 2',
+        '',
+        '      at ServerScriptService.unknown.Shared.Bar.spec:10',
+      ].join('\n');
+
+      const result = parseJestLuaOutput(input, {
+        packageName: 'unknown',
+        sourcemapResolver: resolver,
+      });
+
+      expect(result).toHaveLength(1);
+      // Falls back to heuristic
+      expect(result[0].file).toBe('src/unknown/src/Shared/Bar.spec.lua');
+    });
+  });
+});

package/src/utils/testing/parsers/jest-lua-parser.ts

@@ -0,0 +1,279 @@
+/**
+ * Parser for Jest-lua verbose output (`verbose=true, ci=true`).
+ *
+ * Handles two failure modes:
+ *
+ * 1. **Jest assertion failures** — `●` blocks:
+ *    ```
+ *      ● ObservableList > add and remove > should track count
+ *
+ *        expect(received).toEqual(expected)
+ *
+ *        Expected: 3
+ *        Received: 2
+ *
+ *          at ServerScriptService.observablecollection.Shared.ObservableList.spec:45
+ *    ```
+ *
+ * 2. **Runtime errors** — `Stack Begin`/`Stack End` blocks:
+ *    ```
+ *    Error: attempt to index nil with "Connect"
+ *    Stack Begin
+ *    Script 'ServerScriptService.maid.Shared.Maid.spec', Line 23
+ *    Stack End
+ *    ```
+ *
+ * The parser is intentionally lenient — it extracts what it can, skips what
+ * it can't, and never crashes on unexpected input.
+ */
+
+import * as fs from 'fs';
+import { type Diagnostic } from '@quenty/cli-output-helpers/reporting';
+import { OutputHelper } from '@quenty/cli-output-helpers';
+import type { SourcemapResolver } from '../../sourcemap/index.js';
+import { resolveRobloxTestPath } from './roblox-path-resolver.js';
+
+/** Matches `at ServerScriptService.pkg.Path.spec:45` (with line number) */
+const AT_LOCATION_PATTERN = /^\s+at\s+(.+):(\d+)\s*$/;
+
+/** Matches `at ServerScriptService.pkg.Path.spec` (without line number) */
+const AT_LOCATION_NO_LINE_PATTERN = /^\s+at\s+(\S+)\s*$/;
+
+/** Matches `Script 'ServerScriptService.pkg.Path.spec', Line 23` */
+const SCRIPT_LOCATION_PATTERN = /Script '([^']+)', Line (\d+)/;
+
+/** Matches the Jest failure header: `● TestSuite > nested > test name` */
+const FAILURE_HEADER_PATTERN = /^\s*●\s+(.+)$/;
+
+const enum State {
+  IDLE,
+  FAILURE_BLOCK,
+  STACK_BLOCK,
+}
+
+interface FailureContext {
+  title: string;
+  messageLines: string[];
+  file?: string;
+  line?: number;
+}
+
+interface StackContext {
+  errorMessage: string;
+  file?: string;
+  line?: number;
+}
+
+/**
+ * Search a `.spec.lua` file for an `it()` call matching `testName`.
+ * Returns the 1-indexed line number, or `undefined` if not found.
+ */
+function _findTestLineInFile(
+  filePath: string,
+  testName: string
+): number | undefined {
+  let content: string;
+  try {
+    content = fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return undefined;
+  }
+
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (
+      lines[i].includes(`it("${testName}"`) ||
+      lines[i].includes(`it('${testName}'`)
+    ) {
+      return i + 1;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Parse Jest-lua verbose output into `Diagnostic[]`.
+ *
+ * @param raw - Raw test output (may include ANSI codes)
+ * @param options.packageName - Package name for fallback path resolution
+ */
+export function parseJestLuaOutput(
+  raw: string,
+  options: { packageName: string; sourcemapResolver?: SourcemapResolver }
+): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+  const clean = OutputHelper.stripAnsi(raw);
+  const lines = clean.split('\n');
+
+  let state: State = State.IDLE;
+  let failureCtx: FailureContext | undefined;
+  let stackCtx: StackContext | undefined;
+  let lastNonEmptyLine = '';
+
+  function _emitFailure(ctx: FailureContext): void {
+    const message = ctx.messageLines
+      .join('\n')
+      .trim();
+
+    // 3-tier line resolution:
+    //  1. Primary: line number extracted from `at <path>:<line>` or similar
+    //  2. Secondary: search the resolved .spec.lua file for the it() call
+    //  3. Tertiary: fall back to line 1
+    let file: string;
+    let line: number;
+
+    if (ctx.file) {
+      file = resolveRobloxTestPath(ctx.file, options.sourcemapResolver);
+
+      if (ctx.line) {
+        line = ctx.line;
+      } else {
+        const segments = ctx.title.split(' > ');
+        const testName = segments[segments.length - 1].trim();
+        line = _findTestLineInFile(file, testName) ?? 1;
+      }
+    } else {
+      file = `src/${options.packageName}/src`;
+      line = 1;
+    }
+
+    diagnostics.push({
+      file,
+      line,
+      severity: 'error',
+      title: ctx.title,
+      message: message || 'Test failed',
+      source: 'jest-lua',
+    });
+  }
+
+  function _emitStack(ctx: StackContext): void {
+    const file = ctx.file
+      ? resolveRobloxTestPath(ctx.file, options.sourcemapResolver)
+      : `src/${options.packageName}/src`;
+    const line = ctx.line ?? 1;
+
+    diagnostics.push({
+      file,
+      line,
+      severity: 'error',
+      title: 'Runtime error',
+      message: ctx.errorMessage || 'Unknown runtime error',
+      source: 'jest-lua',
+    });
+  }
+
+  for (const rawLine of lines) {
+    switch (state) {
+      case State.IDLE: {
+        const failureMatch = rawLine.match(FAILURE_HEADER_PATTERN);
+        if (failureMatch) {
+          failureCtx = {
+            title: failureMatch[1].trim(),
+            messageLines: [],
+          };
+          state = State.FAILURE_BLOCK;
+          break;
+        }
+
+        if (rawLine.trim() === 'Stack Begin') {
+          stackCtx = {
+            errorMessage: lastNonEmptyLine,
+          };
+          state = State.STACK_BLOCK;
+          break;
+        }
+
+        if (rawLine.trim() !== '') {
+          lastNonEmptyLine = rawLine.trim();
+        }
+        break;
+      }
+
+      case State.FAILURE_BLOCK: {
+        if (!failureCtx) {
+          state = State.IDLE;
+          break;
+        }
+
+        const atMatch = rawLine.match(AT_LOCATION_PATTERN);
+        if (atMatch) {
+          failureCtx.file = atMatch[1];
+          failureCtx.line = parseInt(atMatch[2], 10);
+          _emitFailure(failureCtx);
+          failureCtx = undefined;
+          state = State.IDLE;
+          break;
+        }
+
+        const atNoLineMatch = rawLine.match(AT_LOCATION_NO_LINE_PATTERN);
+        if (atNoLineMatch) {
+          failureCtx.file = atNoLineMatch[1];
+          _emitFailure(failureCtx);
+          failureCtx = undefined;
+          state = State.IDLE;
+          break;
+        }
+
+        const nextFailure = rawLine.match(FAILURE_HEADER_PATTERN);
+        if (nextFailure) {
+          _emitFailure(failureCtx);
+          failureCtx = {
+            title: nextFailure[1].trim(),
+            messageLines: [],
+          };
+          break;
+        }
+
+        if (rawLine.trim() === 'Stack Begin') {
+          _emitFailure(failureCtx);
+          stackCtx = {
+            errorMessage: failureCtx.messageLines.length > 0
+              ? failureCtx.messageLines[failureCtx.messageLines.length - 1].trim()
+              : failureCtx.title,
+          };
+          failureCtx = undefined;
+          state = State.STACK_BLOCK;
+          break;
+        }
+
+        failureCtx.messageLines.push(rawLine);
+        break;
+      }
+
+      case State.STACK_BLOCK: {
+        if (!stackCtx) {
+          state = State.IDLE;
+          break;
+        }
+
+        const scriptMatch = rawLine.match(SCRIPT_LOCATION_PATTERN);
+        if (scriptMatch) {
+          stackCtx.file = scriptMatch[1];
+          stackCtx.line = parseInt(scriptMatch[2], 10);
+          break;
+        }
+
+        if (rawLine.trim() === 'Stack End') {
+          _emitStack(stackCtx);
+          stackCtx = undefined;
+          state = State.IDLE;
+          break;
+        }
+
+        break;
+      }
+    }
+  }
+
+  // Flush any pending context at end of input
+  if (failureCtx && state === State.FAILURE_BLOCK) {
+    _emitFailure(failureCtx);
+  }
+  if (stackCtx && state === State.STACK_BLOCK) {
+    _emitStack(stackCtx);
+  }
+
+  return diagnostics;
+}