docusaurus-plugin-generate-schema-docs 1.2.0 → 1.3.0

package/__tests__/components/SchemaRows.test.js

@@ -4,77 +4,107 @@ import { render } from '@testing-library/react';
 import SchemaRows from '../../components/SchemaRows';
 
 // Mock child components
-jest.mock('../../components/PropertyRow', () => (props) => <tr><td>Mocked PropertyRow: {props.propertyKey}</td></tr>);
-jest.mock('../../components/TableHeader', () => () => <thead><tr><th>Mocked TableHeader</th></tr></thead>);
+jest.mock('../../components/PropertyRow', () => {
+  const MockPropertyRow = (props) => (
+    <tr>
+      <td>Mocked PropertyRow: {props.row.name}</td>
+    </tr>
+  );
+  MockPropertyRow.displayName = 'MockPropertyRow';
+  return MockPropertyRow;
+});
+
+jest.mock('../../components/FoldableRows', () => {
+  const MockFoldableRows = (props) => (
+    <tr>
+      <td>Mocked FoldableRows: {props.row.choiceType}</td>
+    </tr>
+  );
+  MockFoldableRows.displayName = 'MockFoldableRows';
+  return MockFoldableRows;
+});
 
 describe('SchemaRows', () => {
-    it('renders a PropertyRow for each property', () => {
-        const properties = {
-            name: { type: 'string' },
-            age: { type: 'integer' },
-        };
-        const { getByText } = render(
-            <table>
-                <tbody>
-                    <SchemaRows properties={properties} getConstraints={() => []} />
-                </tbody>
-            </table>
-        );
+  it('renders a PropertyRow for each property type item in tableData', () => {
+    const tableData = [
+      { type: 'property', name: 'name', path: ['name'] },
+      { type: 'property', name: 'age', path: ['age'] },
+    ];
+
+    const { getByText } = render(
+      <table>
+        <tbody>
+          <SchemaRows tableData={tableData} />
+        </tbody>
+      </table>,
+    );
+
+    expect(getByText('Mocked PropertyRow: name')).toBeInTheDocument();
+    expect(getByText('Mocked PropertyRow: age')).toBeInTheDocument();
+  });
+
+  it('renders nested properties from a flat list', () => {
+    const tableData = [
+      { type: 'property', name: 'user', path: ['user'], level: 0 },
+      { type: 'property', name: 'id', path: ['user', 'id'], level: 1 },
+    ];
+
+    const { getByText } = render(
+      <table>
+        <tbody>
+          <SchemaRows tableData={tableData} />
+        </tbody>
+      </table>,
+    );
+
+    // It should render both the parent and child property from the flat list
+    expect(getByText('Mocked PropertyRow: user')).toBeInTheDocument();
+    expect(getByText('Mocked PropertyRow: id')).toBeInTheDocument();
+  });
+
+  it('renders a FoldableRows for choice type items in tableData', () => {
+    const tableData = [
+      {
+        type: 'choice',
+        choiceType: 'oneOf',
+        path: ['choice'],
+        options: [],
+      },
+    ];
 
-        expect(getByText('Mocked PropertyRow: name')).toBeInTheDocument();
-        expect(getByText('Mocked PropertyRow: age')).toBeInTheDocument();
-    });
+    const { getByText } = render(
+      <table>
+        <tbody>
+          <SchemaRows tableData={tableData} />
+        </tbody>
+      </table>,
+    );
 
-    it('recursively renders for nested objects', () => {
-        const properties = {
-            user: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string' },
-                },
-            },
-        };
-        const { getByText } = render(
-            <table>
-                <tbody>
-                    <SchemaRows properties={properties} getConstraints={() => []} />
-                </tbody>
-            </table>
-        );
+    expect(getByText('Mocked FoldableRows: oneOf')).toBeInTheDocument();
+  });
 
-        expect(getByText('Mocked PropertyRow: user')).toBeInTheDocument();
-        expect(getByText('Mocked TableHeader')).toBeInTheDocument();
-        expect(getByText('user { }')).toBeInTheDocument();
-        // This will be inside the nested table
-        expect(getByText('Mocked PropertyRow: name')).toBeInTheDocument();
-    });
+  it('renders a mix of properties and choices', () => {
+    const tableData = [
+      { type: 'property', name: 'prop1', path: ['prop1'] },
+      {
+        type: 'choice',
+        choiceType: 'anyOf',
+        path: ['choice'],
+        options: [],
+      },
+      { type: 'property', name: 'prop2', path: ['prop2'] },
+    ];
 
-    it('recursively renders for nested arrays of objects', () => {
-        const properties = {
-            products: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string' },
-                        price: { type: 'number' },
-                    },
-                },
-            },
-        };
-        const { getByText } = render(
-            <table>
-                <tbody>
-                    <SchemaRows properties={properties} getConstraints={() => []} />
-                </tbody>
-            </table>
-        );
+    const { getByText } = render(
+      <table>
+        <tbody>
+          <SchemaRows tableData={tableData} />
+        </tbody>
+      </table>,
+    );
 
-        expect(getByText('Mocked PropertyRow: products')).toBeInTheDocument();
-        expect(getByText('Mocked TableHeader')).toBeInTheDocument();
-        expect(getByText('products [ ]')).toBeInTheDocument();
-        // These will be inside the nested table
-        expect(getByText('Mocked PropertyRow: name')).toBeInTheDocument();
-        expect(getByText('Mocked PropertyRow: price')).toBeInTheDocument();
-    });
+    expect(getByText('Mocked PropertyRow: prop1')).toBeInTheDocument();
+    expect(getByText('Mocked FoldableRows: anyOf')).toBeInTheDocument();
+    expect(getByText('Mocked PropertyRow: prop2')).toBeInTheDocument();
+  });
 });

