feat: support compiled tests with a sourcemap only (#49)

src/options/helpers/file-navigator/getFileNavigator.ts

@@ -1,36 +1,12 @@
-import fs from 'node:fs/promises';
 import path from 'node:path';
 
 import type { KeyedHelperCustomizer } from 'jest-allure2-reporter';
 
-import { FileNavigator } from '../../../utils';
-
-class FileNavigatorCache {
-  #cache = new Map<string, Promise<FileNavigator | undefined>>();
-
-  resolve(filePath: string): Promise<FileNavigator | undefined> {
-    const absolutePath = path.resolve(filePath);
-    if (!this.#cache.has(absolutePath)) {
-      this.#cache.set(absolutePath, this.#createNavigator(absolutePath));
-    }
-
-    return this.#cache.get(absolutePath)!;
-  }
-
-  #createNavigator = async (filePath: string) => {
-    const sourceCode = await fs.readFile(filePath, 'utf8').catch(() => void 0);
-    return sourceCode == null ? undefined : new FileNavigator(sourceCode);
-  };
-
-  clear() {
-    this.#cache.clear();
-  }
-
-  static readonly instance = new FileNavigatorCache();
-}
+import { FileNavigatorCache } from '../../../utils';
 
 export const getFileNavigator: KeyedHelperCustomizer<'getFileNavigator'> = () => {
-  const cache = new FileNavigatorCache();
+  const cache = FileNavigatorCache.instance;
+
   return (maybeSegmentedFilePath) => {
     const filePath = Array.isArray(maybeSegmentedFilePath)
       ? maybeSegmentedFilePath.join(path.sep)

src/reporter/JestAllure2Reporter.ts

@@ -25,7 +25,7 @@ import type {
 
 import { type ReporterConfig, resolveOptions } from '../options';
 import { AllureMetadataProxy, MetadataSquasher } from '../metadata';
-import { compactArray, stringifyValues } from '../utils';
+import { compactArray, FileNavigatorCache, stringifyValues } from '../utils';
 import { type AllureWriter, FileAllureWriter } from '../serialization';
 import { log, optimizeForTracing } from '../logger';
 
@@ -155,6 +155,7 @@ export class JestAllure2Reporter extends JestMetadataReporter {
   async onTestFileStart(test: Test) {
     super.onTestFileStart(test);
 
+    await FileNavigatorCache.instance.scanSourcemap(test.path);
     const execute = this.#onTestFileStart.bind(this, test);
     const attempt = this.#attemptSync.bind(this, 'onTestFileStart()', execute);
     const testPath = path.relative(this._globalConfig.rootDir, test.path);

src/runtime/modules/StepsDecorator.ts

@@ -61,7 +61,7 @@ export class StepsDecorator {
 
 function resolveParameter(this: unknown[], parameter: UserParameter, index: number) {
   const { name = `${index}`, ...options } =
-    typeof parameter === 'string' ? { name: parameter } : parameter ?? {};
+    typeof parameter === 'string' ? { name: parameter } : (parameter ?? {});
 
   return [name, index, this[index], options, parameter] as ResolvedParameter;
 }

src/utils/FileNavigatorCache.test.ts

@@ -0,0 +1,43 @@
+jest.mock('../logger');
+
+import path from 'node:path';
+
+import { log } from '../logger';
+
+import { FileNavigatorCache } from './FileNavigatorCache';
+
+const __FIXTURES__ = path.join(__dirname, '__fixtures__');
+
+describe('FileNavigatorCache', () => {
+  test('should handle non-existent sourcemap', async () => {
+    const cache = new FileNavigatorCache();
+    await cache.scanSourcemap(path.join(__FIXTURES__, 'non-existent'));
+    await expect(cache.resolve(path.join(__FIXTURES__, 'test.ts'))).resolves.toBeUndefined();
+    expect(log.error).not.toHaveBeenCalled();
+  });
+
+  test('should handle a broken sourcemap', async () => {
+    const cache = new FileNavigatorCache();
+    await cache.scanSourcemap(path.join(__FIXTURES__, 'broken'));
+    await expect(cache.resolve(path.join(__FIXTURES__, 'test.ts'))).resolves.toBeUndefined();
+    expect(log.error).toHaveBeenCalled();
+  });
+
+  test('should handle an empty sourcemap', async () => {
+    const cache = new FileNavigatorCache();
+    await cache.scanSourcemap(path.join(__FIXTURES__, 'empty'));
+    await expect(cache.resolve(path.join(__FIXTURES__, 'test.ts'))).resolves.toBeUndefined();
+  });
+
+  test('should handle a simple sourcemap', async () => {
+    const cache = new FileNavigatorCache();
+    await cache.scanSourcemap(path.join(__FIXTURES__, 'simple'));
+    await expect(cache.resolve(path.join(__FIXTURES__, 'test.ts'))).resolves.toBeDefined();
+  });
+
+  test('should handle a sourcemap with a sourceRoot', async () => {
+    const cache = new FileNavigatorCache();
+    await cache.scanSourcemap(path.join(__FIXTURES__, 'with-root'));
+    await expect(cache.resolve('/home/user/project/test.ts')).resolves.toBeDefined();
+  });
+});

src/utils/FileNavigatorCache.ts

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import type { SourceMapPayload } from 'node:module';
+
+import { log } from '../logger';
+
+import { FileNavigator } from './index';
+
+export class FileNavigatorCache {
+  #cache = new Map<string, Promise<FileNavigator | undefined>>();
+
+  resolve(filePath: string): Promise<FileNavigator | undefined> {
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+    if (!this.#cache.has(absolutePath)) {
+      this.#cache.set(absolutePath, this.#createNavigator(absolutePath));
+    }
+
+    return this.#cache.get(absolutePath)!;
+  }
+
+  async scanSourcemap(filePath: string): Promise<void> {
+    const sourceMapPath = `${filePath}.map`;
+
+    const doesNotExist = await fs.access(sourceMapPath).catch(() => true);
+    if (doesNotExist) return;
+
+    const sourceMapRaw = await fs.readFile(sourceMapPath, 'utf8').catch((error) => {
+      log.error(error, `Failed to read sourcemap for: ${filePath}`);
+    });
+    if (sourceMapRaw == null) return;
+
+    let sourceMap: SourceMapPayload | undefined;
+    try {
+      sourceMap = JSON.parse(sourceMapRaw);
+    } catch (error) {
+      log.error(error, `Failed to parse sourcemap for: ${filePath}`);
+    }
+    if (!sourceMap) return;
+
+    const { sourceRoot, sources, sourcesContent } = sourceMap;
+    if (!sources || !sourcesContent) return;
+
+    const baseDirectory =
+      sourceRoot && path.isAbsolute(sourceRoot) ? sourceRoot : path.dirname(filePath);
+    for (const [index, content] of sourcesContent.entries()) {
+      const source = sources[index];
+      if (!content || !source) continue;
+
+      const sourcePath = path.isAbsolute(source) ? source : path.resolve(baseDirectory, source);
+      if (this.#cache.has(sourcePath)) continue;
+
+      const navigator = new FileNavigator(content);
+      this.#cache.set(sourcePath, Promise.resolve(navigator));
+    }
+  }
+
+  #createNavigator = async (filePath: string) => {
+    const sourceCode = await fs.readFile(filePath, 'utf8').catch(() => void 0);
+    return sourceCode == null ? undefined : new FileNavigator(sourceCode);
+  };
+
+  clear() {
+    this.#cache.clear();
+  }
+
+  static readonly instance = new FileNavigatorCache();
+}

src/utils/__fixtures__/broken.map

@@ -0,0 +1 @@
+{

src/utils/__fixtures__/empty.map

@@ -0,0 +1 @@
+{}

src/utils/__fixtures__/no-content.map

@@ -0,0 +1,3 @@
+{
+  "sources": ["test.ts"]
+}

src/utils/__fixtures__/simple.map

@@ -0,0 +1,4 @@
+{
+  "sources": ["test.ts"],
+  "sourcesContent": ["export default 42;"]
+}

src/utils/__fixtures__/with-root.map

@@ -0,0 +1,5 @@
+{
+  "sources": ["test.ts"],
+  "sourceRoot": "/home/user/project",
+  "sourcesContent": ["export default 42;"]
+}

src/utils/index.ts

@@ -5,6 +5,7 @@ export * from './autoIndent';
 export * from './compactObject';
 export * from './fastMove';
 export * from './FileNavigator';
+export * from './FileNavigatorCache';
 export * from './getFullExtension';
 export * from './getStatusDetails';
 export * from './hijackFunction';