docusaurus-plugin-generate-schema-docs 1.8.4 → 1.8.5

package/__tests__/helpers/processSchema.test.js

@@ -1,11 +1,28 @@
 /**
- * @jest-environment node
+ * @jest-environment @stryker-mutator/jest-runner/jest-env/node
  */
 
 import path from 'path';
 import processSchema from '../../helpers/processSchema';
+import { resolveConstraintSchemaPath } from '../../helpers/constraintSchemaPaths';
+
+jest.mock('../../helpers/constraintSchemaPaths', () => {
+  const actual = jest.requireActual('../../helpers/constraintSchemaPaths');
+  return {
+    ...actual,
+    resolveConstraintSchemaPath: jest.fn(actual.resolveConstraintSchemaPath),
+  };
+});
 
 describe('processSchema', () => {
+  afterEach(() => {
+    resolveConstraintSchemaPath.mockReset();
+    // Restore to original implementation after each test
+    const actual = jest.requireActual('../../helpers/constraintSchemaPaths');
+    resolveConstraintSchemaPath.mockImplementation(
+      actual.resolveConstraintSchemaPath,
+    );
+  });
   it('should bundle refs and return a merged schema', async () => {
     const filePath = path.join(
       __dirname,
@@ -100,4 +117,277 @@ describe('processSchema', () => {
       }),
     );
   });
+
+  // L20: unwrapRedundantNotAnyOf — not: { anyOf: [single] } is unwrapped to the single item
+  it('unwraps not: { anyOf: [singleItem] } to the single item', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-anyof.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // not: { anyOf: [{ const: 'US' }] } should become not: { const: 'US' }
+    expect(mergedSchema.properties.country.not).toEqual({ const: 'US' });
+    // The anyOf wrapper should be gone
+    expect(mergedSchema.properties.country.not.anyOf).toBeUndefined();
+  });
+
+  // L22-28: chained anyOf unwrapping (double-wrapped)
+  it('unwraps doubly-nested not: { anyOf: [{ anyOf: [item] }] } recursively', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-anyof.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // nested.code has not: { anyOf: [{ anyOf: [{ const: 'XX' }] }] }
+    // After two passes of unwrapping it should become not: { const: 'XX' }
+    expect(mergedSchema.properties.nested.properties.code.not).toEqual({
+      const: 'XX',
+    });
+  });
+
+  // L11-12: arrays are traversed recursively
+  it('unwraps not inside array items', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-anyof.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // items array contains an object with not: { anyOf: [{ const: 'forbidden' }] }
+    // After unwrapping it should be not: { const: 'forbidden' }
+    const firstItem = mergedSchema.properties.items.items[0];
+    expect(firstItem.not).toEqual({ const: 'forbidden' });
+  });
+
+  // L20: not value is not an object — should be returned as-is (no crash)
+  it('handles not: true (non-object) without unwrapping', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-non-object.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // not: true should be kept as-is (it is not an object, so no unwrapping)
+    expect(mergedSchema.properties.flag.not).toBe(true);
+  });
+
+  // L20: not value is an object but has no anyOf — not unwrapped
+  it('leaves not: { const: X } alone when there is no anyOf wrapper', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-non-object.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    expect(mergedSchema.properties.name.not).toEqual({ const: 'forbidden' });
+  });
+
+  // L54-55: the read resolver's null-check guard.
+  // This branch is a defensive check: if canRead returns true (because
+  // resolveConstraintSchemaPath returned a path), but then read calls
+  // resolveConstraintSchemaPath again and it returns null, an error is thrown.
+  // Since $RefParser catches read errors and falls back to other resolvers,
+  // this branch cannot be exercised through the public processSchema API.
+  // We verify the guard's correctness by testing that:
+  // 1. canRead correctly identifies constraint URIs
+  // 2. read correctly resolves and reads constraint files
+  // Both are already covered by the constraint resolver tests above.
+  // The null guard on L54-55 exists for safety if the resolver state changes
+  // between canRead and read calls (e.g., file deletion race condition).
+
+  // L46-49: options object — mutateInputSchema: false preserves original schema
+  it('does not mutate the original bundled schema (mutateInputSchema: false)', async () => {
+    // If mutateInputSchema were true, the original file's schema could be modified.
+    // We verify the result is correct, which only works if bundling is non-destructive.
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'main-schema-with-ref.json',
+    );
+    const result1 = await processSchema(filePath);
+    const result2 = await processSchema(filePath);
+
+    // Running processSchema twice on the same file should yield the same results,
+    // which would fail if the input schema was mutated on the first call.
+    expect(result1.title).toBe(result2.title);
+    expect(result1.properties.component.type).toBe(
+      result2.properties.component.type,
+    );
+  });
+
+  // L51-59: canRead / read resolver — constraint refs are handled
+  it('resolves constraint schema refs via the custom resolver', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'main-schema-with-constraints-ref.json',
+    );
+    // If the resolver is broken, this will throw. It passing means read() ran successfully.
+    const mergedSchema = await processSchema(filePath);
+    expect(mergedSchema).toBeDefined();
+    expect(mergedSchema.title).toBe('Main Schema with Constraints Ref');
+  });
+
+  // L27: anyOf with length > 1 stops the while loop early
+  it('does not unwrap not: { anyOf: [a, b] } when anyOf has multiple items', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-anyof-multi.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // not: { anyOf: [{ const: 'US' }, { const: 'CA' }] } should NOT be unwrapped
+    expect(mergedSchema.properties.country.not).toEqual({
+      anyOf: [{ const: 'US' }, { const: 'CA' }],
+    });
+  });
+
+  // Kills mutant 685: && → || on line 20 (normalized.not && typeof ... === 'object')
+  // When not is false (falsy non-object), the && guard must prevent entering the block.
+  // With ||, the code would try to access .anyOf on false and corrupt the value.
+  it('preserves not: false without entering the unwrap block', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-edge-cases.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    expect(mergedSchema.properties.falsy_not.not).toBe(false);
+  });
+
+  // Kills mutant 686: typeof normalized.not === 'object' → true on line 20
+  // The not: true test already exists but we need a strict assertion that the value
+  // is exactly true (not transformed into something else by entering the block)
+  it('does not enter unwrap block when not is a non-object truthy value', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-non-object.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // Strict check: not must remain boolean true, not be replaced by undefined or an object
+    expect(mergedSchema.properties.flag.not).toBe(true);
+    expect(typeof mergedSchema.properties.flag.not).toBe('boolean');
+  });
+
+  // Kills mutants 694-698: while loop condition mutations on lines 23-25
+  // When not is an array, !Array.isArray(candidate) should prevent entering the loop.
+  it('does not unwrap when not value is an array', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-edge-cases.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // not: [{ const: 'A' }, { const: 'B' }] should be kept as-is (array, not unwrapped)
+    expect(Array.isArray(mergedSchema.properties.not_is_array.not)).toBe(true);
+    expect(mergedSchema.properties.not_is_array.not).toEqual([
+      { const: 'A' },
+      { const: 'B' },
+    ]);
+  });
+
+  // Kills mutants on while loop: candidate being null after first unwrap iteration
+  // not: { anyOf: [null] } — the single anyOf element is null, so after unwrapping
+  // the while loop must stop because candidate is null (falsy)
+  it('stops unwrapping when anyOf single element is null', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-edge-cases.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // not: { anyOf: [null] } should unwrap to not: null
+    expect(mergedSchema.properties.not_with_null_candidate.not).toBeNull();
+  });
+
+  // Kills mutant on while loop: anyOf contains an array element
+  // not: { anyOf: [[1, 2, 3]] } — the single anyOf element is an array,
+  // so on the next iteration !Array.isArray(candidate) stops the loop
+  it('stops unwrapping when anyOf single element is itself an array', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-with-not-edge-cases.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // not: { anyOf: [[1, 2, 3]] } should unwrap to not: [1, 2, 3]
+    expect(mergedSchema.properties.not_anyof_contains_array.not).toEqual([
+      1, 2, 3,
+    ]);
+  });
+
+  // Kills mutants 706-710, 712-714, 717: options/resolve block mutations
+  // The constraint resolver must actually resolve the ref and produce correct content.
+  // If the options object is {}, resolve is {}, canRead returns undefined, read fails,
+  // or encoding is wrong, the schema won't have the expected constraint properties.
+  it('constraint resolver produces correct schema content with proper encoding', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'main-schema-with-constraints-ref.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    // Verify the constraint schema was resolved, read with utf8, and merged correctly
+    // These specific values come from the flat-event-params.json constraint schema
+    expect(mergedSchema.additionalProperties.type).toEqual([
+      'string',
+      'number',
+      'integer',
+      'boolean',
+      'null',
+    ]);
+    expect(mergedSchema.properties.items.type).toBe('array');
+    expect(mergedSchema.properties.items.items.type).toBe('object');
+    expect(
+      mergedSchema.properties.items.items.additionalProperties.type,
+    ).toEqual(['string', 'number', 'integer', 'boolean', 'null']);
+    // Verify event property is merged from both constraint and original schema
+    expect(mergedSchema.properties.event.type).toBe('string');
+    expect(mergedSchema.properties.event.const).toBe('screen_view');
+    // Verify screen_name from original schema is preserved
+    expect(mergedSchema.properties.screen_name.type).toBe('string');
+  });
 });