package/__tests__/components/SchemaViewer.test.js

@@ -1,27 +1,44 @@
 import '@testing-library/jest-dom';
 import React from 'react';
-import { render } from '@testing-library/react';
+import { render, screen, within } from '@testing-library/react';
 import SchemaViewer from '../../components/SchemaViewer';
+import choiceEventSchema from '../__fixtures__/static/schemas/choice-event.json';
 
-// Mock child components
+// Mock the CodeBlock component as it's not relevant to this test
+jest.mock('@theme/CodeBlock', () => {
+  const MockCodeBlock = ({ children }) => <pre>{children}</pre>;
+  MockCodeBlock.displayName = 'MockCodeBlock';
+  return MockCodeBlock;
+});
 
-jest.mock('../../components/ExampleDataLayer', () => () => <div>Mocked ExampleDataLayer</div>);
-jest.mock('../../components/PropertiesTable', () => () => <div>Mocked PropertiesTable</div>);
+// Mock the Heading component
+jest.mock('@theme/Heading', () => {
+  const MockHeading = ({ as: Component, ...props }) => <Component {...props} />;
+  MockHeading.displayName = 'MockHeading';
+  return MockHeading;
+});
 
 describe('SchemaViewer', () => {
-    it('renders the schema viewer with all child components', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                name: { type: 'string' },
-            },
-        };
+  it('renders complex schema with payment_method and required indicators', () => {
+    render(<SchemaViewer schema={choiceEventSchema} />);
+
+    // Check that payment_method property name is rendered within the table
+    const table = screen.getByRole('table');
+    expect(within(table).getByText('payment_method')).toBeInTheDocument();
+
+    // Check that the "required" text is rendered for the user_id choice
+    const userIdChoiceHeader = screen.getByText(
+      (content, element) =>
+        element.tagName.toLowerCase() === 'h4' &&
+        content.includes('Select one of the following options:'),
+    );
+    expect(userIdChoiceHeader).toBeInTheDocument();
 
-        const { getByText } = render(<SchemaViewer schema={schema} />);
+    // The required text is rendered as a 'required' constraint code block.
+    // We expect it for 'event', 'user_id', and 'payment_method' at the top level.
+    const requiredConstraints = within(table).getAllByText('required');
 
-        expect(getByText('DataLayer Example')).toBeInTheDocument();
-        expect(getByText('Mocked ExampleDataLayer')).toBeInTheDocument();
-        expect(getByText('Event Properties')).toBeInTheDocument();
-        expect(getByText('Mocked PropertiesTable')).toBeInTheDocument();
-    });
+    // There should be at least 3 required constraints visible at the top level.
+    expect(requiredConstraints.length).toBeGreaterThanOrEqual(3);
+  });
 });

