@afixt/test-utils 1.0.0

package/test/hasParent.test.js

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { hasParent } from '../src/hasParent.js';
+
+describe('hasParent', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('should return true when element has parent matching a tag selector', () => {
+    // Arrange
+    const structure = `
+      <div>
+        <section>
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const result = hasParent(target, ['section']);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true when element has parent matching a class selector', () => {
+    // Arrange
+    const structure = `
+      <div>
+        <section class="test-class">
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const result = hasParent(target, ['.test-class']);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true when element has parent matching an ID selector', () => {
+    // Arrange
+    const structure = `
+      <div>
+        <section id="test-id">
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const result = hasParent(target, ['#test-id']);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true when element has parent matching an attribute selector', () => {
+    // Arrange
+    const structure = `
+      <div>
+        <section data-test="value">
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const result = hasParent(target, ['[data-test="value"]']);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true when element has grandparent matching a selector', () => {
+    // Arrange
+    const structure = `
+      <div class="grandparent">
+        <section>
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const result = hasParent(target, ['.grandparent']);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true when any of multiple selectors matches', () => {
+    // Arrange
+    const structure = `
+      <div>
+        <section class="parent-class">
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const result = hasParent(target, ['article', '.parent-class', '#non-existent']);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return false when no selectors match any parent', () => {
+    // Arrange
+    const structure = `
+      <div>
+        <section>
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const result = hasParent(target, ['article', '.non-existent', '#missing']);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should return false when element has no parent elements', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = hasParent(element, ['div', 'section']);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should handle case-insensitive tag name matching', () => {
+    // Arrange
+    const structure = `
+      <div>
+        <SECTION>
+          <p id="target">Test</p>
+        </SECTION>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const resultLower = hasParent(target, ['section']);
+    const resultUpper = hasParent(target, ['SECTION']);
+    
+    // Assert
+    expect(resultLower).toBe(true);
+    expect(resultUpper).toBe(true);
+  });
+
+  it('should return false for null or undefined elements', () => {
+    // Act & Assert
+    expect(hasParent(null, ['div'])).toBe(false);
+    expect(hasParent(undefined, ['div'])).toBe(false);
+  });
+
+  it('should return false for non-Element objects', () => {
+    // Arrange
+    const nonElements = [{}, [], 123, 'string', () => {}];
+    
+    // Act & Assert
+    nonElements.forEach(item => {
+      expect(hasParent(item, ['div'])).toBe(false);
+    });
+  });
+
+  it('should return false for null, undefined, or empty selectors array', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Act & Assert
+    expect(hasParent(element, null)).toBe(false);
+    expect(hasParent(element, undefined)).toBe(false);
+    expect(hasParent(element, [])).toBe(false);
+  });
+
+  it('should handle invalid selectors gracefully', () => {
+    // Arrange
+    const structure = `
+      <div>
+        <section>
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    // Use a selector that might cause a DOMException, but we still have a valid one
+    const result = hasParent(target, ['section', '>>>:invalid:selector:::']);
+    
+    // Assert
+    expect(result).toBe(true); // Should still find the valid 'section' selector
+  });
+
+  it('should handle complex nested DOM structures', () => {
+    // Arrange
+    const structure = `
+      <div id="root" class="root-class">
+        <article>
+          <section class="level1">
+            <div class="level2" data-test="nested">
+              <p id="target">Test</p>
+            </div>
+          </section>
+        </article>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act & Assert
+    expect(hasParent(target, ['.level2'])).toBe(true);
+    expect(hasParent(target, ['section'])).toBe(true);
+    expect(hasParent(target, ['article'])).toBe(true);
+    expect(hasParent(target, ['#root'])).toBe(true);
+    expect(hasParent(target, ['.root-class'])).toBe(true);
+    expect(hasParent(target, ['[data-test="nested"]'])).toBe(true);
+    expect(hasParent(target, ['span'])).toBe(false); // No span parent
+  });
+
+  it('should find first matching parent when multiple matches exist', () => {
+    // Arrange
+    const structure = `
+      <div class="match">
+        <section class="match">
+          <p id="target">Test</p>
+        </section>
+      </div>
+    `;
+    document.body.innerHTML = structure;
+    const target = document.getElementById('target');
+    
+    // Act
+    const result = hasParent(target, ['.match']);
+    
+    // Assert
+    expect(result).toBe(true); // Should find the immediate .match parent first
+  });
+});

