@afixt/test-utils 1.1.2 → 1.1.4

package/test/index.test.js

@@ -0,0 +1,165 @@
+/**
+ * @file Tests for the main index.js module
+ * @description Verifies that all exports are properly exported from the main entry point
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as utils from '../src/index.js';
+
+describe('index.js exports', () => {
+    it('should export array utilities', () => {
+        expect(utils.arrayUnique).toBeDefined();
+        expect(utils.arrayRemoveByValue).toBeDefined();
+        expect(utils.arrayCount).toBeDefined();
+        expect(utils.cleanBlank).toBeDefined();
+        expect(utils.arrayUtils).toBeDefined();
+    });
+
+    it('should export DOM utilities', () => {
+        expect(utils.hasAttr).toBeDefined();
+        expect(utils.attrBegins).toBeDefined();
+        expect(utils.containsNoCase).toBeDefined();
+        expect(utils.getAttributes).toBeDefined();
+        expect(utils.getAttributesAsString).toBeDefined();
+        expect(utils.getConstructor).toBeDefined();
+        expect(utils.getDocumentSize).toBeDefined();
+        expect(utils.getElementsWithDuplicateIds).toBeDefined();
+        expect(utils.getOuterHTML).toBeDefined();
+        expect(utils.getXPath).toBeDefined();
+        expect(utils.hasFocus).toBeDefined();
+        expect(utils.isFullyVisible).toBeDefined();
+    });
+
+    it('should export accessibility name utilities', () => {
+        expect(utils.getAccessibleText).toBeDefined();
+    });
+
+    it('should export ARIA utilities', () => {
+        expect(utils.hasValidAriaAttributes).toBeDefined();
+        expect(utils.hasValidAriaRole).toBeDefined();
+        expect(utils.isAriaAttributeValid).toBeDefined();
+    });
+
+    it('should export CSS utilities', () => {
+        expect(utils.getCSSGeneratedContent).toBeDefined();
+        expect(utils.getGeneratedContent).toBeDefined();
+        expect(utils.getStyleObject).toBeDefined();
+        expect(utils.hasCSSGeneratedContent).toBeDefined();
+    });
+
+    it('should export table utilities', () => {
+        expect(utils.checkMultiRowsInHeader).toBeDefined();
+        expect(utils.checkMultiRowsWithColspan).toBeDefined();
+        expect(utils.checkInconsistent).toBeDefined();
+        expect(utils.isComplexTable).toBeDefined();
+        expect(utils.isDataTable).toBeDefined();
+        expect(utils.rowCount).toBeDefined();
+        expect(utils.cellCount).toBeDefined();
+        expect(utils.countBordersPct).toBeDefined();
+        expect(utils.colCount).toBeDefined();
+        expect(utils.cellColorDiffs).toBeDefined();
+    });
+
+    it('should export visibility utilities', () => {
+        expect(utils.isOffScreen).toBeDefined();
+        expect(utils.isVisible).toBeDefined();
+    });
+
+    it('should export element relationship utilities', () => {
+        expect(utils.hasParent).toBeDefined();
+        expect(utils.hasAttribute).toBeDefined();
+    });
+
+    it('should export focus management utilities', () => {
+        expect(utils.getFocusableElements).toBeDefined();
+        expect(utils.isFocusable).toBeDefined();
+    });
+
+    it('should export role computation utilities', () => {
+        expect(utils.roleMapping).toBeDefined();
+        expect(utils.getComputedRole).toBeDefined();
+    });
+
+    it('should export image utilities', () => {
+        expect(utils.getImageText).toBeDefined();
+    });
+
+    it('should export testing utilities', () => {
+        expect(utils.testContrast).toBeDefined();
+        expect(utils.langCodes).toBeDefined();
+        expect(utils.validLangCodes).toBeDefined();
+        expect(utils.rtls).toBeDefined();
+        expect(utils.getTwoLetterCode).toBeDefined();
+        expect(utils.testLang).toBeDefined();
+        expect(utils.getLang).toBeDefined();
+        expect(utils.isDirValid).toBeDefined();
+        expect(utils.sortByVisualOrder).toBeDefined();
+        expect(utils.testOrder).toBeDefined();
+    });
+
+    it('should export URL utilities', () => {
+        expect(utils.isValidUrl).toBeDefined();
+    });
+
+    it('should export string utilities', () => {
+        expect(utils.isEmpty).toBeDefined();
+        expect(utils.isString).toBeDefined();
+        expect(utils.strlen).toBeDefined();
+        expect(utils.isNormalInteger).toBeDefined();
+        expect(utils.isUpperCase).toBeDefined();
+        expect(utils.isAlphaNumeric).toBeDefined();
+        expect(utils.getPathFromUrl).toBeDefined();
+        expect(utils.getAllText).toBeDefined();
+        expect(utils.hasText).toBeDefined();
+    });
+
+    it('should export event listener utilities', () => {
+        expect(utils.listEventListeners).toBeDefined();
+        expect(utils.getEventListeners).toBeDefined();
+    });
+
+    it('should export interactive roles array', () => {
+        const interactiveRolesKeys = Object.keys(utils).filter(key => /^\d+$/.test(key));
+        expect(interactiveRolesKeys.length).toBeGreaterThan(0);
+    });
+
+    it('should have object exports for data structures', () => {
+        expect(typeof utils.arrayUtils).toBe('object');
+        expect(typeof utils.roleMapping).toBe('object');
+        expect(typeof utils.langCodes).toBe('object');
+        expect(typeof utils.validLangCodes).toBe('object');
+        expect(typeof utils.rtls).toBe('object');
+    });
+
+    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'
+        ];
+        
+        functionExports.forEach(funcName => {
+            expect(typeof utils[funcName]).toBe('function');
+        });
+    });
+
+    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'
+        ];
+
+        expectedFunctions.forEach(funcName => {
+            expect(utils[funcName]).toBeDefined();
+            expect(typeof utils[funcName]).toBe('function');
+        });
+    });
+});

package/test/interactiveRoles.test.js

@@ -0,0 +1,60 @@
+/**
+ * @file Tests for interactiveRoles utility
+ */
+
+import { describe, it, expect } from 'vitest';
+import interactiveRoles from '../src/interactiveRoles.js';
+
+describe('interactiveRoles', () => {
+    it('should be an array', () => {
+        expect(Array.isArray(interactiveRoles)).toBe(true);
+    });
+
+    it('should contain expected interactive roles', () => {
+        const expectedRoles = [
+            'button',
+            'checkbox', 
+            'combobox',
+            'link',
+            'menu',
+            'menuitemcheckbox',
+            'menuitemradio',
+            'radio',
+            'scrollbar',
+            'slider',
+            'spinbutton',
+            'tablist',
+            'textbox',
+            'toolbar',
+            'switch',
+            'tree'
+        ];
+
+        expectedRoles.forEach(role => {
+            expect(interactiveRoles).toContain(role);
+        });
+    });
+
+    it('should have the correct length', () => {
+        expect(interactiveRoles).toHaveLength(16);
+    });
+
+    it('should contain only string values', () => {
+        interactiveRoles.forEach(role => {
+            expect(typeof role).toBe('string');
+        });
+    });
+
+    it('should not contain duplicates', () => {
+        const uniqueRoles = [...new Set(interactiveRoles)];
+        expect(uniqueRoles).toHaveLength(interactiveRoles.length);
+    });
+
+    it('should contain standard ARIA interactive roles', () => {
+        expect(interactiveRoles).toContain('button');
+        expect(interactiveRoles).toContain('link');
+        expect(interactiveRoles).toContain('textbox');
+        expect(interactiveRoles).toContain('checkbox');
+        expect(interactiveRoles).toContain('radio');
+    });
+});

