now that all the files are as close as possible to prettier's current test configuration we update to prettier's version

Author: Janther

tests/config/utils/compile-contract.js tests/config/compile-contract.jstests/config/utils/compile-contract.js renamed to tests/config/compile-contract.js

@@ -1,5 +1,5 @@
 import { wrap as raw } from "jest-snapshot-serializer-raw";
-import { CURSOR_PLACEHOLDER } from "../constants.js";
+import { CURSOR_PLACEHOLDER } from "./constants.js";
 import visualizeEndOfLine from "./visualize-end-of-line.js";
 import visualizeRange from "./visualize-range.js";
 

…s/config/utils/consistent-end-of-line.js tests/config/consistent-end-of-line.jstests/config/utils/consistent-end-of-line.js renamed to tests/config/consistent-end-of-line.js tests/config/utils/consistent-end-of-line.js renamed to tests/config/consistent-end-of-line.js

@@ -1,3 +1,3 @@
-import runFormatTest from "./run-format-test.js";
+import { runFormatTest } from "./run-format-test.js";
 
 globalThis.runFormatTest = runFormatTest;

tests/config/utils/create-snapshot.js tests/config/create-snapshot.jstests/config/utils/create-snapshot.js renamed to tests/config/create-snapshot.js

@@ -1,13 +1,24 @@
 import fs from "node:fs";
 import path from "node:path";
 import { FORMAT_SCRIPT_FILENAME } from "./constants.js";
-import visualizeEndOfLine from "./utils/visualize-end-of-line.js";
+import visualizeEndOfLine from "./visualize-end-of-line.js";
 
+/**
+@import {Context} from "./run-format-test.js"
+@typedef {Exclude<ReturnType<ReturnType<getFixtures>["next"]>["value"], void>} Fixture
+*/
+
+/**
+@param {Context} context
+*/
 function* getFixtures(context) {
   yield* getFiles(context);
   yield* getSnippets(context);
 }
 
