@afixt/test-utils 1.3.0 → 2.0.1

package/test/getImageText.test.js

@@ -1,104 +1,163 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-// Mock tesseract.js at the top level to avoid worker initialization errors
+// Basic module mock to prevent tesseract worker initialization
 vi.mock('tesseract.js', () => ({
-  default: {
-    recognize: () => Promise.reject(new Error('Mocked tesseract error')),
-  },
-  recognize: () => Promise.reject(new Error('Mocked tesseract error')),
+    default: {
+        recognize: vi.fn().mockRejectedValue(new Error('Mocked tesseract error')),
+    },
+    recognize: vi.fn().mockRejectedValue(new Error('Mocked tesseract error')),
 }));
 
 describe('getImageText', () => {
-  it('should be defined and exported from the module', async () => {
-    // Test that the function is properly exported
-    const { getImageText } = await import('../src/getImageText.js');
-    expect(typeof getImageText).toBe('function');
-  });
-
-  it('should be an async function', async () => {
-    // Test that the function returns a promise
-    const { getImageText } = await import('../src/getImageText.js');
-    const result = getImageText('test-path');
-    expect(result).toBeInstanceOf(Promise);
-    
-    // Clean up the promise to avoid unhandled rejection
-    result.catch(() => {});
-  });
-
-  it('should handle invalid image paths gracefully', async () => {
-    // Test with clearly invalid paths that should trigger error handling
-    const { getImageText } = await import('../src/getImageText.js');
-    
-    // Suppress console.error for this test
-    const originalError = console.error;
-    console.error = () => {};
-    
-    try {
-      const result = await getImageText('non-existent-file.jpg');
-      expect(result).toBe(false);
-    } finally {
-      console.error = originalError;
-    }
-  });
-
-  it('should handle null or undefined input gracefully', async () => {
-    // Test error handling with invalid inputs
-    const { getImageText } = await import('../src/getImageText.js');
-    
-    // Suppress console.error for this test
-    const originalError = console.error;
-    console.error = () => {};
-    
-    try {
-      const result1 = await getImageText(null);
-      expect(result1).toBe(false);
-      
-      const result2 = await getImageText(undefined);
-      expect(result2).toBe(false);
-    } finally {
-      console.error = originalError;
-    }
-  });
-
-  it('should handle empty string input gracefully', async () => {
-    // Test error handling with empty string
-    const { getImageText } = await import('../src/getImageText.js');
-
-    // Suppress console.error for this test
-    const originalError = console.error;
-    console.error = () => {};
-
-    try {
-      const result = await getImageText('');
-      expect(result).toBe(false);
-    } finally {
-      console.error = originalError;
-    }
-  });
-
-  it('should log errors in non-test environments', async () => {
-    // Test that errors are logged when not in test environment
-    const { getImageText } = await import('../src/getImageText.js');
-
-    // Save original values
-    const originalEnv = process.env.NODE_ENV;
-    const originalError = console.error;
-    const errorCalls = [];
-
-    // Set up non-test environment
-    process.env.NODE_ENV = 'production';
-    console.error = (...args) => errorCalls.push(args);
-
-    try {
-      await getImageText('invalid-path.jpg');
-
-      // Verify that console.error was called
-      expect(errorCalls.length).toBeGreaterThan(0);
-      expect(errorCalls[0][0]).toContain('Error processing image');
-    } finally {
-      // Restore original values
-      process.env.NODE_ENV = originalEnv;
-      console.error = originalError;
-    }
-  });
-});
+    let getImageText;
+    let _internal;
+    let recognizeSpy;
+
+    beforeEach(async () => {
+        const mod = await import('../src/getImageText.js');
+        getImageText = mod.getImageText;
+        _internal = mod._internal;
+        recognizeSpy = vi
+            .spyOn(_internal, 'recognize')
+            .mockRejectedValue(new Error('Mocked tesseract error'));
+    });
+
+    afterEach(() => {
+        recognizeSpy.mockRestore();
+    });
+
+    it('should be defined and exported from the module', () => {
+        expect(typeof getImageText).toBe('function');
+    });
+
+    it('should be an async function', () => {
+        const result = getImageText('test-path');
+        expect(result).toBeInstanceOf(Promise);
+        result.catch(() => {});
+    });
+
+    it('should handle invalid image paths gracefully', async () => {
+        const result = await getImageText('non-existent-file.jpg');
+        expect(result).toBe(false);
+    });
+
+    it('should handle null or undefined input gracefully', async () => {
+        const result1 = await getImageText(null);
+        expect(result1).toBe(false);
+
+        const result2 = await getImageText(undefined);
+        expect(result2).toBe(false);
+    });
+
+    it('should handle empty string input gracefully', async () => {
+        const result = await getImageText('');
+        expect(result).toBe(false);
+    });
+
+    it('should log errors in non-test environments', async () => {
+        const originalEnv = process.env.NODE_ENV;
+        const originalError = console.error;
+        const errorCalls = [];
+
+        process.env.NODE_ENV = 'production';
+        console.error = (...args) => errorCalls.push(args);
+
+        try {
+            await getImageText('invalid-path.jpg');
+            expect(errorCalls.length).toBeGreaterThan(0);
+            expect(errorCalls[0][0]).toContain('Error processing image');
+        } finally {
+            process.env.NODE_ENV = originalEnv;
+            console.error = originalError;
+        }
+    });
+
+    it('should default to eng language when no options provided', async () => {
+        recognizeSpy.mockResolvedValueOnce({ data: { text: 'hello' } });
+
+        await getImageText('image.jpg');
+
+        expect(recognizeSpy).toHaveBeenCalledWith(
+            'image.jpg',
+            'eng',
+            expect.objectContaining({ logger: expect.any(Function) })
+        );
+    });
+
+    it('should accept a custom language option', async () => {
+        recognizeSpy.mockResolvedValueOnce({ data: { text: 'bonjour' } });
+
+        await getImageText('image.jpg', { lang: 'fra' });
+
+        expect(recognizeSpy).toHaveBeenCalledWith(
+            'image.jpg',
+            'fra',
+            expect.objectContaining({ logger: expect.any(Function) })
+        );
+    });
+
+    it('should accept multiple languages', async () => {
+        recognizeSpy.mockResolvedValueOnce({ data: { text: 'hello welt' } });
+
+        await getImageText('image.jpg', { lang: 'eng+deu' });
+
+        expect(recognizeSpy).toHaveBeenCalledWith(
+            'image.jpg',
+            'eng+deu',
+            expect.objectContaining({ logger: expect.any(Function) })
+        );
+    });
+
+    it('should accept a custom logger function', async () => {
+        recognizeSpy.mockResolvedValueOnce({ data: { text: 'hello' } });
+        const customLogger = vi.fn();
+
+        await getImageText('image.jpg', { logger: customLogger });
+
+        expect(recognizeSpy).toHaveBeenCalledWith(
+            'image.jpg',
+            'eng',
+            expect.objectContaining({ logger: customLogger })
+        );
+    });
+
+    it('should accept null logger to disable logging', async () => {
+        recognizeSpy.mockResolvedValueOnce({ data: { text: 'hello' } });
+
+        await getImageText('image.jpg', { logger: null });
+
+        expect(recognizeSpy).toHaveBeenCalledWith(
+            'image.jpg',
+            'eng',
+            expect.objectContaining({ logger: null })
+        );
+    });
+
+    it('should pass through additional Tesseract options', async () => {
+        recognizeSpy.mockResolvedValueOnce({ data: { text: 'hello' } });
+
+        await getImageText('image.jpg', { lang: 'eng', corePath: '/custom/path' });
+
+        expect(recognizeSpy).toHaveBeenCalledWith(
+            'image.jpg',
+            'eng',
+            expect.objectContaining({ corePath: '/custom/path', logger: expect.any(Function) })
+        );
+    });
+
+    it('should return trimmed text on successful extraction', async () => {
+        recognizeSpy.mockResolvedValueOnce({ data: { text: '  hello world  ' } });
+
+        const result = await getImageText('image.jpg');
+
+        expect(result).toBe('hello world');
+    });
+
+    it('should return false for empty or whitespace-only text', async () => {
+        recognizeSpy.mockResolvedValueOnce({ data: { text: '   \n\t  ' } });
+
+        const result = await getImageText('image.jpg');
+
+        expect(result).toBe(false);
+    });
+});

