feat: numbering validator adding unit tests

Author: falsaadehh

packages/super-editor/src/core/super-validator/super-validator.js

@@ -194,17 +194,14 @@ export class SuperValidator {
     const { tr } = this.#editor.state;
     const { dispatch } = this.#editor.view;
 
-    const documentAnalysis = this.#analyzeDocument();
-    this.logger.debug('Document analysis for export:', documentAnalysis);
-
     let hasModifiedDocument = false;
     const validationResults = [];
 
     // Run XML validators
     Object.entries(this.#xmlValidators).forEach(([key, validator]) => {
       this.logger.debug(`🕵 Validating export with ${key}...`);
 
-      const { results, modified } = validator(tr, documentAnalysis);
+      const { results, modified } = validator();
       validationResults.push({ key, results });
 
       hasModifiedDocument = hasModifiedDocument || modified;

packages/super-editor/src/core/super-validator/super-validator.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { SuperValidator } from './super-validator.js';
 import { StateValidators } from './validators/state/index.js';
+import { XmlValidators } from './validators/xml/index.js';
 
 vi.mock('./logger/logger.js', () => ({
   createLogger: vi.fn(() => ({
@@ -18,6 +19,13 @@ vi.mock('./validators/state/index.js', () => ({
   },
 }));
 
+vi.mock('./validators/xml/index.js', () => ({
+  XmlValidators: {
+    xmlA: vi.fn(),
+    xmlB: vi.fn(),
+  },
+}));
+
 describe('SuperValidator', () => {
   let mockEditor, mockDoc, mockView, mockTr;
 
@@ -114,4 +122,54 @@ describe('SuperValidator', () => {
 
     expect(result.results).toHaveLength(2);
   });
+
+  describe('validateDocumentExport', () => {
+    it('calls all XML validators and aggregates results; dispatches when modified', () => {
+      const xmlValidatorA = vi.fn(() => ({ modified: true, results: ['fixed numbering'] }));
+      const xmlValidatorB = vi.fn(() => ({ modified: false, results: [] }));
+
+      XmlValidators.xmlA.mockReturnValue(xmlValidatorA);
+      XmlValidators.xmlB.mockReturnValue(xmlValidatorB);
+
+      const instance = new SuperValidator({ editor: mockEditor });
+
+      const result = instance.validateDocumentExport();
+
+      expect(result.modified).toBe(true);
+      expect(result.results).toEqual([
+        { key: 'xmlA', results: ['fixed numbering'] },
+        { key: 'xmlB', results: [] },
+      ]);
+
+      expect(mockView.dispatch).toHaveBeenCalled();
+    });
+
+    it('does not dispatch if no XML validator modified the document', () => {
+      const xmlValidatorA = vi.fn(() => ({ modified: false, results: [] }));
+      const xmlValidatorB = vi.fn(() => ({ modified: false, results: [] }));
+
+      XmlValidators.xmlA.mockReturnValue(xmlValidatorA);
+      XmlValidators.xmlB.mockReturnValue(xmlValidatorB);
+
+      const instance = new SuperValidator({ editor: mockEditor });
+      const result = instance.validateDocumentExport();
+
+      expect(result.modified).toBe(false);
+      expect(mockView.dispatch).not.toHaveBeenCalled();
+    });
+
+    it('does not dispatch if dryRun is true even when modified', () => {
+      const xmlValidatorA = vi.fn(() => ({ modified: true, results: ['something'] }));
+      const xmlValidatorB = vi.fn(() => ({ modified: false, results: [] }));
+
+      XmlValidators.xmlA.mockReturnValue(xmlValidatorA);
+      XmlValidators.xmlB.mockReturnValue(xmlValidatorB);
+
+      const instance = new SuperValidator({ editor: mockEditor, dryRun: true });
+      const result = instance.validateDocumentExport();
+
+      expect(result.modified).toBe(true);
+      expect(mockView.dispatch).not.toHaveBeenCalled();
+    });
+  });
 });

packages/super-editor/src/core/super-validator/validators/xml/numbering/numbering-validator.test.js

@@ -0,0 +1,143 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createNumberingValidator } from './numbering-validator.js';
+
+function makeEditorWithNumbering(numberingXmlLike) {
+  return {
+    converter: {
+      convertedXml: {
+        'word/numbering.xml': numberingXmlLike,
+      },
+    },
+  };
+}
+
+function makeLogger() {
+  return { debug: vi.fn(), withPrefix: vi.fn(() => ({ debug: vi.fn() })) };
+}
+
+describe('numbering-validator', () => {
+  it('returns invalid when numbering.xml is missing or malformed', () => {
+    const cases = [undefined, null, {}, { elements: [] }, { elements: [{}] }, { elements: [{ elements: [] }] }];
+
+    for (const numbering of cases) {
+      const editor = makeEditorWithNumbering(numbering);
+      const logger = makeLogger();
+      const validator = createNumberingValidator({ editor, logger });
+      const result = validator();
+
+      expect(result.modified).toBe(false);
+      expect(result.results).toEqual(['word/numbering.xml is not a valid xml']);
+      expect(logger.debug).not.toHaveBeenCalled();
+    }
+  });
+
+  it('no changes when all <w:num> have valid numeric w:numId', () => {
+    const numbering = {
+      elements: [
+        {
+          elements: [
+            {
+              type: 'element',
+              name: 'w:abstractNum',
+              attributes: { 'w:abstractNumId': '1' },
+              elements: [],
+            },
+            {
+              type: 'element',
+              name: 'w:num',
+              attributes: { 'w:numId': '1' },
+              elements: [],
+            },
+            {
+              type: 'element',
+              name: 'w:pPr',
+              elements: [
+                {
+                  type: 'element',
+                  name: 'w:num',
+                  attributes: { 'w:numId': '42' },
+                  elements: [],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+    const editor = makeEditorWithNumbering(numbering);
+    const logger = makeLogger();
+
+    const validator = createNumberingValidator({ editor, logger });
+    const result = validator();
+
+    expect(result.modified).toBe(false);
+    expect(result.results).toEqual(['No <w:num> entries with null/invalid numId found.']);
+    expect(logger.debug).not.toHaveBeenCalled();
+    // Ensure structure preserved
+    const root = numbering.elements[0].elements;
+    expect(root.find((e) => e.name === 'w:num' && e.attributes['w:numId'] === '1')).toBeTruthy();
+    const nested = root.find((e) => e.name === 'w:pPr').elements;
+    expect(nested.find((e) => e.name === 'w:num' && e.attributes['w:numId'] === '42')).toBeTruthy();
+  });
+
+  it('removes <w:num> elements with invalid/missing w:numId and reports them', () => {
+    const numbering = {
+      elements: [
+        {
+          elements: [
+            // valid
+            { type: 'element', name: 'w:num', attributes: { 'w:numId': '10' }, elements: [] },
+            // invalid: missing attr
+            { type: 'element', name: 'w:num', elements: [] },
+            // invalid: empty string
+            { type: 'element', name: 'w:num', attributes: { 'w:numId': '' }, elements: [] },
+            // invalid: literal "null"
+            { type: 'element', name: 'w:num', attributes: { 'w:numId': 'null' }, elements: [] },
+            // invalid: non-numeric
+            { type: 'element', name: 'w:num', attributes: { 'w:numId': '12a' }, elements: [] },
+            // nested invalid
+            {
+              type: 'element',
+              name: 'w:pPr',
+              elements: [
+                { type: 'element', name: 'w:num', attributes: { 'w:numId': '  ' }, elements: [] },
+                { type: 'element', name: 'w:num', attributes: { 'w:numId': '5' }, elements: [] }, // valid nested
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+    const editor = makeEditorWithNumbering(numbering);
+    const logger = makeLogger();
+
+    const validator = createNumberingValidator({ editor, logger });
+    const result = validator();
+
+    expect(result.modified).toBe(true);
+    expect(result.results).toHaveLength(1);
+    expect(result.results[0]).toMatch(/^Removed invalid <w:num> by numId:/);
+
+    // The order should match traversal order:
+    // missing node, '', 'null', '12a', '' (trim of spaces)
+    expect(result.results[0]).toContain('missing node');
+    expect(result.results[0]).toContain(', ,');
+    expect(result.results[0]).toContain('null');
+    expect(result.results[0]).toContain('12a');
+
+    expect(logger.debug).toHaveBeenCalledTimes(1);
+
+    // Ensure invalid ones are removed but valid remain
+    const root = numbering.elements[0].elements;
+    const rootNums = root.filter((e) => e.name === 'w:num');
+    expect(rootNums).toHaveLength(1);
+    expect(rootNums[0].attributes['w:numId']).toBe('10');
+
+    const nested = root.find((e) => e.name === 'w:pPr').elements;
+    const nestedNums = nested.filter((e) => e.name === 'w:num');
+    expect(nestedNums).toHaveLength(1);
+    expect(nestedNums[0].attributes['w:numId']).toBe('5');
+  });
+});