add unit tests

Author: avivkeller

src/generators/web/utils/__tests__/config.test.mjs

@@ -0,0 +1,163 @@
+import assert from 'node:assert/strict';
+import { describe, it, mock } from 'node:test';
+
+import { SemVer } from 'semver';
+
+import { setConfig } from '../../../../utils/configuration/index.mjs';
+
+mock.module('@node-core/rehype-shiki', {
+  namedExports: {
+    LANGS: [
+      { name: 'javascript', aliases: ['js'], displayName: 'JavaScript' },
+      { name: 'typescript', aliases: ['ts'], displayName: 'TypeScript' },
+      { name: 'python', displayName: 'Python' },
+    ],
+  },
+});
+
+const { buildVersionEntries, buildPageList, buildLanguageDisplayNameMap } =
+  await import('../config.mjs');
+
+await setConfig({
+  version: 'v22.0.0',
+  changelog: [
+    { version: new SemVer('20.0.0'), isLts: true, isCurrent: false },
+    { version: new SemVer('22.0.0'), isLts: false, isCurrent: true },
+  ],
+  generators: {
+    web: {
+      title: 'Node.js',
+      repository: 'nodejs/node',
+      ref: 'main',
+      baseURL: 'https://nodejs.org/docs',
+      editURL: 'https://github.com/nodejs/node/edit/main/doc/api{path}.md',
+      pageURL: '{baseURL}/latest-{version}/api{path}.html',
+    },
+  },
+});
+
+/**
+ * Helper to create a minimal JSX content entry.
+ */
+const makeEntry = (api, name, path) => ({
+  data: {
+    api,
+    path,
+    heading: { depth: 1, data: { name } },
+  },
+});
+
+describe('buildVersionEntries', () => {
+  it('creates version entries with labels and URL templates', () => {
+    const config = {
+      changelog: [
+        { version: new SemVer('20.0.0'), isLts: true, isCurrent: false },
+        { version: new SemVer('22.0.0'), isLts: false, isCurrent: true },
+      ],
+    };
+
+    const result = buildVersionEntries(
+      config,
+      'https://nodejs.org/docs/latest-{version}/api{path}.html'
+    );
+
+    assert.equal(result.length, 2);
+    assert.deepStrictEqual(result[0], {
+      url: 'https://nodejs.org/docs/latest-v20.x/api{path}.html',
+      label: 'v20.x (LTS)',
+      major: 20,
+    });
+    assert.deepStrictEqual(result[1], {
+      url: 'https://nodejs.org/docs/latest-v22.x/api{path}.html',
+      label: 'v22.x (Current)',
+      major: 22,
+    });
+  });
+
+  it('does not append a label suffix for versions that are neither LTS nor Current', () => {
+    const config = {
+      changelog: [
+        { version: new SemVer('18.0.0'), isLts: false, isCurrent: false },
+      ],
+    };
+
+    const result = buildVersionEntries(config, '{version}');
+
+    assert.equal(result[0].label, 'v18.x');
+  });
+
+  it('formats minor versions when minor is non-zero', () => {
+    const config = {
+      changelog: [
+        { version: new SemVer('21.7.0'), isLts: false, isCurrent: false },
+      ],
+    };
+
+    const result = buildVersionEntries(config, '{version}');
+
+    assert.equal(result[0].label, 'v21.7.x');
+    assert.equal(result[0].major, 21);
+  });
+});
+
+describe('buildPageList', () => {
+  it('returns sorted [name, path] tuples from input entries', () => {
+    const input = [
+      makeEntry('http', 'HTTP', '/http'),
+      makeEntry('fs', 'File System', '/fs'),
+    ];
+
+    const result = buildPageList(input);
+
+    assert.equal(result.length, 2);
+    // Sorted alphabetically by name
+    assert.deepStrictEqual(result[0], ['File System', '/fs']);
+    assert.deepStrictEqual(result[1], ['HTTP', '/http']);
+  });
+
+  it('filters out entries whose heading depth is not 1', () => {
+    const input = [
+      makeEntry('fs', 'File System', '/fs'),
+      {
+        data: {
+          api: 'http',
+          path: '/http',
+          heading: { depth: 2, data: { name: 'HTTP' } },
+        },
+      },
+    ];
+
+    const result = buildPageList(input);
+
+    assert.equal(result.length, 1);
+    assert.deepStrictEqual(result[0], ['File System', '/fs']);
+  });
+});
+
+describe('buildLanguageDisplayNameMap', () => {
+  it('returns entries suitable for constructing a Map', () => {
+    const result = buildLanguageDisplayNameMap();
+
+    // Should have one entry per unique language name
+    assert.equal(result.length, 3);
+
+    const map = new Map(result);
+
+    assert.equal(map.get('JavaScript'), undefined);
+    // Each entry is [[aliases..., name], displayName]
+    // Find the javascript entry
+    const jsEntry = result.find(([keys]) => keys.includes('javascript'));
+    assert.ok(jsEntry);
+    assert.deepStrictEqual(jsEntry[0], ['js', 'javascript']);
+    assert.equal(jsEntry[1], 'JavaScript');
+  });
+
+  it('handles languages without aliases', () => {
+    const result = buildLanguageDisplayNameMap();
+
+    const pyEntry = result.find(([keys]) => keys.includes('python'));
+    assert.ok(pyEntry);
+    assert.deepStrictEqual(pyEntry[0], ['python']);
+    assert.equal(pyEntry[1], 'Python');
+  });
+});

