@elliemae/encw-leak-runner 1.0.2

package/lib/runner/tests/batchRunner.test.ts

@@ -0,0 +1,133 @@
+import { BatchRunner } from '../batchRunner.js';
+import { ScenarioRunner } from '../scenarioRunner.js';
+import { ScenarioRegistry } from '../../registry/scenarioRegistry.js';
+import type { MicroappLeakScenario } from '../../types/scenario.js';
+import type { ScenarioResult } from '../../types/results.js';
+import type { RunnerConfig } from '../../types/config.js';
+
+jest.mock('../scenarioRunner.js');
+
+function makeConfig(): RunnerConfig {
+  return {
+    env: {
+      baseUrl: 'https://q3.elliemae.io',
+      instanceId: 'BE11226875',
+      userId: 'admin',
+      password: 'Password#!23',
+    },
+    runner: {
+      headless: true,
+      outputDir: '/tmp/leak-reports',
+      topN: 5,
+    },
+  };
+}
+
+function makeScenario(id: string, tags: string[] = []): MicroappLeakScenario {
+  return {
+    id,
+    name: id.replace(/-/g, ' '),
+    description: `${id} description`,
+    tags,
+    microappSelector: `iframe#${id}`,
+    url: () => `/${id}`,
+    action: jest.fn().mockResolvedValue(undefined),
+  };
+}
+
+function makeResult(name: string, passed: boolean): ScenarioResult {
+  return {
+    name,
+    passed,
+    thresholdResult: { passed, reason: passed ? null : 'threshold exceeded' },
+    report: null,
+    durationMs: 1000,
+    error: null,
+  };
+}
+
+function buildRegistry(scenarios: MicroappLeakScenario[]): ScenarioRegistry {
+  return new ScenarioRegistry().register({
+    microapp: 'one-admin',
+    scenarios,
+  });
+}
+
+describe('BatchRunner', () => {
+  let runMock: jest.Mock;
+
+  beforeEach(() => {
+    runMock = jest.fn();
+    (ScenarioRunner as jest.Mock).mockImplementation(() => ({
+      launchBrowser: jest.fn().mockResolvedValue({
+        close: jest.fn().mockResolvedValue(undefined),
+      }),
+      run: runMock,
+    }));
+  });
+
+  it('runs all scenarios when no filter applied', async () => {
+    const registry = buildRegistry([
+      makeScenario('alpha'),
+      makeScenario('beta'),
+    ]);
+    runMock
+      .mockResolvedValueOnce(makeResult('alpha', true))
+      .mockResolvedValueOnce(makeResult('beta', true));
+
+    const runner = new BatchRunner(makeConfig(), registry);
+    const summary = await runner.runAll();
+
+    expect(runMock).toHaveBeenCalledTimes(2);
+    expect(summary.results).toHaveLength(2);
+    expect(summary.passCount).toBe(2);
+    expect(summary.failCount).toBe(0);
+  });
+
+  it('filters scenarios by tag', async () => {
+    const registry = buildRegistry([
+      makeScenario('alpha', ['critical']),
+      makeScenario('beta', ['optional']),
+    ]);
+    runMock.mockResolvedValueOnce(makeResult('alpha', true));
+
+    const runner = new BatchRunner(makeConfig(), registry);
+    const summary = await runner.runByTag('critical');
+
+    expect(runMock).toHaveBeenCalledTimes(1);
+    expect(summary.results[0].name).toBe('alpha');
+  });
+
+  it('runs a single scenario by registry key', async () => {
+    const registry = buildRegistry([
+      makeScenario('alpha'),
+      makeScenario('beta'),
+    ]);
+    runMock.mockResolvedValueOnce(makeResult('alpha', false));
+
+    const runner = new BatchRunner(makeConfig(), registry);
+    const summary = await runner.runByName('one-admin/alpha');
+
+    expect(runMock).toHaveBeenCalledTimes(1);
+    expect(summary.failCount).toBe(1);
+  });
+
+  it('throws when scenario key is not in the registry', async () => {
+    const runner = new BatchRunner(makeConfig(), new ScenarioRegistry());
+    await expect(runner.runByName('one-admin/unknown')).rejects.toThrow(
+      'No scenario registered with key "one-admin/unknown"',
+    );
+  });
+
+  it('totalDurationMs is sum of all scenario durations', async () => {
+    const registry = buildRegistry([makeScenario('a'), makeScenario('b')]);
+    runMock
+      .mockResolvedValueOnce({ ...makeResult('a', true), durationMs: 3000 })
+      .mockResolvedValueOnce({ ...makeResult('b', true), durationMs: 4000 });
+
+    const runner = new BatchRunner(makeConfig(), registry);
+    const summary = await runner.runAll();
+
+    expect(summary.totalDurationMs).toBe(7000);
+  });
+});