package/__tests__/components/TableHeader.test.js

@@ -4,17 +4,17 @@ import { render } from '@testing-library/react';
 import TableHeader from '../../components/TableHeader';
 
 describe('TableHeader', () => {
-    it('renders the table header with correct columns', () => {
-        const { getByText } = render(
-            <table>
-                <TableHeader />
-            </table>
-        );
+  it('renders the table header with correct columns', () => {
+    const { getByText } = render(
+      <table>
+        <TableHeader />
+      </table>,
+    );
 
-        expect(getByText('Property')).toBeInTheDocument();
-        expect(getByText('Type')).toBeInTheDocument();
-        expect(getByText('Constraints')).toBeInTheDocument();
-        expect(getByText('Examples')).toBeInTheDocument();
-        expect(getByText('Description')).toBeInTheDocument();
-    });
+    expect(getByText('Property')).toBeInTheDocument();
+    expect(getByText('Type')).toBeInTheDocument();
+    expect(getByText('Constraints')).toBeInTheDocument();
+    expect(getByText('Examples')).toBeInTheDocument();
+    expect(getByText('Description')).toBeInTheDocument();
+  });
 });

package/__tests__/generateEventDocs.nested.test.js

@@ -0,0 +1,80 @@
+/**
+ * @jest-environment node
+ */
+
+import generateEventDocs from '../generateEventDocs';
+import fs from 'fs';
+import path from 'path';
+
+jest.mock('fs', () => {
+  const memfs = require('memfs');
+  return memfs;
+});
+
+describe('generateEventDocs (nested oneOf)', () => {
+  const testSiteDir = path.resolve(__dirname, '__fixtures_nested__');
+  const options = {
+    organizationName: 'test-org',
+    projectName: 'test-project',
+    siteDir: testSiteDir,
+    url: 'https://tracking-docs-demo.buchert.digital',
+  };
+  const baseOutputDir = path.join(options.siteDir, 'docs');
+
+  beforeEach(() => {
+    fs.vol.reset();
+    const realFs = jest.requireActual('fs');
+    const nestedSchemasDir = path.resolve(
+      __dirname,
+      '__fixtures__/static/schemas/nested',
+    );
+    const targetSchemasDir = path.join(testSiteDir, 'static/schemas');
+    fs.vol.mkdirSync(targetSchemasDir, { recursive: true });
+
+    const files = realFs.readdirSync(nestedSchemasDir, { withFileTypes: true });
+    for (const file of files) {
+      const filePath = path.join(nestedSchemasDir, file.name);
+      const content = realFs.readFileSync(filePath);
+      fs.vol.writeFileSync(path.join(targetSchemasDir, file.name), content);
+    }
+  });
+
+  it('should generate nested documentation correctly', async () => {
+    console.log = jest.fn(); // suppress console.log
+
+    await generateEventDocs(options);
+
+    const parentDir = path.join(baseOutputDir, 'parent-event');
+    // The child directory is prefixed because it's an item in the parent's oneOf
+    const childDir = path.join(parentDir, '01-child-event');
+
+    // Check for directory structure
+    expect(fs.existsSync(parentDir)).toBe(true);
+    expect(fs.existsSync(childDir)).toBe(true);
+
+    const parentIndex = fs.readFileSync(
+      path.join(parentDir, 'index.mdx'),
+      'utf-8',
+    );
+    expect(parentIndex).toMatchSnapshot();
+
+    const childIndex = fs.readFileSync(
+      path.join(childDir, 'index.mdx'),
+      'utf-8',
+    );
+    expect(childIndex).toMatchSnapshot();
+
+    // Check content of generated files
+    const grandchildA = fs.readFileSync(
+      path.join(childDir, '01-grandchild-a.mdx'),
+      'utf-8',
+    );
+    expect(grandchildA).toMatchSnapshot();
+
+    const grandchildB = fs.readFileSync(
+      path.join(childDir, '02-grandchild-b.mdx'),
+      'utf-8',
+    );
+    expect(grandchildB).toMatchSnapshot();
+  });
+});