package/__tests__/helpers/schema-doc-template.test.js

@@ -0,0 +1,54 @@
+import MdxTemplate from '../../helpers/schema-doc-template';
+
+describe('MdxTemplate', () => {
+  const baseData = {
+    schema: {
+      title: 'Test Event',
+      description: 'A test event schema.',
+    },
+    mergedSchema: { title: 'Test Event', properties: {} },
+    editUrl: 'https://github.com/org/repo/edit/main/schema.json',
+    file: 'schema.json',
+    topPartialImport: '',
+    bottomPartialImport: '',
+    topPartialComponent: '',
+    bottomPartialComponent: '',
+    dataLayerName: null,
+    sourcePath: 'schemas/test.json',
+    schemaSources: null,
+  };
+
+  it('renders template without dataLayerName attribute when dataLayerName is falsy', () => {
+    const result = MdxTemplate(baseData);
+    expect(result).toContain('# Test Event');
+    expect(result).not.toContain("dataLayerName={'");
+  });
+
+  it('renders template with dataLayerName attribute when dataLayerName is provided', () => {
+    const result = MdxTemplate({ ...baseData, dataLayerName: 'dataLayer' });
+    expect(result).toContain("dataLayerName={'dataLayer'}");
+  });
+
+  it('uses schema as sourceSchema when schemaSources does not contain sourcePath', () => {
+    const result = MdxTemplate({
+      ...baseData,
+      schemaSources: { 'other/path.json': { title: 'Other' } },
+    });
+    // sourceSchema falls back to schema since sourcePath is not in schemaSources
+    expect(result).toContain(JSON.stringify(baseData.schema));
+  });
+
+  it('uses schemaSources entry as sourceSchema when sourcePath matches', () => {
+    const sourceSchema = { title: 'Source Schema', custom: true };
+    const result = MdxTemplate({
+      ...baseData,
+      schemaSources: { 'schemas/test.json': sourceSchema },
+    });
+    expect(result).toContain(JSON.stringify(sourceSchema));
+  });
+
+  it('uses schema as sourceSchema when schemaSources is null/undefined', () => {
+    const result = MdxTemplate({ ...baseData, schemaSources: null });
+    expect(result).toContain(JSON.stringify(baseData.schema));
+  });
+});

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

