@afixt/test-utils 1.1.1 → 1.1.3

package/test/stringUtils.test.js

@@ -94,13 +94,247 @@ describe('stringUtils', () => {
     });
   });
 
+  describe('isAlphaNumeric', () => {
+    it('should return true for strings containing only alphanumeric characters', () => {
+      expect(stringUtils.isAlphaNumeric('abc123')).toBe(true);
+      expect(stringUtils.isAlphaNumeric('ABC')).toBe(true);
+      expect(stringUtils.isAlphaNumeric('123')).toBe(true);
+      expect(stringUtils.isAlphaNumeric('Test123')).toBe(true);
+      expect(stringUtils.isAlphaNumeric('a')).toBe(true);
+      expect(stringUtils.isAlphaNumeric('1')).toBe(true);
+    });
+
+    it('should return false for strings containing non-alphanumeric characters', () => {
+      expect(stringUtils.isAlphaNumeric('abc 123')).toBe(false); // space
+      expect(stringUtils.isAlphaNumeric('abc-123')).toBe(false); // hyphen
+      expect(stringUtils.isAlphaNumeric('abc_123')).toBe(false); // underscore
+      expect(stringUtils.isAlphaNumeric('abc@123')).toBe(false); // special character
+      expect(stringUtils.isAlphaNumeric('abc.123')).toBe(false); // period
+      expect(stringUtils.isAlphaNumeric('abc!123')).toBe(false); // exclamation
+      expect(stringUtils.isAlphaNumeric('')).toBe(false); // empty string
+    });
+
+    it('should return false for special edge cases', () => {
+      expect(stringUtils.isAlphaNumeric('\n')).toBe(false); // newline
+      expect(stringUtils.isAlphaNumeric('\t')).toBe(false); // tab
+      expect(stringUtils.isAlphaNumeric('   ')).toBe(false); // whitespace
+    });
+  });
+
   describe('getPathFromUrl', () => {
     it('should extract the pathname correctly', () => {
       expect(stringUtils.getPathFromUrl('https://example.com/path/to/resource')).toBe('/path/to/resource');
       expect(stringUtils.getPathFromUrl('https://example.com/')).toBe('/');
       expect(stringUtils.getPathFromUrl('https://example.com/path?query=string')).toBe('/path');
     });
+
+    it('should handle complex URLs', () => {
+      expect(stringUtils.getPathFromUrl('https://subdomain.example.com/path/to/resource')).toBe('/path/to/resource');
+      expect(stringUtils.getPathFromUrl('http://example.com/path/to/resource#hash')).toBe('/path/to/resource');
+      expect(stringUtils.getPathFromUrl('https://example.com:8080/path')).toBe('/path');
+    });
+
+    it('should handle URLs with encoded characters', () => {
+      expect(stringUtils.getPathFromUrl('https://example.com/path%20with%20spaces')).toBe('/path%20with%20spaces');
+      expect(stringUtils.getPathFromUrl('https://example.com/path/with/special%20chars')).toBe('/path/with/special%20chars');
+    });
+  });
+
+  describe('getAllText', () => {
+    it('should extract text from simple text nodes', () => {
+      const div = document.createElement('div');
+      div.textContent = 'Hello World';
+      
+      expect(stringUtils.getAllText(div)).toBe('Hello World');
+    });
+
+    it('should extract text from nested elements', () => {
+      const div = document.createElement('div');
+      const span = document.createElement('span');
+      span.textContent = 'Hello';
+      const text = document.createTextNode(' World');
+      
+      div.appendChild(span);
+      div.appendChild(text);
+      
+      expect(stringUtils.getAllText(div)).toBe('Hello World');
+    });
+
+    it('should extract aria-label attributes', () => {
+      const div = document.createElement('div');
+      const button = document.createElement('button');
+      button.setAttribute('aria-label', 'Close dialog');
+      button.textContent = 'X';
+      
+      div.appendChild(button);
+      
+      const result = stringUtils.getAllText(div);
+      expect(result).toContain('Close dialog');
+      expect(result).toContain('X');
+    });
+
+    it('should extract alt attributes from images', () => {
+      const div = document.createElement('div');
+      const img = document.createElement('img');
+      img.setAttribute('alt', 'Profile picture');
+      img.setAttribute('src', 'profile.jpg');
+      
+      div.appendChild(img);
+      
+      expect(stringUtils.getAllText(div)).toBe('Profile picture');
+    });
+
+    it('should handle mixed content with text, aria-labels, and alt text', () => {
+      const div = document.createElement('div');
+      
+      // Add some text
+      const textNode = document.createTextNode('Welcome ');
+      div.appendChild(textNode);
+      
+      // Add element with aria-label
+      const button = document.createElement('button');
+      button.setAttribute('aria-label', 'Help');
+      button.textContent = '?';
+      div.appendChild(button);
+      
+      // Add some more text
+      const moreText = document.createTextNode(' to our site ');
+      div.appendChild(moreText);
+      
+      // Add image with alt text
+      const img = document.createElement('img');
+      img.setAttribute('alt', 'Company logo');
+      div.appendChild(img);
+      
+      const result = stringUtils.getAllText(div);
+      expect(result).toContain('Welcome');
+      expect(result).toContain('Help');
+      expect(result).toContain('?');
+      expect(result).toContain('to our site');
+      expect(result).toContain('Company logo');
+    });
+
+    it('should handle empty elements', () => {
+      const div = document.createElement('div');
+      expect(stringUtils.getAllText(div)).toBe('');
+    });
+
+    it('should trim whitespace from text nodes', () => {
+      const div = document.createElement('div');
+      const textNode = document.createTextNode('   Hello World   ');
+      div.appendChild(textNode);
+      
+      expect(stringUtils.getAllText(div)).toBe('Hello World');
+    });
+
+    it('should handle elements with only whitespace', () => {
+      const div = document.createElement('div');
+      const textNode = document.createTextNode('   ');
+      div.appendChild(textNode);
+      
+      // Should use textContent.trim() as fallback for empty text
+      expect(stringUtils.getAllText(div)).toBe('');
+    });
+
+    it('should handle deeply nested structures', () => {
+      const div = document.createElement('div');
+      const section = document.createElement('section');
+      const article = document.createElement('article');
+      const p = document.createElement('p');
+      
+      p.textContent = 'Deep content';
+      article.appendChild(p);
+      section.appendChild(article);
+      div.appendChild(section);
+      
+      expect(stringUtils.getAllText(div)).toBe('Deep content');
+    });
+
+    it('should handle images without alt attributes', () => {
+      const div = document.createElement('div');
+      const img = document.createElement('img');
+      img.setAttribute('src', 'image.jpg');
+      // No alt attribute
+      
+      const text = document.createTextNode('Some text');
+      div.appendChild(text);
+      div.appendChild(img);
+      
+      expect(stringUtils.getAllText(div)).toBe('Some text');
+    });
+
+    it('should handle elements without aria-label', () => {
+      const div = document.createElement('div');
+      const button = document.createElement('button');
+      button.textContent = 'Click me';
+      // No aria-label attribute
+      
+      div.appendChild(button);
+      
+      expect(stringUtils.getAllText(div)).toBe('Click me');
+    });
   });
 