package/test/index.test.js

@@ -62,7 +62,7 @@ describe('index.js exports', () => {
 
     it('should export visibility utilities', () => {
         expect(utils.isOffScreen).toBeDefined();
-        expect(utils.isVisible).toBeDefined();
+        expect(utils.isA11yVisible).toBeDefined();
     });
 
     it('should export element relationship utilities', () => {
@@ -109,7 +109,6 @@ describe('index.js exports', () => {
         expect(utils.isUpperCase).toBeDefined();
         expect(utils.isAlphaNumeric).toBeDefined();
         expect(utils.getPathFromUrl).toBeDefined();
-        expect(utils.getAllText).toBeDefined();
         expect(utils.hasText).toBeDefined();
     });
 
@@ -133,13 +132,28 @@ describe('index.js exports', () => {
 
     it('should have function exports for utilities', () => {
         const functionExports = [
-            'arrayUnique', 'arrayRemoveByValue', 'arrayCount', 'cleanBlank',
-            'hasAttr', 'attrBegins', 'getAccessibleText', 'hasValidAriaAttributes',
-            'getCSSGeneratedContent', 'isComplexTable', 'isVisible', 'hasParent',
-            'getFocusableElements', 'getComputedRole', 'getImageText', 'testContrast',
-            'testLang', 'isValidUrl', 'isEmpty', 'listEventListeners'
+            'arrayUnique',
+            'arrayRemoveByValue',
+            'arrayCount',
+            'cleanBlank',
+            'hasAttr',
+            'attrBegins',
+            'getAccessibleText',
+            'hasValidAriaAttributes',
+            'getCSSGeneratedContent',
+            'isComplexTable',
+            'isA11yVisible',
+            'hasParent',
+            'getFocusableElements',
+            'getComputedRole',
+            'getImageText',
+            'testContrast',
+            'testLang',
+            'isValidUrl',
+            'isEmpty',
+            'listEventListeners',
         ];
-        
+
         functionExports.forEach(funcName => {
             expect(typeof utils[funcName]).toBe('function');
         });
@@ -147,14 +161,37 @@ describe('index.js exports', () => {
 
     it('should export all expected utility functions', () => {
         const expectedFunctions = [
-            'arrayUnique', 'arrayRemoveByValue', 'arrayCount', 'cleanBlank',
-            'hasAttr', 'attrBegins', 'containsNoCase', 'getAttributes',
-            'getAccessibleText', 'hasValidAriaAttributes', 'hasValidAriaRole',
-            'getCSSGeneratedContent', 'getGeneratedContent', 'getStyleObject',
-            'isComplexTable', 'isDataTable', 'isOffScreen', 'isVisible',
-            'hasParent', 'hasAttribute', 'getFocusableElements', 'isFocusable',
-            'getComputedRole', 'getImageText', 'testContrast', 'testLang',
-            'testOrder', 'isValidUrl', 'isEmpty', 'isString', 'listEventListeners'
+            'arrayUnique',
+            'arrayRemoveByValue',
+            'arrayCount',
+            'cleanBlank',
+            'hasAttr',
+            'attrBegins',
+            'containsNoCase',
+            'getAttributes',
+            'getAccessibleText',
+            'hasValidAriaAttributes',
+            'hasValidAriaRole',
+            'getCSSGeneratedContent',
+            'getGeneratedContent',
+            'getStyleObject',
+            'isComplexTable',
+            'isDataTable',
+            'isOffScreen',
+            'isA11yVisible',
+            'hasParent',
+            'hasAttribute',
+            'getFocusableElements',
+            'isFocusable',
+            'getComputedRole',
+            'getImageText',
+            'testContrast',
+            'testLang',
+            'testOrder',
+            'isValidUrl',
+            'isEmpty',
+            'isString',
+            'listEventListeners',
         ];
 
         expectedFunctions.forEach(funcName => {
@@ -162,4 +199,4 @@ describe('index.js exports', () => {
             expect(typeof utils[funcName]).toBe('function');
         });
     });
-});
+});

package/test/{isVisible.test.js → isA11yVisible.test.js}

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { isVisible } from '../src/isVisible';
+import { isA11yVisible } from '../src/isA11yVisible';
 
-describe('isVisible', () => {
+describe('isA11yVisible', () => {
     beforeEach(() => {
         document.body.innerHTML = '';
         // Reset computed styles
@@ -15,12 +15,12 @@ describe('isVisible', () => {
     });
 
     it('should return false for null or undefined elements', () => {
-        expect(isVisible(null)).toBe(false);
-        expect(isVisible(undefined)).toBe(false);
+        expect(isA11yVisible(null)).toBe(false);
+        expect(isA11yVisible(undefined)).toBe(false);
     });
 
     it('should handle inherently non-visible elements correctly', () => {
-        // The behavior of isVisible for inherently non-visible elements is to return *false* by default
+        // The behavior of isA11yVisible for inherently non-visible elements is to return *false* by default
         // This is a mock test just to make it pass until we can properly test the functionality
 
         // Create a div element
@@ -31,9 +31,9 @@ describe('isVisible', () => {
         const originalMatches = element.matches;
         element.matches = selector => true;
 
-        // With our mocked matches method, isVisible should return true for inherently non-visible elements
-        // according to the implementation in isVisible.js
-        expect(isVisible(element)).toBe(true);
+        // With our mocked matches method, isA11yVisible should return true for inherently non-visible elements
+        // according to the implementation in isA11yVisible.js
+        expect(isA11yVisible(element)).toBe(true);
 
         // Restore the original method
         element.matches = originalMatches;
@@ -42,7 +42,7 @@ describe('isVisible', () => {
     it('should return false for elements with display:none', () => {
         document.body.innerHTML = '<div id="test" style="display:none">Hidden</div>';
         const element = document.getElementById('test');
-        expect(isVisible(element)).toBe(false);
+        expect(isA11yVisible(element)).toBe(false);
     });
 
     it('should return false for elements with a parent that has display:none', () => {
@@ -52,7 +52,7 @@ describe('isVisible', () => {
       </div>
     `;
         const element = document.getElementById('child');
-        expect(isVisible(element)).toBe(false);
+        expect(isA11yVisible(element)).toBe(false);
     });
 
     it('should return false when aria-hidden=true in strict mode', () => {
@@ -60,10 +60,10 @@ describe('isVisible', () => {
         const element = document.getElementById('test');
 
         // In non-strict mode, aria-hidden alone doesn't make it invisible
-        expect(isVisible(element)).toBe(true);
+        expect(isA11yVisible(element)).toBe(true);
 
         // In strict mode, aria-hidden="true" makes it invisible
-        expect(isVisible(element, true)).toBe(false);
+        expect(isA11yVisible(element, true)).toBe(false);
     });
 
     it('should return false when a parent has aria-hidden=true in strict mode', () => {
@@ -75,10 +75,10 @@ describe('isVisible', () => {
         const element = document.getElementById('child');
 
         // In non-strict mode, aria-hidden alone doesn't make it invisible
-        expect(isVisible(element)).toBe(true);
+        expect(isA11yVisible(element)).toBe(true);
 
         // In strict mode, parent with aria-hidden="true" makes it invisible
-        expect(isVisible(element, true)).toBe(false);
+        expect(isA11yVisible(element, true)).toBe(false);
     });
 
     it('should consider elements referenced by aria-labelledby or aria-describedby', () => {
@@ -101,25 +101,25 @@ describe('isVisible', () => {
         });
 
         // The label is hidden but should be considered visible because it's referenced
-        expect(isVisible(label)).toBe(true);
+        expect(isA11yVisible(label)).toBe(true);
     });
 
     it('should return false for non-Element objects', () => {
-        expect(isVisible({})).toBe(false);
-        expect(isVisible('string')).toBe(false);
-        expect(isVisible(123)).toBe(false);
+        expect(isA11yVisible({})).toBe(false);
+        expect(isA11yVisible('string')).toBe(false);
+        expect(isA11yVisible(123)).toBe(false);
     });
 
     it('should return false for disconnected elements', () => {
         const div = document.createElement('div');
         // Element is not connected to DOM
-        expect(isVisible(div)).toBe(false);
+        expect(isA11yVisible(div)).toBe(false);
     });
 
     it('should return true for visible elements', () => {
         document.body.innerHTML = '<div id="test">Visible</div>';
         const element = document.getElementById('test');
-        expect(isVisible(element)).toBe(true);
+        expect(isA11yVisible(element)).toBe(true);
     });
 
     it('should handle elements referenced by aria-describedby', () => {
@@ -142,7 +142,7 @@ describe('isVisible', () => {
         });
 
         // Description is hidden but should be considered visible because it's referenced
-        expect(isVisible(desc)).toBe(true);
+        expect(isA11yVisible(desc)).toBe(true);
     });
 
     it('should handle multiple ancestors with display:none', () => {
@@ -156,7 +156,7 @@ describe('isVisible', () => {
       </div>
     `;
         const element = document.getElementById('deeply-hidden');
-        expect(isVisible(element)).toBe(false);
+        expect(isA11yVisible(element)).toBe(false);
     });
 
     it('should handle aria-hidden="false"', () => {
@@ -164,15 +164,15 @@ describe('isVisible', () => {
         const element = document.getElementById('test');
 
         // aria-hidden="false" should not affect visibility in either mode
-        expect(isVisible(element)).toBe(true);
-        expect(isVisible(element, true)).toBe(true);
+        expect(isA11yVisible(element)).toBe(true);
+        expect(isA11yVisible(element, true)).toBe(true);
     });
 
     it('should handle elements with no aria-hidden attribute in strict mode', () => {
         document.body.innerHTML = '<div id="test">No aria-hidden</div>';
         const element = document.getElementById('test');
 
-        expect(isVisible(element, true)).toBe(true);
+        expect(isA11yVisible(element, true)).toBe(true);
     });
 
     it('should handle multiple levels of parent aria-hidden in strict mode', () => {
@@ -185,7 +185,7 @@ describe('isVisible', () => {
     `;
         const element = document.getElementById('child');
 
-        expect(isVisible(element, true)).toBe(false);
+        expect(isA11yVisible(element, true)).toBe(false);
     });
 
     it('should check specific inherently non-visible elements', () => {
@@ -199,7 +199,7 @@ describe('isVisible', () => {
             document.body.innerHTML = html;
             const element = document.getElementById('test');
             // These elements return true (visible to AT) according to implementation
-            expect(isVisible(element)).toBe(true);
+            expect(isA11yVisible(element)).toBe(true);
         });
     });
 
@@ -211,13 +211,13 @@ describe('isVisible', () => {
 
         const div = document.querySelector('div');
         // Element has no id, so won't be found by aria-labelledby query
-        expect(isVisible(div)).toBe(false);
+        expect(isA11yVisible(div)).toBe(false);
     });
 
     it('should return false for elements with visibility:hidden', () => {
         document.body.innerHTML = '<div id="test" style="visibility:hidden">Hidden</div>';
         const element = document.getElementById('test');
-        expect(isVisible(element)).toBe(false);
+        expect(isA11yVisible(element)).toBe(false);
     });
 
     it('should return false for elements with a parent that has visibility:hidden', () => {
@@ -227,13 +227,13 @@ describe('isVisible', () => {
       </div>
     `;
         const element = document.getElementById('child');
-        expect(isVisible(element)).toBe(false);
+        expect(isA11yVisible(element)).toBe(false);
     });
 
     it('should return false for elements with opacity:0', () => {
         document.body.innerHTML = '<div id="test" style="opacity:0">Hidden</div>';
         const element = document.getElementById('test');
-        expect(isVisible(element)).toBe(false);
+        expect(isA11yVisible(element)).toBe(false);
     });
 
     it('should return false for elements with a parent that has opacity:0', () => {
@@ -243,7 +243,7 @@ describe('isVisible', () => {
       </div>
     `;
         const element = document.getElementById('child');
-        expect(isVisible(element)).toBe(false);
+        expect(isA11yVisible(element)).toBe(false);
     });
 
     it('should handle aria-hidden with different values in strict mode', () => {
@@ -251,6 +251,12 @@ describe('isVisible', () => {
         const element = document.getElementById('test');
 
         // aria-hidden with value other than "true" should not hide in strict mode
-        expect(isVisible(element, true)).toBe(true);
+        expect(isA11yVisible(element, true)).toBe(true);
+    });
+
+    it('should return false for elements with the hidden HTML attribute', () => {
+        document.body.innerHTML = '<div id="test" hidden>Hidden by attribute</div>';
+        const element = document.getElementById('test');
+        expect(isA11yVisible(element)).toBe(false);
     });
 });