ava 4.0.0-alpha.1 → 4.0.1

package/lib/serialize-error.js

@@ -1,42 +1,45 @@
-'use strict';
-const path = require('path');
-const cleanYamlObject = require('clean-yaml-object');
-const concordance = require('concordance');
-const isError = require('is-error');
-const slash = require('slash');
-const StackUtils = require('stack-utils');
-const assert = require('./assert');
-const concordanceOptions = require('./concordance-options').default;
+import path from 'node:path';
+import process from 'node:process';
+import {fileURLToPath, pathToFileURL} from 'node:url';
+
+import cleanYamlObject from 'clean-yaml-object';
+import concordance from 'concordance';
+import isError from 'is-error';
+import StackUtils from 'stack-utils';
+
+import {AssertionError} from './assert.js';
+import concordanceOptions from './concordance-options.js';
 
 function isAvaAssertionError(source) {
-	return source instanceof assert.AssertionError;
+	return source instanceof AssertionError;
 }
 
 function filter(propertyName, isRoot) {
 	return !isRoot || (propertyName !== 'message' && propertyName !== 'name' && propertyName !== 'stack');
 }
 
+function normalizeFile(file, ...base) {
+	return file.startsWith('file://') ? file : pathToFileURL(path.resolve(...base, file)).toString();
+}
+
 const stackUtils = new StackUtils();
 function extractSource(stack, testFile) {
 	if (!stack || !testFile) {
 		return null;
 	}
 
-	// Normalize the test file so it matches `callSite.file`.
-	const relFile = path.relative(process.cwd(), testFile);
-	const normalizedFile = process.platform === 'win32' ? slash(relFile) : relFile;
+	testFile = normalizeFile(testFile);
+
 	for (const line of stack.split('\n')) {
-		try {
-			const callSite = stackUtils.parseLine(line);
-			if (callSite.file === normalizedFile) {
-				return {
-					isDependency: false,
-					isWithinProject: true,
-					file: path.resolve(process.cwd(), callSite.file),
-					line: callSite.line
-				};
-			}
-		} catch {}
+		const callSite = stackUtils.parseLine(line);
+		if (callSite && normalizeFile(callSite.file) === testFile) {
+			return {
+				isDependency: false,
+				isWithinProject: true,
+				file: testFile,
+				line: callSite.line,
+			};
+		}
 	}
 
 	return null;
@@ -52,8 +55,8 @@ function buildSource(source) {
 	// directory set to the project directory.
 	const projectDir = process.cwd();
 
-	const file = path.resolve(projectDir, source.file.trim());
-	const rel = path.relative(projectDir, file);
+	const file = normalizeFile(source.file.trim(), projectDir);
+	const rel = path.relative(projectDir, fileURLToPath(file));
 
 	const [segment] = rel.split(path.sep);
 	const isWithinProject = segment !== '..' && (process.platform !== 'win32' || !segment.includes(':'));
@@ -63,7 +66,7 @@ function buildSource(source) {
 		isDependency,
 		isWithinProject,
 		file,
-		line: source.line
+		line: source.line,
 	};
 }
 
@@ -75,7 +78,7 @@ function trySerializeError(error, shouldBeautifyStack, testFile) {
 		nonErrorObject: false,
 		source: extractSource(stack, testFile),
 		stack,
-		shouldBeautifyStack
+		shouldBeautifyStack,
 	};
 
 	if (error.actualStack) {
@@ -86,7 +89,6 @@ function trySerializeError(error, shouldBeautifyStack, testFile) {
 		retval.improperUsage = error.improperUsage;
 		retval.message = error.message;
 		retval.name = error.name;
-		retval.statements = error.statements;
 		retval.values = error.values;
 
 		if (error.fixedSource) {
@@ -143,12 +145,12 @@ function trySerializeError(error, shouldBeautifyStack, testFile) {
 	return retval;
 }
 
-function serializeError(origin, shouldBeautifyStack, error, testFile) {
+export default function serializeError(origin, shouldBeautifyStack, error, testFile) {
 	if (!isError(error)) {
 		return {
 			avaAssertionError: false,
 			nonErrorObject: true,
-			formatted: concordance.formatDescriptor(concordance.describe(error, concordanceOptions), concordanceOptions)
+			formatted: concordance.formatDescriptor(concordance.describe(error, concordanceOptions), concordanceOptions),
 		};
 	}
 
@@ -162,9 +164,7 @@ function serializeError(origin, shouldBeautifyStack, error, testFile) {
 			name: replacement.name,
 			message: replacement.message,
 			stack: replacement.stack,
-			summary: replacement.message
+			summary: replacement.message,
 		};
 	}
 }
-
-module.exports = serializeError;

package/lib/snapshot-manager.js

@@ -1,19 +1,19 @@
-'use strict';
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const zlib = require('zlib');
-
-const concordance = require('concordance');
-const indentString = require('indent-string');
-const convertSourceMap = require('convert-source-map');
-const slash = require('slash');
-const writeFileAtomic = require('write-file-atomic');
-const mem = require('mem');
-const cbor = require('cbor');
-
-const concordanceOptions = require('./concordance-options').snapshotManager;
+import {Buffer} from 'node:buffer';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import {findSourceMap} from 'node:module';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import zlib from 'node:zlib';
+
+import cbor from 'cbor';
+import concordance from 'concordance';
+import indentString from 'indent-string';
+import mem from 'mem';
+import slash from 'slash';
+import writeFileAtomic from 'write-file-atomic';
+
+import {snapshotManager as concordanceOptions} from './concordance-options.js';
 
 // Increment if encoding layout or Concordance serialization versions change. Previous AVA versions will not be able to
 // decode buffers generated by a newer version, so changing this value will require a major version bump of AVA itself.
@@ -30,24 +30,22 @@ const REPORT_TRAILING_NEWLINE = Buffer.from('\n', 'ascii');
 
 const SHA_256_HASH_LENGTH = 32;
 
-class SnapshotError extends Error {
+export class SnapshotError extends Error {
 	constructor(message, snapPath) {
 		super(message);
 		this.name = 'SnapshotError';
 		this.snapPath = snapPath;
 	}
 }
-exports.SnapshotError = SnapshotError;
 
-class ChecksumError extends SnapshotError {
+export class ChecksumError extends SnapshotError {
 	constructor(snapPath) {
 		super('Checksum mismatch', snapPath);
 		this.name = 'ChecksumError';
 	}
 }
-exports.ChecksumError = ChecksumError;
 
-class VersionMismatchError extends SnapshotError {
+export class VersionMismatchError extends SnapshotError {
 	constructor(snapPath, version) {
 		super('Unexpected snapshot version', snapPath);
 		this.name = 'VersionMismatchError';
@@ -55,20 +53,25 @@ class VersionMismatchError extends SnapshotError {
 		this.expectedVersion = VERSION;
 	}
 }
-exports.VersionMismatchError = VersionMismatchError;
+
+export class InvalidSnapshotError extends SnapshotError {
+	constructor(snapPath) {
+		super('Invalid snapshot file', snapPath);
+		this.name = 'InvalidSnapshotError';
+	}
+}
 
 const LEGACY_SNAPSHOT_HEADER = Buffer.from('// Jest Snapshot v1');
 function isLegacySnapshot(buffer) {
 	return LEGACY_SNAPSHOT_HEADER.equals(buffer.slice(0, LEGACY_SNAPSHOT_HEADER.byteLength));
 }
 
-class LegacyError extends SnapshotError {
+export class LegacyError extends SnapshotError {
 	constructor(snapPath) {
 		super('Legacy snapshot file', snapPath);
 		this.name = 'LegacyError';
 	}
 }
-exports.LegacyError = LegacyError;
 
 function tryRead(file) {
 	try {
@@ -85,14 +88,16 @@ function tryRead(file) {
 function formatEntry(snapshot, index) {
 	const {
 		data,
-		label = `Snapshot ${index + 1}` // Human-readable labels start counting at 1.
+		label = `Snapshot ${index + 1}`, // Human-readable labels start counting at 1.
 	} = snapshot;
 
-	const description = data ?
-		concordance.formatDescriptor(concordance.deserialize(data), concordanceOptions) :
-		'<No Data>';
+	const description = data
+		? concordance.formatDescriptor(concordance.deserialize(data), concordanceOptions)
+		: '<No Data>';
 
-	return `> ${label}\n\n${indentString(description, 4)}`;
+	const blockquote = label.split(/\n/).map(line => '> ' + line).join('\n');
+
+	return `${blockquote}\n\n${indentString(description, 4)}`;
 }
 
 function combineEntries({blocks}) {
@@ -173,14 +178,14 @@ function sortBlocks(blocksByTitle, blockIndices) {
 			}
 
 			return a - b;
-		}
+		},
 	);
 }
 
-function encodeSnapshots(snapshotData) {
-	const encoded = cbor.encodeOne(snapshotData, {
+async function encodeSnapshots(snapshotData) {
+	const encoded = await cbor.encodeAsync(snapshotData, {
 		omitUndefinedProperties: true,
-		canonical: true
+		canonical: true,
 	});
 	const compressed = zlib.gzipSync(encoded);
 	compressed[9] = 0x03; // Override the GZip header containing the OS to always be Linux
@@ -189,7 +194,7 @@ function encodeSnapshots(snapshotData) {
 		READABLE_PREFIX,
 		VERSION_HEADER,
 		sha256sum,
-		compressed
+		compressed,
 	], READABLE_PREFIX.byteLength + VERSION_HEADER.byteLength + SHA_256_HASH_LENGTH + compressed.byteLength);
 }
 
@@ -200,7 +205,12 @@ function decodeSnapshots(buffer, snapPath) {
 
 	// The version starts after the readable prefix, which is ended by a newline
 	// byte (0x0A).
-	const versionOffset = buffer.indexOf(0x0A) + 1;
+	const newline = buffer.indexOf(0x0A);
+	if (newline === -1) {
+		throw new InvalidSnapshotError(snapPath);
+	}
+
+	const versionOffset = newline + 1;
 	const version = buffer.readUInt16LE(versionOffset);
 	if (version !== VERSION) {
 		throw new VersionMismatchError(snapPath, version);
@@ -341,14 +351,14 @@ class Manager {
 		this.recordSerialized({belongsTo, index, ...snapshot});
 	}
 
-	save() {
+	async save() {
 		const {dir, relFile, snapFile, snapPath, reportPath} = this;
 
 		if (this.updating && this.newBlocksByTitle.size === 0) {
-			return [
-				...cleanFile(snapPath),
-				...cleanFile(reportPath)
-			];
+			return {
+				changedFiles: [cleanFile(snapPath), cleanFile(reportPath)].flat(),
+				temporaryFiles: [],
+			};
 		}
 
 		if (!this.hasChanges) {
@@ -357,42 +367,45 @@ class Manager {
 
 		const snapshots = {
 			blocks: sortBlocks(this.newBlocksByTitle, this.blockIndices).map(
-				([title, block]) => ({title, ...block})
-			)
+				([title, block]) => ({title, ...block}),
+			),
 		};
 
-		const buffer = encodeSnapshots(snapshots);
+		const buffer = await encodeSnapshots(snapshots);
 		const reportBuffer = generateReport(relFile, snapFile, snapshots);
 
-		fs.mkdirSync(dir, {recursive: true});
-
-		const paths = [snapPath, reportPath];
-		const tmpfileCreated = tmpfile => paths.push(tmpfile);
-		writeFileAtomic.sync(snapPath, buffer, {tmpfileCreated});
-		writeFileAtomic.sync(reportPath, reportBuffer, {tmpfileCreated});
-		return paths;
+		await fs.promises.mkdir(dir, {recursive: true});
+
+		const temporaryFiles = [];
+		const tmpfileCreated = file => temporaryFiles.push(file);
+		await Promise.all([
+			writeFileAtomic(snapPath, buffer, {tmpfileCreated}),
+			writeFileAtomic(reportPath, reportBuffer, {tmpfileCreated}),
+		]);
+		return {
+			changedFiles: [snapPath, reportPath],
+			temporaryFiles,
+		};
 	}
 }
 
 const resolveSourceFile = mem(file => {
-	const testDir = path.dirname(file);
-	const buffer = tryRead(file);
-	if (!buffer) {
-		return file; // Assume the file is stubbed in our test suite.
+	const sourceMap = findSourceMap(file);
+	if (sourceMap === undefined) {
+		return file;
 	}
 
-	const source = buffer.toString();
-	const converter = convertSourceMap.fromSource(source) || convertSourceMap.fromMapFileSource(source, testDir);
-	if (converter) {
-		const map = converter.toObject();
-		const firstSource = `${map.sourceRoot || ''}${map.sources[0]}`;
-		return path.resolve(testDir, firstSource);
+	const {payload} = sourceMap;
+	if (payload.sources.length === 0) { // Hypothetical?
+		return file;
 	}
 
-	return file;
+	return payload.sources[0].startsWith('file://')
+		? fileURLToPath(payload.sources[0])
+		: payload.sources[0];
 });
 
-const determineSnapshotDir = mem(({file, fixedLocation, projectDir}) => {
+export const determineSnapshotDir = mem(({file, fixedLocation, projectDir}) => {
 	const testDir = path.dirname(resolveSourceFile(file));
 	if (fixedLocation) {
 		const relativeTestLocation = path.relative(projectDir, testDir);
@@ -411,8 +424,6 @@ const determineSnapshotDir = mem(({file, fixedLocation, projectDir}) => {
 	return testDir;
 }, {cacheKey: ([{file}]) => file});
 
-exports.determineSnapshotDir = determineSnapshotDir;
-
 function determineSnapshotPaths({file, fixedLocation, projectDir}) {
 	const dir = determineSnapshotDir({file, fixedLocation, projectDir});
 	const relFile = path.relative(projectDir, resolveSourceFile(file));
@@ -426,7 +437,7 @@ function determineSnapshotPaths({file, fixedLocation, projectDir}) {
 		snapFile,
 		reportFile,
 		snapPath: path.join(dir, snapFile),
-		reportPath: path.join(dir, reportFile)
+		reportPath: path.join(dir, reportFile),
 	};
 }
 
@@ -443,14 +454,14 @@ function cleanFile(file) {
 	}
 }
 
-function load({file, fixedLocation, projectDir, recordNewSnapshots, updating}) {
+export function load({file, fixedLocation, projectDir, recordNewSnapshots, updating}) {
 	// Keep runner unit tests that use `new Runner()` happy
 	if (file === undefined || projectDir === undefined) {
 		return new Manager({
 			recordNewSnapshots,
 			updating,
 			oldBlocksByTitle: new Map(),
-			newBlocksByTitle: new Map()
+			newBlocksByTitle: new Map(),
 		});
 	}
 
@@ -463,7 +474,7 @@ function load({file, fixedLocation, projectDir, recordNewSnapshots, updating}) {
 			updating,
 			...paths,
 			oldBlocksByTitle: new Map(),
-			newBlocksByTitle: new Map()
+			newBlocksByTitle: new Map(),
 		});
 	}
 
@@ -477,11 +488,9 @@ function load({file, fixedLocation, projectDir, recordNewSnapshots, updating}) {
 		blocksByTitle = new Map();
 
 		if (!updating) { // Discard all decoding errors when updating snapshots
-			if (error instanceof SnapshotError) {
-				snapshotError = error;
-			} else {
-				throw error;
-			}
+			snapshotError = error instanceof SnapshotError
+				? error
+				: new InvalidSnapshotError(paths.snapPath);
 		}
 	}
 
@@ -491,8 +500,6 @@ function load({file, fixedLocation, projectDir, recordNewSnapshots, updating}) {
 		...paths,
 		oldBlocksByTitle: blocksByTitle,
 		newBlocksByTitle: updating ? new Map() : blocksByTitle,
-		error: snapshotError
+		error: snapshotError,
 	});
 }
-
-exports.load = load;