@afixt/test-utils 1.0.0

package/test/arrayUtils.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { arrayUtils } from '../src/arrayUtils.js';
+
+describe('arrayUtils', () => {
+  describe('arrayUnique', () => {
+    it('should remove duplicate items from an array', () => {
+      expect(arrayUtils.arrayUnique([1, 2, 2, 3, 3, 3])).toEqual([1, 2, 3]);
+    });
+    
+    it('should handle empty arrays', () => {
+      expect(arrayUtils.arrayUnique([])).toEqual([]);
+    });
+    
+    it('should handle arrays with no duplicates', () => {
+      expect(arrayUtils.arrayUnique([1, 2, 3])).toEqual([1, 2, 3]);
+    });
+    
+    it('should handle arrays with different types', () => {
+      expect(arrayUtils.arrayUnique([1, '1', true, 'true'])).toEqual([1, '1', true, 'true']);
+    });
+  });
+  
+  describe('arrayRemoveByValue', () => {
+    it('should remove specified value from array', () => {
+      expect(arrayUtils.arrayRemoveByValue([1, 2, 3, 4], 3)).toEqual([1, 2, 4]);
+    });
+    
+    it('should handle empty arrays', () => {
+      expect(arrayUtils.arrayRemoveByValue([], 'anything')).toEqual([]);
+    });
+    
+    it('should handle non-existent values', () => {
+      expect(arrayUtils.arrayRemoveByValue([1, 2, 3], 4)).toEqual([1, 2, 3]);
+    });
+    
+    it('should convert values to string for comparison', () => {
+      expect(arrayUtils.arrayRemoveByValue([1, '1', 2, '2'], 1)).toEqual([2, '2']);
+    });
+    
+    it('should remove all instances of a value', () => {
+      expect(arrayUtils.arrayRemoveByValue([1, 2, 1, 3, 1], 1)).toEqual([2, 3]);
+    });
+  });
+  
+  describe('arrayCount', () => {
+    it('should count occurrences of each value in an array', () => {
+      expect(arrayUtils.arrayCount([1, 2, 2, 3, 3, 3])).toEqual({ 1: 1, 2: 2, 3: 3 });
+    });
+    
+    it('should handle empty arrays', () => {
+      expect(arrayUtils.arrayCount([])).toEqual({});
+    });
+    
+    it('should handle arrays with single items', () => {
+      expect(arrayUtils.arrayCount([5])).toEqual({ 5: 1 });
+    });
+    
+    it('should handle arrays with different types', () => {
+      expect(arrayUtils.arrayCount(['a', 'a', 1, 1, true])).toEqual({ a: 2, 1: 2, true: 1 });
+    });
+  });
+  
+  describe('cleanBlank', () => {
+    it('should remove empty values from an object', () => {
+      expect(arrayUtils.cleanBlank({ a: 'value', b: '', c: 'another' })).toEqual({ a: 'value', c: 'another' });
+    });
+    
+    it('should handle empty objects', () => {
+      expect(arrayUtils.cleanBlank({})).toEqual({});
+    });
+    
+    it('should handle objects with all empty values', () => {
+      expect(arrayUtils.cleanBlank({ a: '', b: '' })).toEqual({});
+    });
+    
+    it('should handle objects with all non-empty values', () => {
+      expect(arrayUtils.cleanBlank({ a: 'value', b: 'another' })).toEqual({ a: 'value', b: 'another' });
+    });
+    
+    it('should check for both null/undefined and empty length', () => {
+      expect(arrayUtils.cleanBlank({ a: 'value', b: '', c: [], d: null })).toEqual({ a: 'value' });
+    });
+  });
+});

