refactor: typescript __mocks__

Author: JounQin

.prettierignore

@@ -1,6 +1 @@
 .yarn
-node_modules
-.nyc_output
-coverage
-dist
-tests/fixtures/

.prettierrc.mjs

@@ -3,12 +3,19 @@
 /** @import { Config, Plugin } from 'prettier' */
 
 import base from '@1stg/prettier-config/semi';
-import svelte from 'prettier-plugin-svelte';
+import * as jsdoc from 'prettier-plugin-jsdoc';
+import * as jsdocType from 'prettier-plugin-jsdoc-type';
+import * as svelte from 'prettier-plugin-svelte';
 
 /** @type {Config} */
 const config = {
   ...base,
-  plugins: [.../** @type {Plugin[]} */ (base.plugins), svelte],
+  plugins: [
+    .../** @type {Plugin[]} */ (base.plugins),
+    jsdoc,
+    jsdocType,
+    svelte,
+  ],
 };
 
 export default config;

EXAMPLES.md

@@ -23,6 +23,7 @@ gulp.task('js:format', function () {
 
 ```js
 var through = require('through2');
+var PluginError = require('plugin-error');
 var prettierEslint = require('prettier-eslint');
 
 const options = {
@@ -49,13 +50,13 @@ module.exports = function () {
 
     if (file.isStream()) {
       return callback(
-        new utils.PluginError('prettier-eslint', "doesn't support Streams"),
+        new PluginError('prettier-eslint', "doesn't support Streams"),
       );
     }
 
     const sourceCode = file.contents.toString();
     const formatted = prettierEslint({
-      ...config,
+      ...options,
       text: sourceCode,
     });
 

__mocks__/eslint.js renamed to __mocks__/eslint.ts

@@ -1,44 +1,57 @@
-// this mock file is so eslint doesn't attempt to actually
-// search around the file system for stuff
+/**
+ * This mock file is so eslint doesn't attempt to actually search around the
+ * file system for stuff, we can not use `.ts` because it's called by
+ * `test/fixtures/node_modules/eslint/index.js`
+ */
+
+import eslint_, { type ESLint as ESLint_ } from 'eslint';
+
+import type { ESLintLintText, MockESLint } from '../mock.js';
 
-/** @import { ESLintConfig } from 'prettier-eslint' */
+import type { ESLintConfig } from 'prettier-eslint';
+
+const eslint = jest.requireActual<typeof eslint_>('eslint');
 
-const eslint = /** @type {typeof import('eslint')} */ (
-  jest.requireActual('eslint')
-);
 const { ESLint } = eslint;
 
 const mockCalculateConfigForFileSpy = jest.fn(mockCalculateConfigForFile);
-mockCalculateConfigForFileSpy.overrides = {};
+
+Object.assign(mockCalculateConfigForFileSpy, { overrides: {} });
+
 const mockLintTextSpy = jest.fn(mockLintText);
 
-module.exports = Object.assign(eslint, {
+export = Object.assign(eslint, {
   ESLint: jest.fn(MockESLint),
   mock: {
     calculateConfigForFile: mockCalculateConfigForFileSpy,
     lintText: mockLintTextSpy,
   },
 });
 
-function MockESLint(...args) {
+function MockESLint(options: ESLint_.Options): MockESLint {
   globalThis.__PRETTIER_ESLINT_TEST_STATE__.eslintPath = __filename;
-  const eslintInstance = new ESLint(...args);
+  const eslintInstance = new ESLint(options) as MockESLint;
   eslintInstance.calculateConfigForFile = mockCalculateConfigForFileSpy;
+  // eslint-disable-next-line @typescript-eslint/unbound-method
   eslintInstance._originalLintText = eslintInstance.lintText;
   eslintInstance.lintText = mockLintTextSpy;
   return eslintInstance;
 }
 
-MockESLint.prototype = Object.create(ESLint.prototype);
+MockESLint.prototype = Object.create(ESLint.prototype) as ESLint_;
 
 /**
- * @param {string} filePath
- * @returns {ESLintConfig} -- eslint config
- * @throws {Error} -- if `throwError` is specifically set on the spy, or if the
- *   filePath is not handled
+ * @throws If `throwError` is specifically set on the spy, or if the filePath is
+ *   not handled
  */
-function mockCalculateConfigForFile(filePath) {
-  if (mockCalculateConfigForFileSpy.throwError) {
+// eslint-disable-next-line @typescript-eslint/require-await
+async function mockCalculateConfigForFile(
+  filePath: string,
+): Promise<ESLintConfig> {
+  if (
+    'throwError' in mockCalculateConfigForFileSpy &&
+    mockCalculateConfigForFileSpy.throwError instanceof Error
+  ) {
     throw mockCalculateConfigForFileSpy.throwError;
   }
   if (!filePath) {
@@ -80,8 +93,11 @@ function mockCalculateConfigForFile(filePath) {
   );
 }
 
-function mockLintText(...args) {
-  if (mockLintTextSpy.throwError) {
+function mockLintText(this: MockESLint, ...args: Parameters<ESLintLintText>) {
+  if (
+    'throwError' in mockLintTextSpy &&
+    mockLintTextSpy.throwError instanceof Error
+  ) {
     throw mockLintTextSpy.throwError;
   }
   return this._originalLintText(...args);

__mocks__/fs.js

@@ -0,0 +1,19 @@
+import type Fs_ from 'node:fs';
+
+type Fs = typeof Fs_;
+
+const fs = jest.requireActual<Fs>('fs');
+
+// eslint-disable-next-line prefer-object-spread -- typing issue
+export = Object.assign({}, fs, {
+  readFileSync: jest.fn((filename: string) => {
+    if (filename.endsWith('package.json')) {
+      return '{"name": "fake", "version": "0.0.0", "prettier": {}}';
+    }
+    if (/\.[jt]s$/.test(filename)) {
+      return 'var fake = true';
+    }
+
+    return '';
+  }),
+});

__mocks__/fs.ts

@@ -0,0 +1,39 @@
+import type {
+  GetLogger,
+  Logger,
+  LogLevel,
+} from 'loglevel-colored-level-prefix';
+
+const logger: Logger = {
+  setLevel: jest.fn(),
+  debug: jest.fn(getTestImplementation('debug')),
+  error: jest.fn(getTestImplementation('error')),
+  info: jest.fn(getTestImplementation('info')),
+  silent: jest.fn(getTestImplementation('silent')),
+  trace: jest.fn(getTestImplementation('trace')),
+  warn: jest.fn(getTestImplementation('warn')),
+};
+
+const mock: (typeof getLogger)['mock'] = { clearAll, logger, logThings: [] };
+
+const getLogger = (() => logger) as unknown as GetLogger;
+
+Object.assign(getLogger, { mock });
+
+export = getLogger;
+
+function clearAll() {
+  for (const name of Object.keys(logger) as LogLevel[]) {
+    logger[name].mockClear();
+  }
+}
+
+function getTestImplementation(level: LogLevel) {
+  return testLogImplementation;
+
+  function testLogImplementation(message: string, ...args: unknown[]) {
+    if (mock.logThings === 'all' || mock.logThings.includes(level)) {
+      console.log(level, message, ...args); // eslint-disable-line no-console
+    }
+  }
+}

__mocks__/loglevel-colored-level-prefix.js

@@ -0,0 +1,34 @@
+/**
+ * We can not use `.ts` because it's called by
+ * `test/fixtures/node_modules/prettier/index.js`
+ */
+
+import type { Options } from 'prettier';
+
+import type { PrettierMock } from '../mock.js';
+
+const prettier = jest.requireActual<PrettierMock>('prettier');
+
+const { format } = prettier;
+
+export = prettier;
+
+const mockFormatSpy = jest.fn(mockFormat);
+
+Object.assign(prettier, {
+  format: mockFormatSpy,
+  resolveConfig: jest.fn(),
+});
+
+function mockFormat(source: string, options?: Options): Promise<string> {
+  globalThis.__PRETTIER_ESLINT_TEST_STATE__.prettierPath = __filename;
+
+  if (
+    'throwError' in mockFormatSpy &&
+    mockFormatSpy.throwError instanceof Error
+  ) {
+    throw mockFormatSpy.throwError;
+  }
+
+  return format(source, options);
+}

__mocks__/loglevel-colored-level-prefix.ts

@@ -9,7 +9,7 @@ export default tseslint.config(
   ...base,
   ...nodeDependencies.configs['flat/recommended'],
   {
-    ignores: ['test/fixtures'],
+    ignores: ['test/fixtures', '!test/fixtures/paths/node_modules/**/*.js'],
   },
   {
     rules: {
@@ -30,7 +30,7 @@ export default tseslint.config(
     },
   },
   {
-    files: ['**/__mocks__/**/*.js', '**/*.spec.ts'],
+    files: ['__mocks__/**/*.{js,ts}', 'test/**/*.spec.ts'],
     languageOptions: {
       globals: globals.jest,
     },

__mocks__/prettier.js

@@ -1,3 +1,5 @@
+/// <reference types="@total-typescript/ts-reset" />
+
 declare global {
   declare var __PRETTIER_ESLINT_TEST_STATE__: {
     eslintPath?: string;

__mocks__/prettier.ts

@@ -0,0 +1,20 @@
+// @ts-check
+
+/** @import { Config } from 'jest' */
+
+module.exports = /** @satisfies {Config} */ ({
+  collectCoverage: true,
+  collectCoverageFrom: ['src/**/*.ts'],
+  coverageThreshold: {
+    global: {
+      branches: 96,
+      functions: 100,
+      lines: 100,
+      statements: 100,
+    },
+  },
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.ts$': '@swc-node/jest',
+  },
+});