package/lib/runner/tests/scenarioRunner.test.ts

@@ -0,0 +1,162 @@
+import type { Browser } from '@playwright/test';
+import { ScenarioRunner } from '../scenarioRunner.js';
+import type { RunnerConfig } from '../../types/config.js';
+import type { MicroappLeakScenario } from '../../types/scenario.js';
+
+function makeConfig(overrides: Partial<RunnerConfig> = {}): RunnerConfig {
+  return {
+    env: {
+      baseUrl: 'https://q3.elliemae.io',
+      instanceId: 'BE11226875',
+      userId: 'admin',
+      password: 'Password#!23',
+    },
+    runner: {
+      headless: true,
+      outputDir: '/tmp/leak-reports-test',
+      topN: 5,
+    },
+    ...overrides,
+  };
+}
+
+function makeScenario(
+  overrides: Partial<MicroappLeakScenario> = {},
+): MicroappLeakScenario {
+  return {
+    id: 'test-scenario',
+    name: 'test-scenario',
+    description: 'Test scenario',
+    microappSelector: 'iframe#test-app',
+    url: () => 'https://q3.elliemae.io/test',
+    action: jest.fn().mockResolvedValue(undefined),
+    back: jest.fn().mockResolvedValue(undefined),
+    repeat: () => 1,
+    thresholds: {
+      maxRetainedSizeDeltaBytes: 10 * 1024 * 1024,
+      maxNewLeakGroups: 0,
+    },
+    ...overrides,
+  };
+}
+
+jest.mock('@elliemae/smoked-suite', () => {
+  // HeapMemoryProfiler must be a real class because IframeHeapProfiler extends it
+  class HeapMemoryProfiler {
+    constructor(
+      private readonly page: unknown,
+      private readonly outputDir: string,
+    ) {}
+
+    protected getCDPTarget(): unknown {
+      return this.page;
+    }
+
+    captureSnapshot(label: string): Promise<string> {
+      return Promise.resolve(`${this.outputDir}/${label}.heapsnapshot`);
+    }
+
+    compare(): Promise<null> {
+      return Promise.resolve(null);
+    }
+  }
+
+  return {
+    HeapMemoryProfiler,
+    AuthManager: jest.fn().mockImplementation(() => ({
+      login: jest.fn().mockResolvedValue(undefined),
+    })),
+    PageSetup: jest.fn().mockImplementation(() => ({
+      apply: jest.fn().mockResolvedValue(undefined),
+    })),
+  };
+});
+
+describe('ScenarioRunner', () => {
+  it('constructs without throwing', () => {
+    expect(() => new ScenarioRunner(makeConfig())).not.toThrow();
+  });
+
+  it('run() returns a ScenarioResult with error when browser interactions fail', async () => {
+    const runner = new ScenarioRunner(makeConfig());
+    const scenario = makeScenario();
+
+    const mockPage = {
+      context: jest.fn().mockReturnValue({
+        browser: () => ({ browserType: () => ({ name: () => 'chromium' }) }),
+        newCDPSession: jest.fn().mockResolvedValue({
+          send: jest.fn().mockResolvedValue(undefined),
+          on: jest.fn(),
+          detach: jest.fn().mockResolvedValue(undefined),
+        }),
+      }),
+      goto: jest.fn().mockRejectedValue(new Error('Navigation failed')),
+      waitForTimeout: jest.fn().mockResolvedValue(undefined),
+      locator: jest.fn().mockReturnValue({
+        elementHandle: jest.fn().mockResolvedValue(null),
+      }),
+      addInitScript: jest.fn().mockResolvedValue(undefined),
+      route: jest.fn().mockResolvedValue(undefined),
+    };
+
+    const mockBrowser = {
+      newContext: jest.fn().mockResolvedValue({
+        newPage: jest.fn().mockResolvedValue(mockPage),
+        close: jest.fn().mockResolvedValue(undefined),
+      }),
+    } as unknown as Browser;
+
+    const result = await runner.run(scenario, mockBrowser);
+
+    expect(result.name).toBe('test-scenario');
+    expect(typeof result.durationMs).toBe('number');
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+    expect(typeof result.passed).toBe('boolean');
+    // With navigation failure, should have error set
+    expect(result.error).not.toBeNull();
+    expect(result.passed).toBe(false);
+  });
+
+  it('run() returns a ScenarioResult with the correct shape on any outcome', async () => {
+    const runner = new ScenarioRunner(makeConfig());
+    const scenario = makeScenario();
+
+    const mockBrowser = {
+      newContext: jest.fn().mockResolvedValue({
+        newPage: jest.fn().mockResolvedValue({
+          context: jest.fn().mockReturnValue({
+            browser: () => ({
+              browserType: () => ({ name: () => 'chromium' }),
+            }),
+            newCDPSession: jest.fn().mockResolvedValue({
+              send: jest.fn().mockResolvedValue(undefined),
+              on: jest.fn(),
+              detach: jest.fn().mockResolvedValue(undefined),
+            }),
+          }),
+          goto: jest.fn().mockRejectedValue(new Error('Page load failed')),
+          waitForTimeout: jest.fn().mockResolvedValue(undefined),
+          locator: jest.fn().mockReturnValue({
+            elementHandle: jest.fn().mockResolvedValue(null),
+          }),
+          addInitScript: jest.fn().mockResolvedValue(undefined),
+          route: jest.fn().mockResolvedValue(undefined),
+        }),
+        close: jest.fn().mockResolvedValue(undefined),
+      }),
+    } as unknown as Browser;
+
+    const result = await runner.run(scenario, mockBrowser);
+
+    // ScenarioResult shape
+    expect(result).toHaveProperty('name');
+    expect(result).toHaveProperty('passed');
+    expect(result).toHaveProperty('thresholdResult');
+    expect(result).toHaveProperty('report');
+    expect(result).toHaveProperty('durationMs');
+    expect(result).toHaveProperty('error');
+
+    expect(result.thresholdResult).toHaveProperty('passed');
+    expect(result.thresholdResult).toHaveProperty('reason');
+  });
+});

