@diplodoc/cli 5.46.1 → 5.47.0

package/tests/e2e/themer.test.ts

@@ -0,0 +1,307 @@
+import {describe, expect, it} from 'vitest';
+import {existsSync} from 'node:fs';
+import {readFile} from 'node:fs/promises';
+import {join} from 'node:path';
+
+import {TestAdapter, getTestPaths} from '../fixtures';
+
+describe('Build themer feature', () => {
+    it.each([
+        ['md2md', true, false],
+        ['md2html', false, true],
+    ])('generates theme.css from theme.yaml (%s)', async (_, md2md, md2html) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test1');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md,
+            md2html,
+        });
+
+        const cssPath = join(outputPath, '_assets', 'style', 'theme.css');
+        const css = await readFile(cssPath, 'utf8');
+
+        expect(css).toContain('--g-color-base-brand: var(--g-color-private-base-brand-550-solid);');
+        expect(css).toContain('--g-color-private-base-brand-550-solid: rgb(255 0 0);');
+        expect(css).toContain('--g-color-private-base-brand-600-solid: rgb(255 25 25);');
+        expect(css).toContain('--yfm-color-link: green;');
+        expect(css).toContain('--yfm-color-link: blue;');
+        expect(css).toContain('--g-color-base-selection: rgb(255 0 255);');
+        expect(css).toContain('--g-color-base-background: hsl(60 100% 50%);');
+        expect(css).toContain('--g-color-base-background: rgba(255, 165, 0, 1);');
+        expect(css).toContain('--g-color-base-selection: hsla(0 0% 50% / 1);');
+        expect(css).toContain('--yfm-color-note-info-background: red;');
+    });
+
+    it.each([
+        ['md2md', true, false],
+        ['md2html', false, true],
+    ])('generates theme.css with theme.yaml and flag value (%s)', async (_, md2md, md2html) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test1');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md,
+            md2html,
+            args: '--theme pink',
+        });
+
+        const cssPath = join(outputPath, '_assets', 'style', 'theme.css');
+        const css = await readFile(cssPath, 'utf8');
+
+        expect(css).toContain('--g-color-base-brand: var(--g-color-private-base-brand-550-solid);');
+        expect(css).toContain('--g-color-private-base-brand-550-solid: rgb(255 192 203);');
+        expect(css).toContain('--g-color-private-base-brand-600-solid: rgb(234 177 188);');
+        expect(css).toContain('--yfm-color-link: green;');
+        expect(css).toContain('--yfm-color-link: blue;');
+        expect(css).toContain('--g-color-base-selection: rgb(255 0 255);');
+        expect(css).toContain('--g-color-base-background: hsl(60 100% 50%);');
+        expect(css).toContain('--g-color-base-background: rgba(255, 165, 0, 1);');
+        expect(css).toContain('--g-color-base-selection: hsla(0 0% 50% / 1);');
+        expect(css).toContain('--yfm-color-note-info-background: red;');
+    });
+
+    it.each([
+        ['md2md', true, false],
+        ['md2html', false, true],
+    ])('generates theme.css from flag value only (%s)', async (_, md2md, md2html) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test3');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md,
+            md2html,
+            args: '--theme pink',
+        });
+
+        const cssPath = join(outputPath, '_assets', 'style', 'theme.css');
+        const css = await readFile(cssPath, 'utf8');
+
+        expect(existsSync(join(inputPath, 'theme.yaml'))).toBe(false);
+        expect(css).toContain('--g-color-base-brand: var(--g-color-private-base-brand-550-solid);');
+        expect(css).toContain('--g-color-private-base-brand-550-solid: rgb(255 192 203);');
+        expect(css).toContain('--g-color-private-base-brand-600-solid: rgb(234 177 188);');
+    });
+
+    it('custom styles override theme colors', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test1');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: false,
+            md2html: true,
+            args: '--allow-custom-resources true',
+        });
+
+        const htmlPath = join(outputPath, 'index.html');
+        const html = await readFile(htmlPath, 'utf8');
+
+        const themeIndex = html.indexOf('_assets/style/theme.css');
+        const customIndex = html.indexOf('_assets/style/custom.css');
+        expect(customIndex).toBeGreaterThan(themeIndex);
+    });
+
+    it('does not generates theme.css if not theme.yaml and flag', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test3');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: false,
+            md2html: true,
+        });
+
+        const htmlPath = join(outputPath, 'index.html');
+        const html = await readFile(htmlPath, 'utf8');
+
+        const themeIndex = html.indexOf('_assets/style/theme.css');
+        expect(themeIndex).toBe(-1);
+
+        const themePath = join(outputPath, '_assets', 'style', 'theme.css');
+        expect(existsSync(themePath)).toBe(false);
+    });
+
+    it.each([
+        ['md2md', 'md'],
+        ['md2html', 'html'],
+    ])('includes errors for invalid colors from theme.yaml and flag (%s)', async (_, format) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test2');
+
+        const report = await TestAdapter.build.run(inputPath, outputPath, [
+            '-f',
+            format,
+            '--theme',
+            'pinkk',
+        ]);
+
+        expect(report.code).toBe(1);
+        expect(report.errors.includes('ERR Invalid color: "pinkk"')).toBe(true);
+        expect(report.errors.includes('ERR Invalid color: "redd"')).toBe(true);
+        expect(report.errors.includes('ERR /dark/link must be string')).toBe(true);
+        expect(report.errors.includes('ERR Invalid color: "5"')).toBe(true);
+        expect(report.errors.includes('ERR Invalid color: ""')).toBe(true);
+        expect(report.errors.includes('ERR Invalid color: " "')).toBe(true);
+    });
+
+    it.each([
+        ['md2md', 'md'],
+        ['md2html', 'html'],
+    ])('warns about unknown color keys in theme.yaml (%s)', async (_, format) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test1');
+
+        const report = await TestAdapter.build.run(inputPath, outputPath, ['-f', format]);
+
+        expect(report.code).toBe(0);
+        expect(
+            report.warns.includes(
+                'WARN File theme.yaml must NOT have additional properties "base-brandd"',
+            ),
+        ).toBe(true);
+        expect(
+            report.warns.includes('WARN /dark must NOT have additional properties "unknown-color"'),
+        ).toBe(true);
+    });
+
+    it.each([
+        ['md2md', 'md'],
+        ['md2html', 'html'],
+    ])('includes errors for invalid syntax in theme.yaml (%s)', async (_, format) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test4');
+
+        const report = await TestAdapter.build.run(inputPath, outputPath, ['-f', format]);
+
+        expect(report.code).toBe(1);
+        expect(
+            report.errors.includes(
+                'ERR Failed to generate theme: YAMLException: bad indentation of a mapping entry (3:5)',
+            ),
+        ).toBe(true);
+    });
+
+    it.each([
+        ['md2md', true, false],
+        ['md2html', false, true],
+    ])('generates theme.css from .yfm (%s)', async (_, md2md, md2html) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test5');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md,
+            md2html,
+        });
+
+        const cssPath = join(outputPath, '_assets', 'style', 'theme.css');
+        const css = await readFile(cssPath, 'utf8');
+
+        expect(css).toContain('--g-color-base-brand: var(--g-color-private-base-brand-550-solid);');
+        expect(css).toContain('--g-color-private-base-brand-550-solid: rgb(255 0 0);');
+        expect(css).toContain('--g-color-private-base-brand-600-solid: rgb(234 4 5);');
+    });
+
+    it.each([
+        ['md2md', true, false],
+        ['md2html', false, true],
+    ])('generates theme.css from codeHighlight only (%s)', async (_, md2md, md2html) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test6');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md,
+            md2html,
+        });
+
+        const cssPath = join(outputPath, '_assets', 'style', 'theme.css');
+        const css = await readFile(cssPath, 'utf8');
+
+        expect(existsSync(join(inputPath, 'theme.yaml'))).toBe(false);
+        expect(css).toContain('.g-root_theme_light .dc-doc-page .yfm .hljs');
+        expect(css).toContain('.g-root_theme_dark .dc-doc-page .yfm .hljs');
+        expect(css).toContain('.g-root_theme_light .dc-doc-page .yfm .hljs-keyword');
+        expect(css).toContain('.g-root_theme_dark .dc-doc-page .yfm .hljs-keyword');
+    });
+
+    it.each([
+        ['md2md', true, false],
+        ['md2html', false, true],
+    ])(
+        'generates theme.css from codeHighlight with theme.yaml overrides (%s)',
+        async (_, md2md, md2html) => {
+            const {inputPath, outputPath} = getTestPaths('mocks/themer/test7');
+
+            await TestAdapter.testBuildPass(inputPath, outputPath, {
+                md2md,
+                md2html,
+            });
+
+            const cssPath = join(outputPath, '_assets', 'style', 'theme.css');
+            const css = await readFile(cssPath, 'utf8');
+
+            expect(css).toContain('.g-root_theme_light .dc-doc-page .yfm .hljs');
+            expect(css).toContain('.g-root_theme_dark .dc-doc-page .yfm .hljs');
+
+            expect(css).toContain('--yfm-color-code: #111111;');
+            expect(css).toContain('--yfm-color-code-background: #ffeeaa;');
+            expect(css).toContain('--yfm-color-code: #eeeeee;');
+            expect(css).toContain('--yfm-color-code-background: #221144;');
+
+            expect(css).toContain('color: var(--yfm-color-code);');
+            expect(css).toContain('background: var(--yfm-color-code-background);');
+        },
+    );
+
+    it.each([
+        ['md2md', 'md'],
+        ['md2html', 'html'],
+    ])('includes error for unknown code highlight theme (%s)', async (_, format) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test8');
+
+        const report = await TestAdapter.build.run(inputPath, outputPath, ['-f', format]);
+
+        expect(report.code).toBe(1);
+        expect(
+            report.errors.includes(
+                'ERR Failed to generate theme: Error: Unknown highlight.js theme: "unknown-highlight-theme"',
+            ),
+        ).toBe(true);
+    });
+
+    it.each([
+        ['md2md', true, false],
+        ['md2html', false, true],
+    ])('flag overrides theme from .yfm (%s)', async (_, md2md, md2html) => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test5');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md,
+            md2html,
+            args: '--theme pink',
+        });
+
+        const cssPath = join(outputPath, '_assets', 'style', 'theme.css');
+        const css = await readFile(cssPath, 'utf8');
+
+        expect(css).toContain('--g-color-base-brand: var(--g-color-private-base-brand-550-solid);');
+        expect(css).toContain('--g-color-private-base-brand-550-solid: rgb(255 192 203);');
+        expect(css).toContain('--g-color-private-base-brand-600-solid: rgb(234 177 188);');
+    });
+
+    it('add theme to front matter', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test5');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+        });
+
+        const mdPath = join(outputPath, 'index.md');
+        const md = await readFile(mdPath, 'utf8');
+
+        expect(md).toMatch(/theme:\s*_assets[/\\]style[/\\]theme\.css/);
+    });
+
+    it('does not add theme to front matter when theme.css is not generated', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/themer/test3');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+        });
+
+        const mdPath = join(outputPath, 'index.md');
+        const md = await readFile(mdPath, 'utf8');
+
+        expect(md).not.toMatch(/theme:\s*_assets[/\\]style[/\\]theme\.css/);
+    });
+});