-  // Add more tests for getAllText and hasText when running in a DOM environment
+  describe('hasText', () => {
+    it('should return true for elements with text content', () => {
+      const div = document.createElement('div');
+      div.textContent = 'Hello World';
+      
+      expect(stringUtils.hasText(div)).toBe(true);
+    });
+
+    it('should return false for empty elements', () => {
+      const div = document.createElement('div');
+      
+      expect(stringUtils.hasText(div)).toBe(false);
+    });
+
+    it('should return false for elements with only whitespace', () => {
+      const div = document.createElement('div');
+      div.textContent = '   \n\t   ';
+      
+      expect(stringUtils.hasText(div)).toBe(false);
+    });
+
+    it('should return true for elements with aria-label', () => {
+      const div = document.createElement('div');
+      const button = document.createElement('button');
+      button.setAttribute('aria-label', 'Close');
+      
+      div.appendChild(button);
+      
+      expect(stringUtils.hasText(div)).toBe(true);
+    });
+
+    it('should return true for elements with image alt text', () => {
+      const div = document.createElement('div');
+      const img = document.createElement('img');
+      img.setAttribute('alt', 'Profile picture');
+      
+      div.appendChild(img);
+      
+      expect(stringUtils.hasText(div)).toBe(true);
+    });
+
+    it('should return true for nested elements with text', () => {
+      const div = document.createElement('div');
+      const span = document.createElement('span');
+      span.textContent = 'Nested text';
+      
+      div.appendChild(span);
+      
+      expect(stringUtils.hasText(div)).toBe(true);
+    });
+
+    it('should return false for elements with empty nested structure', () => {
+      const div = document.createElement('div');
+      const span = document.createElement('span');
+      const p = document.createElement('p');
+      
+      div.appendChild(span);
+      span.appendChild(p);
+      
+      expect(stringUtils.hasText(div)).toBe(false);
+    });
+  });
 });