package/lib/scenarios/index.ts

@@ -0,0 +1,8 @@
+import { ScenarioRegistry } from '../registry/scenarioRegistry.js';
+import { oneAdminScenarios } from './one-admin/index.js';
+
+export const scenarioRegistry: ScenarioRegistry =
+  new ScenarioRegistry().register({
+    microapp: 'one-admin',
+    scenarios: oneAdminScenarios,
+  });

package/lib/scenarios/one-admin/export-navigation.scenario.ts

@@ -0,0 +1,38 @@
+import type { MicroappLeakScenario } from '../../types/scenario.js';
+import {
+  SelectSettingsPageModel,
+  ExportPageModel,
+} from './page-models/index.js';
+
+export const exportNavigationScenario: MicroappLeakScenario = {
+  id: 'export-navigation',
+  name: 'Export Navigation',
+  description: 'Navigate to export page and come back - verify iframe GC',
+  tags: ['critical'],
+  microappSelector: 'iframe#pui-iframe-container-emAdminUI',
+
+  url: () => '/admin/oneadmin/migrate',
+
+  async action(page, frame) {
+    const settings = new SelectSettingsPageModel(frame);
+    await settings.container.waitFor({ state: 'visible' });
+    await settings.expandTreeItem('eFolder');
+    await settings.selectTreeItem('Enhanced Conditions');
+    await settings.clickExport();
+
+    const exportPage = new ExportPageModel(frame);
+    await exportPage.sourceDataTab.waitFor({ state: 'visible' });
+    await exportPage.dataTable.waitFor({ state: 'visible' });
+  },
+
+  async back(page) {
+    await ExportPageModel.clickBackAndWaitForSettings(page);
+  },
+
+  repeat: () => 3,
+
+  thresholds: {
+    maxRetainedSizeDeltaBytes: 10 * 1024 * 1024,
+    maxNewLeakGroups: 0,
+  },
+};

package/lib/scenarios/one-admin/index.ts

@@ -0,0 +1,6 @@
+import type { MicroappLeakScenario } from '../../types/scenario.js';
+import { exportNavigationScenario } from './export-navigation.scenario.js';
+
+export const oneAdminScenarios: readonly MicroappLeakScenario[] = [
+  exportNavigationScenario,
+];

package/lib/scenarios/one-admin/page-models/ExportPageModel.ts

@@ -0,0 +1,26 @@
+import type { Frame, Locator, Page } from '@playwright/test';
+
+const IFRAME_SELECTOR = 'iframe#pui-iframe-container-emAdminUI';
+const SETTINGS_URL_PATTERN = /\/admin\/oneadmin\/migrate(?:\/)?$/;
+
+export class ExportPageModel {
+  constructor(private readonly frame: Frame) {}
+
+  get sourceDataTab(): Locator {
+    return this.frame.getByRole('tab', { name: /Source Data/i });
+  }
+
+  get dataTable(): Locator {
+    return this.frame.locator('[role="table"]').first();
+  }
+
+  static async clickBackAndWaitForSettings(page: Page): Promise<void> {
+    await Promise.all([
+      page.waitForURL(SETTINGS_URL_PATTERN),
+      page
+        .frameLocator(IFRAME_SELECTOR)
+        .getByRole('button', { name: /back/i })
+        .click(),
+    ]);
+  }
+}

