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

package/__tests__/helpers/exampleModel.test.js

@@ -132,4 +132,213 @@ describe('buildExampleModel', () => {
       'android-firebase-kotlin-sdk',
     ]);
   });
+
+  it('falls back to default target when x-tracking-targets is null (optional chain)', () => {
+    const schema = {
+      'x-tracking-targets': null,
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+      },
+    };
+
+    const targets = resolveExampleTargets(schema);
+    expect(targets.map((t) => t.id)).toEqual([DEFAULT_SNIPPET_TARGET_ID]);
+  });
+
+  it('falls back to default target when x-tracking-targets is an empty array', () => {
+    const schema = {
+      'x-tracking-targets': [],
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+      },
+    };
+
+    const targets = resolveExampleTargets(schema);
+    expect(targets.map((t) => t.id)).toEqual([DEFAULT_SNIPPET_TARGET_ID]);
+    expect(targets).toHaveLength(1);
+  });
+
+  it('filters out null targets and falls back to default when all target IDs are invalid', () => {
+    const schema = {
+      'x-tracking-targets': ['nonexistent-target-id'],
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+      },
+    };
+
+    // All invalid IDs should be caught, filtered out, then fall back to default
+    const targets = resolveExampleTargets(schema);
+    expect(targets.map((t) => t.id)).toEqual([DEFAULT_SNIPPET_TARGET_ID]);
+  });
+
+  it('filters out null when one target ID is invalid but keeps valid ones', () => {
+    const schema = {
+      'x-tracking-targets': [
+        'web-datalayer-js',
+        'nonexistent-target-id',
+        'android-firebase-kotlin-sdk',
+      ],
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+      },
+    };
+
+    const targets = resolveExampleTargets(schema);
+    expect(targets.map((t) => t.id)).toEqual([
+      'web-datalayer-js',
+      'android-firebase-kotlin-sdk',
+    ]);
+  });
+
+  it('returns empty variantGroups and isSimpleDefault false when schema produces no examples', () => {
+    // A schema with type object but no properties and no examples yields no example groups
+    const schema = {
+      type: 'object',
+    };
+
+    const model = buildExampleModel(schema);
+    expect(model.variantGroups).toEqual([]);
+    expect(model.isSimpleDefault).toBe(false);
+    expect(model.targets).toHaveLength(1);
+    expect(model.targets[0].id).toBe(DEFAULT_SNIPPET_TARGET_ID);
+  });
+
+  it('sets isSimpleDefault to false when there are multiple variantGroups', () => {
+    const model = buildExampleModel(choiceEventSchema);
+    expect(model.isSimpleDefault).toBe(false);
+    expect(model.variantGroups.length).toBeGreaterThan(1);
+  });
+
+  it('sets isSimpleDefault to false when single variantGroup property is not "default"', () => {
+    // A schema with exactly one oneOf choice point produces a single variantGroup
+    // whose property is the field name (not 'default')
+    const schema = {
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+        category: {
+          oneOf: [
+            { title: 'Standard', const: 'standard' },
+            { title: 'Premium', const: 'premium' },
+          ],
+        },
+      },
+    };
+
+    const model = buildExampleModel(schema);
+    expect(model.variantGroups).toHaveLength(1);
+    expect(model.variantGroups[0].property).not.toBe('default');
+    expect(model.isSimpleDefault).toBe(false);
+  });
+
+  it('falls back to default target when schema is undefined (optional chaining guard)', () => {
+    const targets = resolveExampleTargets(undefined);
+    expect(targets).toHaveLength(1);
+    expect(targets[0].id).toBe(DEFAULT_SNIPPET_TARGET_ID);
+  });
+
+  it('falls back to default target when schema is null (optional chaining guard)', () => {
+    const targets = resolveExampleTargets(null);
+    expect(targets).toHaveLength(1);
+    expect(targets[0].id).toBe(DEFAULT_SNIPPET_TARGET_ID);
+  });
+
+  it('uses configured array content (not empty) when x-tracking-targets is absent', () => {
+    // Kills ArrayDeclaration mutant: [DEFAULT_SNIPPET_TARGET_ID] -> []
+    // If the fallback were [], targets would be empty, triggering the line-27 fallback
+    // but the target IDs would differ in the mapping step
+    const schema = { type: 'object' };
+    const targets = resolveExampleTargets(schema);
+    expect(targets).toHaveLength(1);
+    expect(targets[0].id).toBe(DEFAULT_SNIPPET_TARGET_ID);
+  });
+
+  it('treats non-array x-tracking-targets as absent and falls back to default', () => {
+    // Kills ConditionalExpression mutant on line 12: configured.length > 0 -> true
+    // When configured is a string (truthy but not an Array), Array.isArray is false
+    // so it should still fall back to default
+    const schema = {
+      'x-tracking-targets': 'not-an-array',
+      type: 'object',
+    };
+    const targets = resolveExampleTargets(schema);
+    expect(targets).toHaveLength(1);
+    expect(targets[0].id).toBe(DEFAULT_SNIPPET_TARGET_ID);
+  });
+
+  it('generates option ids from property name and index', () => {
+    // Kills StringLiteral mutant: `${group.property}-${index}` -> ``
+    const schema = {
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+      },
+    };
+
+    const model = buildExampleModel(schema);
+    expect(model.variantGroups[0].options[0].id).toBe('default-0');
+  });
+
+  it('generates sequential option ids for choice schemas', () => {
+    // Further kills StringLiteral mutant by checking index > 0
+    const schema = {
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+        category: {
+          oneOf: [
+            { title: 'Standard', const: 'standard' },
+            { title: 'Premium', const: 'premium' },
+          ],
+        },
+      },
+    };
+
+    const model = buildExampleModel(schema);
+    const group = model.variantGroups[0];
+    expect(group.options[0].id).toBe(`${group.property}-0`);
+    expect(group.options[1].id).toBe(`${group.property}-1`);
+  });
+
+  it('sets isSimpleDefault to false for multiple groups even if first is "default"', () => {
+    // Kills ConditionalExpression mutant on line 66: variantGroups.length === 1 -> true
+    // choiceEventSchema produces multiple variant groups, so isSimpleDefault must be false
+    // even if the mutant forces length===1 to true
+    const model = buildExampleModel(choiceEventSchema);
+    expect(model.variantGroups.length).toBeGreaterThan(1);
+    expect(model.isSimpleDefault).toBe(false);
+  });
+
+  it('returns early return shape when schema has no properties', () => {
+    // Kills BlockStatement and condition mutants on line 34
+    // Verifies the exact shape of the early-return object
+    const schema = { type: 'object' };
+    const model = buildExampleModel(schema);
+    expect(model).toEqual({
+      targets: expect.any(Array),
+      variantGroups: [],
+      isSimpleDefault: false,
+    });
+  });
+
+  it('includes snippets keyed by each target id when multiple targets are configured', () => {
+    const schema = {
+      'x-tracking-targets': ['web-datalayer-js', 'android-firebase-kotlin-sdk'],
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+      },
+    };
+
+    const model = buildExampleModel(schema);
+    const snippetKeys = Object.keys(model.variantGroups[0].options[0].snippets);
+    expect(snippetKeys).toEqual([
+      'web-datalayer-js',
+      'android-firebase-kotlin-sdk',
+    ]);
+  });
 });

