add tests

- clean up formatting and linting

Author: abdulahmad307

.github/actions/find/src/findForUrl.ts

@@ -30,18 +30,24 @@ export async function findForUrl(
   try {
     const scansContext = getScansContext()
 
-    let rawFindings = {} as axe.AxeResults
+    let rawFindings: axe.AxeResults | undefined
     if (scansContext.shouldPerformAxeScan) {
       rawFindings = await new AxeBuilder({page}).analyze()
     }
 
-    const plugins = await loadPlugins()
-    for (const plugin of plugins) {
-      if (scansContext.scans.includes(plugin.name)) {
-        console.log('Running plugin: ', plugin.name)
-        await plugin.default({page, addFinding, url})
-      } else {
-        console.log(`Skipping plugin ${plugin.name} because it is not included in the 'scans' input`)
+    // - this condition is not required, but makes it easier to make assertions
+    //   in unit tests on whether 'loadPlugins' was called or not
+    // - alternatively, we can wrap the 'plugin.default(...)' call in another function
+    //   and make assertions on whether that function was called or not
+    if (scansContext.shouldRunPlugins) {
+      const plugins = await loadPlugins()
+      for (const plugin of plugins) {
+        if (scansContext.scansToPerform.includes(plugin.name)) {
+          console.log('Running plugin: ', plugin.name)
+          await plugin.default({page, addFinding, url})
+        } else {
+          console.log(`Skipping plugin ${plugin.name} because it is not included in the 'scans' input`)
+        }
       }
     }
 
@@ -51,17 +57,18 @@ export async function findForUrl(
     }
 
     console.log('rawFindings: ', rawFindings)
-    findings = rawFindings?.violations.map(violation => ({
-      scannerType: 'axe',
-      url,
-      html: violation.nodes[0].html.replace(/'/g, '''),
-      problemShort: violation.help.toLowerCase().replace(/'/g, '''),
-      problemUrl: violation.helpUrl.replace(/'/g, '''),
-      ruleId: violation.id,
-      solutionShort: violation.description.toLowerCase().replace(/'/g, '''),
-      solutionLong: violation.nodes[0].failureSummary?.replace(/'/g, '''),
-      screenshotId,
-    }))
+    findings =
+      rawFindings?.violations.map(violation => ({
+        scannerType: 'axe',
+        url,
+        html: violation.nodes[0].html.replace(/'/g, '''),
+        problemShort: violation.help.toLowerCase().replace(/'/g, '''),
+        problemUrl: violation.helpUrl.replace(/'/g, '''),
+        ruleId: violation.id,
+        solutionShort: violation.description.toLowerCase().replace(/'/g, '''),
+        solutionLong: violation.nodes[0].failureSummary?.replace(/'/g, '''),
+        screenshotId,
+      })) || []
   } catch (e) {
     console.error('Error during accessibility scan:', e)
   }

.github/actions/find/src/pluginManager.ts

@@ -2,14 +2,19 @@ import * as fs from 'fs'
 import * as path from 'path'
 import {fileURLToPath} from 'url'
 import {dynamicImport} from './dynamicImport.js'
+import type {Finding} from './types.d.js'
+import playwright from 'playwright'
 
 // Helper to get __dirname equivalent in ES Modules
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
-// - plugins are js files right now, so they dont have a type
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const plugins: any[] = []
+export type Plugin = {
+  name: string
+  default: (options: {page: playwright.Page; addFinding: (findingData: Finding) => void; url: string}) => Promise<void>
+}
+
+const plugins: Plugin[] = []
 let pluginsLoaded = false
 
 export async function loadPlugins() {
@@ -36,7 +41,6 @@ export const abortError = [
 ].join('\n')
 
 export function clearCache() {
-  console.log('clearing plugin cache')
   pluginsLoaded = false
   plugins.length = 0
 }

.github/actions/find/src/scansContextProvider.ts

@@ -1,25 +1,36 @@
 import core from '@actions/core'
 
 type ScansContext = {
-  scans: Array<string>
+  scansToPerform: Array<string>
   shouldPerformAxeScan: boolean
+  shouldRunPlugins: boolean
 }
 let scansContext: ScansContext | undefined
 
 export function getScansContext() {
   if (!scansContext) {
     const scansJson = core.getInput('scans', {required: false})
-    const scans = JSON.parse(scansJson || '{}')
+    console.log('scans input: ', scansJson)
+    const scansToPerform = JSON.parse(scansJson || '{}')
+    // - if we dont have a scans input
+    //   or we do have a scans input, but it only has 1 item and its 'axe'
+    //   then we only want to run 'axe' and not the plugins
+    const onlyAxeScan = scansToPerform.length === 0 || (scansToPerform.length === 1 && scansToPerform[0] === 'axe')
 
     scansContext = {
-      scans,
+      scansToPerform,
       // - if no 'scans' input is provided, we default to the existing behavior
       //   (only axe scan) for backwards compatability.
       // - we can enforce using the 'scans' input in a future major release and
       //   mark it as required
-      shouldPerformAxeScan: !scansJson || scans.includes('axe'),
+      shouldPerformAxeScan: !scansJson || scansToPerform.includes('axe'),
+      shouldRunPlugins: scansToPerform.length > 0 && !onlyAxeScan,
     }
   }
 
   return scansContext
 }
+
+export function clearCache() {
+  scansContext = undefined
+}

.github/actions/find/tests/findForUrl.test.ts

@@ -0,0 +1,106 @@
+import {describe, it, expect, vi} from 'vitest'
+import core from '@actions/core'
+import {findForUrl} from '../src/findForUrl.js'
+import AxeBuilder from '@axe-core/playwright'
+import axe from 'axe-core'
+import * as pluginManager from '../src/pluginManager.js'
+import {clearCache} from '../src/scansContextProvider.js'
+
+vi.mock('playwright', () => ({
+  default: {
+    chromium: {
+      launch: () => ({
+        newContext: () => ({
+          newPage: () => ({
+            pageUrl: '',
+            goto: () => {},
+            url: () => {},
+          }),
+          close: () => {},
+        }),
+        close: () => {},
+      }),
+    },
+  },
+}))
+
+vi.mock('@axe-core/playwright', () => {
+  const AxeBuilderMock = vi.fn()
+  AxeBuilderMock.prototype.analyze = vi.fn(() => {
+    console.log('calling mock analyze')
+    return Promise.resolve({violations: []} as unknown as axe.AxeResults)
+  })
+  return {default: AxeBuilderMock}
+})
+
+let actionInput: string = ''
+let loadedPlugins: pluginManager.Plugin[] = []
+
+function clearAll() {
+  clearCache()
+  vi.clearAllMocks()
+}
+
+describe('findForUrl', () => {
+  vi.spyOn(core, 'getInput').mockImplementation(() => actionInput)
+  vi.spyOn(pluginManager, 'loadPlugins').mockImplementation(() => Promise.resolve(loadedPlugins))
+
+  async function axeOnlyTest() {
+    clearAll()
+
+    await findForUrl('test.com')
+    expect(AxeBuilder.prototype.analyze).toHaveBeenCalledTimes(1)
+    expect(pluginManager.loadPlugins).toHaveBeenCalledTimes(0)
+  }
+
+  describe('when no scans list is provided', () => {
+    it('defaults to running only axe scan', async () => {
+      actionInput = ''
+      await axeOnlyTest()
+    })
+  })
+
+  describe('when a scans list is provided', () => {
+    describe('and the list _only_ includes axe', () => {
+      it('runs only the axe scan', async () => {
+        actionInput = JSON.stringify(['axe'])
+        await axeOnlyTest()
+      })
+    })
+
+    describe('and the list includes axe and other scans', () => {
+      it('runs axe and plugins', async () => {
+        actionInput = JSON.stringify(['axe', 'custom-scan'])
+        clearAll()
+
+        await findForUrl('test.com')
+        expect(AxeBuilder.prototype.analyze).toHaveBeenCalledTimes(1)
+        expect(pluginManager.loadPlugins).toHaveBeenCalledTimes(1)
+      })
+    })
+
+    describe('and the list does not include axe', () => {
+      it('only runs plugins', async () => {
+        actionInput = JSON.stringify(['custom-scan'])
+        clearAll()
+
+        await findForUrl('test.com')
+        expect(AxeBuilder.prototype.analyze).toHaveBeenCalledTimes(0)
+        expect(pluginManager.loadPlugins).toHaveBeenCalledTimes(1)
+      })
+    })
+
+    it('should only run scans that are included in the list', async () => {
+      loadedPlugins = [
+        {name: 'custom-scan-1', default: vi.fn()},
+        {name: 'custom-scan-2', default: vi.fn()},
+      ]
+      actionInput = JSON.stringify(['custom-scan-1'])
+      clearAll()
+
+      await findForUrl('test.com')
+      expect(loadedPlugins[0].default).toHaveBeenCalledTimes(1)
+      expect(loadedPlugins[1].default).toHaveBeenCalledTimes(0)
+    })
+  })
+})