src/generators/web/utils/config.mjs

@@ -15,7 +15,7 @@ import { getSortedHeadNodes } from '../../jsx-ast/utils/getSortedHeadNodes.mjs';
  * @param {string} pageURLBase
  * @returns {Array<{url: string, label: string, major: number}>}
  */
-function buildVersionEntries(config, pageURLBase) {
+export function buildVersionEntries(config, pageURLBase) {
   return config.changelog.map(({ version, isLts, isCurrent }) => {
     let label = `v${getVersionFromSemVer(version)}`;
     const url = pageURLBase.replace('{version}', label);
@@ -35,7 +35,7 @@ function buildVersionEntries(config, pageURLBase) {
  * @param {Array<import('../../jsx-ast/utils/buildContent.mjs').JSXContent>} input
  * @returns {Array<[string, string]>}
  */
-function buildPageList(input) {
+export function buildPageList(input) {
   const headNodes = getSortedHeadNodes(input.map(e => e.data));
   return headNodes.map(node => [node.heading.data.name, node.path]);
 }
@@ -45,7 +45,7 @@ function buildPageList(input) {
  *
  * @returns {Array<[string[], string]>}
  */
-function buildLanguageDisplayNameMap() {
+export function buildLanguageDisplayNameMap() {
   return [
     ...new Map(
       LANGS.map(({ name, aliases = [], displayName }) => [

src/utils/__tests__/loaders.test.mjs

@@ -8,7 +8,8 @@ mock.module('node:fs/promises', {
   },
 });
 
-const { toParsedURL, loadFromURL } = await import('../loaders.mjs');
+const { toParsedURL, loadFromURL, importFromURL } =
+  await import('../loaders.mjs');
 
 describe('toParsedURL', () => {
   it('should return the same URL instance when given a URL object', () => {
@@ -51,3 +52,18 @@ describe('loadFromURL', () => {
     assert.strictEqual(result, 'fetched content');
   });
 });
+
+describe('importFromURL', () => {
+  it('should import a module from a valid URL and return default export', async () => {
+    const mod = await importFromURL(import.meta.url);
+    // The test file itself has no default export, so the full module is returned
+    assert.ok(mod !== undefined);
+  });
+
+  it('should resolve a relative path to an absolute file URL', async () => {
+    // Importing the loaders module itself as a sanity check
+    const mod = await importFromURL(new URL('../loaders.mjs', import.meta.url));
+    assert.ok(typeof mod.loadFromURL === 'function');
+    assert.ok(typeof mod.importFromURL === 'function');
+  });
+});

src/utils/__tests__/misc.test.mjs

@@ -3,7 +3,7 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 
-import { lazy, isPlainObject, deepMerge } from '../misc.mjs';
+import { lazy, isPlainObject, extractPrimitives, deepMerge } from '../misc.mjs';
 
 describe('lazy', () => {
   it('should call the function only once and cache the result', () => {
@@ -38,6 +38,55 @@ describe('isPlainObject', () => {
   });
 });
 
+describe('extractPrimitives', () => {
+  it('should keep string, number, boolean, and null values', () => {
+    const obj = { a: 'hello', b: 42, c: true, d: null };
+    assert.deepStrictEqual(extractPrimitives(obj), {
+      a: 'hello',
+      b: 42,
+      c: true,
+      d: null,
+    });
+  });
+
+  it('should remove object and function values', () => {
+    const obj = {
+      name: 'test',
+      nested: { foo: 'bar' },
+      fn: () => {},
+      count: 5,
+    };
+    const result = extractPrimitives(obj);
+    assert.deepStrictEqual(result, { name: 'test', count: 5 });
+  });
+
+  it('should keep arrays of primitives', () => {
+    const obj = { tags: ['a', 'b'], name: 'test' };
+    assert.deepStrictEqual(extractPrimitives(obj), {
+      tags: ['a', 'b'],
+      name: 'test',
+    });
+  });
+
+  it('should remove arrays containing objects', () => {
+    const obj = { items: [{ id: 1 }], name: 'test' };
+    assert.deepStrictEqual(extractPrimitives(obj), { name: 'test' });
+  });
+
+  it('should keep undefined values', () => {
+    const obj = { a: undefined, b: 'yes' };
+    const result = extractPrimitives(obj);
+    assert.strictEqual('a' in result, true);
+    assert.strictEqual(result.a, undefined);
+    assert.strictEqual(result.b, 'yes');
+  });
+
+  it('should return an empty object when all values are non-primitive', () => {
+    const obj = { a: {}, b: [{ x: 1 }], c: () => {} };
+    assert.deepStrictEqual(extractPrimitives(obj), {});
+  });
+});
+
 describe('deepMerge', () => {
   it('should merge flat objects with source taking precedence over base', () => {
     const result = deepMerge({ a: 1, b: 2 }, { b: 10, c: 3 });