package/__tests__/helpers/file-system.test.js

@@ -1,6 +1,11 @@
 import fs from 'fs';
 import path from 'path';
-import { readSchemas, writeDoc, createDir } from '../../helpers/file-system';
+import {
+  readSchemas,
+  writeDoc,
+  createDir,
+  readSchemaSources,
+} from '../../helpers/file-system';
 
 jest.mock('fs', () => {
   const memfs = require('memfs');
@@ -24,6 +29,16 @@ describe('file-system helpers', () => {
       expect(schemas[0].fileName).toBe('schema1.json');
       expect(schemas[1].fileName).toBe('schema2.json');
     });
+
+    it('should parse schema content as JSON', () => {
+      // L17: StringLiteral → "" — encoding must be 'utf-8' to get string
+      fs.vol.reset();
+      fs.vol.fromJSON({
+        '/s/test.json': '{"id":"test-schema"}',
+      });
+      const schemas = readSchemas('/s');
+      expect(schemas[0].schema).toEqual({ id: 'test-schema' });
+    });
   });
 
   describe('writeDoc', () => {
@@ -33,6 +48,15 @@ describe('file-system helpers', () => {
       const content = fs.readFileSync('/output/doc1.mdx', 'utf-8');
       expect(content).toBe('content');
     });
+
+    it('should log the generated file path', () => {
+      // L57: StringLiteral → `` — empty template literal
+      fs.mkdirSync('/out', { recursive: true });
+      const spy = jest.spyOn(console, 'log').mockImplementation(() => {});
+      writeDoc('/out', 'doc.mdx', 'hello');
+      expect(spy).toHaveBeenCalledWith(expect.stringContaining('Generated'));
+      spy.mockRestore();
+    });
   });
 
   describe('createDir', () => {
@@ -40,5 +64,53 @@ describe('file-system helpers', () => {
       createDir('/new-dir');
       expect(fs.existsSync('/new-dir')).toBe(true);
     });
+
+    it('should not call mkdirSync when directory already exists', () => {
+      // L5: ConditionalExpression → true — mutant always calls mkdirSync
+      fs.mkdirSync('/existing-dir', { recursive: true });
+      const spy = jest.spyOn(fs, 'mkdirSync');
+      createDir('/existing-dir');
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('should create nested directories recursively', () => {
+      // L6: ObjectLiteral → {} and BooleanLiteral → false
+      // Without recursive: true, creating nested dirs would fail
+      createDir('/a/b/c/d');
+      expect(fs.existsSync('/a/b/c/d')).toBe(true);
+    });
+  });
+
+  describe('readSchemaSources', () => {
+    it('should read json files recursively and key by relative path', () => {
+      // L39: ConditionalExpression → false and StringLiteral → ""
+      // L45: StringLiteral → "" (encoding)
+      fs.vol.reset();
+      fs.vol.fromJSON({
+        '/root/a.json': '{"name":"a"}',
+        '/root/sub/b.json': '{"name":"b"}',
+        '/root/skip.txt': 'not json',
+      });
+      const result = readSchemaSources('/root');
+      expect(Object.keys(result)).toEqual(
+        expect.arrayContaining(['a.json', 'sub/b.json']),
+      );
+      expect(Object.keys(result)).not.toContain('skip.txt');
+      expect(result['a.json']).toEqual({ name: 'a' });
+      expect(result['sub/b.json']).toEqual({ name: 'b' });
+    });
+
+    it('should only include .json files, not other extensions', () => {
+      // L39: StringLiteral → "" would match all files including .txt
+      fs.vol.reset();
+      fs.vol.fromJSON({
+        '/root/valid.json': '{}',
+        '/root/readme.txt': 'text',
+        '/root/data.csv': 'csv',
+      });
+      const result = readSchemaSources('/root');
+      expect(Object.keys(result)).toEqual(['valid.json']);
+    });
   });
 });