@@ -1,12 +1,46 @@
 /**
- * @jest-environment node
+ * @jest-environment @stryker-mutator/jest-runner/jest-env/node
  */
 
-import { processOneOfSchema } from '../../helpers/schema-processing';
+import { processOneOfSchema, slugify } from '../../helpers/schema-processing';
 import path from 'path';
 import fs from 'fs';
 
 describe('schema-processing', () => {
+  describe('slugify', () => {
+    it('returns "option" for falsy input', () => {
+      expect(slugify('')).toBe('option');
+      expect(slugify(null)).toBe('option');
+      expect(slugify(undefined)).toBe('option');
+    });
+
+    it('replaces multiple spaces with a single hyphen', () => {
+      expect(slugify('hello   world')).toBe('hello-world');
+    });
+
+    it('removes non-word characters', () => {
+      expect(slugify('hello!@#world')).toBe('helloworld');
+    });
+
+    it('replaces multiple consecutive hyphens with a single hyphen', () => {
+      expect(slugify('hello---world')).toBe('hello-world');
+    });
+
+    it('trims leading hyphens', () => {
+      expect(slugify('-hello')).toBe('hello');
+      expect(slugify('--hello')).toBe('hello');
+    });
+
+    it('trims trailing hyphens', () => {
+      expect(slugify('hello-')).toBe('hello');
+      expect(slugify('hello--')).toBe('hello');
+    });
+
+    it('converts to lowercase', () => {
+      expect(slugify('Hello World')).toBe('hello-world');
+    });
+  });
+
   describe('processOneOfSchema', () => {
     it('should merge oneOf options with the root schema', async () => {
       const rootSchema = {
@@ -119,6 +153,92 @@ describe('schema-processing', () => {
       expect(mergedEcommerce.properties.transaction_id.type).toBe('string');
     });
 
+    it('returns an empty array when schema has no oneOf', async () => {
+      const schema = {
+        $id: 'root.json',
+        title: 'Root',
+        properties: { foo: { type: 'string' } },
+      };
+      const result = await processOneOfSchema(schema, '/path/to/schema.json');
+      expect(result).toEqual([]);
+    });
+
+    it('uses $anchor as slug when option has $anchor but no $id ending in .json', async () => {
+      const rootSchema = {
+        $id: 'root.json',
+        title: 'Root',
+        oneOf: [
+          {
+            $anchor: 'my-anchor',
+            title: 'Anchored Option',
+          },
+        ],
+      };
+      const result = await processOneOfSchema(
+        rootSchema,
+        '/path/to/schema.json',
+      );
+      expect(result[0].slug).toBe('my-anchor');
+      expect(result[0].schema.$id).toBe('root.json#my-anchor');
+    });
+
+    it('uses basename of $id ending in .json as slug and preserves original $id', async () => {
+      const rootSchema = {
+        $id: 'root.json',
+        title: 'Root',
+        oneOf: [
+          {
+            $id: 'sub/my-option.json',
+            title: 'Option With Id',
+          },
+        ],
+      };
+      const result = await processOneOfSchema(
+        rootSchema,
+        '/path/to/schema.json',
+      );
+      expect(result[0].slug).toBe('my-option');
+      expect(result[0].schema.$id).toBe('sub/my-option.json');
+    });
+
+    it('does not treat $id not ending in .json as hadId', async () => {
+      const rootSchema = {
+        $id: 'root.json',
+        title: 'Root',
+        oneOf: [
+          {
+            $id: 'not-a-json-file',
+            title: 'No Json Extension',
+          },
+        ],
+      };
+      const result = await processOneOfSchema(
+        rootSchema,
+        '/path/to/schema.json',
+      );
+      expect(result[0].slug).toBe('no-json-extension');
+      expect(result[0].schema.$id).toBe('root.json#no-json-extension');
+    });
+
+    it('does not resolve $ref that starts with #', async () => {
+      const rootSchema = {
+        $id: 'root.json',
+        title: 'Root',
+        oneOf: [
+          {
+            $ref: '#/definitions/internal',
+            title: 'Internal Ref',
+          },
+        ],
+      };
+      const result = await processOneOfSchema(
+        rootSchema,
+        '/path/to/schema.json',
+      );
+      expect(result[0].schema.$ref).toBe('#/definitions/internal');
+      expect(result[0].sourceFilePath).toBeNull();
+    });
+
     it('preserves parent allOf metadata when root oneOf options are file refs', async () => {
       const rootFile = path.join(
         __dirname,