package/lib/scenarios/one-admin/page-models/SelectSettingsPageModel.ts

@@ -0,0 +1,30 @@
+import type { Frame, Locator } from '@playwright/test';
+
+export class SelectSettingsPageModel {
+  constructor(private readonly frame: Frame) {}
+
+  get container(): Locator {
+    return this.frame.locator('#one-admin-console-container');
+  }
+
+  get exportButton(): Locator {
+    return this.frame.getByRole('button', { name: 'Export' });
+  }
+
+  async expandTreeItem(name: string): Promise<void> {
+    const treeItem = this.frame.locator(
+      `[role="treeitem"]:has-text("${name}")`,
+    );
+    await treeItem
+      .locator('button[aria-label*="expand"], button[aria-label*="toggle"]')
+      .click();
+  }
+
+  async selectTreeItem(name: string): Promise<void> {
+    await this.frame.locator(`[role="treeitem"]:has-text("${name}")`).click();
+  }
+
+  async clickExport(): Promise<void> {
+    await this.exportButton.click();
+  }
+}

package/lib/scenarios/one-admin/page-models/index.ts

@@ -0,0 +1,2 @@
+export { SelectSettingsPageModel } from './SelectSettingsPageModel.js';
+export { ExportPageModel } from './ExportPageModel.js';

package/lib/types/config.ts

@@ -0,0 +1,34 @@
+export interface EnvironmentParams {
+  readonly baseUrl: string;
+  readonly instanceId: string;
+  readonly userId: string;
+  readonly password: string;
+}
+
+export interface RunnerOptions {
+  readonly headless: boolean;
+  readonly outputDir: string;
+  readonly topN: number;
+}
+
+export interface AiConfig {
+  readonly model: string;
+  readonly temperature: number;
+  readonly apiKey: string;
+}
+
+export interface RunnerConfig {
+  readonly env: EnvironmentParams;
+  readonly runner: RunnerOptions;
+  readonly ai?: AiConfig;
+}
+
+export interface ResolvedThresholds {
+  maxRetainedSizeDeltaBytes: number;
+  maxNewLeakGroups: number;
+}
+
+export const DEFAULT_THRESHOLDS: ResolvedThresholds = {
+  maxRetainedSizeDeltaBytes: 10 * 1024 * 1024,
+  maxNewLeakGroups: 0,
+};

package/lib/types/results.ts

@@ -0,0 +1,22 @@
+import type { ComparisonReport } from '@elliemae/encw-heap-doctor';
+
+export interface ThresholdResult {
+  readonly passed: boolean;
+  readonly reason: string | null;
+}
+
+export interface ScenarioResult {
+  readonly name: string;
+  readonly passed: boolean;
+  readonly thresholdResult: ThresholdResult;
+  readonly report: ComparisonReport | null;
+  readonly durationMs: number;
+  readonly error: Error | null;
+}
+
+export interface RunSummary {
+  readonly results: readonly ScenarioResult[];
+  readonly totalDurationMs: number;
+  readonly passCount: number;
+  readonly failCount: number;
+}

package/lib/types/scenario.ts

@@ -0,0 +1,18 @@
+import type { Page, Frame } from '@playwright/test';
+
+export interface MicroappLeakScenario {
+  /** Kebab-case identifier used as the scenario portion of the registry key. */
+  readonly id: string;
+  name: string;
+  description: string;
+  tags?: string[];
+  microappSelector: string;
+  url(): string;
+  action(page: Page, frame: Frame): Promise<void>;
+  back?(page: Page): Promise<void>;
+  repeat?(): number;
+  thresholds?: {
+    maxRetainedSizeDeltaBytes?: number;
+    maxNewLeakGroups?: number;
+  };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@elliemae/encw-leak-runner",
+  "version": "1.0.2",
+  "description": "Playwright orchestration framework for microapp memory leak detection",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/lib/index.d.ts",
+  "bin": {
+    "leak-runner": "./dist/bin/leak-runner.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/lib/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "zod": "^3.25.76",
+    "@elliemae/encw-heap-doctor": "26.2.15",
+    "@elliemae/smoked-suite": "26.2.26"
+  },
+  "devDependencies": {
+    "@elliemae/pui-cli": "~8.59.3",
+    "@playwright/test": "~1.58.2",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pui-cli pack -p -t node && esbuild bin/leak-runner.ts --bundle --packages=external --platform=node --target=node18 --format=esm --outdir=dist/bin",
+    "dev": "pui-cli pack -t node && esbuild bin/leak-runner.ts --bundle --packages=external --platform=node --target=node18 --format=esm --outdir=dist/bin",
+    "test": "pui-cli test -p",
+    "test-watch": "jest --watch",
+    "lint": "pui-cli lint",
+    "lint:fix": "pui-cli lint --fix",
+    "tscheck": "pui-cli tscheck --files"
+  }
+}

