@diplodoc/cli 5.46.1 → 5.47.0

package/tests/e2e/init.test.ts

@@ -0,0 +1,105 @@
+import {mkdtemp, rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {afterEach, beforeEach, describe, expect, it} from 'vitest';
+
+import {TestAdapter, compareDirectories} from '../fixtures';
+
+function run(args: string[]) {
+    return TestAdapter.runner.runYfmDocs(['init', ...args]);
+}
+
+let tmpDir: string;
+
+beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'yfm-init-'));
+});
+
+afterEach(async () => {
+    await rm(tmpDir, {recursive: true, force: true});
+});
+
+describe('yfm init — single-lang', () => {
+    it('creates project structure', async () => {
+        const out = join(tmpDir, 'proj');
+        const report = await run(['--output', out, '--name', 'My Docs', '--skip-interactive']);
+
+        expect(report.code).toBe(0);
+        await compareDirectories(out);
+    });
+
+    it('derives project name from output directory basename', async () => {
+        const out = join(tmpDir, 'my-project');
+        await run(['--output', out]);
+
+        await compareDirectories(out);
+    });
+
+    it('--no-header removes navigation block', async () => {
+        const out = join(tmpDir, 'proj');
+        await run(['--output', out, '--name', 'My Docs', '--no-header', '--skip-interactive']);
+
+        await compareDirectories(out);
+    });
+});
+
+describe('yfm init — multi-lang', () => {
+    it('creates project structure', async () => {
+        const out = join(tmpDir, 'proj');
+        const report = await run([
+            '--output',
+            out,
+            '--langs',
+            'ru,en',
+            '--name',
+            'My Docs',
+            '--skip-interactive',
+        ]);
+
+        expect(report.code).toBe(0);
+        await compareDirectories(out);
+    });
+
+    it('--default-lang sets lang field in .yfm', async () => {
+        const out = join(tmpDir, 'proj');
+        await run([
+            '--output',
+            out,
+            '--langs',
+            'ru,en',
+            '--default-lang',
+            'en',
+            '--name',
+            'My Docs',
+            '--skip-interactive',
+        ]);
+
+        await compareDirectories(out);
+    });
+
+    it('--no-header removes navigation from all toc.yaml files', async () => {
+        const out = join(tmpDir, 'proj');
+        await run([
+            '--output',
+            out,
+            '--langs',
+            'ru,en',
+            '--no-header',
+            '--name',
+            'My Docs',
+            '--skip-interactive',
+        ]);
+
+        await compareDirectories(out);
+    });
+});
+
+describe('yfm init — errors', () => {
+    it('fails with non-zero exit code if output directory is not empty', async () => {
+        const out = join(tmpDir, 'proj');
+        await run(['--output', out]);
+
+        const report = await run(['--output', out]);
+        expect(report.code).toBeGreaterThan(0);
+    });
+});

package/tests/e2e/llms.spec.ts

@@ -0,0 +1,24 @@
+import {describe, test} from 'vitest';
+
+import {TestAdapter, compareDirectories, getTestPaths} from '../fixtures';
+
+describe('llms.txt', () => {
+    // Builds the same fixture in both md and html with `--llms` (variant B):
+    //   - md  output -> `${outputPath}`      (llms-full.txt has includes merged)
+    //   - html output -> `${outputPath}-html` (llms-full.txt keeps include directives)
+    // The fixture also has per-page frontmatter descriptions (surfaced in
+    // llms.txt) and a `when: showBeta` page that the default version filters
+    // out — proving the artifacts stay consistent with the built "version".
+    test('generates llms.txt and llms-full.txt for md and html', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/llms');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: true,
+            args: '--llms',
+        });
+
+        await compareDirectories(outputPath);
+        await compareDirectories(`${outputPath}-html`);
+    });
+});

package/tests/e2e/load-custom-resources.spec.ts

@@ -0,0 +1,23 @@
+import {describe} from 'vitest';
+
+import {generateMapTestTemplate} from '../fixtures';
+
+describe('Allow load custom resources', () => {
+    generateMapTestTemplate(
+        'md2md with custom resources',
+        'mocks/load-custom-resources/md2md-with-resources',
+        {md2html: false, args: '--allow-custom-resources'},
+    );
+
+    generateMapTestTemplate(
+        'md2html with custom resources',
+        'mocks/load-custom-resources/md2html-with-resources',
+        {md2md: false, args: '--allow-custom-resources'},
+    );
+
+    generateMapTestTemplate(
+        'md2html single page with custom resources',
+        'mocks/load-custom-resources/single-page-with-resources',
+        {md2md: false, args: '--allow-custom-resources --single-page'},
+    );
+});

package/tests/e2e/markdown-options.spec.ts

@@ -0,0 +1,17 @@
+import {describe} from 'vitest';
+
+import {generateMapTestTemplate} from '../fixtures';
+
+describe('Markdown options from .yfm config', () => {
+    generateMapTestTemplate(
+        'Markdown options from .yfm config 1',
+        'mocks/markdown-options/example-1',
+        {md2html: true, md2md: false, args: '-j2'},
+    );
+
+    generateMapTestTemplate(
+        'Markdown options from .yfm config 2',
+        'mocks/markdown-options/example-2',
+        {md2html: true, md2md: false, args: '-j2'},
+    );
+});

package/tests/e2e/merge-includes.spec.ts

