test(plugin-axe): use jest-extended

Author: hanna-skryl

packages/plugin-axe/src/lib/config.unit.test.ts

@@ -6,51 +6,36 @@ describe('axePluginOptionsSchema', () => {
     expect(axePluginOptionsSchema.parse({}).preset).toBe('wcag21aa');
   });
 
-  it('should accept wcag21aa preset', () => {
-    expect(() =>
-      axePluginOptionsSchema.parse({ preset: 'wcag21aa' }),
-    ).not.toThrow();
-  });
-
-  it('should accept wcag22aa preset', () => {
-    expect(() =>
-      axePluginOptionsSchema.parse({ preset: 'wcag22aa' }),
-    ).not.toThrow();
-  });
-
-  it('should accept best-practice preset', () => {
-    expect(() =>
-      axePluginOptionsSchema.parse({ preset: 'best-practice' }),
-    ).not.toThrow();
-  });
-
-  it('should accept all preset', () => {
-    expect(() => axePluginOptionsSchema.parse({ preset: 'all' })).not.toThrow();
-  });
-
-  it('should accept number scoreTargets', () => {
+  it.each(['wcag21aa', 'wcag22aa', 'best-practice', 'all'])(
+    'should validate %j as a valid preset value',
+    preset => {
+      expect(() => axePluginOptionsSchema.parse({ preset })).not.toThrow();
+    },
+  );
+
+  it('should accept scoreTargets as a number between 0 and 1', () => {
     expect(() =>
       axePluginOptionsSchema.parse({ scoreTargets: 0.99 }),
     ).not.toThrow();
   });
 
-  it('should accept object scoreTargets', () => {
+  it('should accept scoreTargets as an audit-specific score map', () => {
     expect(() =>
       axePluginOptionsSchema.parse({
         scoreTargets: { 'color-contrast': 0.99 },
       }),
     ).not.toThrow();
   });
 
-  it('should throw for invalid preset', () => {
+  it('should reject invalid preset values', () => {
     expect(() => axePluginOptionsSchema.parse({ preset: 'wcag3aa' })).toThrow();
   });
 
-  it('should throw for invalid scoreTargets value', () => {
+  it('should reject scoreTargets values greater than 1', () => {
     expect(() => axePluginOptionsSchema.parse({ scoreTargets: 1.5 })).toThrow();
   });
 
-  it('should throw for negative scoreTargets', () => {
+  it('should reject negative scoreTargets', () => {
     expect(() =>
       axePluginOptionsSchema.parse({ scoreTargets: -0.1 }),
     ).toThrow();

packages/plugin-axe/src/lib/meta/audits.unit.test.ts

@@ -1,54 +1,30 @@
 import { describe, expect, it } from 'vitest';
-import type { Audit } from '@code-pushup/models';
 import { loadAxeRules, transformRulesToAudits } from './transform.js';
 
 describe('transformRulesToAudits', () => {
-  describe('wcag21aa preset', () => {
-    it('should return approximately 67 audits', () => {
-      const audits = transformRulesToAudits(loadAxeRules('wcag21aa'));
-
-      expect(audits.length).toBeGreaterThanOrEqual(65);
-      expect(audits.length).toBeLessThanOrEqual(70);
-    });
-  });
-
-  describe('wcag22aa preset', () => {
-    it('should return approximately 68 audits', () => {
-      const audits = transformRulesToAudits(loadAxeRules('wcag22aa'));
-
-      expect(audits.length).toBeGreaterThanOrEqual(66);
-      expect(audits.length).toBeLessThanOrEqual(72);
-    });
-  });
-
-  describe('best-practice preset', () => {
-    it('should return approximately 30 audits', () => {
-      const audits = transformRulesToAudits(loadAxeRules('best-practice'));
-
-      expect(audits.length).toBeGreaterThanOrEqual(25);
-      expect(audits.length).toBeLessThanOrEqual(35);
-    });
-  });
-
-  describe('all preset', () => {
-    it('should return approximately 104 audits', () => {
-      const audits = transformRulesToAudits(loadAxeRules('all'));
-
-      expect(audits.length).toBeGreaterThanOrEqual(100);
-      expect(audits.length).toBeLessThanOrEqual(110);
-    });
-  });
-
-  describe('audit structure', () => {
-    it('should have slug, title, description, and docsUrl', () => {
-      const audit = transformRulesToAudits(
-        loadAxeRules('wcag21aa'),
-      )[0] as Audit;
-
-      expect(audit.slug).toBeTruthy();
-      expect(audit.title).toBeTruthy();
-      expect(audit.description).toBeTruthy();
-      expect(audit.docsUrl).toMatch(/^https:\/\//);
+  it.each([
+    ['wcag21aa' as const, 65, 70],
+    ['wcag22aa' as const, 66, 72],
+    ['best-practice' as const, 25, 35],
+    ['all' as const, 100, 110],
+  ])(
+    'should transform %j preset rules into audits within expected range',
+    (preset, min, max) => {
+      expect(transformRulesToAudits(loadAxeRules(preset))).toBeInRange(
+        min,
+        max,
+      );
+    },
+  );
+
+  it('should include required metadata fields for all transformed audits', () => {
+    const audit = transformRulesToAudits(loadAxeRules('wcag21aa'))[0]!;
+
+    expect(audit).toMatchObject({
+      slug: expect.any(String),
+      title: expect.any(String),
+      description: expect.any(String),
+      docsUrl: expect.stringMatching(/^https:\/\//),
     });
   });
 });

packages/plugin-axe/src/lib/meta/groups.unit.test.ts

@@ -1,128 +1,105 @@
 import type { RuleMetadata } from 'axe-core';
 import { describe, expect, it } from 'vitest';
+import type { Group } from '@code-pushup/models';
 import { loadAxeRules, transformRulesToGroups } from './transform.js';
 
 describe('transformRulesToGroups', () => {
-  describe('wcag21aa preset', () => {
-    it('should create WCAG 2.1 Level A and AA groups', () => {
-      const groups = transformRulesToGroups(
-        loadAxeRules('wcag21aa'),
-        'wcag21aa',
-      );
-
-      expect(groups.map(({ slug }) => slug)).toEqual([
-        'wcag21-level-a',
-        'wcag21-level-aa',
-      ]);
-      expect(groups.map(({ title }) => title)).toEqual([
-        'WCAG 2.1 Level A',
-        'WCAG 2.1 Level AA',
-      ]);
-    });
+  it('should create WCAG 2.1 Level A and AA groups for "wcag21aa" preset', () => {
+    const groups = transformRulesToGroups(loadAxeRules('wcag21aa'), 'wcag21aa');
 
-    it('should have refs in WCAG groups', () => {
-      transformRulesToGroups(loadAxeRules('wcag21aa'), 'wcag21aa').forEach(
-        ({ refs }) => {
-          expect(refs.length).toBeGreaterThan(0);
-        },
-      );
+    expect(groups).toBeArrayOfSize(2);
+    expect(groups).toPartiallyContain({
+      slug: 'wcag21-level-a',
+      title: 'WCAG 2.1 Level A',
+    });
+    expect(groups).toPartiallyContain({
+      slug: 'wcag21-level-aa',
+      title: 'WCAG 2.1 Level AA',
     });
   });
 
-  describe('wcag22aa preset', () => {
-    it('should create WCAG 2.2 Level A and AA groups', () => {
-      const groups = transformRulesToGroups(
-        loadAxeRules('wcag22aa'),
-        'wcag22aa',
-      );
-
-      expect(groups.map(({ slug }) => slug)).toEqual([
-        'wcag22-level-a',
-        'wcag22-level-aa',
-      ]);
-      expect(groups.map(({ title }) => title)).toEqual([
-        'WCAG 2.2 Level A',
-        'WCAG 2.2 Level AA',
-      ]);
-    });
+  it('should populate group refs with audit references for "wcag21aa" preset', () => {
+    const groups = transformRulesToGroups(loadAxeRules('wcag21aa'), 'wcag21aa');
+
+    expect(groups[0]!.refs).not.toBeEmpty();
+    expect(groups[1]!.refs).not.toBeEmpty();
   });
 
-  describe('best-practice preset', () => {
-    it('should create multiple category groups', () => {
-      expect(
-        transformRulesToGroups(loadAxeRules('best-practice'), 'best-practice')
-          .length,
-      ).toBeGreaterThan(5);
+  it('should create WCAG 2.2 Level A and AA groups for "wcag22aa" preset', () => {
+    const groups = transformRulesToGroups(loadAxeRules('wcag22aa'), 'wcag22aa');
+
+    expect(groups).toBeArrayOfSize(2);
+    expect(groups).toPartiallyContain({
+      slug: 'wcag22-level-a',
+      title: 'WCAG 2.2 Level A',
     });
+    expect(groups).toPartiallyContain({
+      slug: 'wcag22-level-aa',
+      title: 'WCAG 2.2 Level AA',
+    });
+  });
 
-    it('should format category titles correctly', () => {
-      const groups = transformRulesToGroups(
-        loadAxeRules('best-practice'),
-        'best-practice',
-      );
+  it('should create multiple category groups for "best-practice" preset', () => {
+    expect(
+      transformRulesToGroups(loadAxeRules('best-practice'), 'best-practice')
+        .length,
+    ).toBeGreaterThan(5);
+  });
 
-      expect(groups.find(({ slug }) => slug === 'aria')?.title).toBe('ARIA');
-      expect(groups.find(({ slug }) => slug === 'name-role-value')?.title).toBe(
-        'Names & Labels',
-      );
+  it('should format category titles using display names', () => {
+    const groups = transformRulesToGroups(
+      loadAxeRules('best-practice'),
+      'best-practice',
+    );
+
+    expect(groups).toPartiallyContain({ slug: 'aria', title: 'ARIA' });
+    expect(groups).toPartiallyContain({
+      slug: 'name-role-value',
+      title: 'Names & Labels',
     });
+  });
 
-    it('should format unknown category titles with title case', () => {
-      const groups = transformRulesToGroups(
-        [{ tags: ['cat.some-new-category', 'best-practice'] } as RuleMetadata],
-        'best-practice',
-      );
+  it('should format unknown category titles with title case', () => {
+    const groups = transformRulesToGroups(
+      [{ tags: ['cat.some-new-category', 'best-practice'] } as RuleMetadata],
+      'best-practice',
+    );
 
-      expect(
-        groups.find(({ slug }) => slug === 'some-new-category')?.title,
-      ).toBe('Some New Category');
+    expect(groups).toPartiallyContain({
+      slug: 'some-new-category',
+      title: 'Some New Category',
     });
+  });
 
-    it('should remove "cat." prefix from category slugs', () => {
-      transformRulesToGroups(
-        loadAxeRules('best-practice'),
-        'best-practice',
-      ).forEach(({ slug }) => {
-        expect(slug).not.toMatch(/^cat\./);
-      });
-    });
+  it('should remove "cat." prefix from category slugs', () => {
+    const groups = transformRulesToGroups(
+      loadAxeRules('best-practice'),
+      'best-practice',
+    );
+
+    expect(groups).toSatisfyAll<Group>(({ slug }) => !slug.match(/^cat\./));
   });
 
-  describe('all preset', () => {
-    it('should combine WCAG and category groups', () => {
-      const groups = transformRulesToGroups(loadAxeRules('all'), 'all');
+  it('should include both WCAG 2.2 and category groups for "all" preset', () => {
+    const groups = transformRulesToGroups(loadAxeRules('all'), 'all');
 
-      expect(groups.filter(({ slug }) => slug.startsWith('wcag'))).toHaveLength(
-        2,
-      );
-      expect(
-        groups.filter(({ slug }) => !slug.startsWith('wcag')).length,
-      ).toBeGreaterThan(5);
-    });
+    expect(groups).toPartiallyContain({ slug: 'wcag22-level-a' });
+    expect(groups).toPartiallyContain({ slug: 'wcag22-level-aa' });
 
-    it('should use WCAG 2.2 for all preset', () => {
-      const groups = transformRulesToGroups(loadAxeRules('all'), 'all');
+    expect(groups).toSatisfyAny(({ slug }) => !slug.startsWith('wcag'));
+  });
 
-      expect(groups.some(({ slug }) => slug === 'wcag22-level-a')).toBe(true);
-      expect(groups.some(({ slug }) => slug === 'wcag22-level-aa')).toBe(true);
-    });
+  it('should assign equal weight to all audit references within groups', () => {
+    const groups = transformRulesToGroups(loadAxeRules('wcag21aa'), 'wcag21aa');
+
+    expect(groups).toSatisfyAll<Group>(({ refs }) =>
+      refs.every(({ weight }) => weight === 1),
+    );
   });
 
-  describe('group structure', () => {
-    it('should have all refs with weight 1', () => {
-      transformRulesToGroups(loadAxeRules('wcag21aa'), 'wcag21aa').forEach(
-        ({ refs }) => {
-          refs.forEach(({ weight }) => {
-            expect(weight).toBe(1);
-          });
-        },
-      );
-    });
+  it('should filter out empty groups', () => {
+    const groups = transformRulesToGroups(loadAxeRules('all'), 'all');
 
-    it('should filter out empty groups', () => {
-      transformRulesToGroups(loadAxeRules('all'), 'all').forEach(({ refs }) => {
-        expect(refs.length).toBeGreaterThan(0);
-      });
-    });
+    expect(groups).toSatisfyAll<Group>(({ refs }) => refs.length > 0);
   });
 });

packages/plugin-axe/src/lib/processing.unit.test.ts

@@ -2,32 +2,32 @@ import { describe, expect, it } from 'vitest';
 import { processAuditsAndGroups } from './processing';
 
 describe('processAuditsAndGroups', () => {
-  it('should return audits and groups without expansion for single URL', () => {
+  it('should return audits and groups without expansion when analyzing single URL', () => {
     const { audits, groups } = processAuditsAndGroups(
       ['https://example.com'],
       'wcag21aa',
     );
 
-    expect(audits.length).toBeGreaterThan(0);
-    expect(groups.length).toBeGreaterThan(0);
+    expect(audits).not.toBeEmpty();
+    expect(groups).not.toBeEmpty();
 
-    expect(audits[0]?.slug).not.toContain('-1');
-    expect(groups[0]?.slug).not.toContain('-1');
+    expect(audits[0]!.slug).not.toContain('-1');
+    expect(groups[0]!.slug).not.toContain('-1');
   });
 
-  it('should expand audits and groups for multiple URLs', () => {
+  it('should expand audits and groups when analyzing multiple URLs', () => {
     const { audits, groups } = processAuditsAndGroups(
       ['https://example.com', 'https://another-example.com'],
       'wcag21aa',
     );
 
-    expect(audits.length).toBeGreaterThan(0);
-    expect(groups.length).toBeGreaterThan(0);
+    expect(audits).not.toBeEmpty();
+    expect(groups).not.toBeEmpty();
 
-    expect(audits[0]?.slug).toContain('-1');
-    expect(groups[0]?.slug).toContain('-1');
+    expect(audits[0]!.slug).toContain('-1');
+    expect(groups[0]!.slug).toContain('-1');
 
-    expect(audits[0]?.title).toContain('(example.com)');
-    expect(groups[0]?.title).toContain('(example.com)');
+    expect(audits[0]!.title).toContain('(example.com)');
+    expect(groups[0]!.title).toContain('(example.com)');
   });
 });