package/test/hasValidAriaAttributes.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { hasValidAriaAttributes } from '../src/hasValidAriaAttributes';
+
+describe('hasValidAriaAttributes', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('should return false for null element', () => {
+    expect(hasValidAriaAttributes(null)).toBe(false);
+  });
+
+  it('should return false for non-DOM elements', () => {
+    expect(hasValidAriaAttributes({})).toBe(false);
+    expect(hasValidAriaAttributes([])).toBe(false);
+    expect(hasValidAriaAttributes('string')).toBe(false);
+  });
+
+  it('should return false for elements with no attributes', () => {
+    const div = document.createElement('div');
+    document.body.appendChild(div);
+    
+    expect(hasValidAriaAttributes(div)).toBe(false);
+  });
+
+  it('should return false for elements with no ARIA attributes', () => {
+    const div = document.createElement('div');
+    div.setAttribute('id', 'test');
+    div.setAttribute('class', 'test-class');
+    div.setAttribute('data-test', 'value');
+    document.body.appendChild(div);
+    
+    expect(hasValidAriaAttributes(div)).toBe(false);
+  });
+
+  it('should return false for elements with invalid ARIA attributes', () => {
+    const div = document.createElement('div');
+    div.setAttribute('aria-foo', 'bar');
+    div.setAttribute('aria-invalid-attr', 'value');
+    document.body.appendChild(div);
+    
+    expect(hasValidAriaAttributes(div)).toBe(false);
+  });
+
+  it('should return true for elements with valid ARIA attributes', () => {
+    const div = document.createElement('div');
+    div.setAttribute('aria-label', 'Test Label');
+    document.body.appendChild(div);
+    
+    expect(hasValidAriaAttributes(div)).toBe(true);
+  });
+
+  it('should return true when element has both valid and invalid attributes', () => {
+    const div = document.createElement('div');
+    div.setAttribute('aria-foo', 'invalid');
+    div.setAttribute('aria-hidden', 'true');
+    document.body.appendChild(div);
+    
+    expect(hasValidAriaAttributes(div)).toBe(true);
+  });
+
+  it('should be case-insensitive for attribute names', () => {
+    const div = document.createElement('div');
+    div.setAttribute('ARIA-LABEL', 'Test Label');
+    document.body.appendChild(div);
+    
+    expect(hasValidAriaAttributes(div)).toBe(true);
+  });
+
+  it('should check multiple valid ARIA attributes', () => {
+    const button = document.createElement('button');
+    button.setAttribute('aria-expanded', 'false');
+    button.setAttribute('aria-controls', 'panel-1');
+    button.setAttribute('aria-pressed', 'false');
+    document.body.appendChild(button);
+    
+    expect(hasValidAriaAttributes(button)).toBe(true);
+  });
+});

package/test/hasValidAriaRole.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { hasValidAriaRole } from '../src/hasValidAriaRole.js';
+
+describe('hasValidAriaRole', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('should return true for an element with a valid ARIA role', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.setAttribute('role', 'button');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = hasValidAriaRole(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return false for an element with an invalid ARIA role', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.setAttribute('role', 'invalid-role');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = hasValidAriaRole(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should return false for an element without a role attribute', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = hasValidAriaRole(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should return false for null or non-element input', () => {
+    // Act & Assert
+    expect(hasValidAriaRole(null)).toBe(false);
+    expect(hasValidAriaRole(undefined)).toBe(false);
+    expect(hasValidAriaRole({})).toBe(false);
+    expect(hasValidAriaRole('')).toBe(false);
+  });
+
+  it('should correctly handle elements with multiple roles (should use the first one)', () => {
+    // Arrange
+    const validMultipleRoles = document.createElement('div');
+    validMultipleRoles.setAttribute('role', 'button presentation');
+    
+    const invalidMultipleRoles = document.createElement('div');
+    invalidMultipleRoles.setAttribute('role', 'invalid-role button');
+    
+    document.body.appendChild(validMultipleRoles);
+    document.body.appendChild(invalidMultipleRoles);
+    
+    // Act & Assert
+    expect(hasValidAriaRole(validMultipleRoles)).toBe(true);
+    expect(hasValidAriaRole(invalidMultipleRoles)).toBe(false);
+  });
+
+  it('should handle roles with extra whitespace', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.setAttribute('role', '  button  ');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = hasValidAriaRole(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should recognize various valid roles', () => {
+    // Test a sample of different valid roles
+    const validRoles = ['alert', 'button', 'checkbox', 'dialog', 'navigation', 'main', 'region'];
+    
+    validRoles.forEach(role => {
+      // Arrange
+      const element = document.createElement('div');
+      element.setAttribute('role', role);
+      document.body.appendChild(element);
+      
+      // Act & Assert
+      expect(hasValidAriaRole(element)).toBe(true);
+    });
+  });
+});

