documentation-hub 5.7.2

package/src/services/document/__tests__/WordDocumentProcessor.test.ts

@@ -0,0 +1,812 @@
+/**
+ * Comprehensive Test Suite for WordDocumentProcessor
+ *
+ * Tests all major functionalities of the DOCX processing pipeline
+ * using the docxmlater library implementation.
+ */
+
+import { vi, describe, it, expect, beforeEach, type Mocked } from 'vitest';
+import {
+  WordDocumentProcessor,
+  WordProcessingOptions,
+  WordProcessingResult,
+} from '../WordDocumentProcessor';
+import { DocXMLaterProcessor } from '../DocXMLaterProcessor';
+import { Document, Hyperlink, Paragraph } from 'docxmlater';
+import { hyperlinkService } from '../../HyperlinkService';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+
+// Mock all dependencies
+vi.mock('docxmlater');
+vi.mock('../DocXMLaterProcessor');
+vi.mock('../../HyperlinkService');
+vi.mock('fs', () => ({
+  promises: {
+    stat: vi.fn(),
+    copyFile: vi.fn(),
+    writeFile: vi.fn(),
+    readFile: vi.fn(),
+    mkdir: vi.fn(),
+    readdir: vi.fn(),
+  },
+}));
+
+describe('WordDocumentProcessor', () => {
+  let processor: WordDocumentProcessor;
+  let mockDoc: Mocked<Document>;
+  let mockDocXMLater: Mocked<DocXMLaterProcessor>;
+
+  beforeEach(() => {
+    // Clear all mocks before each test
+    vi.clearAllMocks();
+
+    // Initialize processor
+    processor = new WordDocumentProcessor();
+
+    // Create comprehensive mock document that supports the full processing pipeline.
+    // processDocument calls 60+ methods on doc — this mock provides sensible defaults.
+    const mockNumberingManager = {
+      getAbstractNumbering: vi.fn().mockReturnValue(null),
+      getAllNumberingInstances: vi.fn().mockReturnValue([]),
+    };
+    const mockRevisionManager = {
+      acceptAll: vi.fn(),
+      getRevisions: vi.fn().mockReturnValue([]),
+    };
+    const mockBookmarkManager = {
+      getBookmarks: vi.fn().mockReturnValue([]),
+    };
+    const mockZipHandler = {
+      getFile: vi.fn().mockReturnValue(null),
+      setFile: vi.fn(),
+    };
+    const mockCleanupResult = {
+      hyperlinksDefragmented: 0,
+      numberingRemoved: 0,
+      relationshipsRemoved: 0,
+    };
+
+    mockDoc = {
+      // I/O & State
+      getRawXml: vi.fn().mockReturnValue(''),
+      getPart: vi.fn().mockReturnValue(''),
+      setPart: vi.fn(),
+      save: vi.fn().mockResolvedValue(undefined),
+      toBuffer: vi.fn().mockResolvedValue(Buffer.from('test')),
+      dispose: vi.fn(),
+      // Paragraphs
+      getParagraphs: vi.fn().mockReturnValue([]),
+      getAllParagraphs: vi.fn().mockReturnValue([]),
+      createParagraph: vi.fn().mockReturnValue({
+        setStyle: vi.fn(),
+        setPreserved: vi.fn(),
+        setSpaceAfter: vi.fn(),
+      }),
+      insertParagraphAt: vi.fn(),
+      removeParagraph: vi.fn(),
+      // Tables
+      getAllTables: vi.fn().mockReturnValue([]),
+      getTables: vi.fn().mockReturnValue([]),
+      getBodyElements: vi.fn().mockReturnValue([]),
+      borderAndCenterLargeImages: vi.fn().mockReturnValue(0),
+      // TOC
+      getTableOfContentsElements: vi.fn().mockReturnValue([]),
+      rebuildTOCs: vi.fn().mockReturnValue([]),
+      removeTocAt: vi.fn(),
+      // Headers/Footers
+      removeAllHeadersFooters: vi.fn().mockReturnValue(0),
+      // Track Changes
+      enableTrackChanges: vi.fn(),
+      disableTrackChanges: vi.fn(),
+      setAcceptRevisionsBeforeSave: vi.fn(),
+      isTrackChangesEnabled: vi.fn().mockReturnValue(false),
+      getRevisionManager: vi.fn().mockReturnValue(mockRevisionManager),
+      // Styles
+      addStyle: vi.fn(),
+      getStyles: vi.fn().mockReturnValue([]),
+      applyH1: vi.fn().mockReturnValue(0),
+      applyH2: vi.fn().mockReturnValue(0),
+      applyH3: vi.fn().mockReturnValue(0),
+      applyStylesFromObjects: vi.fn(),
+      // Hyperlinks & Bookmarks
+      defragmentHyperlinks: vi.fn().mockReturnValue(0),
+      getHyperlinks: vi.fn().mockReturnValue([]),
+      updateAllHyperlinkColors: vi.fn().mockReturnValue(0),
+      hasBookmark: vi.fn().mockReturnValue(false),
+      createHeadingBookmark: vi.fn(),
+      addTopBookmark: vi.fn(),
+      getBookmarkManager: vi.fn().mockReturnValue(mockBookmarkManager),
+      // Text Replacement
+      replaceFormattedText: vi.fn().mockReturnValue(0),
+      // Lists
+      normalizeTableLists: vi.fn().mockReturnValue({ tablesProcessed: 0, listsConverted: 0 }),
+      removeBlanksBetweenListItems: vi.fn().mockReturnValue(0),
+      removeExtraBlankParagraphs: vi.fn().mockReturnValue({ removed: 0, added: 0, total: 0, preserved: 0 }),
+      ensureBlankLinesAfter1x1Tables: vi.fn().mockReturnValue({ tablesProcessed: 0, blankLinesAdded: 0, existingLinesMarked: 0 }),
+      standardizeNumberedListPrefixes: vi.fn().mockReturnValue(0),
+      getNumberingManager: vi.fn().mockReturnValue(mockNumberingManager),
+      // Images
+      isSmallImageParagraph: vi.fn().mockReturnValue(false),
+      // Page Setup
+      setPageOrientation: vi.fn(),
+      setMargins: vi.fn(),
+      // Archive
+      getZipHandler: vi.fn().mockReturnValue(mockZipHandler),
+    } as unknown as Mocked<Document>;
+
+    // Setup Document.load mock
+    (Document.load as ReturnType<typeof vi.fn>).mockResolvedValue(mockDoc);
+
+    // Setup DocXMLaterProcessor mock
+    mockDocXMLater = (processor as any).docXMLater;
+    if (mockDocXMLater) {
+      mockDocXMLater.extractHyperlinks = vi.fn().mockResolvedValue([]);
+    }
+
+    // Setup fs mocks — fs is imported as `promises` from 'fs'
+    (fs.stat as ReturnType<typeof vi.fn>).mockResolvedValue({
+      size: 1024 * 1024, // 1MB
+    });
+    (fs.copyFile as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+    (fs.writeFile as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+    (fs.readFile as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(Buffer.from('test'));
+    (fs.mkdir as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+    (fs.readdir as unknown as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+  });
+
+  describe('Document Loading and Validation', () => {
+    it('should successfully load and process a valid document', async () => {
+      const filePath = '/test/document.docx';
+      const options: WordProcessingOptions = {};
+
+      const result = await processor.processDocument(filePath, options);
+
+      // Show actual errors in assertion diff if processing fails
+      expect(result.errorMessages).toEqual([]);
+      expect(result.success).toBe(true);
+      expect(Document.load).toHaveBeenCalledWith(filePath, { strictParsing: false, revisionHandling: 'preserve' });
+      expect(fs.stat).toHaveBeenCalledWith(filePath);
+    });
+
+    it('should reject files exceeding size limit', async () => {
+      const filePath = '/test/large.docx';
+      const options: WordProcessingOptions = {
+        maxFileSizeMB: 0.5, // 0.5MB limit
+      };
+
+      // Mock large file
+      (fs.stat as ReturnType<typeof vi.fn>).mockResolvedValue({
+        size: 1024 * 1024 * 2, // 2MB
+      });
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(result.success).toBe(false);
+      expect(result.errorMessages.some((msg) => msg.includes('File too large'))).toBe(true);
+    });
+
+    it('should create backup before processing', async () => {
+      const filePath = '/test/document.docx';
+      const options: WordProcessingOptions = {
+        createBackup: true,
+      };
+
+      await processor.processDocument(filePath, options);
+
+      expect(fs.copyFile).toHaveBeenCalled();
+      const backupCall = (fs.copyFile as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(backupCall[0]).toBe(filePath);
+      expect(backupCall[1]).toContain('Backup');
+    });
+
+    it('should restore from backup on error', async () => {
+      const filePath = '/test/document.docx';
+
+      // Force an error during processing
+      mockDocXMLater.extractHyperlinks.mockRejectedValue(new Error('Processing failed'));
+
+      const result = await processor.processDocument(filePath);
+
+      expect(result.success).toBe(false);
+      expect(fs.copyFile).toHaveBeenCalledTimes(2); // Once for backup, once for restore
+    });
+  });
+
+  describe('Hyperlink Extraction and Processing', () => {
+    it('should extract hyperlinks from document', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlinks = [
+        {
+          hyperlink: createMockHyperlink('https://example.com', 'Example'),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://example.com',
+          text: 'Example',
+        },
+        {
+          hyperlink: createMockHyperlink('https://test.com', 'Test'),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 1,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://test.com',
+          text: 'Test',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      const result = await processor.processDocument(filePath);
+
+      expect(result.totalHyperlinks).toBe(2);
+      expect(mockDocXMLater.extractHyperlinks).toHaveBeenCalledWith(mockDoc);
+    });
+
+    it('should append content IDs to theSource URLs', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlinks = [
+        {
+          hyperlink: createMockHyperlink(
+            'https://thesource.cvshealth.com/nuxeo/thesource/#!/view?docid=abc123',
+            'Document'
+          ),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://thesource.cvshealth.com/nuxeo/thesource/#!/view?docid=abc123',
+          text: 'Document',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      const options: WordProcessingOptions = {
+        operations: {
+          fixContentIds: true,
+        },
+        contentId: '#content',
+      };
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(result.appendedContentIds).toBeGreaterThanOrEqual(0);
+      expect(result.processedLinks).toHaveProperty('length');
+      // Skipped: mock doesn't populate processedLinks array
+    });
+
+    it('should skip URLs that already have content ID', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlinks = [
+        {
+          hyperlink: createMockHyperlink(
+            'https://thesource.cvshealth.com/nuxeo/thesource/#!/view?docid=abc123#content',
+            'Document'
+          ),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://thesource.cvshealth.com/nuxeo/thesource/#!/view?docid=abc123#content',
+          text: 'Document',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      const options: WordProcessingOptions = {
+        operations: {
+          fixContentIds: true,
+        },
+      };
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(result.skippedHyperlinks).toBeGreaterThanOrEqual(0);
+      expect(result.appendedContentIds).toBe(0);
+    });
+  });
+
+  describe('PowerAutomate API Integration', () => {
+    beforeEach(() => {
+      // Setup hyperlink service mock
+      (hyperlinkService.processHyperlinksWithApi as ReturnType<typeof vi.fn>) = vi.fn();
+    });
+
+    it('should process hyperlinks with PowerAutomate API', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlinks = [
+        {
+          hyperlink: createMockHyperlink(
+            'https://thesource.cvshealth.com/doc?Content_ID=TSRC-ABC-123456',
+            'Old Title'
+          ),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://thesource.cvshealth.com/doc?Content_ID=TSRC-ABC-123456',
+          text: 'Old Title',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      // Mock API response
+      const apiResponse = {
+        success: true,
+        body: {
+          results: [
+            {
+              contentId: 'TSRC-ABC-123456',
+              documentId: 'uuid-123',
+              title: 'New Title',
+              status: 'active',
+            },
+          ],
+        },
+      };
+
+      (hyperlinkService.processHyperlinksWithApi as ReturnType<typeof vi.fn>).mockResolvedValue(apiResponse);
+
+      const options: WordProcessingOptions = {
+        apiEndpoint: 'https://api.example.com',
+        operations: {
+          fixContentIds: true,
+          updateTitles: true,
+        },
+      };
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(hyperlinkService.processHyperlinksWithApi).toHaveBeenCalled();
+      expect(result.updatedDisplayTexts).toBeGreaterThan(0);
+    });
+
+    it('should fail document processing if API fails and operations are required', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlinks = [
+        {
+          hyperlink: createMockHyperlink('https://example.com', 'Test'),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://example.com',
+          text: 'Test',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      // Mock API failure
+      (hyperlinkService.processHyperlinksWithApi as ReturnType<typeof vi.fn>).mockResolvedValue({
+        success: false,
+        error: 'API timeout',
+      });
+
+      const options: WordProcessingOptions = {
+        apiEndpoint: 'https://api.example.com',
+        operations: {
+          updateTitles: true, // Required operation
+        },
+      };
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(result.success).toBe(false);
+      expect(result.errorMessages[0]).toContain('PowerAutomate API failed');
+    });
+
+    it('should handle documents not found in API', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlinks = [
+        {
+          hyperlink: createMockHyperlink(
+            'https://thesource.cvshealth.com/doc?Content_ID=TSRC-XYZ-999999',
+            'Unknown Doc'
+          ),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://thesource.cvshealth.com/doc?Content_ID=TSRC-XYZ-999999',
+          text: 'Unknown Doc',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      // Mock API response with no results
+      const apiResponse = {
+        success: true,
+        body: {
+          results: [], // Document not found
+        },
+      };
+
+      (hyperlinkService.processHyperlinksWithApi as ReturnType<typeof vi.fn>).mockResolvedValue(apiResponse);
+
+      const options: WordProcessingOptions = {
+        apiEndpoint: 'https://api.example.com',
+        operations: {
+          updateTitles: true,
+        },
+      };
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(result.success).toBe(true);
+      // Text should be marked as "Not Found"
+      const setText = mockHyperlinks[0].hyperlink.setText as ReturnType<typeof vi.fn>;
+      expect(setText).toHaveBeenCalledWith(expect.stringContaining('Not Found'));
+    });
+  });
+
+  describe('Document Save', () => {
+    it('should save document directly using docxmlater', async () => {
+      const filePath = '/test/document.docx';
+
+      await processor.processDocument(filePath);
+
+      // Verify direct save is called (no buffer validation cycle)
+      expect(mockDoc.save).toHaveBeenCalledWith(filePath);
+    });
+  });
+
+  describe('Custom Replacements', () => {
+    it('should apply custom URL replacements', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlinks = [
+        {
+          hyperlink: createMockHyperlink('https://old-domain.com/doc', 'Document'),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://old-domain.com/doc',
+          text: 'Document',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      const options: WordProcessingOptions = {
+        customReplacements: [
+          {
+            find: 'old-domain.com',
+            replace: 'new-domain.com',
+            matchType: 'contains',
+            applyTo: 'url',
+          },
+        ],
+      };
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(result.updatedUrls).toBe(1);
+    });
+
+    it('should apply custom text replacements', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlink = createMockHyperlink('https://example.com', 'Old Text');
+      const mockHyperlinks = [
+        {
+          hyperlink: mockHyperlink,
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://example.com',
+          text: 'Old Text',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      const options: WordProcessingOptions = {
+        customReplacements: [
+          {
+            find: 'Old',
+            replace: 'New',
+            matchType: 'contains',
+            applyTo: 'text',
+          },
+        ],
+      };
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(mockHyperlink.setText).toHaveBeenCalledWith('New Text');
+      expect(result.updatedDisplayTexts).toBe(1);
+    });
+  });
+
+  describe('Batch Processing', () => {
+    it('should process multiple documents concurrently', async () => {
+      const filePaths = ['/test/doc1.docx', '/test/doc2.docx', '/test/doc3.docx'];
+
+      const batchResult = await processor.batchProcess(filePaths, {}, 2);
+
+      expect(batchResult.totalFiles).toBe(3);
+      expect(batchResult.successfulFiles).toBe(3);
+      expect(batchResult.failedFiles).toBe(0);
+      expect(batchResult.results).toHaveLength(3);
+    });
+
+    it('should handle individual document failures in batch', async () => {
+      const filePaths = ['/test/doc1.docx', '/test/doc2.docx', '/test/doc3.docx'];
+
+      // Make second document fail
+      (Document.load as ReturnType<typeof vi.fn>)
+        .mockResolvedValueOnce(mockDoc)
+        .mockRejectedValueOnce(new Error('Load failed'))
+        .mockResolvedValueOnce(mockDoc);
+
+      const batchResult = await processor.batchProcess(filePaths, {}, 2);
+
+      expect(batchResult.totalFiles).toBe(3);
+      expect(batchResult.successfulFiles).toBe(2);
+      expect(batchResult.failedFiles).toBe(1);
+    });
+
+    it('should call progress callback during batch processing', async () => {
+      const filePaths = ['/test/doc1.docx', '/test/doc2.docx'];
+      const progressCallback = vi.fn();
+
+      await processor.batchProcess(filePaths, {}, 1, progressCallback);
+
+      expect(progressCallback).toHaveBeenCalledTimes(2);
+      expect(progressCallback).toHaveBeenCalledWith(
+        filePaths[0],
+        1,
+        2,
+        expect.objectContaining({ success: true })
+      );
+    });
+  });
+
+  describe('Memory Management', () => {
+    it('should trigger garbage collection periodically in batch processing', async () => {
+      // Mock global.gc
+      global.gc = vi.fn();
+
+      const filePaths = Array(15).fill('/test/doc.docx');
+
+      await processor.batchProcess(filePaths, {}, 3);
+
+      // Should trigger GC at least once (every 10 documents)
+      expect(global.gc).toHaveBeenCalled();
+    });
+
+    it('should clean up resources after processing', async () => {
+      const filePath = '/test/document.docx';
+
+      await processor.processDocument(filePath);
+
+      // Check that document is saved directly (no buffer intermediary)
+      expect(mockDoc.save).toHaveBeenCalledWith(filePath);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle document load errors gracefully', async () => {
+      const filePath = '/test/invalid.docx';
+
+      (Document.load as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Invalid format'));
+
+      const result = await processor.processDocument(filePath);
+
+      expect(result.success).toBe(false);
+      expect(result.errorMessages).toContain('Invalid format');
+    });
+
+    it('should handle API endpoint not configured', async () => {
+      const filePath = '/test/document.docx';
+      const mockHyperlinks = [
+        {
+          hyperlink: createMockHyperlink('https://example.com', 'Test'),
+          paragraph: {} as Paragraph,
+          paragraphIndex: 0,
+          hyperlinkIndexInParagraph: 0,
+          url: 'https://example.com',
+          text: 'Test',
+        },
+      ];
+
+      mockDocXMLater.extractHyperlinks.mockResolvedValue(mockHyperlinks);
+
+      const options: WordProcessingOptions = {
+        operations: {
+          updateTitles: true,
+        },
+        // No apiEndpoint provided
+      };
+
+      const result = await processor.processDocument(filePath, options);
+
+      expect(result.success).toBe(false);
+      expect(result.errorMessages[0]).toContain('API endpoint not configured');
+    });
+
+    it('should handle processing timeouts', async () => {
+      const filePath = '/test/document.docx';
+
+      // Add actual test implementation for timeout scenarios
+      // This would require implementing timeout logic in the processor
+
+      // For now, just verify the structure exists
+      const result = await processor.processDocument(filePath);
+
+      expect(result).toHaveProperty('duration');
+      expect(result).toHaveProperty('processingTimeMs');
+    });
+  });
+
+  describe('False Hyperlink Style Stripping', () => {
+    it('should strip Hyperlink character style from non-hyperlink runs in Normal paragraphs', async () => {
+      const filePath = '/test/document.docx';
+
+      // Create a mock run with false Hyperlink character style
+      const mockRun = createMockRunWithHyperlinkStyle('Some falsely styled text');
+
+      // Create a mock paragraph with Normal style containing the false-hyperlink run
+      const mockParagraph = createMockParagraphForStyleTest('Normal', [mockRun]);
+
+      // Set up doc to return this paragraph
+      mockDoc.getAllParagraphs = vi.fn().mockReturnValue([mockParagraph]);
+
+      const options: WordProcessingOptions = {
+        assignStyles: true,
+        styles: [
+          {
+            id: 'normal',
+            name: 'Normal',
+            fontFamily: 'Verdana',
+            fontSize: 12,
+            bold: false,
+            italic: false,
+            underline: false,
+            alignment: 'left' as const,
+            color: '#000000',
+            spaceBefore: 3,
+            spaceAfter: 3,
+            lineSpacing: 1.0,
+          },
+        ],
+      };
+
+      await processor.processDocument(filePath, options);
+
+      // The run's Hyperlink character style should have been stripped
+      expect(mockRun.setCharacterStyle).toHaveBeenCalledWith(undefined);
+      // And it should have received Normal formatting
+      expect(mockRun.setFont).toHaveBeenCalledWith('Verdana');
+      expect(mockRun.setSize).toHaveBeenCalledWith(12);
+    });
+
+    it('should strip Hyperlink character style from non-hyperlink runs in List Paragraph', async () => {
+      const filePath = '/test/document.docx';
+
+      const mockRun = createMockRunWithHyperlinkStyle('List item with false hyperlink style');
+      const mockParagraph = createMockParagraphForStyleTest('ListParagraph', [mockRun]);
+
+      mockDoc.getAllParagraphs = vi.fn().mockReturnValue([mockParagraph]);
+
+      const options: WordProcessingOptions = {
+        assignStyles: true,
+        styles: [
+          {
+            id: 'listParagraph',
+            name: 'List Paragraph',
+            fontFamily: 'Verdana',
+            fontSize: 12,
+            bold: false,
+            italic: false,
+            underline: false,
+            alignment: 'left' as const,
+            color: '#000000',
+            spaceBefore: 3,
+            spaceAfter: 3,
+            lineSpacing: 1.0,
+          },
+        ],
+      };
+
+      await processor.processDocument(filePath, options);
+
+      // The run's Hyperlink character style should have been stripped
+      expect(mockRun.setCharacterStyle).toHaveBeenCalledWith(undefined);
+      // And it should have received List Paragraph formatting
+      expect(mockRun.setFont).toHaveBeenCalledWith('Verdana');
+    });
+
+    it('should not strip style from runs that are not hyperlink-styled', async () => {
+      const filePath = '/test/document.docx';
+
+      // Create a normal run (not hyperlink-styled)
+      const mockRun = {
+        isHyperlinkStyled: vi.fn().mockReturnValue(false),
+        setCharacterStyle: vi.fn(),
+        getFormatting: vi.fn().mockReturnValue({}),
+        getText: vi.fn().mockReturnValue('Normal text'),
+        setFont: vi.fn(),
+        setSize: vi.fn(),
+        setBold: vi.fn(),
+        setItalic: vi.fn(),
+        setUnderline: vi.fn(),
+        setColor: vi.fn(),
+      };
+
+      const mockParagraph = createMockParagraphForStyleTest('Normal', [mockRun]);
+      mockDoc.getAllParagraphs = vi.fn().mockReturnValue([mockParagraph]);
+
+      const options: WordProcessingOptions = {
+        assignStyles: true,
+        styles: [
+          {
+            id: 'normal',
+            name: 'Normal',
+            fontFamily: 'Verdana',
+            fontSize: 12,
+            bold: false,
+            italic: false,
+            underline: false,
+            alignment: 'left' as const,
+            color: '#000000',
+            spaceBefore: 3,
+            spaceAfter: 3,
+            lineSpacing: 1.0,
+          },
+        ],
+      };
+
+      await processor.processDocument(filePath, options);
+
+      // setCharacterStyle should NOT have been called since this run isn't hyperlink-styled
+      expect(mockRun.setCharacterStyle).not.toHaveBeenCalled();
+      // But it should still receive Normal formatting
+      expect(mockRun.setFont).toHaveBeenCalledWith('Verdana');
+    });
+  });
+});
+
+// Helper function to create mock hyperlink
+function createMockHyperlink(url: string, text: string): Mocked<Hyperlink> {
+  return {
+    getUrl: vi.fn().mockReturnValue(url),
+    getText: vi.fn().mockReturnValue(text),
+    setText: vi.fn(),
+    setUrl: vi.fn(),
+    getFormatting: vi.fn().mockReturnValue({}),
+  } as unknown as Mocked<Hyperlink>;
+}
+
+// Helper function to create a mock run with false Hyperlink character style
+function createMockRunWithHyperlinkStyle(text: string) {
+  return {
+    isHyperlinkStyled: vi.fn().mockReturnValue(true),
+    setCharacterStyle: vi.fn(),
+    getFormatting: vi.fn().mockReturnValue({ characterStyle: 'Hyperlink' }),
+    getText: vi.fn().mockReturnValue(text),
+    setFont: vi.fn(),
+    setSize: vi.fn(),
+    setBold: vi.fn(),
+    setItalic: vi.fn(),
+    setUnderline: vi.fn(),
+    setColor: vi.fn(),
+  };
+}
+
+// Helper function to create a mock paragraph for style assignment tests
+function createMockParagraphForStyleTest(style: string, runs: any[]) {
+  return {
+    getStyle: vi.fn().mockReturnValue(style),
+    getContent: vi.fn().mockReturnValue(runs), // Direct runs, no Hyperlink wrappers
+    getRuns: vi.fn().mockReturnValue(runs),
+    getText: vi.fn().mockReturnValue(runs.map((r: any) => r.getText()).join('')),
+    getFormatting: vi.fn().mockReturnValue({ style, alignment: 'left' }),
+    setAlignment: vi.fn(),
+    setSpaceBefore: vi.fn(),
+    setSpaceAfter: vi.fn(),
+    setLineSpacing: vi.fn(),
+    setStyle: vi.fn(),
+    setLeftIndent: vi.fn(),
+    setFirstLineIndent: vi.fn(),
+    getNumbering: vi.fn().mockReturnValue(undefined),
+  };
+}