package/test/isAriaAttributesValid.test.js

@@ -80,4 +80,40 @@ describe('isAriaAttributeValid', () => {
       expect(isAriaAttributeValid(attr)).toBe(true);
     });
   });
+
+  it('should validate newer and less common ARIA attributes', () => {
+    const newerAttributes = [
+      'aria-braillelabel',
+      'aria-brailleroledescription',
+      'aria-colcount',
+      'aria-colindex',
+      'aria-colindextext',
+      'aria-colspan',
+      'aria-current',
+      'aria-description',
+      'aria-details',
+      'aria-dropeffect',
+      'aria-errormessage',
+      'aria-flowto',
+      'aria-grabbed',
+      'aria-keyshortcuts',
+      'aria-modal',
+      'aria-roledescription',
+      'aria-rowcount',
+      'aria-rowindex',
+      'aria-rowindextext',
+      'aria-rowspan'
+    ];
+    
+    newerAttributes.forEach(attr => {
+      expect(isAriaAttributeValid(attr)).toBe(true);
+    });
+  });
+
+  it('should handle edge cases with empty string and whitespace', () => {
+    expect(isAriaAttributeValid('')).toBe(false);
+    expect(isAriaAttributeValid('   ')).toBe(false);
+    expect(isAriaAttributeValid('\t')).toBe(false);
+    expect(isAriaAttributeValid('\n')).toBe(false);
+  });
 });