package/__tests__/generateEventDocs.test.js

@@ -7,78 +7,84 @@ import fs from 'fs';
 import path from 'path';
 
 jest.mock('fs', () => {
-    const originalFs = jest.requireActual('fs');
-    return {
-        ...originalFs,
-        writeFileSync: jest.fn(),
-        mkdirSync: jest.fn(),
-        existsSync: jest.fn(),
-        readdirSync: originalFs.readdirSync,
-        readFileSync: originalFs.readFileSync,
-    };
+  const memfs = require('memfs');
+  return memfs;
 });
 
-describe('generateEventDocs', () => {
-
-    const options = {
-        organizationName: 'test-org',
-        projectName: 'test-project',
-        // Use the fixtures directory as the siteDir for tests
-        siteDir: path.resolve(__dirname, '__fixtures__')
+describe('generateEventDocs (non-versioned)', () => {
+  const options = {
+    organizationName: 'test-org',
+    projectName: 'test-project',
+    // Use the fixtures directory as the siteDir for tests
+    siteDir: path.resolve(__dirname, '__fixtures__'),
+    url: 'https://tracking-docs-demo.buchert.digital',
+  };
+  const outputDir = path.join(options.siteDir, 'docs');
+
+  beforeEach(() => {
+    fs.vol.reset();
+    const realFs = jest.requireActual('fs');
+    const fixturesDir = path.resolve(__dirname, '__fixtures__');
+
+    function readDirRecursive(dir) {
+      const files = realFs.readdirSync(dir, { withFileTypes: true });
+      for (const file of files) {
+        const filePath = path.join(dir, file.name);
+        if (file.isDirectory()) {
+          fs.vol.mkdirSync(filePath, { recursive: true });
+          readDirRecursive(filePath);
+        } else {
+          const content = realFs.readFileSync(filePath);
+          fs.vol.writeFileSync(filePath, content);
+        }
+      }
     }
-    const outputDir = path.join(options.siteDir, 'docs/events');
-    const partialsDir = path.join(options.siteDir, 'docs/partials');
-
-
-    beforeEach(() => {
-        // Clear all instances and calls to constructor and all methods:
-        fs.writeFileSync.mockClear();
-        fs.mkdirSync.mockClear();
-        fs.existsSync.mockClear();
-    });
-
-    it('should generate documentation correctly when no partials exist', async () => {
-        console.log = jest.fn(); // suppress console.log
-
-        // Simulate that no partials exist
-        fs.existsSync.mockReturnValue(false);
-
-        await generateEventDocs(options);
-
-        // Expect writeFileSync to have been called once for each schema
-        expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
-
-        // Check the content of the generated file
-        const [filePath, content] = fs.writeFileSync.mock.calls[0];
-        expect(filePath).toBe(path.join(outputDir, 'add-to-cart-event.mdx'));
-        expect(content).toMatchSnapshot();
-    });
-
-    it('should generate documentation with top and bottom partials when they exist', async () => {
-        console.log = jest.fn(); // suppress console.log
-
-        // Simulate that the output directory and partials exist
-        fs.existsSync.mockImplementation((filePath) => {
-            if (filePath === outputDir) {
-                return true;
-            }
-            if (filePath === path.join(partialsDir, 'add-to-cart-event.mdx')) {
-                return true;
-            }
-            if (filePath === path.join(partialsDir, 'add-to-cart-event_bottom.mdx')) {
-                return true;
-            }
-            return false;
-        });
-
-        await generateEventDocs(options);
-
-        // Expect writeFileSync to have been called once for each schema
-        expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
-
-        // Check the content of the generated file
-        const [filePath, content] = fs.writeFileSync.mock.calls[0];
-        expect(filePath).toBe(path.join(outputDir, 'add-to-cart-event.mdx'));
-        expect(content).toMatchSnapshot();
-    });
+    readDirRecursive(fixturesDir);
+  });
+
+  it('should generate documentation correctly', async () => {
+    console.log = jest.fn(); // suppress console.log
+
+    await generateEventDocs(options);
+
+    const choiceEventDir = path.join(outputDir, 'root-choice-event');
+    expect(fs.existsSync(choiceEventDir)).toBe(true);
+
+    // Check content of generated files
+    const addToCart = fs.readFileSync(
+      path.join(outputDir, 'add-to-cart-event.mdx'),
+      'utf-8',
+    );
+    expect(addToCart).toMatchSnapshot();
+
+    const choiceEvent = fs.readFileSync(
+      path.join(outputDir, 'choice-event.mdx'),
+      'utf-8',
+    );
+    expect(choiceEvent).toMatchSnapshot();
+
+    const rootAnyOf = fs.readFileSync(
+      path.join(outputDir, 'root-any-of-event.mdx'),
+      'utf-8',
+    );
+    expect(rootAnyOf).toMatchSnapshot();
+
+    const rootChoiceIndex = fs.readFileSync(
+      path.join(choiceEventDir, 'index.mdx'),
+      'utf-8',
+    );
+    expect(rootChoiceIndex).toMatchSnapshot();
+
+    const rootChoiceA = fs.readFileSync(
+      path.join(choiceEventDir, '01-option-a.mdx'),
+      'utf-8',
+    );
+    expect(rootChoiceA).toMatchSnapshot();
+
+    const rootChoiceB = fs.readFileSync(
+      path.join(choiceEventDir, '02-option-b.mdx'),
+      'utf-8',
+    );
+    expect(rootChoiceB).toMatchSnapshot();
+  });
 });

package/__tests__/generateEventDocs.versioned.test.js

@@ -0,0 +1,69 @@
+/**
+ * @jest-environment node
+ */
+
+import generateEventDocs from '../generateEventDocs';
+import fs from 'fs';
+import path from 'path';
+
+jest.mock('fs', () => {
+  const originalFs = jest.requireActual('fs');
+  return {
+    ...originalFs,
+    writeFileSync: jest.fn(),
+    mkdirSync: jest.fn(),
+    existsSync: jest.fn(),
+    readdirSync: originalFs.readdirSync,
+    readFileSync: originalFs.readFileSync,
+  };
+});
+
+describe('generateEventDocs (versioned)', () => {
+  const options = {
+    organizationName: 'test-org',
+    projectName: 'test-project',
+    url: 'https://tracking-docs-demo.buchert.digital/',
+    // Use the fixtures_versioned directory as the siteDir for tests
+    siteDir: path.resolve(__dirname, '__fixtures_versioned__'),
+  };
+  const partialsDir = path.join(options.siteDir, 'docs/partials');
+
+  beforeEach(() => {
+    // Clear all instances and calls to constructor and all methods:
+    fs.writeFileSync.mockClear();
+    fs.mkdirSync.mockClear();
+    fs.existsSync.mockClear();
+  });
+
+  it('should generate documentation for "current" version', async () => {
+    // Mock fs.writeFileSync to capture the output
+    fs.writeFileSync = jest.fn();
+
+    const currentOptions = { ...options, version: 'current' };
+    await generateEventDocs(currentOptions);
+
+    expect(fs.writeFileSync).toHaveBeenCalled();
+    const [filePath, content] = fs.writeFileSync.mock.calls[0];
+    const outputDir = path.join(options.siteDir, 'docs');
+    expect(filePath).toBe(path.join(outputDir, 'add-to-cart-event.mdx'));
+    expect(content).toMatchSnapshot();
+  });
+
+  it('should generate documentation for a specific version', async () => {
+    // Mock fs.writeFileSync to capture the output
+    fs.writeFileSync = jest.fn();
+
+    const versionedOptions = { ...options, version: '1.1.1' };
+    await generateEventDocs(versionedOptions);
+
+    expect(fs.writeFileSync).toHaveBeenCalled();
+    const [filePath, content] = fs.writeFileSync.mock.calls[0];
+    const outputDir = path.join(
+      options.siteDir,
+      'versioned_docs',
+      'version-1.1.1',
+    );
+    expect(filePath).toBe(path.join(outputDir, 'add-to-cart-event.mdx'));
+    expect(content).toMatchSnapshot();
+  });
+});