package/tests/e2e/toc-label.test.ts

@@ -0,0 +1,23 @@
+import {describe, it} from 'vitest';
+
+import {TestAdapter, compareDirectories, getTestPaths} from '../fixtures';
+
+describe('Toc label', () => {
+    it('should pass TocLabel object through to toc output', async () => {
+        const {inputPath, outputPath} = getTestPaths('mocks/toc-label');
+
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2md: true,
+            md2html: false,
+            args: '-j2',
+        });
+        await TestAdapter.testBuildPass(outputPath, outputPath + '-html', {
+            md2md: false,
+            md2html: true,
+            args: '-j2',
+        });
+
+        await compareDirectories(outputPath);
+        await compareDirectories(outputPath + '-html');
+    });
+});

package/tests/e2e/translation.spec.ts

@@ -0,0 +1,221 @@
+import type {TranslateRunArgs} from '../fixtures';
+
+import {describe, test} from 'vitest';
+
+import {TestAdapter, compareDirectories, getTestPaths} from '../fixtures';
+
+const generateMapTestTemplate = (
+    testTitle: string,
+    testRootPath: string,
+    args: TranslateRunArgs,
+    ignoreFileContent = true,
+    // TODO: added especialy for 'extract openapi spec files with custom openapi schema provided' test, arc test issue
+    ignoreFileList = false,
+) => {
+    test(testTitle, async () => {
+        const {inputPath, outputPath} = getTestPaths(testRootPath);
+
+        await TestAdapter.testTranslatePass(inputPath, outputPath, args);
+
+        await compareDirectories(outputPath, ignoreFileContent, false, ignoreFileList);
+    });
+};
+
+const generateFilesYamlTestTemplate = (
+    testTitle: string,
+    testRootPath: string,
+    args: TranslateRunArgs,
+) => {
+    test(testTitle, async () => {
+        const {inputPath, outputPath} = getTestPaths(testRootPath);
+
+        await TestAdapter.testTranslatePass(inputPath, outputPath, args);
+
+        await compareDirectories(outputPath);
+    });
+};
+
+const buildFilesYamlTestTemplate = (
+    testTitle: string,
+    testRootPath: string,
+    buildProps: {md2md?: boolean; md2html?: boolean},
+) => {
+    test(testTitle, async () => {
+        const {inputPath, outputPath} = getTestPaths(testRootPath);
+        const {md2md, md2html} = buildProps;
+
+        // Disable OpenAPI spec companions: the mock ships an openapi spec, and emitting the
+        // `*.openapi.json` companion would change these translation snapshots.
+        await TestAdapter.testBuildPass(inputPath, outputPath, {
+            md2html,
+            md2md,
+            args: '--no-ai-openapi-companions',
+        });
+
+        await compareDirectories(outputPath);
+    });
+};
+
+describe('Translate command', () => {
+    buildFilesYamlTestTemplate(
+        'build translated md files and remove no-translate directives',
+        'mocks/translation/no-translate',
+        {md2md: true},
+    );
+
+    buildFilesYamlTestTemplate(
+        'build translated static files and remove no-translate directives',
+        'mocks/translation/no-translate',
+        {md2html: true},
+    );
+
+    generateFilesYamlTestTemplate('extract openapi spec files', 'mocks/translation/openapi', {
+        subcommand: 'extract',
+        source: 'ru-RU',
+        target: 'es-ES',
+    });
+
+    generateFilesYamlTestTemplate(
+        'extract openapi spec files with --no-ref-resolve option',
+        'mocks/translation/openapi',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+            additionalArgs: '--no-ref-resolve',
+        },
+    );
+
+    generateMapTestTemplate(
+        'extract openapi spec files with custom openapi schema provided',
+        'mocks/translation/openapi',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+            additionalArgs:
+                '--schema mocks/translation/custom-schema/custom-openapi-schema-30.yaml',
+        },
+        false,
+        true,
+    );
+
+    generateFilesYamlTestTemplate('compose openapi spec files', 'mocks/translation/compose', {
+        subcommand: 'compose',
+        source: 'ru-RU',
+        target: 'es-ES',
+    });
+
+    generateMapTestTemplate(
+        'do not translate merged entries with included toc',
+        'mocks/translation/toc-include',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+        },
+    );
+
+    generateMapTestTemplate('do not filter files on extract', 'mocks/translation/dir-files', {
+        subcommand: 'extract',
+        source: 'ru-RU',
+        target: 'es-ES',
+    });
+
+    generateMapTestTemplate('filter files on extract', 'mocks/translation/dir-files', {
+        subcommand: 'extract',
+        source: 'ru-RU',
+        target: 'es-ES',
+        additionalArgs: '--filter',
+    });
+
+    generateMapTestTemplate(
+        'filter files on extract with extra exclude option',
+        'mocks/translation/dir-files',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+            additionalArgs: '--exclude ru/to-be-excluded.md --filter',
+        },
+    );
+
+    const vars = {skip: 'prod'};
+    generateMapTestTemplate(
+        'filter files on extract with extra vars option',
+        'mocks/translation/dir-files',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+            additionalArgs: `--vars ${JSON.stringify(vars)} --filter`,
+        },
+    );
+
+    const conditions = {tld: 'ru'};
+    generateMapTestTemplate(
+        'resolve liquid conditions if vars specified, liquid syntax will be deleted',
+        'mocks/translation/conditions',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+            additionalArgs: `--vars ${JSON.stringify(conditions)}`,
+        },
+        false,
+    );
+
+    generateMapTestTemplate(
+        'do not resolve liquid conditions if vars not specified and send content as is for extract',
+        'mocks/translation/conditions',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+        },
+        false,
+    );
+
+    generateMapTestTemplate(
+        'test no-translate directive',
+        'mocks/translation/no-translate',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+        },
+        false,
+    );
+
+    generateFilesYamlTestTemplate('extract yaml scheme files', 'mocks/translation/yaml-scheme', {
+        subcommand: 'extract',
+        source: 'ru-RU',
+        target: 'en-US',
+    });
+
+    let conditionVars = {prod: true, inner: true, list: ['item']};
+    generateMapTestTemplate(
+        'save truthy liquid conditions structures',
+        'mocks/translation/conditions',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+            additionalArgs: `--vars ${JSON.stringify(conditionVars)}`,
+        },
+        false,
+    );
+
+    conditionVars = {prod: false, inner: false, list: ['item']};
+    generateMapTestTemplate(
+        'remove falsy liquid conditions structures',
+        'mocks/translation/conditions',
+        {
+            subcommand: 'extract',
+            source: 'ru-RU',
+            target: 'es-ES',
+            additionalArgs: `--vars ${JSON.stringify(conditionVars)}`,
+        },
+        false,
+    );
+});

package/tests/e2e/vars-conditions.spec.ts

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