Fix broken tests

leeyi45 · leeyi45 · commit 9c02cca5b4b5 · 2025-07-17T19:32:25.000+08:00
diff --git a/lib/buildtools/src/build/__tests__/all.test.ts b/lib/buildtools/src/build/__tests__/all.test.ts
@@ -14,7 +14,7 @@ vi.mock(import('../../getGitRoot.js'));
 vi.spyOn(all, 'buildAll');
 const mockedBuildBundle = vi.spyOn(modules, 'buildBundle');
 const mockedBuildTab = vi.spyOn(modules, 'buildTab');
-const mockedBuildJson = vi.spyOn(docs, 'buildSingleBundleDocs');
+const mockedBuildSingleBundleDocs = vi.spyOn(docs, 'buildSingleBundleDocs');
 
 const mockedRunTsc = vi.spyOn(tsc, 'runTsc').mockResolvedValue({
   severity: Severity.SUCCESS,
@@ -46,7 +46,7 @@ describe('Test the buildAll command', () => {
         input: {} as any
       });
 
-      mockedBuildJson.mockResolvedValueOnce({
+      mockedBuildSingleBundleDocs.mockResolvedValueOnce({
         type: 'docs',
         severity: Severity.SUCCESS,
         path: '/build/jsons',
@@ -64,7 +64,7 @@ describe('Test the buildAll command', () => {
         input: {} as any
       });
 
-      mockedBuildJson.mockResolvedValueOnce({
+      mockedBuildSingleBundleDocs.mockResolvedValueOnce({
         type: 'docs',
         severity: Severity.SUCCESS,
         path: '/build/jsons',
@@ -83,7 +83,7 @@ describe('Test the buildAll command', () => {
         input: {} as any
       });
 
-      mockedBuildJson.mockResolvedValueOnce({
+      mockedBuildSingleBundleDocs.mockResolvedValueOnce({
         type: 'docs',
         severity: Severity.SUCCESS,
         path: '/build/jsons',
@@ -130,7 +130,7 @@ describe('Test the buildAll command', () => {
         errors: []
       });
 
-      mockedBuildJson.mockResolvedValueOnce({
+      mockedBuildSingleBundleDocs.mockResolvedValueOnce({
         type: 'docs',
         severity: Severity.SUCCESS,
         path: '/build/jsons',
@@ -151,7 +151,7 @@ describe('Test the buildAll command', () => {
         input: {} as any
       });
 
-      mockedBuildJson.mockResolvedValueOnce({
+      mockedBuildSingleBundleDocs.mockResolvedValueOnce({
         type: 'docs',
         severity: Severity.ERROR,
         errors: [],
diff --git a/lib/buildtools/src/build/docs/index.ts b/lib/buildtools/src/build/docs/index.ts
@@ -53,12 +53,12 @@ export async function buildSingleBundleDocs(bundle: ResolvedBundle, outDir: stri
   return buildJson(bundle, outDir, project);
 }
 
-type BuildAllBundleDocsResult = ResultType;
+type BuildHtmlResult = ResultType;
 
 /**
  * Builds HTML documentation for all bundles. Needs to be run after {@link buildSingleBundleDocs}
  */
-export async function buildHtml(bundles: Record<string, ResolvedBundle>, outDir: string, logLevel: td.LogLevel): Promise<BuildAllBundleDocsResult> {
+export async function buildHtml(bundles: Record<string, ResolvedBundle>, outDir: string, logLevel: td.LogLevel): Promise<BuildHtmlResult> {
   const jsonStats = await mapAsync(Object.values(bundles), async ({ name, directory }) => {
     try {
       const stats = await fs.stat(`${directory}/dist/docs.json`);
diff --git a/lib/buildtools/src/commands/__tests__/commandUtils.test.ts b/lib/buildtools/src/commands/__tests__/commandUtils.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, test } from "vitest";
+import { Severity } from "../../types.js";
+import { processResult } from "../commandUtils.js";
+
+describe('Testing processResults', () => {
+  const testCases: [any, Severity][] = [
+    [{ severity: Severity.SUCCESS }, Severity.SUCCESS],
+    [{ severity: Severity.ERROR }, Severity.ERROR],
+    [
+      {
+        items: [{ severity: Severity.ERROR }, { severity: Severity.SUCCESS }]
+      },
+      Severity.ERROR
+    ],
+    [
+      {
+        item1: { severity: Severity.WARN },
+        item2: {
+          item3: {},
+          item4: {
+            item5: { severity: Severity.WARN },
+            severity: Severity.ERROR
+          }
+        }
+      },
+      Severity.ERROR
+    ]
+  ];
+
+  test.each(testCases)('%#', (obj, expected) => {
+    if (expected === Severity.ERROR) {
+      expect(() => processResult(obj, false)).processExit();
+    } else {
+      expect(() => processResult(obj, false)).not.processExit();
+    }
+  });
+});
diff --git a/lib/buildtools/src/commands/build.ts b/lib/buildtools/src/commands/build.ts
@@ -118,5 +118,5 @@ export const getBuildHtmlCommand = () => new Command('html')
 
     const htmlResult = await buildHtml(resolveResult.bundles, outDir, logLevel);
     console.log(formatResult(htmlResult, 'html'));
-    processResult({ results: htmlResult }, false);
+    processResult(htmlResult, false);
   });
diff --git a/lib/buildtools/src/commands/commandUtils.ts b/lib/buildtools/src/commands/commandUtils.ts
@@ -1,9 +1,8 @@
 import { InvalidArgumentError, Option } from '@commander-js/extra-typings';
 import chalk from 'chalk';
 import { LogLevel } from 'typedoc';
-import type { LintResult } from '../prebuild/lint.js';
-import type { TscResult } from '../prebuild/tsc.js';
-import type { ErrorResult, Severity } from '../types.js';
+import { Severity, type ErrorResult } from '../types.js';
+import { isSeverity } from '../utils.js';
 
 export const lintOption = new Option('--lint', 'Run ESLint when building')
   .default(false);
@@ -46,27 +45,33 @@ export function objectKeys<T extends string | number | symbol>(obj: Record<T, un
  * are errors, or if there are warnings and `errorOnWarning` has been given as `true`.\
  * Mainly intended for use with CI pipelines so that processes can exit with non-zero codes
  */
-export function processResult({ results, tsc, lint }: { results?: { severity: Severity }, tsc?: TscResult, lint?: LintResult }, errorOnWarning: boolean) {
-  const severities: Severity[] = [];
+export function processResult(obj: object, errorOnWarning: boolean) {
+  function* severities(obj: object): Generator<Severity> {
+    if (obj === null) {
+      yield Severity.SUCCESS;
+      return;
+    }
 
-  if (results) {
-    severities.push(results.severity);
-  }
+    if (Array.isArray(obj)) {
+      for (const item of obj) {
+        yield* severities(item);
+      }
 
-  if (tsc) {
-    severities.push(tsc.severity);
-  }
+      return;
+    }
 
-  if (lint) {
-    severities.push(lint.severity);
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === 'severity' && isSeverity(value)) yield value;
+      if (typeof value === 'object') yield* severities(value);
+    }
   }
 
-  for (const severity of severities) {
+  for (const severity of severities(obj)) {
     switch (severity) {
-      case 'warn': {
+      case Severity.WARN: {
         if (!errorOnWarning) continue;
       }
-      case 'error':
+      case Severity.ERROR:
         process.exit(1);
     }
   }
diff --git a/lib/buildtools/src/prebuild/lint.ts b/lib/buildtools/src/prebuild/lint.ts
@@ -2,7 +2,7 @@ import { promises as fs, type Dirent } from 'fs';
 import pathlib from 'path';
 import chalk from 'chalk';
 import { ESLint } from 'eslint';
-import { getGitRoot } from '../getGitRoot.js';
+import { getGitRoot, getOutDir } from '../getGitRoot.js';
 import { Severity, type InputAsset } from '../types.js';
 import { findSeverity, flatMapAsync, isNodeError } from '../utils.js';
 
@@ -49,13 +49,14 @@ export async function runEslint(input: InputAsset, fix: boolean, stats: boolean)
     }
 
     if (stats) {
-      await fs.mkdir(`${gitRoot}/lintstats`, { recursive: true });
+      const outDir = await getOutDir();
+      await fs.mkdir(`${outDir}/lintstats`, { recursive: true });
 
       const statsFormatter = await linter.loadFormatter('json');
       const statsFormatted = await statsFormatter.format(linterResults);
       const stringified = JSON.stringify(JSON.parse(statsFormatted), null, 2);
 
-      await fs.writeFile(`${gitRoot}/lintstats/${input.type}-${input.name}.json`, stringified);
+      await fs.writeFile(`${outDir}/lintstats/${input.type}-${input.name}.json`, stringified);
     }
 
     const outputFormatter = await linter.loadFormatter('stylish');
diff --git a/lib/buildtools/src/utils.ts b/lib/buildtools/src/utils.ts
@@ -2,6 +2,12 @@ import { Severity, type ResolvedBundle, type ResolvedTab } from './types.js';
 
 export type AwaitedReturn<T extends (...args: any[]) => Promise<any>> = Awaited<ReturnType<T>>;
 
+export function isSeverity(obj: unknown): obj is Severity {
+  if (typeof obj !== 'string') return false;
+
+  return obj === Severity.ERROR || obj === Severity.WARN || obj === Severity.SUCCESS;
+}
+
 export function compareSeverity(lhs: Severity, rhs: Severity): Severity {
   switch (lhs) {
     case Severity.SUCCESS:
diff --git a/lib/buildtools/vitest.d.ts b/lib/buildtools/vitest.d.ts
@@ -8,8 +8,14 @@ declare module 'vitest' {
     commandSuccess: () => Promise<T>
 
     /**
-     * Asserts that process.exit was called with the specified code
+     * Asserts that process.exit was called with the specified code when the promise resolves
      */
     commandExit: (code?: number) => Promise<T>
+
+    /**
+     * Asserts that process.exit was called with the specified code when the
+     * function is called
+     */
+    processExit: (code?: number) => T
   }
-}
+}
diff --git a/lib/buildtools/vitest.setup.ts b/lib/buildtools/vitest.setup.ts
@@ -3,6 +3,10 @@ import { expect, vi } from 'vitest';
 
 class MockProcessError extends Error {
   constructor(public readonly code: number) { super(); }
+
+  toString() {
+    return `process.exit was called with ${this.code}`;
+  }
 };
 
 vi.mock('chalk', () => {
@@ -90,5 +94,25 @@ expect.extend({
         message: () => `Command rejected with unexpected error: ${error}`
       };
     }
+  },
+  processExit(received: () => any, expected: number = 1) {
+    try {
+      received();
+      return {
+        pass: false,
+        message: () => `Expected function to call process.exit with code ${expected}`
+      };
+    } catch (error) {
+      if (error instanceof MockProcessError) {
+        return {
+          pass: error.code === expected,
+          message: () => `process.exit called with ${expected}`
+        };
+      }
+      return {
+        pass: false,
+        message: () => `Function threw an unexpected error: ${error}`
+      };
+    }
   }
 });
diff --git a/lib/markdown-tree/src/__tests__/index.test.ts b/lib/markdown-tree/src/__tests__/index.test.ts
@@ -1,6 +1,7 @@
 import fs from 'fs';
 import { describe, expect, test, vi } from 'vitest';
 import { generateStructure } from '../structure';
+import { generateTree } from '../tree';
 import { isRootYamlObject, isYamlObject } from '../types';
 
 const mockExistsSync = vi.spyOn(fs, 'existsSync');
@@ -50,7 +51,27 @@ describe('Test isRootYamlObject', () => {
   });
 });
 
-describe('Test structure generation', () => {
+test('structure generation', () => {
+  const [structure, commentLoc, warnings] = generateStructure({
+    name: 'root',
+    children: [{
+      name: 'item1',
+      comment: 'this is a comment'
+    },
+    'item2',
+    {
+      name: 'item3',
+      comment: 'also a comment'
+    }
+    ]
+  });
+  expect(warnings.length).toEqual(0);
+  expect(generateTree(structure, commentLoc)).toMatchInlineSnapshot(`
+    "root
+    ├── item1  // this is a comment
+    ├── item2
+    └── item3  // also a comment"
+  `);
 });
 
 describe('Test tree validation', () => {
diff --git a/lib/markdown-tree/src/structure.ts b/lib/markdown-tree/src/structure.ts
@@ -4,7 +4,11 @@ import { parseDocument } from 'yaml';
 import { generateTree } from './tree';
 import { isRootYamlObject, type DirectoryTreePluginOptions, type FileStructure, type RootYamlObject, type YamlObject } from './types';
 
-export function parseContent(content: string, docdir: string, options: DirectoryTreePluginOptions = {}): [string, string[]] {
+/**
+ * Convert the given the YAML string into the ASCII directory tree representation
+ * @param docdir The path to the directory containing the markdown file that contains this dirtree snippet
+ */
+export function parseContent(content: string, docdir: string, options: DirectoryTreePluginOptions = {}): [content: string, warnings: string[]] {
   const yamlNode = parseDocument(content);
 
   if (yamlNode.errors.length > 0) {
@@ -30,7 +34,7 @@ export function parseContent(content: string, docdir: string, options: Directory
  * provided follows the directory structure of the directory at the given path.
  */
 
-export function generateStructure(rootObj: RootYamlObject, validatePath?: string): [FileStructure, number, string[]] {
+export function generateStructure(rootObj: RootYamlObject, validatePath?: string): [structure: FileStructure, loc: number, warnings: string[]] {
   const rootName = rootObj.name ?? (validatePath !== undefined ? pathlib.basename(validatePath) : 'root');
 
   const root: FileStructure = {
diff --git a/lib/markdown-tree/vitest.config.js b/lib/markdown-tree/vitest.config.js
@@ -1,4 +1,5 @@
 // Markdown-Tree plugin vitest
+// @ts-check
 
 import { defineProject, mergeConfig } from 'vitest/config';
 import rootConfig from '../../vitest.config';
diff --git a/vitest.config.js b/vitest.config.js
@@ -15,11 +15,15 @@ export default defineConfig({
       provider: 'v8',
       exclude: [
         ...coverageConfigDefaults.exclude,
-        '**/dist/**',
+        'build/**',
         '**/__mocks__/**',
         '**/__test_mocks__/**',
         '**/bin/**',
         '**/build.js',
+        '**.config.[cm]?[jt]s',
+        '**/coverage/**',
+        '**/dist/**',
+        '**/src/**/samples/**',
         `${import.meta.dirname}/lib/buildtools/src/build/docs/drawdown.ts`
       ]
     },