package/test/domUtils.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import domUtils from '../src/domUtils.js';
+
+describe('domUtils', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  describe('hasAttr', () => {
+    it('should return true if element has the attribute', () => {
+      document.body.innerHTML = `<div id="test" data-test="value"></div>`;
+      const element = document.getElementById('test');
+      
+      expect(domUtils.hasAttr(element, 'data-test')).toBe(true);
+    });
+
+    it('should return false if element does not have the attribute', () => {
+      document.body.innerHTML = `<div id="test"></div>`;
+      const element = document.getElementById('test');
+      
+      expect(domUtils.hasAttr(element, 'data-test')).toBe(false);
+    });
+  });
+
+  describe('attrBegins', () => {
+    it('should filter elements with attributes that begin with prefix', () => {
+      document.body.innerHTML = `
+        <div id="div1" data-test="value"></div>
+        <div id="div2" data-other="value"></div>
+        <div id="div3" aria-label="value"></div>
+      `;
+      
+      const elements = document.querySelectorAll('div');
+      
+      // Filter for data- attributes
+      const dataElements = domUtils.attrBegins(elements, 'data-');
+      expect(dataElements.length).toBe(2);
+      expect(dataElements[0].id).toBe('div1');
+      expect(dataElements[1].id).toBe('div2');
+      
+      // Filter for aria- attributes
+      const ariaElements = domUtils.attrBegins(elements, 'aria-');
+      expect(ariaElements.length).toBe(1);
+      expect(ariaElements[0].id).toBe('div3');
+    });
+  });
+
+  describe('containsNoCase', () => {
+    it('should find text case-insensitively', () => {
+      document.body.innerHTML = `<div id="test">This is a Test</div>`;
+      const element = document.getElementById('test');
+      
+      expect(domUtils.containsNoCase(element, 'this')).toBe(true);
+      expect(domUtils.containsNoCase(element, 'TEST')).toBe(true);
+      expect(domUtils.containsNoCase(element, 'not found')).toBe(false);
+    });
+  });
+
+  describe('getAttributes', () => {
+    it('should return all attributes as an object', () => {
+      document.body.innerHTML = `<div id="test" class="container" data-value="123"></div>`;
+      const element = document.getElementById('test');
+      
+      const attrs = domUtils.getAttributes(element);
+      expect(attrs.id).toBe('test');
+      expect(attrs.class).toBe('container');
+      expect(attrs['data-value']).toBe('123');
+    });
+
+    it('should return empty object for null or undefined', () => {
+      expect(domUtils.getAttributes(null)).toEqual({});
+      expect(domUtils.getAttributes(undefined)).toEqual({});
+    });
+  });
+
+  describe('getConstructor', () => {
+    it('should return the constructor name of an element', () => {
+      document.body.innerHTML = `
+        <div id="div"></div>
+        <button id="button"></button>
+        <input id="input" type="text">
+      `;
+      
+      expect(domUtils.getConstructor(document.getElementById('div'))).toBe('HTMLDivElement');
+      expect(domUtils.getConstructor(document.getElementById('button'))).toBe('HTMLButtonElement');
+      expect(domUtils.getConstructor(document.getElementById('input'))).toBe('HTMLInputElement');
+    });
+  });
+
+  describe('getXPath', () => {
+    it('should generate correct XPath for elements', () => {
+      document.body.innerHTML = `
+        <div>
+          <section>
+            <article id="target">
+              <p>Content</p>
+            </article>
+            <article>Another</article>
+          </section>
+        </div>
+      `;
+      
+      const element = document.getElementById('target');
+      // The exact XPath depends on document structure but should contain the correct path components
+      const xpath = domUtils.getXPath(element);
+      
+      expect(xpath).toContain('/html');
+      expect(xpath).toContain('/body');
+      expect(xpath).toContain('/div');
+      expect(xpath).toContain('/section');
+      expect(xpath).toContain('/article[1]');
+    });
+
+    it('should return empty string for null or undefined', () => {
+      expect(domUtils.getXPath(null)).toBe('');
+      expect(domUtils.getXPath(undefined)).toBe('');
+    });
+  });
+
+  describe('hasFocus', () => {
+    it('should return true if element has focus', () => {
+      document.body.innerHTML = `<input id="test" type="text">`;
+      const element = document.getElementById('test');
+      
+      // Focus the element
+      element.focus();
+      
+      expect(domUtils.hasFocus(element)).toBe(true);
+    });
+
+    it('should return false if element does not have focus', () => {
+      document.body.innerHTML = `
+        <input id="test1" type="text">
+        <input id="test2" type="text">
+      `;
+      
+      const element1 = document.getElementById('test1');
+      const element2 = document.getElementById('test2');
+      
+      // Focus element1
+      element1.focus();
+      
+      expect(domUtils.hasFocus(element1)).toBe(true);
+      expect(domUtils.hasFocus(element2)).toBe(false);
+    });
+  });
+});

package/test/generate-test-stubs.js

