fix unit tests

Author: avivkeller

packages/rehype-shiki/package.json

@@ -7,7 +7,8 @@
   },
   "scripts": {
     "lint:js": "eslint \"**/*.mjs\"",
-    "test": "node --test"
+    "test": "turbo test:unit",
+    "test:unit": "node --experimental-test-module-mocks --test \"**/*.test.mjs\""
   },
   "dependencies": {
     "@shikijs/core": "^3.3.0",

packages/rehype-shiki/src/__tests__/highlighter.test.mjs

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict';
+import { describe, it, mock } from 'node:test';
+
+// Mock dependencies
+const mockShiki = {
+  codeToHtml: mock.fn(() => '<pre><code>highlighted code</code></pre>'),
+  codeToHast: mock.fn(() => ({ type: 'element', tagName: 'pre' })),
+};
+
+mock.module('@shikijs/core', {
+  namedExports: { createHighlighterCoreSync: () => mockShiki },
+});
+
+mock.module('@shikijs/engine-javascript', {
+  namedExports: { createJavaScriptRegexEngine: () => ({}) },
+});
+
+mock.module('shiki/themes/nord.mjs', {
+  defaultExport: { name: 'nord', colors: { 'editor.background': '#2e3440' } },
+});
+
+describe('createHighlighter', async () => {
+  const { createHighlighter } = await import('../highlighter.mjs');
+
+  describe('getLanguageDisplayName', () => {
+    it('returns display name for known languages', () => {
+      const langs = [
+        { name: 'javascript', displayName: 'JavaScript', aliases: ['js'] },
+      ];
+      const highlighter = createHighlighter({ langs });
+
+      assert.strictEqual(
+        highlighter.getLanguageDisplayName('javascript'),
+        'JavaScript'
+      );
+      assert.strictEqual(
+        highlighter.getLanguageDisplayName('js'),
+        'JavaScript'
+      );
+    });
+
+    it('returns original name for unknown languages', () => {
+      const highlighter = createHighlighter({ langs: [] });
+      assert.strictEqual(
+        highlighter.getLanguageDisplayName('unknown'),
+        'unknown'
+      );
+    });
+  });
+
+  describe('highlightToHtml', () => {
+    it('extracts inner HTML from code tag', () => {
+      mockShiki.codeToHtml.mock.mockImplementationOnce(
+        () => '<pre><code>const x = 1;</code></pre>'
+      );
+
+      const highlighter = createHighlighter({});
+      const result = highlighter.highlightToHtml('const x = 1;', 'javascript');
+
+      assert.strictEqual(result, 'const x = 1;');
+    });
+  });
+
+  describe('highlightToHast', () => {
+    it('returns HAST tree from shiki', () => {
+      const expectedHast = { type: 'element', tagName: 'pre' };
+      mockShiki.codeToHast.mock.mockImplementationOnce(() => expectedHast);
+
+      const highlighter = createHighlighter({});
+      const result = highlighter.highlightToHast('code', 'javascript');
+
+      assert.deepStrictEqual(result, expectedHast);
+    });
+  });
+});

packages/rehype-shiki/src/__tests__/languages.test.mjs

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import { describe, it, mock } from 'node:test';
+
+// Simplified mocks - only mock what's actually needed
+mock.module('../index.mjs', {
+  namedExports: { highlightToHast: mock.fn(() => ({ children: [] })) },
+});
+
+mock.module('classnames', {
+  defaultExport: (...args) => args.filter(Boolean).join(' '),
+});
+
+mock.module('hast-util-to-string', {
+  namedExports: { toString: () => 'code' },
+});
+
+const mockVisit = mock.fn();
+mock.module('unist-util-visit', {
+  namedExports: { visit: mockVisit, SKIP: Symbol() },
+});
+
+describe('rehypeShikiji', async () => {
+  const { default: rehypeShikiji } = await import('../plugin.mjs');
+  const mockTree = { type: 'root', children: [] };
+
+  it('calls visit twice', () => {
+    mockVisit.mock.resetCalls();
+    rehypeShikiji()(mockTree);
+    assert.strictEqual(mockVisit.mock.calls.length, 2);
+  });
+
+  it('creates CodeTabs for multiple code blocks', () => {
+    const parent = {
+      children: [
+        {
+          tagName: 'pre',
+          children: [
+            {
+              tagName: 'code',
+              data: { meta: 'displayName="JS"' },
+              properties: { className: ['language-js'] },
+            },
+          ],
+        },
+        {
+          tagName: 'pre',
+          children: [
+            {
+              tagName: 'code',
+              data: { meta: 'displayName="TS"' },
+              properties: { className: ['language-ts'] },
+            },
+          ],
+        },
+      ],
+    };
+
+    mockVisit.mock.mockImplementation((tree, selector, visitor) => {
+      if (selector === 'element') {
+        visitor(parent.children[0], 0, parent);
+      }
+    });
+
+    rehypeShikiji()(mockTree);
+    assert.ok(parent.children.some(child => child.tagName === 'CodeTabs'));
+  });
+});

packages/rehype-shiki/src/__tests__/plugin.test.mjs

@@ -4,7 +4,7 @@ import classNames from 'classnames';
 import { toString } from 'hast-util-to-string';
 import { SKIP, visit } from 'unist-util-visit';
 
-import { highlightToHast } from '.';
+import { highlightToHast } from './index.mjs';
 
 // This is what Remark will use as prefix within a <pre> className
 // to attribute the current language of the <pre> element

packages/rehype-shiki/src/plugin.mjs

@@ -6,7 +6,7 @@
     "lint:js": {
       "inputs": ["src/**/*.mjs"]
     },
-    "test": {
+    "test:unit": {
       "inputs": ["src/**/*.mjs"]
     }
   }