package/test/isAriaAttributesValid.test.js

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import { isAriaAttributeValid } from '../src/isAriaAttributesValid';
+
+describe('isAriaAttributeValid', () => {
+  it('should return false for null or undefined input', () => {
+    expect(isAriaAttributeValid(null)).toBe(false);
+    expect(isAriaAttributeValid(undefined)).toBe(false);
+  });
+
+  it('should return false for non-string input', () => {
+    expect(isAriaAttributeValid(123)).toBe(false);
+    expect(isAriaAttributeValid({})).toBe(false);
+    expect(isAriaAttributeValid([])).toBe(false);
+  });
+
+  it('should return false for non-aria attributes', () => {
+    expect(isAriaAttributeValid('id')).toBe(false);
+    expect(isAriaAttributeValid('class')).toBe(false);
+    expect(isAriaAttributeValid('data-test')).toBe(false);
+    expect(isAriaAttributeValid('role')).toBe(false);
+  });
+
+  it('should return false for invalid aria attributes', () => {
+    expect(isAriaAttributeValid('aria-foo')).toBe(false);
+    expect(isAriaAttributeValid('aria-testing')).toBe(false);
+    expect(isAriaAttributeValid('aria')).toBe(false);
+  });
+
+  it('should return true for valid aria attributes', () => {
+    expect(isAriaAttributeValid('aria-label')).toBe(true);
+    expect(isAriaAttributeValid('aria-hidden')).toBe(true);
+    expect(isAriaAttributeValid('aria-expanded')).toBe(true);
+    expect(isAriaAttributeValid('aria-pressed')).toBe(true);
+  });
+
+  it('should be case-insensitive', () => {
+    expect(isAriaAttributeValid('ARIA-LABEL')).toBe(true);
+    expect(isAriaAttributeValid('Aria-Hidden')).toBe(true);
+    expect(isAriaAttributeValid('aria-EXPANDED')).toBe(true);
+  });
+
+  it('should validate all standard ARIA attributes', () => {
+    const standardAttributes = [
+      'aria-activedescendant',
+      'aria-atomic',
+      'aria-autocomplete',
+      'aria-busy',
+      'aria-checked',
+      'aria-controls',
+      'aria-describedby',
+      'aria-disabled',
+      'aria-expanded',
+      'aria-haspopup',
+      'aria-hidden',
+      'aria-invalid',
+      'aria-label',
+      'aria-labelledby',
+      'aria-level',
+      'aria-live',
+      'aria-multiline',
+      'aria-multiselectable',
+      'aria-orientation',
+      'aria-owns',
+      'aria-placeholder',
+      'aria-posinset',
+      'aria-pressed',
+      'aria-readonly',
+      'aria-relevant',
+      'aria-required',
+      'aria-selected',
+      'aria-setsize',
+      'aria-sort',
+      'aria-valuemax',
+      'aria-valuemin',
+      'aria-valuenow',
+      'aria-valuetext'
+    ];
+    
+    standardAttributes.forEach(attr => {
+      expect(isAriaAttributeValid(attr)).toBe(true);
+    });
+  });
+});