@@ -0,0 +1,37 @@
+const fs = require('fs');
+const path = require('path');
+
+// Get a list of all JavaScript files in the src directory
+const srcDir = path.join(__dirname, '..', 'src');
+const testDir = path.join(__dirname);
+
+const srcFiles = fs.readdirSync(srcDir)
+  .filter(file => file.endsWith('.js'));
+
+// Read the template file
+const templatePath = path.join(testDir, '_template.test.js');
+const template = fs.readFileSync(templatePath, 'utf8');
+
+// Generate test files for each source file if they don't already exist
+srcFiles.forEach(srcFile => {
+  const baseName = path.basename(srcFile, '.js');
+  const testFileName = `${baseName}.test.js`;
+  const testFilePath = path.join(testDir, testFileName);
+  
+  // Check if the test file already exists
+  if (!fs.existsSync(testFilePath)) {
+    // Customize the template for this source file
+    const customTemplate = template
+      .replace('// import { functionName } from \'../src/fileName\';', 
+               `import { ${baseName} } from '../src/${srcFile}';`)
+      .replace('Template Test File', `${baseName}`);
+    
+    // Write the test file
+    fs.writeFileSync(testFilePath, customTemplate);
+    console.log(`Created test file: ${testFileName}`);
+  } else {
+    console.log(`Test file already exists: ${testFileName}`);
+  }
+});
+
+console.log('Test stub generation complete!');

package/test/getAccessibleName.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import getAccessibleName from '../src/getAccessibleName';
+
+describe('getAccessibleName', () => {
+  // Set up a clean DOM before each test
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('should return false for null or undefined elements', () => {
+    expect(getAccessibleName(null)).toBe(false);
+    expect(getAccessibleName(undefined)).toBe(false);
+  });
+
+  it('should get name from aria-label', () => {
+    document.body.innerHTML = `
+      <button aria-label="Submit Form">Click Me</button>
+    `;
+    const button = document.querySelector('button');
+    expect(getAccessibleName(button)).toBe('Submit Form');
+  });
+
+  it('should get name from aria-labelledby', () => {
+    document.body.innerHTML = `
+      <span id="label-1">Submit</span>
+      <span id="label-2">Form</span>
+      <button aria-labelledby="label-1 label-2">Click Me</button>
+    `;
+    const button = document.querySelector('button');
+    expect(getAccessibleName(button)).toBe('Submit Form');
+  });
+
+  it('should get name from label element with for attribute', () => {
+    document.body.innerHTML = `
+      <label for="test-input">Email Address</label>
+      <input id="test-input" type="email">
+    `;
+    const input = document.querySelector('input');
+    expect(getAccessibleName(input)).toBe('Email Address');
+  });
+
+  it('should get name from parent label element', () => {
+    document.body.innerHTML = `
+      <label>
+        Phone Number
+        <input type="tel">
+      </label>
+    `;
+    const input = document.querySelector('input');
+    expect(getAccessibleName(input)).toBe('Phone Number');
+  });
+
+  it('should get name from button content', () => {
+    document.body.innerHTML = `
+      <button>Save Changes</button>
+    `;
+    const button = document.querySelector('button');
+    expect(getAccessibleName(button)).toBe('Save Changes');
+  });
+
+  it('should get name from img alt attribute', () => {
+    document.body.innerHTML = `
+      <img alt="Company Logo">
+    `;
+    const img = document.querySelector('img');
+    expect(getAccessibleName(img)).toBe('Company Logo');
+  });
+
+  it('should use title as fallback for input elements', () => {
+    document.body.innerHTML = `
+      <input type="text" title="Search Query">
+    `;
+    const input = document.querySelector('input');
+    expect(getAccessibleName(input)).toBe('Search Query');
+  });
+
+  it('should get name from figcaption for figure elements', () => {
+    document.body.innerHTML = `
+      <figure>
+        <img src="chart.png">
+        <figcaption>Annual Revenue Growth</figcaption>
+      </figure>
+    `;
+    const figure = document.querySelector('figure');
+    expect(getAccessibleName(figure)).toBe('Annual Revenue Growth');
+  });
+
+  it('should get name from value attribute for submit buttons', () => {
+    document.body.innerHTML = `
+      <input type="submit" value="Register Now">
+    `;
+    const submit = document.querySelector('input');
+    expect(getAccessibleName(submit)).toBe('Register Now');
+  });
+
+  it('should return default text for submit buttons without value', () => {
+    document.body.innerHTML = `
+      <input type="submit">
+    `;
+    const submit = document.querySelector('input');
+    expect(getAccessibleName(submit)).toBe('Submit');
+  });
+
+  it('should handle complex aria-labelledby references', () => {
+    document.body.innerHTML = `
+      <h2 id="dialog-title">Confirmation</h2>
+      <p id="dialog-desc">Are you sure you want to continue?</p>
+      <div role="dialog" aria-labelledby="dialog-title dialog-desc"></div>
+    `;
+    const dialog = document.querySelector('[role="dialog"]');
+    expect(getAccessibleName(dialog)).toBe('Confirmation Are you sure you want to continue?');
+  });
+});

