add plugin manager test

Author: abdulahmad307

.github/actions/file/tests/pluginManager.test.ts

@@ -0,0 +1,10 @@
+
+// - this exists because I'm not sure how to mock
+//   the dynamic import function, so mocking this instead
+// - also, vitest has a limitation on mocking:
+//   https://vitest.dev/guide/mocking/modules.html#mocking-modules-pitfalls
+// - basically if a function is called by another function in the same file
+//   it can't be mocked. So this was extracted into a separate file
+export async function dynamicImport(path: string) {
+  return import(path)
+}

.github/actions/find/src/dynamicImport.ts

@@ -3,7 +3,7 @@ import AxeBuilder from '@axe-core/playwright'
 import playwright from 'playwright'
 import {AuthContext} from './AuthContext.js'
 import {generateScreenshots} from './generateScreenshots.js'
-import { loadPlugins } from './pluginManager.js';
+import { loadPlugins } from './pluginManager.js'
 
 
 export async function findForUrl(
@@ -21,18 +21,18 @@ export async function findForUrl(
   await page.goto(url)
   console.log(`Scanning ${page.url()}`)
 
-  let findings: Finding[] = [];
+  let findings: Finding[] = []
   const addFinding = (findingData: Finding) => {
-    findings.push(findingData);
-  };
+    findings.push(findingData)
+  }
 
   try {
     const rawFindings = await new AxeBuilder({page}).analyze()
 
-    const plugins = await loadPlugins();
+    const plugins = await loadPlugins()
     for (const plugin of plugins) {
-      console.log('Running plugin: ', plugin.name);
-      await plugin.default({ page, addFinding, url });
+      console.log('Running plugin: ', plugin.name)
+      await plugin.default({ page, addFinding, url })
     }
 
     let screenshotId: string | undefined

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

@@ -1,65 +1,83 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
+import * as fs from 'fs'
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+import { dynamicImport } from './dynamicImport.js'
 
 // Helper to get __dirname equivalent in ES Modules
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
-const plugins: any[] = [];
-let pluginsLoaded = false;
+const plugins: any[] = []
+let pluginsLoaded = false
 
 
 export async function loadPlugins() {
+  console.log('loading plugins')
+
   try {
     if (!pluginsLoaded) {
-      await loadBuiltInPlugins();
-      await loadCustomPlugins();
+      await loadBuiltInPlugins()
+      await loadCustomPlugins()
     }
   } catch (e) {
-    plugins.length = 0;
-    console.log('There was an error while loading plugins.');
-    console.log('Clearing all plugins and aborting custom plugin scans.');
-    console.log('Please check the logs for hints as to what may have gone wrong.');
+    plugins.length = 0
+    console.log(abortError)
   } finally {
-    pluginsLoaded = true;
-    return plugins;
+    pluginsLoaded = true
+    return plugins
   }
 }
 
-async function loadBuiltInPlugins() {
-  console.log('Loading built-in plugins');
+export const abortError = [
+  'There was an error while loading plugins.',
+  'Clearing all plugins and aborting custom plugin scans.',
+  'Please check the logs for hints as to what may have gone wrong.'
+].join('\n')
+
+
+export function clearCache() {
+  console.log('clearing plugin cache')
+  pluginsLoaded = false
+  plugins.length = 0
+}
+
+
+// exported for mocking/testing. not for actual use
+export async function loadBuiltInPlugins() {
+  console.log('Loading built-in plugins')
 
-  const pluginsPath = '../../../scanner-plugins/';
+  const pluginsPath = '../../../scanner-plugins/'
   await loadPluginsFromPath({
     readPath: path.join(__dirname, pluginsPath),
     importPath: pluginsPath,
-  });
+  })
 }
 
-async function loadCustomPlugins() {
-  console.log('Loading custom plugins');
+// exported for mocking/testing. not for actual use
+export async function loadCustomPlugins() {
+  console.log('Loading custom plugins')
 
-  const pluginsPath = process.cwd() + '/.github/scanner-plugins/';
+  const pluginsPath = process.cwd() + '/.github/scanner-plugins/'
   await loadPluginsFromPath({
     readPath: pluginsPath,
     importPath: pluginsPath
-  });
+  })
 }
 
-async function loadPluginsFromPath({ readPath, importPath }: { readPath: string, importPath: string }) {
+// exported for mocking/testing. not for actual use
+export async function loadPluginsFromPath({ readPath, importPath }: { readPath: string, importPath: string }) {
   try {
-    const res = fs.readdirSync(readPath);
+    const res = fs.readdirSync(readPath)
     for (const pluginFolder of res) {
-      console.log('Found plugin: ', pluginFolder);
+      console.log('Found plugin: ', pluginFolder)
       // @ts-ignore
-      plugins.push(await import(path.join(importPath, pluginFolder, '/index.js')));
+      plugins.push(await dynamicImport(path.join(importPath, pluginFolder, '/index.js')))
     }
   } catch (e) {
     // - log errors here for granular info
-    console.log('error: ');
-    console.log(e);
+    console.log('error: ')
+    console.log(e)
     // - throw error to handle aborting the plugin scans
-    throw(e);
+    throw(e)
   }
 }

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

@@ -0,0 +1,57 @@
+import {describe, it, expect, vi, beforeEach} from 'vitest'
+
+import * as fs from 'fs'
+import * as dynamicImportModule from '../src/dynamicImport.js'
+import * as pluginManager from '../src/pluginManager.js'
+
+
+// - enable spying on fs
+// https://vitest.dev/guide/browser/#limitations
+vi.mock('fs', { spy: true })
+vi.mock('../src/pluginManager.js', { spy: true })
+
+describe('loadPlugins', () => {
+  vi.spyOn(dynamicImportModule, 'dynamicImport').mockImplementation((path) => (
+    Promise.resolve(path)
+  ))
+  beforeEach(() => {
+    vi.spyOn(fs, 'readdirSync').mockImplementation((readPath) => {
+      return [readPath + '/plugin-1', readPath + '/plugin-2']
+    })
+  })
+
+  describe('when plugins are not loaded', () => {
+    it('loads them', async () => {
+      pluginManager.clearCache()
+      const plugins = await pluginManager.loadPlugins()
+      expect(dynamicImportModule.dynamicImport).toHaveBeenCalledTimes(4)
+      expect(plugins.length).toBe(4)
+    })
+  })
+
+  describe('when plugins are already loaded', () => {
+    it('caches them and doesnt load them again', async () => {
+      pluginManager.clearCache()
+      await pluginManager.loadPlugins()
+      await pluginManager.loadPlugins()
+      expect(pluginManager.loadBuiltInPlugins).toHaveBeenCalledTimes(0)
+      expect(pluginManager.loadCustomPlugins).toHaveBeenCalledTimes(0)
+    })
+  })
+
+  describe('when there is an error loading plugins', () => {
+    beforeEach(() => {
+      vi.spyOn(fs, 'readdirSync').mockImplementation(() => {
+        throw new Error('test error')
+      })
+    })
+
+    it('Aborts loading all plugins', async () => {
+      pluginManager.clearCache()
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+      const plugins = await pluginManager.loadPlugins()
+      expect(plugins.length).toBe(0)
+      expect(consoleLogSpy).toHaveBeenCalledWith(pluginManager.abortError)
+    })
+  })
+})