package/test/testContrast.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach } from 'vitest';
 import { testContrast } from '../src/testContrast';
 
 describe('testContrast', () => {
@@ -18,16 +18,17 @@ describe('testContrast', () => {
     expect(testContrast(div)).toBe(true);
   });
 
-  it('should handle color contrast ratio correctly', () => {
-    // Mock a function to test the specific case
+  it('should handle identical colors (JSDOM test case)', () => {
     const div = document.createElement('div');
-    div.textContent = 'Test text with identical colors';
-    div.setAttribute('data-test-identical-colors', 'true');
+    div.textContent = 'Test text';
+    div.style.color = 'rgb(0, 0, 0)';
+    div.style.backgroundColor = 'rgb(0, 0, 0)';
     document.body.appendChild(div);
     
-    // Since JSDOM doesn't properly handle computed styles, we can only verify
-    // that the function works and doesn't throw exceptions
-    expect(() => testContrast(div)).not.toThrow();
+    // In JSDOM, this may return true due to computed style limitations
+    // The function is designed to handle this specific test case
+    const result = testContrast(div);
+    expect(typeof result).toBe('boolean');
   });
 
   it('should return true for elements with sufficient contrast (AA)', () => {
@@ -74,4 +75,171 @@ describe('testContrast', () => {
     // Bold text at 14px is treated as large text (3:1 for AA)
     expect(testContrast(div, { level: 'AA' })).toBe(true);
   });
+
+  it('should handle default options when none provided', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Default options text';
+    div.style.color = 'rgb(0, 0, 0)';
+    div.style.backgroundColor = 'rgb(255, 255, 255)';
+    document.body.appendChild(div);
+    
+    expect(testContrast(div)).toBe(true);
+  });
+
+  it('should handle elements with background images', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Text with background image';
+    div.style.color = 'rgb(0, 0, 0)';
+    div.style.backgroundImage = 'url(image.jpg)';
+    document.body.appendChild(div);
+    
+    // Should return true because background color can't be determined
+    expect(testContrast(div)).toBe(true);
+  });
+
+  it('should handle invisible elements', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Hidden text';
+    div.style.display = 'none';
+    document.body.appendChild(div);
+    
+    expect(testContrast(div)).toBe(true);
+  });
+
+  it('should handle offscreen elements', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Offscreen text';
+    div.style.position = 'absolute';
+    div.style.left = '-9999px';
+    document.body.appendChild(div);
+    
+    expect(testContrast(div)).toBe(true);
+  });
+
+  it('should handle AA level for medium text (14-17px)', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Medium text';
+    div.style.color = 'rgb(100, 100, 100)';
+    div.style.backgroundColor = 'rgb(255, 255, 255)';
+    div.style.fontSize = '16px';
+    document.body.appendChild(div);
+    
+    expect(testContrast(div, { level: 'AA' })).toBe(true);
+  });
+
+  it('should handle AAA level for large text', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Large text AAA';
+    div.style.color = 'rgb(80, 80, 80)';
+    div.style.backgroundColor = 'rgb(255, 255, 255)';
+    div.style.fontSize = '20px';
+    document.body.appendChild(div);
+    
+    expect(testContrast(div, { level: 'AAA' })).toBe(true);
+  });
+
+  it('should handle bold text at 14px for AAA', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Bold 14px AAA';
+    div.style.color = 'rgb(60, 60, 60)';
+    div.style.backgroundColor = 'rgb(255, 255, 255)';
+    div.style.fontSize = '14px';
+    div.style.fontWeight = 'bold';
+    document.body.appendChild(div);
+    
+    expect(testContrast(div, { level: 'AAA' })).toBe(true);
+  });
+
+  it('should handle numeric font weight', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Numeric weight';
+    div.style.color = 'rgb(80, 80, 80)';
+    div.style.backgroundColor = 'rgb(255, 255, 255)';
+    div.style.fontSize = '14px';
+    div.style.fontWeight = '700';
+    document.body.appendChild(div);
+    
+    expect(testContrast(div, { level: 'AA' })).toBe(true);
+  });
+
+  it('should handle transparent background with parent', () => {
+    const parent = document.createElement('div');
+    parent.style.backgroundColor = 'rgb(255, 255, 255)';
+    
+    const child = document.createElement('div');
+    child.textContent = 'Child with transparent bg';
+    child.style.color = 'rgb(0, 0, 0)';
+    child.style.backgroundColor = 'rgba(0, 0, 0, 0)';
+    
+    parent.appendChild(child);
+    document.body.appendChild(parent);
+    
+    expect(testContrast(child)).toBe(true);
+  });
+
+  it('should handle elements without computed styles properly', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Test without style';
+    
+    // Just test that the function handles elements without explicit styles
+    expect(() => testContrast(div)).not.toThrow();
+    expect(typeof testContrast(div)).toBe('boolean');
+  });
+
+  it('should handle small text requiring 4.5:1 ratio', () => {
+    const div = document.createElement('div');
+    div.textContent = 'Small text';
+    div.style.color = 'rgb(0, 0, 0)';
+    div.style.backgroundColor = 'rgb(255, 255, 255)';
+    div.style.fontSize = '12px';
+    document.body.appendChild(div);
+    
+    expect(testContrast(div, { level: 'AA' })).toBe(true);
+  });
+
+  it('should handle element with parent having different colors', () => {
+    const parent = document.createElement('div');
+    parent.style.color = 'rgb(255, 0, 0)'; // Different color
+    parent.style.backgroundColor = 'rgb(0, 0, 255)'; // Different background
+    
+    const child = document.createElement('div');
+    child.textContent = 'Child with different colors';
+    child.style.color = 'rgb(0, 0, 0)';
+    child.style.backgroundColor = 'rgb(255, 255, 255)';
+    
+    parent.appendChild(child);
+    document.body.appendChild(parent);
+    
+    expect(testContrast(child)).toBe(true);
+  });
+
+  it('should handle element with parent having same colors', () => {
+    const parent = document.createElement('div');
+    parent.style.color = 'rgb(0, 0, 0)'; // Same color
+    parent.style.backgroundColor = 'rgb(255, 255, 255)'; // Same background
+    parent.style.fontSize = '16px'; // Same size
+    parent.style.fontWeight = 'normal'; // Same weight
+    
+    const child = document.createElement('div');
+    child.textContent = 'Child with same colors';
+    child.style.color = 'rgb(0, 0, 0)';
+    child.style.backgroundColor = 'rgb(255, 255, 255)';
+    child.style.fontSize = '16px';
+    child.style.fontWeight = 'normal';
+    
+    parent.appendChild(child);
+    document.body.appendChild(parent);
+    
+    expect(testContrast(child)).toBe(true);
+  });
+
+  it('should handle element without parent', () => {
+    const div = document.createElement('div');
+    div.textContent = 'No parent element';
+    div.style.color = 'rgb(0, 0, 0)';
+    div.style.backgroundColor = 'rgb(255, 255, 255)';
+    
+    // Don't append to body to test no parent scenario
+    expect(testContrast(div)).toBe(true);
+  });
 });