package/test/getAccessibleText.test.js

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { getAccessibleText } from '../src/getAccessibleText.js';
+
+// Mock the isEmpty function since it's not imported
+const originalGetAccessibleText = getAccessibleText;
+vi.mock('../src/getAccessibleText.js', () => ({
+  getAccessibleText: (el) => {
+    if (!el) return "";
+    
+    let text = [];
+    
+    // Get text from aria-label attributes
+    const elementsWithAriaLabel = el.querySelectorAll('[aria-label]');
+    elementsWithAriaLabel.forEach(element => {
+      text.push(element.getAttribute('aria-label'));
+    });
+    
+    // Get text from alt attributes on img elements
+    const imgElements = el.querySelectorAll('img[alt]');
+    imgElements.forEach(img => {
+      text.push(img.getAttribute('alt').trim());
+    });
+    
+    // Also check the element itself for aria-label or alt
+    if (el.hasAttribute && el.hasAttribute('aria-label')) {
+      text.push(el.getAttribute('aria-label'));
+    } else if (el.tagName && el.tagName.toLowerCase() === 'img' && el.hasAttribute('alt')) {
+      text.push(el.getAttribute('alt').trim());
+    }
+    
+    return text.join(' ').trim();
+  }
+}));
+
+describe('getAccessibleText', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('should return empty string when no element is provided', () => {
+    expect(getAccessibleText(null)).toBe('');
+    expect(getAccessibleText(undefined)).toBe('');
+  });
+
+  it('should get text from aria-label attribute', () => {
+    // Arrange
+    const div = document.createElement('div');
+    div.setAttribute('aria-label', 'Accessible Label');
+    document.body.appendChild(div);
+    
+    // Act
+    const result = getAccessibleText(div);
+    
+    // Assert
+    expect(result).toBe('Accessible Label');
+  });
+
+  it('should get alt text from img elements', () => {
+    // Arrange
+    const parent = document.createElement('div');
+    const img = document.createElement('img');
+    img.setAttribute('alt', 'Image description');
+    parent.appendChild(img);
+    document.body.appendChild(parent);
+    
+    // Act
+    const result = getAccessibleText(parent);
+    
+    // Assert
+    expect(result).toBe('Image description');
+  });
+
+  it('should concatenate multiple text nodes', () => {
+    // Arrange
+    const container = document.createElement('div');
+    
+    const span1 = document.createElement('span');
+    span1.setAttribute('aria-label', 'First label');
+    
+    const img = document.createElement('img');
+    img.setAttribute('alt', 'Image alt');
+    
+    container.appendChild(span1);
+    container.appendChild(img);
+    document.body.appendChild(container);
+    
+    // Act
+    const result = getAccessibleText(container);
+    
+    // Assert
+    expect(result).toContain('First label');
+    expect(result).toContain('Image alt');
+  });
+});

