@capillarytech/creatives-library 8.0.263 → 8.0.265

package/v2Components/HtmlEditor/utils/__tests__/htmlValidator.enhanced.test.js

@@ -7,7 +7,7 @@
 import {
   validateHTML,
   validateCSS,
-  extractAndValidateCSS,
+  extractAndValidateCSS
 } from '../htmlValidator';
 
 // Mock liquidTemplateSupport module
@@ -15,8 +15,8 @@ jest.mock('../liquidTemplateSupport', () => ({
   validateLiquidHTML: jest.fn(() => ({
     errors: [],
     warnings: [],
-    info: [],
-  })),
+    info: []
+  }))
 }));
 
 // Mock console.warn to avoid noise in tests
@@ -80,7 +80,7 @@ describe('Enhanced htmlValidator Tests', () => {
       });
 
       it('handles very long HTML content', () => {
-        const longHtml = `<p>${'a'.repeat(50000)}</p>`;
+        const longHtml = '<p>' + 'a'.repeat(50000) + '</p>';
         const result = validateHTML(longHtml);
 
         expect(result).toBeDefined();
@@ -109,36 +109,24 @@ describe('Enhanced htmlValidator Tests', () => {
         const html = '<a href="javascript:alert(1)">Click</a>';
         const result = validateHTML(html);
 
-        // Unsafe protocols are BLOCKING ERRORS (sanitizer.dangerousProtocolDetected)
         expect(result.errors.length).toBeGreaterThan(0);
         expect(result.isValid).toBe(false);
-        // Verify it's the correct rule
-        const error = result.errors.find((e) => e.rule === 'sanitizer.dangerousProtocolDetected');
-        expect(error).toBeDefined();
       });
 
       it('detects potentially unsafe data protocol', () => {
         const html = '<img src="data:image/svg+xml,<svg>...">';
         const result = validateHTML(html);
 
-        // Unsafe protocols are BLOCKING ERRORS (sanitizer.dangerousProtocolDetected)
         expect(result.errors.length).toBeGreaterThan(0);
         expect(result.isValid).toBe(false);
-        // Verify it's the correct rule
-        const error = result.errors.find((e) => e.rule === 'sanitizer.dangerousProtocolDetected');
-        expect(error).toBeDefined();
       });
 
       it('detects potentially unsafe vbscript protocol', () => {
         const html = '<a href="vbscript:msgbox(1)">Click</a>';
         const result = validateHTML(html);
 
-        // Unsafe protocols are BLOCKING ERRORS (sanitizer.dangerousProtocolDetected)
         expect(result.errors.length).toBeGreaterThan(0);
         expect(result.isValid).toBe(false);
-        // Verify it's the correct rule
-        const error = result.errors.find((e) => e.rule === 'sanitizer.dangerousProtocolDetected');
-        expect(error).toBeDefined();
       });
 
       it('handles script tags appropriately', () => {
@@ -429,7 +417,7 @@ describe('Enhanced htmlValidator Tests', () => {
       });
 
       it('handles very long CSS content', () => {
-        const longCSS = `.long { ${'color: red; '.repeat(1000)}}`;
+        const longCSS = '.long { ' + 'color: red; '.repeat(1000) + '}';
         const result = validateCSS(longCSS);
 
         expect(result).toBeDefined();
@@ -448,10 +436,8 @@ describe('Enhanced htmlValidator Tests', () => {
         const result = validateCSS(css);
 
         expect(result).toBeDefined();
-        // CSS validation issues are WARNINGS (not blocking errors)
-        expect(result.warnings.length).toBeGreaterThan(0);
-        // isValid can be true if only warnings exist (warnings don't block)
-        expect(typeof result.isValid).toBe('boolean');
+        expect(result.isValid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
       });
 
       it('detects empty rules', () => {
@@ -462,10 +448,8 @@ describe('Enhanced htmlValidator Tests', () => {
         const result = validateCSS(css);
 
         expect(result).toBeDefined();
-        // CSS validation issues are WARNINGS (not blocking errors)
-        expect(result.warnings.length).toBeGreaterThan(0);
-        // isValid can be true if only warnings exist (warnings don't block)
-        expect(typeof result.isValid).toBe('boolean');
+        expect(result.isValid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
       });
     });
   });
@@ -552,10 +536,8 @@ describe('Enhanced htmlValidator Tests', () => {
         const result = extractAndValidateCSS(html);
 
         expect(result).toBeDefined();
-        // CSS validation issues are WARNINGS (not blocking errors)
-        expect(result.warnings.length).toBeGreaterThan(0);
-        // isValid can be true if only warnings exist (warnings don't block)
-        expect(typeof result.isValid).toBe('boolean');
+        expect(result.isValid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
       });
     });
 
@@ -594,7 +576,7 @@ describe('Enhanced htmlValidator Tests', () => {
       const mockHTMLHint = {
         verify: jest.fn(() => {
           throw new Error('HTMLHint validation failed');
-        }),
+        })
       };
 
       // Temporarily replace HTMLHint
@@ -603,13 +585,9 @@ describe('Enhanced htmlValidator Tests', () => {
       const html = '<div>Test content</div>';
       const result = validateHTML(html);
 
-      // HTMLHint errors are caught and handled gracefully - result should still be defined
-      // When HTMLHint throws, it's caught and a warning is added (not an error)
-      expect(result).toBeDefined();
-      expect(typeof result.isValid).toBe('boolean');
-      // HTMLHint errors are converted to warnings in the catch block
-      expect(result.warnings.length).toBeGreaterThan(0);
-      expect(result.warnings[0].message).toContain('HTMLHint validation failed');
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0].message).toContain('HTMLHint validation failed');
 
       // Restore original HTMLHint
       require('htmlhint').HTMLHint = originalHTMLHint;
@@ -662,9 +640,10 @@ describe('Enhanced htmlValidator Tests', () => {
     });
 
     it('falls back to default formatter when custom formatter fails', () => {
-      const failingFormatter = jest.fn((key, values) =>
+      const failingFormatter = jest.fn((key, values) => {
         // Don't throw error, just return the key as fallback behavior
-        key);
+        return key;
+      });
 
       const html = '<a href="javascript:alert(1)">Unsafe link</a>';
       const result = validateHTML(html, 'email', failingFormatter);
@@ -742,10 +721,8 @@ line4`;
       const css = '.class { }';
       const result = validateCSS(css);
 
-      // CSS validation issues are WARNINGS (not blocking errors)
-      expect(result.warnings.length).toBeGreaterThan(0);
-      // isValid can be true if only warnings exist (warnings don't block)
-      expect(typeof result.isValid).toBe('boolean');
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
     });
 
     it('handles multiple consecutive unsafe protocols', () => {
@@ -778,15 +755,9 @@ line4`;
       // Get the mocked module and set it to return specific results
       const { validateLiquidHTML } = require('../liquidTemplateSupport');
       validateLiquidHTML.mockImplementation(() => ({
-        errors: [{
-          type: 'error', message: 'Liquid error', line: 1, column: 1, rule: 'liquid-test', severity: 'error', source: 'liquid',
-        }],
-        warnings: [{
-          type: 'warning', message: 'Liquid warning', line: 1, column: 1, rule: 'liquid-test', severity: 'warning', source: 'liquid',
-        }],
-        info: [{
-          type: 'info', message: 'Liquid info', line: 1, column: 1, rule: 'liquid-test', severity: 'info', source: 'liquid',
-        }],
+        errors: [{ type: 'error', message: 'Liquid error', line: 1, column: 1, rule: 'liquid-test', severity: 'error', source: 'liquid' }],
+        warnings: [{ type: 'warning', message: 'Liquid warning', line: 1, column: 1, rule: 'liquid-test', severity: 'warning', source: 'liquid' }],
+        info: [{ type: 'info', message: 'Liquid info', line: 1, column: 1, rule: 'liquid-test', severity: 'info', source: 'liquid' }]
       }));
 
       const html = '<div>{{ liquid.template }}</div>';
@@ -819,9 +790,7 @@ line4`;
       // Get the mocked module and set it to return only some result types
       const { validateLiquidHTML } = require('../liquidTemplateSupport');
       validateLiquidHTML.mockImplementation(() => ({
-        errors: [{
-          type: 'error', message: 'Liquid error', line: 1, column: 1, rule: 'liquid-test', severity: 'error', source: 'liquid',
-        }],
+        errors: [{ type: 'error', message: 'Liquid error', line: 1, column: 1, rule: 'liquid-test', severity: 'error', source: 'liquid' }],
         // Missing warnings and info arrays
       }));
 
@@ -839,9 +808,7 @@ line4`;
       // Get the mocked module and set it to return only warnings
       const { validateLiquidHTML } = require('../liquidTemplateSupport');
       validateLiquidHTML.mockImplementation(() => ({
-        warnings: [{
-          type: 'warning', message: 'Liquid warning', line: 1, column: 1, rule: 'liquid-test', severity: 'warning', source: 'liquid',
-        }],
+        warnings: [{ type: 'warning', message: 'Liquid warning', line: 1, column: 1, rule: 'liquid-test', severity: 'warning', source: 'liquid' }],
       }));
 
       const html = '<div>{{ liquid.template }}</div>';
@@ -858,9 +825,7 @@ line4`;
       // Get the mocked module and set it to return only info
       const { validateLiquidHTML } = require('../liquidTemplateSupport');
       validateLiquidHTML.mockImplementation(() => ({
-        info: [{
-          type: 'info', message: 'Liquid info', line: 1, column: 1, rule: 'liquid-test', severity: 'info', source: 'liquid',
-        }],
+        info: [{ type: 'info', message: 'Liquid info', line: 1, column: 1, rule: 'liquid-test', severity: 'info', source: 'liquid' }],
       }));
 
       const html = '<div>{{ liquid.template }}</div>';
@@ -886,10 +851,8 @@ line4`;
       `;
       const result = validateCSS(css);
 
-      // CSS validation issues are WARNINGS (not blocking errors)
-      expect(result.warnings.length).toBeGreaterThan(0);
-      // isValid can be true if only warnings exist (warnings don't block)
-      expect(typeof result.isValid).toBe('boolean');
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
     });
 
     it('handles CSS with nested braces', () => {
@@ -900,10 +863,8 @@ line4`;
       `;
       const result = validateCSS(css);
 
-      // CSS validation issues are WARNINGS (not blocking errors)
-      expect(result.warnings.length).toBeGreaterThan(0);
-      // isValid can be true if only warnings exist (warnings don't block)
-      expect(typeof result.isValid).toBe('boolean');
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
     });
 
     it('handles CSS with mixed valid and invalid rules', () => {
@@ -915,11 +876,9 @@ line4`;
       `;
       const result = validateCSS(css);
 
-      // CSS validation issues are WARNINGS (not blocking errors)
-      // Should detect at least one empty rule as warning
-      expect(result.warnings.length).toBeGreaterThanOrEqual(1);
-      // isValid can be true if only warnings exist (warnings don't block)
-      expect(typeof result.isValid).toBe('boolean');
+      expect(result.isValid).toBe(false);
+      // Should detect at least one empty rule
+      expect(result.errors.length).toBeGreaterThanOrEqual(1);
     });
 
     it('handles CSS validation exception scenarios', () => {
@@ -958,126 +917,6 @@ line4`;
     });
   });
 
-  describe('getSeverityLevel edge cases (lines 112-118, 159-166)', () => {
-    it('categorizes warning-level HTMLHint rules as warnings', () => {
-      // Test with HTML that triggers known warning rules like tag-pair
-      const html = '<p>Unclosed paragraph tag';
-      const result = validateHTML(html);
-
-      // Should have warnings for unclosed tag
-      expect(result).toBeDefined();
-      expect(result.warnings.length).toBeGreaterThanOrEqual(0);
-    });
-
-    it('categorizes attr-no-duplication rule as warning', () => {
-      const html = '<div class="test" class="duplicate">Duplicate attribute</div>';
-      const result = validateHTML(html);
-
-      expect(result).toBeDefined();
-      // Should categorize as warning based on warningRules list
-      expect(typeof result.isValid).toBe('boolean');
-    });
-
-    it('categorizes id-unique rule as warning', () => {
-      const html = '<div id="unique"><span id="unique">Duplicate ID</span></div>';
-      const result = validateHTML(html);
-
-      expect(result).toBeDefined();
-      expect(typeof result.isValid).toBe('boolean');
-    });
-
-    it('categorizes spec-char-escape rule as warning', () => {
-      const html = '<p>Special characters & < ></p>';
-      const result = validateHTML(html);
-
-      expect(result).toBeDefined();
-      expect(typeof result.isValid).toBe('boolean');
-    });
-
-    it('categorizes tagname-lowercase rule as warning', () => {
-      const html = '<DIV><P>Uppercase tags</P></DIV>';
-      const result = validateHTML(html);
-
-      expect(result).toBeDefined();
-      expect(typeof result.isValid).toBe('boolean');
-    });
-
-    it('categorizes alt-require rule as warning', () => {
-      const html = '<img src="test.jpg">';
-      const result = validateHTML(html);
-
-      expect(result).toBeDefined();
-      expect(typeof result.isValid).toBe('boolean');
-    });
-
-    it('downgrades HTMLHint error type to warning (line 163-164)', () => {
-      // HTMLHint "error" types that are not in warningRules should be downgraded to warning
-      // This covers the case where type === 'error' returns 'warning'
-      const htmlWithStructuralError = '<div><span>Missing closing span</div>';
-      const result = validateHTML(htmlWithStructuralError);
-
-      expect(result).toBeDefined();
-      // Structural HTML errors are downgraded to warnings
-      expect(typeof result.isValid).toBe('boolean');
-    });
-
-    it('returns info for non-warning, non-error types (line 166)', () => {
-      // Test content that would produce info-level issues
-      const simpleHtml = '<div></div>';
-      const result = validateHTML(simpleHtml);
-
-      expect(result).toBeDefined();
-      expect(typeof result.isValid).toBe('boolean');
-      // Info array should exist
-      expect(Array.isArray(result.info)).toBe(true);
-    });
-
-    it('processes multiple issues with different severity levels (lines 112-118)', () => {
-      // HTML that produces multiple issues with different severities
-      const mixedHtml = `
-        <DIV class="test" class="dup">
-          <IMG src="">
-          <P>Text
-        </DIV>
-      `;
-      const result = validateHTML(mixedHtml);
-
-      expect(result).toBeDefined();
-      // Should process and categorize issues correctly
-      expect(Array.isArray(result.errors)).toBe(true);
-      expect(Array.isArray(result.warnings)).toBe(true);
-      expect(Array.isArray(result.info)).toBe(true);
-    });
-
-    it('pushes warning severity to warnings array (line 112-113)', () => {
-      // This specifically tests when error.severity === 'warning'
-      const htmlWithWarnings = '<DIV></DIV>'; // Uppercase tag names
-      const result = validateHTML(htmlWithWarnings);
-
-      expect(result).toBeDefined();
-      // Warnings should be in the warnings array
-      expect(Array.isArray(result.warnings)).toBe(true);
-    });
-
-    it('pushes info severity to info array (line 114-115)', () => {
-      // Content that produces info-level validation results
-      const simpleContent = '<div><p>Valid content</p></div>';
-      const result = validateHTML(simpleContent);
-
-      expect(result).toBeDefined();
-      expect(Array.isArray(result.info)).toBe(true);
-    });
-
-    it('pushes other severities to warnings array as fallback (line 116-117)', () => {
-      // This covers the else branch where unknown severities go to warnings
-      const html = '<div>Test</div>';
-      const result = validateHTML(html);
-
-      expect(result).toBeDefined();
-      expect(Array.isArray(result.warnings)).toBe(true);
-    });
-  });
-
   describe('extractAndValidateCSS Advanced Tests', () => {
     it('handles multiple style tags with mixed validity', () => {
       const html = `
@@ -1088,10 +927,8 @@ line4`;
       `;
       const result = extractAndValidateCSS(html);
 
-      // CSS validation issues are WARNINGS (not blocking errors)
-      expect(result.warnings.length).toBeGreaterThan(0);
-      // isValid can be true if only warnings exist (warnings don't block)
-      expect(typeof result.isValid).toBe('boolean');
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
     });
 
     it('handles style tags with complex CSS', () => {
@@ -1106,21 +943,17 @@ line4`;
       `;
       const result = extractAndValidateCSS(html);
 
-      // CSS validation issues are WARNINGS (not blocking errors)
-      expect(result.warnings.length).toBeGreaterThan(0);
-      // isValid can be true if only warnings exist (warnings don't block)
-      expect(typeof result.isValid).toBe('boolean');
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
     });
 
     it('correctly identifies unclosed style tags', () => {
       const html = '<style>.test { color: red; }';
       const result = extractAndValidateCSS(html);
 
-      // CSS validation issues are WARNINGS (not blocking errors)
-      expect(result.warnings.length).toBeGreaterThan(0);
-      expect(result.warnings.some((warning) => warning.rule === 'unclosed-style-tag')).toBe(true);
-      // isValid can be true if only warnings exist (warnings don't block)
-      expect(typeof result.isValid).toBe('boolean');
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors.some(error => error.rule === 'unclosed-style-tag')).toBe(true);
     });
 
     it('handles multiple unclosed style tags', () => {
@@ -1131,10 +964,8 @@ line4`;
       `;
       const result = extractAndValidateCSS(html);
 
-      // CSS validation issues are WARNINGS (not blocking errors)
-      expect(result.warnings.length).toBeGreaterThan(0);
-      // isValid can be true if only warnings exist (warnings don't block)
-      expect(typeof result.isValid).toBe('boolean');
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
     });
   });
 
@@ -1186,10 +1017,10 @@ line4`;
         '<table><tr><td>Table content</td></tr></table>',
         '<form><input type="text"><button>Submit</button></form>',
         '<ul><li>List item 1</li><li>List item 2</li></ul>',
-        '<article><header><h1>Article</h1></header><p>Content</p></article>',
+        '<article><header><h1>Article</h1></header><p>Content</p></article>'
       ];
 
-      testCases.forEach((html) => {
+      testCases.forEach(html => {
         const result = validateHTML(html);
         expect(result).toBeDefined();
         expect(typeof result.isValid).toBe('boolean');
@@ -1208,4 +1039,4 @@ line4`;
       expect(typeof inappResult.isValid).toBe('boolean');
     });
   });
-});
+});

package/v2Components/HtmlEditor/utils/__tests__/validationAdapter.test.js

@@ -238,137 +238,3 @@ describe('getValidationSummary', () => {
   });
 });
 
-describe('validationAdapter error handling', () => {
-  describe('transformValidationToErrorInfo error handling', () => {
-    it('handles validation without getAllIssues method (line 33-36)', () => {
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const validation = {
-        isValidating: false,
-        // Missing getAllIssues method
-      };
-
-      const result = transformValidationToErrorInfo(validation);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('[validationAdapter] validation.getAllIssues is not a function'),
-        validation
-      );
-      expect(result).toEqual({
-        errorMessages: {
-          LIQUID_ERROR_MSG: [],
-          STANDARD_ERROR_MSG: [],
-        },
-      });
-
-      consoleSpy.mockRestore();
-    });
-
-    it('handles getAllIssues returning non-array (line 40-43)', () => {
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const validation = {
-        isValidating: false,
-        getAllIssues: jest.fn(() => 'not an array'), // Returns string instead of array
-      };
-
-      const result = transformValidationToErrorInfo(validation);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('[validationAdapter] validation.getAllIssues() did not return an array'),
-        'not an array'
-      );
-      expect(result).toEqual({
-        errorMessages: {
-          LIQUID_ERROR_MSG: [],
-          STANDARD_ERROR_MSG: [],
-        },
-      });
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('hasValidationErrors error handling', () => {
-    it('handles validation without getAllIssues method (line 106-110)', () => {
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const validation = {
-        isValidating: false,
-        // Missing getAllIssues method
-      };
-
-      const result = hasValidationErrors(validation);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('[validationAdapter] validation.getAllIssues is not a function'),
-        validation
-      );
-      expect(result).toBe(false);
-
-      consoleSpy.mockRestore();
-    });
-
-    it('handles getAllIssues returning non-array (line 112-116)', () => {
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const validation = {
-        isValidating: false,
-        getAllIssues: jest.fn(() => null), // Returns null instead of array
-      };
-
-      const result = hasValidationErrors(validation);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('[validationAdapter] validation.getAllIssues() did not return an array'),
-        null
-      );
-      expect(result).toBe(false);
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('getValidationSummary error handling', () => {
-    it('handles validation without getAllIssues method (line 131-135)', () => {
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const validation = {
-        isValidating: false,
-        // Missing getAllIssues method
-      };
-
-      const result = getValidationSummary(validation);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('[validationAdapter] validation.getAllIssues is not a function'),
-        validation
-      );
-      expect(result).toEqual({
-        totalErrors: 0,
-        totalWarnings: 0,
-        hasLiquidErrors: false,
-      });
-
-      consoleSpy.mockRestore();
-    });
-
-    it('handles getAllIssues returning non-array (line 138-141)', () => {
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const validation = {
-        isValidating: false,
-        getAllIssues: jest.fn(() => ({})), // Returns object instead of array
-      };
-
-      const result = getValidationSummary(validation);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('[validationAdapter] validation.getAllIssues() did not return an array'),
-        {}
-      );
-      expect(result).toEqual({
-        totalErrors: 0,
-        totalWarnings: 0,
-        hasLiquidErrors: false,
-      });
-
-      consoleSpy.mockRestore();
-    });
-  });
-});
-