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

package/__tests__/helpers/schema-processing.test.js

@@ -0,0 +1,82 @@
+import { processOneOfSchema } from '../../helpers/schema-processing';
+import path from 'path';
+
+describe('schema-processing', () => {
+  describe('processOneOfSchema', () => {
+    it('should merge oneOf options with the root schema', async () => {
+      const rootSchema = {
+        title: 'Root',
+        description: 'Root description',
+        oneOf: [
+          {
+            title: 'Option 1',
+            description: 'Description for Option 1',
+            properties: {
+              prop1: { type: 'string' },
+            },
+          },
+          {
+            title: 'Option 2',
+            properties: {
+              prop2: { type: 'number' },
+            },
+          },
+        ],
+        properties: {
+          commonProp: { type: 'boolean' },
+        },
+      };
+
+      const filePath = '/path/to/schema.json';
+      const result = await processOneOfSchema(rootSchema, filePath);
+
+      expect(result).toHaveLength(2);
+
+      // Check the first merged schema
+      expect(result[0].schema.title).toBe('Option 1');
+      expect(result[0].schema.description).toBe('Description for Option 1');
+      expect(result[0].schema.properties.commonProp).toEqual({
+        type: 'boolean',
+      });
+      expect(result[0].schema.properties.prop1).toEqual({ type: 'string' });
+      expect(result[0].schema.oneOf).toBeUndefined();
+
+      // Check the second merged schema
+      expect(result[1].schema.title).toBe('Option 2');
+      expect(result[1].schema.description).toBe('Root description'); // Fallback
+      expect(result[1].schema.properties.prop2).toEqual({ type: 'number' });
+      expect(result[1].slug).toBe('option-2');
+    });
+
+    it('should use option $id when available', async () => {
+      const rootSchema = {
+        $id: 'root.json',
+        title: 'Root',
+        oneOf: [
+          {
+            $id: 'option1.json',
+            title: 'Option 1',
+          },
+        ],
+      };
+      const filePath = '/path/to/schema.json';
+      const result = await processOneOfSchema(rootSchema, filePath);
+      expect(result[0].schema.$id).toBe('option1.json');
+    });
+
+    it('should generate a new $id when option $id is not available', async () => {
+      const rootSchema = {
+        $id: 'root.json',
+        title: 'Root',
+        oneOf: [
+          {
+            title: 'Option 1',
+          },
+        ],
+      };
+      const filePath = '/path/to/schema.json';
+      const result = await processOneOfSchema(rootSchema, filePath);
+      expect(result[0].schema.$id).toBe('root.json#option-1');
+    });
+  });
+});

package/__tests__/helpers/schemaToExamples.test.js

@@ -0,0 +1,56 @@
+import { schemaToExamples } from '../../helpers/schemaToExamples';
+import choiceEventSchema from '../__fixtures__/static/schemas/choice-event.json';
+
+describe('schemaToExamples', () => {
+  it('should generate examples for all options in a complex schema', () => {
+    const exampleGroups = schemaToExamples(choiceEventSchema);
+
+    // Should find two choice points: user_id and payment_method
+    expect(exampleGroups).toHaveLength(2);
+
+    // Find the user_id group
+    const userIdGroup = exampleGroups.find(
+      (group) => group.property === 'user_id',
+    );
+    expect(userIdGroup).toBeDefined();
+    expect(userIdGroup.options).toHaveLength(2); // String and Integer
+
+    // Find the payment_method group
+    const paymentMethodGroup = exampleGroups.find(
+      (group) => group.property === 'payment_method',
+    );
+    expect(paymentMethodGroup).toBeDefined();
+    expect(paymentMethodGroup.options).toHaveLength(2); // Credit Card and PayPal
+
+    // Check the Credit Card example
+    const creditCardOption = paymentMethodGroup.options.find(
+      (opt) => opt.title === 'Credit Card',
+    );
+    expect(creditCardOption).toBeDefined();
+    expect(creditCardOption.example).toHaveProperty('payment_method');
+    expect(creditCardOption.example.payment_method).toHaveProperty(
+      'card_number',
+    );
+
+    // Check the PayPal example
+    const payPalOption = paymentMethodGroup.options.find(
+      (opt) => opt.title === 'PayPal',
+    );
+    expect(payPalOption).toBeDefined();
+    expect(payPalOption.example).toHaveProperty('payment_method');
+    expect(payPalOption.example.payment_method).toHaveProperty('email');
+
+    // Check the user_id examples
+    const userIdStringOption = userIdGroup.options.find(
+      (opt) => opt.title === 'User ID as String',
+    );
+    expect(userIdStringOption).toBeDefined();
+    expect(userIdStringOption.example).toHaveProperty('payment_method');
+
+    const userIdIntegerOption = userIdGroup.options.find(
+      (opt) => opt.title === 'User ID as Integer',
+    );
+    expect(userIdIntegerOption).toBeDefined();
+    expect(userIdIntegerOption.example).toHaveProperty('payment_method');
+  });
+});

package/__tests__/helpers/schemaToTableData.filtering.test.js

@@ -0,0 +1,65 @@
+import { schemaToTableData } from '../../helpers/schemaToTableData';
+
+describe('schemaToTableData filtering', () => {
+  it('filters out a property with x-gtm-clear that is effectively empty', () => {
+    const schema = {
+      properties: {
+        empty_object: {
+          'x-gtm-clear': true,
+          type: 'object',
+          properties: {},
+        },
+        should_appear: {
+          type: 'string',
+        },
+      },
+    };
+
+    const tableData = schemaToTableData(schema);
+
+    expect(tableData).toHaveLength(1);
+    expect(tableData[0].name).toBe('should_appear');
+  });
+
+  it('does NOT filter a property with x-gtm-clear if it contains data', () => {
+    const schema = {
+      properties: {
+        non_empty_object: {
+          'x-gtm-clear': true,
+          type: 'object',
+          properties: {
+            child_prop: {
+              type: 'string', // This is "data"
+            },
+          },
+        },
+      },
+    };
+
+    const tableData = schemaToTableData(schema);
+
+    // Both the parent and child should appear
+    expect(tableData).toHaveLength(2);
+    expect(tableData[0].name).toBe('non_empty_object');
+    expect(tableData[1].name).toBe('child_prop');
+  });
+
+  it('does NOT filter a property if x-gtm-clear is not exactly true', () => {
+    const schema = {
+      properties: {
+        empty_object_false: {
+          'x-gtm-clear': false,
+          type: 'object',
+          properties: {},
+        },
+        empty_object_missing: {
+          type: 'object',
+          properties: {},
+        },
+      },
+    };
+
+    const tableData = schemaToTableData(schema);
+    expect(tableData).toHaveLength(2);
+  });
+});