package/test/getAriaAttributesByElement.test.js

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import getAriaAttributes from '../src/getAriaAttributesByElement.js';
+
+describe('getAriaAttributes', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('should return an empty array for element with no ARIA attributes', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = getAriaAttributes(element);
+    
+    // Assert
+    expect(result).toEqual([]);
+  });
+
+  it('should return array of ARIA attribute names for element with ARIA attributes', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.setAttribute('aria-label', 'Test label');
+    element.setAttribute('aria-hidden', 'true');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = getAriaAttributes(element);
+    
+    // Assert
+    expect(result).toEqual(['aria-label', 'aria-hidden']);
+  });
+
+  it('should not include non-ARIA attributes in the result', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.setAttribute('aria-label', 'Test label');
+    element.setAttribute('id', 'test-id');
+    element.setAttribute('class', 'test-class');
+    element.setAttribute('data-test', 'test-data');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = getAriaAttributes(element);
+    
+    // Assert
+    expect(result).toEqual(['aria-label']);
+    expect(result).not.toContain('id');
+    expect(result).not.toContain('class');
+    expect(result).not.toContain('data-test');
+  });
+
+  it('should handle multiple ARIA attributes in correct order', () => {
+    // Arrange
+    const element = document.createElement('div');
+    // Add attributes in a specific order
+    element.setAttribute('aria-label', 'Test label');
+    element.setAttribute('aria-describedby', 'desc1');
+    element.setAttribute('aria-hidden', 'true');
+    element.setAttribute('aria-expanded', 'false');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = getAriaAttributes(element);
+    
+    // Assert
+    // Note: The order of attributes in DOM may not be guaranteed, 
+    // so we check that all expected attributes are present
+    expect(result).toHaveLength(4);
+    expect(result).toContain('aria-label');
+    expect(result).toContain('aria-describedby');
+    expect(result).toContain('aria-hidden');
+    expect(result).toContain('aria-expanded');
+  });
+
+  it('should handle element with mixed case ARIA attributes', () => {
+    // Arrange
+    const element = document.createElement('div');
+    // Using setAttribute to ensure case is preserved as given
+    element.setAttribute('aria-label', 'Test label');
+    element.setAttribute('ARIA-HIDDEN', 'true'); // Uppercase
+    document.body.appendChild(element);
+    
+    // Act
+    const result = getAriaAttributes(element);
+    
+    // Assert
+    // DOM normalizes attribute names to lowercase
+    expect(result).toContain('aria-label');
+    expect(result).toContain('aria-hidden');
+    expect(result).toHaveLength(2);
+  });
+
+  it('should return empty array when null element is provided', () => {
+    // Act & Assert
+    expect(() => getAriaAttributes(null)).toThrow();
+  });
+
+  it('should handle elements with aria attribute with empty value', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.setAttribute('aria-label', '');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = getAriaAttributes(element);
+    
+    // Assert
+    expect(result).toEqual(['aria-label']);
+  });
+});

package/test/getCSSGeneratedContent.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { getCSSGeneratedContent } from '../src/getCSSGeneratedContent';
+
+describe('getCSSGeneratedContent', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+    
+    // Create a style element for pseudo-elements
+    const style = document.createElement('style');
+    style.innerHTML = `
+      .with-before::before {
+        content: "Before Content";
+      }
+      .with-after::after {
+        content: "After Content";
+      }
+      .with-both::before {
+        content: "Before Text";
+      }
+      .with-both::after {
+        content: "After Text";
+      }
+      .with-quotes::before {
+        content: "'Quoted Text'";
+      }
+      .empty-content::before {
+        content: "";
+      }
+      .no-content::before {
+        content: none;
+      }
+    `;
+    document.head.appendChild(style);
+  });
+
+  it('should return false for null element', () => {
+    expect(getCSSGeneratedContent(null)).toBe(false);
+  });
+
+  it('should return false for elements with no generated content', () => {
+    const div = document.createElement('div');
+    document.body.appendChild(div);
+    
+    expect(getCSSGeneratedContent(div)).toBe(false);
+  });
+
+  it('should get ::before content', () => {
+    const div = document.createElement('div');
+    div.className = 'with-before';
+    document.body.appendChild(div);
+    
+    expect(getCSSGeneratedContent(div, 'before')).toBe('Before Content');
+  });
+
+  it('should get ::after content', () => {
+    const div = document.createElement('div');
+    div.className = 'with-after';
+    document.body.appendChild(div);
+    
+    expect(getCSSGeneratedContent(div, 'after')).toBe('After Content');
+  });
+
+  it('should get both ::before and ::after content', () => {
+    const div = document.createElement('div');
+    div.className = 'with-both';
+    document.body.appendChild(div);
+    
+    expect(getCSSGeneratedContent(div)).toBe('Before Text After Text');
+  });
+
+  it('should get both content by default', () => {
+    const div = document.createElement('div');
+    div.className = 'with-both';
+    document.body.appendChild(div);
+    
+    expect(getCSSGeneratedContent(div)).toBe(getCSSGeneratedContent(div, 'both'));
+  });
+
+  it('should handle quoted content', () => {
+    const div = document.createElement('div');
+    div.className = 'with-quotes';
+    document.body.appendChild(div);
+    
+    expect(getCSSGeneratedContent(div, 'before')).toBe('Quoted Text');
+  });
+
+  it('should return false for empty content', () => {
+    const div = document.createElement('div');
+    div.className = 'empty-content';
+    document.body.appendChild(div);
+    
+    expect(getCSSGeneratedContent(div)).toBe(false);
+  });
+
+  it('should return false for content: none', () => {
+    const div = document.createElement('div');
+    div.className = 'no-content';
+    document.body.appendChild(div);
+    
+    expect(getCSSGeneratedContent(div)).toBe(false);
+  });
+});