+/**
+@param {Context} context
+*/
 function* getFiles(context) {
   const { dirname } = context;
   for (const file of fs.readdirSync(dirname, { withFileTypes: true })) {
@@ -36,6 +47,9 @@ function* getFiles(context) {
   }
 }
 
+/**
+@param {Context} context
+*/
 function* getSnippets(context) {
   for (const [index, snippet] of context.snippets.entries()) {
     const testCase =

tests/config/format-test-setup.js

@@ -19,6 +19,10 @@ const indexProperties = [
   },
 ];
 
+/**
+@param {string} originalText
+@param {any} originalOptions
+*/
 function replacePlaceholders(originalText, originalOptions) {
   const indexes = indexProperties
     .map(({ property, placeholder }) => {

tests/config/get-fixtures.js

@@ -3,12 +3,36 @@ import url from "node:url";
 import { FORMAT_SCRIPT_FILENAME } from "./constants.js";
 import { getFixtures } from "./get-fixtures.js";
 import { testFixture } from "./run-test.js";
-import { stringifyOptionsForTitle } from "./utils/stringify-options-for-title.js";
+import { stringifyOptionsForTitle } from "./stringify-options-for-title.js";
 import {
   isErrorTest as isErrorTestDirectory,
   normalizeDirectory,
 } from "./utilities.js";
 
+/**
+@typedef {
+  | string
+  | { code: string; name?: string; filename?: string; output?: string }
+} Snippet
+@typedef {{
+  dirname: string,
+  stringifiedOptions: string,
+  parsers: string[],
+  options: any,
+  explicitParsers: string[],
+  rawOptions: any,
+  snippets: Snippet[],
+}} Context
+*/
+
+/**
+@param {
+  | ImportMeta
+  | { importMeta: ImportMeta, snippets?: Snippet[] }
+} rawFixtures
+@param {string[]} explicitParsers
+@param {any} rawOptions
+*/
 function runFormatTest(rawFixtures, explicitParsers, rawOptions) {
   const { importMeta, snippets = [] } = rawFixtures.importMeta
     ? rawFixtures
@@ -36,6 +60,8 @@ function runFormatTest(rawFixtures, explicitParsers, rawOptions) {
     options = { errors: true, ...options };
   }
 
+  // Make sure tests are in correct location
+
   const context = {
     dirname,
     stringifiedOptions: stringifyOptionsForTitle(rawOptions),
@@ -51,4 +77,4 @@ function runFormatTest(rawFixtures, explicitParsers, rawOptions) {
   }
 }
 
-export default runFormatTest;
+export { runFormatTest };

tests/config/replace-placeholders.js

@@ -1,12 +1,10 @@
 import getPrettier from "./get-prettier.js";
 import getPlugins from "./get-plugins.js";
 import { CURSOR_PLACEHOLDER } from "./constants.js";
-import visualizeEndOfLine from "./utils/visualize-end-of-line.js";
-import { replacePlaceholders } from "./replace-placeholders.js";
+import visualizeEndOfLine from "./visualize-end-of-line.js";
 
 async function parse(input, options) {
   const prettier = await getPrettier();
-
   const { ast } = await prettier.__debug.parse(
     input,
     await loadPlugins(options),
@@ -15,11 +13,7 @@ async function parse(input, options) {
   return ast;
 }
 
-async function format(originalText, originalOptions) {
-  const { text: input, options } = replacePlaceholders(
-    originalText,
-    originalOptions,
-  );
+async function format(input, options) {
   const inputWithCursor = insertCursor(input, options.cursorOffset);
   const prettier = await getPrettier();
 

tests/config/run-format-test.js

@@ -11,7 +11,15 @@ import * as testAntlrFormat from "./test-antlr-format.js";
 import * as testVariantCoverage from "./test-variant-coverage.js";
 import { shouldThrowOnFormat } from "./utilities.js";
 
-async function testFixture(fixture) {
+/**
+@import {Fixture} from "./get-fixtures.js"
+@typedef {ReturnType<getTestCase>} TestCase
+*/
+
+/**
+@param {Fixture} fixture
+*/
+function testFixture(fixture) {
   const { name, context } = fixture;
   const { stringifiedOptions, parsers } = context;
 
@@ -40,94 +48,109 @@ async function testFixture(fixture) {
           return name;
         },
         test: {
-          run: (testCase) => testFormat.run(testCase, testCaseForSnapshot),
+          run: (testCase, name) =>
+            testFormat.run(testCase, name, testCaseForSnapshot),
         },
       },
       {
         name: "ast compare",
-        test: { run: testAstCompare.run },
+        test: { run: testAstCompare.run, skip: testAstCompare.skip },
         skip: () => !FULL_TEST,
       },
       // The following cases only need run on main parser
       {
         name: "second format",
-        test: { run: testSecondFormat.run },
+        test: { run: testSecondFormat.run, skip: testSecondFormat.skip },
         skip: (testCase) => !FULL_TEST || testCase !== testCaseForSnapshot,
       },
       {
         name: "end of line (CRLF)",
-        test: { run: (testCase) => testEndOfLine.run(testCase, "\r\n") },
+        test: {
+          run: (testCase, name) => testEndOfLine.run(testCase, name, "\r\n"),
+          skip: testEndOfLine.skip,
+        },
         skip: (testCase) => !FULL_TEST || testCase !== testCaseForSnapshot,
       },
       {
         name: "end of line (CR)",
-        test: { run: (testCase) => testEndOfLine.run(testCase, "\r") },
+        test: {
+          run: (testCase, name) => testEndOfLine.run(testCase, name, "\r"),
+          skip: testEndOfLine.skip,
+        },
         skip: (testCase) => !FULL_TEST || testCase !== testCaseForSnapshot,
       },
       {
         name: "BOM",
-        test: { run: testBom.run },
+        test: { run: testBom.run, skip: testBom.skip },
         skip: (testCase) => !FULL_TEST || testCase !== testCaseForSnapshot,
       },
       // The following cases only need run if the parser is Slang
       {
         name: "ANTLR format",
-        test: { run: testAntlrFormat.run },
+        test: { run: testAntlrFormat.run, skip: testAntlrFormat.skip },
         skip: (testCase) =>
           !FULL_TEST ||
           testCase !== testCaseForSnapshot ||
           testCase.parser !== "slang",
       },
       {
         name: "bytecode comparison",
-        test: { run: testBytecodeCompare.run },
+        test: { run: testBytecodeCompare.run, skip: testBytecodeCompare.skip },
         skip: (testCase) =>
           !FULL_TEST ||
           testCase !== testCaseForSnapshot ||
           testCase.parser !== "slang",
       },
       {
         name: "variant coverage",
-        test: { run: testVariantCoverage.run },
+        test: { run: testVariantCoverage.run, skip: testVariantCoverage.skip },
         skip: (testCase) =>
           !FULL_TEST ||
           testCase !== testCaseForSnapshot ||
           testCase.parser !== "slang",
       },
     ]) {
       for (const testCase of testCases) {
-        if (functionality.skip?.(testCase)) {
+        if (
+          functionality.skip?.(testCase) ||
+          functionality.test.skip?.(testCase)
+        ) {
           continue;
         }
+
         let { name } = functionality;
         if (typeof name === "function") {
           name = name(testCase);
         } else if (hasMultipleParsers) {
           name += ` [${testCase.parser}]`;
         }
-        test(name, async () => {
-          await functionality.test.run(testCase);
-        });
+
+        functionality.test.run(testCase, name);
       }
     }
   });
 }
 
+/**
+@param {Fixture} fixture
+@param {string} parser
+*/
 function getTestCase(fixture, parser) {
   const { code: originalText, context, filepath } = fixture;
 
   const { text: code, options: formatOptions } = replacePlaceholders(
     originalText,
     {
       printWidth: 80,
-      ...context.options,
       filepath,
+      ...context.options,
       parser,
     },
   );
 
   const expectFail = shouldThrowOnFormat(fixture, formatOptions);
 
+  /** @type {ReturnType<format> | undefined} */
   let promise;
 
   return {