@@ -0,0 +1,196 @@
+import {describe, test} from 'vitest';
+
+import {TestAdapter, compareDirectories, getTestPaths} from '../fixtures';
+
+describe('Merge includes (md2md)', () => {
+    test('basic: simple include is inlined', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/basic');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('nested: outer inlined, inner as fallback', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/nested');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('relative-paths: inlined content has rebased paths', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/relative-paths');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('hash-section: includes with hash extract sections inline', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/hash-fallback');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('term-inline: includes inside term defs use fallback (not inlined)', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/term-inline');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes --multiline-term-definitions',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('inline-context: non-standalone includes use fallback', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/inline-context');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('term-extract: dep with terms → terms extracted, content inlined (Step 4)', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/term-extract');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes --multiline-term-definitions',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('yfm-table: include followed by || separator is inlined', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/yfm-table');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('yfm-table: include ending with HTML block places || on its own line', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/yfm-table-html-block');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('yfm-table: include with `|` in inline code falls back to {% included %}', async () => {
+        const {inputPath, outputPath} = getTestPaths(
+            'mocks/merge-includes/yfm-table-pipe-in-content',
+        );
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('indent-paragraph: include under indent with indented top-level paragraph falls back to {% included %}', async () => {
+        const {inputPath, outputPath} = getTestPaths(
+            'mocks/merge-includes/indent-paragraph-in-include',
+        );
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('html-in-list: include with <style> in list (any indent) uses fallback', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/html-in-list');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('hash-section-html: hash-section include in list is inlined when only other section has <style>', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/hash-section-html');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('without flag: includes are NOT merged', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/basic');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--no-merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('html-comment-blanks: blank lines inside HTML comments keep list/cut continuity', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/html-comment-blanks');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('include-in-code-block: include shown as code example is NOT expanded', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/include-in-code-block');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+
+    test('include-after-fence: include placed right after a closing ``` fence is inlined', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/merge-includes/include-after-fence');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--merge-includes',
+        });
+        await compareDirectories(outputPath);
+    });
+});

package/tests/e2e/metadata.spec.ts

@@ -0,0 +1,79 @@
+import {readFileSync, readdirSync} from 'node:fs';
+import {join} from 'node:path';
+import {describe, expect, test} from 'vitest';
+
+import {TestAdapter, generateMapTestTemplate, getTestPaths} from '../fixtures';
+
+function findFile(dir: string, predicate: (name: string) => boolean): string | null {
+    try {
+        for (const name of readdirSync(dir, {withFileTypes: true})) {
+            const full = join(dir, name.name);
+
+            if (name.isDirectory()) {
+                const found = findFile(full, predicate);
+
+                if (found) {
+                    return found;
+                }
+            } else if (predicate(name.name)) {
+                return full;
+            }
+        }
+    } catch {
+        return null;
+    }
+
+    return null;
+}
+
+describe('Allow load custom resources', () => {
+    generateMapTestTemplate('md2md with metadata', 'mocks/metadata/md2md-with-metadata', {
+        md2html: false,
+    });
+
+    generateMapTestTemplate('md2html with metadata', 'mocks/metadata/md2html-with-metadata', {
+        md2md: false,
+    });
+
+    test('include file with csp metadata does not leak frontmatter into rendered HTML (two-step build)', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/metadata/include-with-csp-meta');
+
+        // Step 1: md2md — include files get CSP frontmatter from config resources
+        // Disable merge-includes so include files are written to disk for verification
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '--no-merge-includes',
+        });
+
+        // Verify that md2md wrote frontmatter to the include file
+        const mdIncludePath = findFile(
+            outputPath,
+            (n) => n.includes('support') && n.endsWith('.md'),
+        );
+        expect(mdIncludePath).toBeTruthy();
+        if (!mdIncludePath) {
+            throw new Error('mdIncludePath is null');
+        }
+        const mdContent = readFileSync(mdIncludePath, 'utf8');
+        expect(mdContent).toMatch(/^---/);
+        expect(mdContent).toMatch(/csp:/);
+
+        // Step 2: md2html on md2md output — include frontmatter must not leak into HTML
+        await TestAdapter.testBuildPass(outputPath, outputPath + '-html', {
+            md2md: false,
+            md2html: true,
+        });
+
+        const htmlPath = findFile(outputPath + '-html', (n) => n === 'page.html');
+        expect(htmlPath).toBeTruthy();
+        if (!htmlPath) {
+            throw new Error('htmlPath is null');
+        }
+        const html = readFileSync(htmlPath, 'utf8');
+
+        expect(html).not.toMatch(/style-src:\s*unsafe-inline/);
+        expect(html).not.toMatch(/connect-src:\s*uaas\.yandex\.ru/);
+        expect(html).toMatch(/Support content only/);
+    }, 45000);
+});

package/tests/e2e/nested-include-links.spec.ts

@@ -0,0 +1,26 @@
+import {readFileSync} from 'node:fs';
+import {resolve} from 'node:path';
+import {describe, expect, test} from 'vitest';
+
+import {TestAdapter, getTestPaths} from '../fixtures';
+
+describe('Nested include links', () => {
+    test('Links in nested includes should resolve relative to the include file, not the entry file', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/nested-include-links');
+
+        // Build directly to HTML
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: false,
+            md2html: true,
+        });
+
+        const htmlPath = resolve(outputPath, 'sub/deep/entry.html');
+        const html = readFileSync(htmlPath, 'utf8');
+
+        // The link from other/page.md is [link to target](../target.md)
+        // It should resolve relative to other/page.md → target.md → target.html
+        // NOT relative to the entry file sub/deep/entry.md → sub/deep/target.html
+        expect(html).toContain('target.html');
+        expect(html).not.toContain('sub/deep/target.html');
+    });
+});

package/tests/e2e/neuro-expert.test.ts

@@ -0,0 +1,16 @@
+import {describe, it} from 'vitest';
+
+import {TestAdapter, compareDirectories, getTestPaths} from '../fixtures';
+
+describe('Neuro-expert', () => {
+    it('Neuro-expert', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/neuro-expert');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: false,
+            md2html: true,
+            args: '-j2',
+        });
+        await compareDirectories(outputPath);
+    });
+});