package/reports/analysis/index.html

@@ -0,0 +1,116 @@
+
+<!doctype html>
+<html lang="en">
+
+<head>
+    <title>Code coverage report for analysis</title>
+    <meta charset="utf-8" />
+    <link rel="stylesheet" href="../prettify.css" />
+    <link rel="stylesheet" href="../base.css" />
+    <link rel="shortcut icon" type="image/x-icon" href="../favicon.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style type='text/css'>
+        .coverage-summary .sorter {
+            background-image: url(../sort-arrow-sprite.png);
+        }
+    </style>
+</head>
+    
+<body>
+<div class='wrapper'>
+    <div class='pad1'>
+        <h1><a href="../index.html">All files</a> analysis</h1>
+        <div class='clearfix'>
+            
+            <div class='fl pad1y space-right2'>
+                <span class="strong">100% </span>
+                <span class="quiet">Statements</span>
+                <span class='fraction'>11/11</span>
+            </div>
+        
+            
+            <div class='fl pad1y space-right2'>
+                <span class="strong">100% </span>
+                <span class="quiet">Branches</span>
+                <span class='fraction'>3/3</span>
+            </div>
+        
+            
+            <div class='fl pad1y space-right2'>
+                <span class="strong">100% </span>
+                <span class="quiet">Functions</span>
+                <span class='fraction'>2/2</span>
+            </div>
+        
+            
+            <div class='fl pad1y space-right2'>
+                <span class="strong">100% </span>
+                <span class="quiet">Lines</span>
+                <span class='fraction'>11/11</span>
+            </div>
+        
+            
+        </div>
+        <p class="quiet">
+            Press <em>n</em> or <em>j</em> to go to the next uncovered block, <em>b</em>, <em>p</em> or <em>k</em> for the previous block.
+        </p>
+        <template id="filterTemplate">
+            <div class="quiet">
+                Filter:
+                <input type="search" id="fileSearch">
+            </div>
+        </template>
+    </div>
+    <div class='status-line high'></div>
+    <div class="pad1">
+<table class="coverage-summary">
+<thead>
+<tr>
+   <th data-col="file" data-fmt="html" data-html="true" class="file">File</th>
+   <th data-col="pic" data-type="number" data-fmt="html" data-html="true" class="pic"></th>
+   <th data-col="statements" data-type="number" data-fmt="pct" class="pct">Statements</th>
+   <th data-col="statements_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="branches" data-type="number" data-fmt="pct" class="pct">Branches</th>
+   <th data-col="branches_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="functions" data-type="number" data-fmt="pct" class="pct">Functions</th>
+   <th data-col="functions_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="lines" data-type="number" data-fmt="pct" class="pct">Lines</th>
+   <th data-col="lines_raw" data-type="number" data-fmt="html" class="abs"></th>
+</tr>
+</thead>
+<tbody><tr>
+	<td class="file high" data-value="thresholdEvaluator.ts"><a href="thresholdEvaluator.ts.html">thresholdEvaluator.ts</a></td>
+	<td data-value="100" class="pic high">
+	<div class="chart"><div class="cover-fill cover-full" style="width: 100%"></div><div class="cover-empty" style="width: 0%"></div></div>
+	</td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="11" class="abs high">11/11</td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="3" class="abs high">3/3</td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="2" class="abs high">2/2</td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="11" class="abs high">11/11</td>
+	</tr>
+
+</tbody>
+</table>
+</div>
+                <div class='push'></div><!-- for sticky footer -->
+            </div><!-- /wrapper -->
+            <div class='footer quiet pad2 space-top1 center small'>
+                Code coverage generated by
+                <a href="https://istanbul.js.org/" target="_blank" rel="noopener noreferrer">istanbul</a>
+                at 2026-05-08T18:03:27.910Z
+            </div>
+        <script src="../prettify.js"></script>
+        <script>
+            window.onload = function () {
+                prettyPrint();
+            };
+        </script>
+        <script src="../sorter.js"></script>
+        <script src="../block-navigation.js"></script>
+    </body>
+</html>
+