package/__tests__/helpers/getConstraints.test.js

@@ -116,4 +116,31 @@ describe('getConstraints', () => {
     };
     expect(getConstraints(prop, false)).toEqual(['not: { type: "string" }']);
   });
+
+  it('should not include uniqueItems constraint when value is false', () => {
+    const prop = { uniqueItems: false };
+    expect(getConstraints(prop, false)).toEqual([]);
+  });
+
+  it('should not include additionalProperties constraint when value is true', () => {
+    const prop = { additionalProperties: true };
+    expect(getConstraints(prop, false)).toEqual([]);
+  });
+
+  it('should render "not" constraint with nested array values', () => {
+    const prop = {
+      not: { enum: ['a', 'b'] },
+    };
+    expect(getConstraints(prop, false)).toEqual(['not: { enum: ["a", "b"] }']);
+  });
+
+  it('should render "not" constraint with deeply nested array of objects', () => {
+    const prop = {
+      not: { items: [{ type: 'string' }, { type: 'number' }] },
+    };
+    const result = getConstraints(prop, false);
+    expect(result).toEqual([
+      'not: { items: [{ type: "string" }, { type: "number" }] }',
+    ]);
+  });
 });

package/__tests__/helpers/mergeSchema.test.js

@@ -0,0 +1,94 @@
+import { mergeSchema } from '../../helpers/mergeSchema';
+
+describe('mergeSchema', () => {
+  it('merges allOf into a single schema', () => {
+    const result = mergeSchema({
+      allOf: [
+        { type: 'object', properties: { a: { type: 'string' } } },
+        { type: 'object', properties: { b: { type: 'number' } } },
+      ],
+    });
+
+    expect(result.properties).toEqual({
+      a: { type: 'string' },
+      b: { type: 'number' },
+    });
+  });
+
+  it('preserves $defs via the baseResolvers', () => {
+    const result = mergeSchema({
+      allOf: [
+        {
+          type: 'object',
+          $defs: { shared: { type: 'string' } },
+          properties: { a: { type: 'string' } },
+        },
+        {
+          type: 'object',
+          $defs: { other: { type: 'number' } },
+          properties: { b: { type: 'number' } },
+        },
+      ],
+    });
+
+    expect(result.$defs).toEqual({
+      shared: { type: 'string' },
+      other: { type: 'number' },
+    });
+  });
+
+  it('passes custom resolvers through to json-schema-merge-allof', () => {
+    const customTitleResolver = (values) => values.join(' + ');
+
+    const result = mergeSchema(
+      {
+        allOf: [
+          {
+            type: 'object',
+            title: 'Foo',
+            properties: { a: { type: 'string' } },
+          },
+          {
+            type: 'object',
+            title: 'Bar',
+            properties: { b: { type: 'number' } },
+          },
+        ],
+      },
+      { resolvers: { title: customTitleResolver } },
+    );
+
+    expect(result.title).toBe('Foo + Bar');
+  });
+
+  it('works without custom options', () => {
+    const result = mergeSchema({
+      allOf: [{ type: 'object', properties: { x: { type: 'boolean' } } }],
+    });
+
+    expect(result.properties.x).toEqual({ type: 'boolean' });
+  });
+
+  it('merges additional options beyond resolvers', () => {
+    // ignoreAdditionalProperties is a real json-schema-merge-allof option
+    const result = mergeSchema(
+      {
+        allOf: [
+          {
+            type: 'object',
+            properties: { a: { type: 'string' } },
+            additionalProperties: false,
+          },
+          {
+            type: 'object',
+            properties: { b: { type: 'number' } },
+          },
+        ],
+      },
+      { ignoreAdditionalProperties: true },
+    );
+
+    expect(result.properties.a).toEqual({ type: 'string' });
+    expect(result.properties.b).toEqual({ type: 'number' });
+  });
+});