@nexustools/nwjstestrunner 0.0.0-stage → 1.0.0-beta.1

package/src/harness/test-http-server.ts

@@ -0,0 +1,162 @@
+import * as fs from 'fs';
+import * as http from 'http';
+import * as path from 'path';
+import { TestHttpServerOptions } from '../types/test-runner-types';
+
+const DEFAULT_MIME_TYPES: Record<string, string> = {
+  '.html': 'text/html; charset=utf-8',
+  '.htm': 'text/html; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.mjs': 'application/javascript; charset=utf-8',
+  '.cjs': 'application/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map': 'application/json; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.wasm': 'application/wasm',
+  '.txt': 'text/plain; charset=utf-8',
+  '.xml': 'application/xml; charset=utf-8'
+};
+
+export class TestHttpServer {
+  private readonly options: TestHttpServerOptions;
+  private server: http.Server | null = null;
+  private boundPort = 0;
+
+  constructor(options: TestHttpServerOptions) {
+    this.options = options;
+  }
+
+  public getPort(): number {
+    return this.boundPort;
+  }
+
+  public getBaseUrl(): string {
+    const host = this.options.host || '127.0.0.1';
+    return `http://${host}:${this.boundPort}`;
+  }
+
+  public async start(): Promise<number> {
+    if (this.server && this.boundPort > 0) {
+      return this.boundPort;
+    }
+
+    const projectRootDir = path.resolve(this.options.projectRootDir);
+    const defaultEntry = this.options.defaultEntryFile || 'index.html';
+    const host = this.options.host || '127.0.0.1';
+    const port = this.options.port ?? 0;
+    const ignore404 = new Set(this.options.ignore404Paths ?? ['/favicon.ico']);
+    const mimeTypes: Record<string, string> = {
+      ...DEFAULT_MIME_TYPES,
+      ...(this.options.customMimeTypes || {})
+    };
+
+    this.server = http.createServer(async (req, res) => {
+      try {
+        const reqUrl = req.url || '/';
+        const rawPath = reqUrl.split('?')[0] || '/';
+        const reqPath = decodeURIComponent(rawPath);
+
+        if (this.options.routeHandler) {
+          const handled = await this.options.routeHandler(req, res, {
+            projectRootDir,
+            reqPath,
+            reqUrl
+          });
+          if (handled === true || res.writableEnded || res.headersSent) {
+            return;
+          }
+        }
+
+        const relPath =
+          reqPath === '/'
+            ? defaultEntry
+            : reqPath.startsWith('/')
+              ? reqPath.slice(1)
+              : reqPath;
+        const filePath = path.resolve(projectRootDir, relPath);
+
+        // Guard against directory traversal outside projectRootDir
+        const normalizedRoot = projectRootDir.endsWith(path.sep)
+          ? projectRootDir
+          : projectRootDir + path.sep;
+        const isInsideProject =
+          filePath === projectRootDir || filePath.startsWith(normalizedRoot);
+
+        if (
+          isInsideProject &&
+          relPath &&
+          fs.existsSync(filePath) &&
+          fs.statSync(filePath).isFile()
+        ) {
+          const ext = path.extname(filePath).toLowerCase();
+          const contentType = mimeTypes[ext] || 'application/octet-stream';
+          res.writeHead(200, {
+            'Content-Type': contentType,
+            'Access-Control-Allow-Origin': '*',
+            'Cache-Control': 'no-store'
+          });
+          fs.createReadStream(filePath).pipe(res);
+          return;
+        }
+
+        if (!ignore404.has(reqPath) && this.options.onHttp404) {
+          this.options.onHttp404(reqPath, filePath);
+        }
+
+        res.writeHead(404, {
+          'Content-Type': 'text/plain; charset=utf-8',
+          'Access-Control-Allow-Origin': '*'
+        });
+        res.end(`404 Not Found: ${reqPath}`);
+      } catch (err: any) {
+        if (!res.headersSent) {
+          res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+        }
+        res.end(`500 Internal Server Error: ${err?.message || String(err)}`);
+      }
+    });
+
+    return new Promise<number>((resolve, reject) => {
+      if (!this.server) {
+        reject(new Error('HTTP server not created'));
+        return;
+      }
+      this.server.once('error', (err) => reject(err));
+      this.server.listen(port, host, () => {
+        const addr = this.server?.address();
+        if (addr && typeof addr === 'object') {
+          this.boundPort = addr.port;
+          resolve(this.boundPort);
+        } else {
+          reject(new Error('Failed to resolve bound port for TestHttpServer'));
+        }
+      });
+    });
+  }
+
+  public async stop(): Promise<void> {
+    if (!this.server) return;
+    const srv = this.server;
+    this.server = null;
+    this.boundPort = 0;
+    return new Promise<void>((resolve) => {
+      try {
+        srv.close(() => resolve());
+      } catch (_e) {
+        resolve();
+      }
+    });
+  }
+}

package/src/harness/test-log-writer.ts

@@ -0,0 +1,154 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export class TestLogWriter {
+  private readonly logFilePath: string;
+  private readonly headerTitle: string;
+  private readonly errorLogs: string[] = [];
+  private totalTests = 0;
+  private passedCount = 0;
+  private failedCount = 0;
+
+  constructor(logFilePath: string, headerTitle = 'NW.js Desktop Client Test Harness Log') {
+    this.logFilePath = path.resolve(logFilePath);
+    this.headerTitle = headerTitle;
+    this.ensureDirectory();
+  }
+
+  private ensureDirectory(): void {
+    try {
+      fs.mkdirSync(path.dirname(this.logFilePath), { recursive: true });
+    } catch (_e) {}
+  }
+
+  public getLogFilePath(): string {
+    return this.logFilePath;
+  }
+
+  public getErrorLogs(): ReadonlyArray<string> {
+    return this.errorLogs;
+  }
+
+  public getMetrics(): { totalTests: number; passedCount: number; failedCount: number } {
+    return {
+      totalTests: this.totalTests,
+      passedCount: this.passedCount,
+      failedCount: this.failedCount
+    };
+  }
+
+  public setTotalTests(total: number): void {
+    this.totalTests = Math.max(0, total);
+  }
+
+  public setCounts(passed: number, failed: number): void {
+    this.passedCount = Math.max(0, passed);
+    this.failedCount = Math.max(0, failed);
+  }
+
+  public incrementPassed(delta = 1): void {
+    this.passedCount += delta;
+  }
+
+  public incrementFailed(delta = 1): void {
+    this.failedCount += delta;
+  }
+
+  public writeInitialInterruptedBanner(): void {
+    try {
+      this.ensureDirectory();
+      const lines = [
+        '==================================================',
+        this.headerTitle,
+        '==================================================',
+        `Started at: ${new Date().toISOString()}`,
+        'Status: Tests interupted'
+      ];
+      fs.writeFileSync(this.logFilePath, lines.join('\n'), 'utf-8');
+    } catch (_e) {}
+  }
+
+  public writeProgressSnapshot(statusLabel = 'Tests interupted'): void {
+    try {
+      this.ensureDirectory();
+      const lines = [
+        '==================================================',
+        this.headerTitle,
+        '==================================================',
+        `Updated at: ${new Date().toISOString()}`,
+        `Status: ${statusLabel || 'Tests interupted'}`,
+        `Total Tests: ${this.totalTests}`,
+        `Passed: ${this.passedCount}`,
+        `Failed: ${this.failedCount}`,
+        '=================================================='
+      ];
+      if (this.errorLogs.length > 0) {
+        lines.push('FAILURES & ERRORS:');
+        for (const err of this.errorLogs) {
+          lines.push(err);
+        }
+      }
+      fs.writeFileSync(this.logFilePath, lines.join('\n'), 'utf-8');
+    } catch (_e) {}
+  }
+
+  public recordError(source: string, err: any): string {
+    const detail =
+      err && typeof err === 'object' && (err.stack || err.message)
+        ? err.stack || err.message
+        : String(err);
+    const errMsg = `[ERROR][${source}] ${detail}`;
+    this.errorLogs.push(errMsg);
+    console.error(errMsg);
+    this.writeProgressSnapshot('Tests interupted (Running with errors)');
+    return errMsg;
+  }
+
+  public writeFinalSummary(): { exitCode: number; logText: string } {
+    const totalPassed = this.passedCount;
+    let totalFailed = this.failedCount;
+
+    if (this.totalTests > 0 && totalPassed + totalFailed !== this.totalTests) {
+      this.recordError(
+        'TestCountMismatchError',
+        `Test count mismatch: total expected ${this.totalTests}, but executed passed (${totalPassed}) + failed (${totalFailed}) = ${totalPassed + totalFailed}`
+      );
+    }
+
+    if (this.errorLogs.length > 0 && totalFailed === 0) {
+      totalFailed = 1;
+    }
+
+    const totalAll = this.totalTests || totalPassed + totalFailed;
+    const testLogLines = [
+      '==================================================',
+      this.headerTitle,
+      '==================================================',
+      `Completed at: ${new Date().toISOString()}`,
+      `Total Tests: ${totalAll}`,
+      `Passed: ${totalPassed}`,
+      `Failed: ${totalFailed}`,
+      '=================================================='
+    ];
+
+    if (this.errorLogs.length > 0) {
+      testLogLines.push('FAILURES & ERRORS:');
+      for (const err of this.errorLogs) {
+        testLogLines.push(err);
+      }
+    } else {
+      testLogLines.push('SUCCESS: All tests completed cleanly.');
+    }
+
+    const logText = testLogLines.join('\n');
+    try {
+      this.ensureDirectory();
+      fs.writeFileSync(this.logFilePath, logText, 'utf-8');
+    } catch (e) {
+      console.error('Failed to write test log:', e);
+    }
+
+    const exitCode = this.errorLogs.length > 0 || totalFailed > 0 ? 1 : 0;
+    return { exitCode, logText };
+  }
+}

package/src/harness/webview-test-controller.ts

@@ -0,0 +1,192 @@
+import {
+  WaitForScreenLoadOptions,
+  WebviewExecutionResult
+} from '../types/test-runner-types';
+
+export class WebviewTestController {
+  private readonly webview: any;
+  private readonly onError?: (source: string, err: any) => void;
+  private readonly onLoadAbort?: (reason: string) => void;
+  private readonly consoleErrorLevel: number;
+
+  constructor(
+    webview: any,
+    options?: {
+      consoleErrorLevel?: number;
+      onError?: (source: string, err: any) => void;
+      onLoadAbort?: (reason: string) => void;
+    }
+  ) {
+    this.webview = webview;
+    this.consoleErrorLevel = options?.consoleErrorLevel ?? 2;
+    this.onError = options?.onError;
+    this.onLoadAbort = options?.onLoadAbort;
+  }
+
+  public attachEventListeners(onContentLoad: () => void): void {
+    if (!this.webview || typeof this.webview.addEventListener !== 'function') {
+      return;
+    }
+
+    this.webview.addEventListener('console-message', (e: any) => {
+      if (e && typeof e.level === 'number' && e.level >= this.consoleErrorLevel) {
+        this.onError?.(`WebviewConsole[L${e.level}]`, e.message);
+      }
+    });
+
+    this.webview.addEventListener('loadabort', (e: any) => {
+      const reason = e?.reason || 'Unknown reason';
+      this.onError?.('WebviewLoadAbort', `Failed to load client in webview: ${reason}`);
+      this.onLoadAbort?.(reason);
+    });
+
+    this.webview.addEventListener('contentload', () => {
+      onContentLoad();
+    });
+  }
+
+  public navigate(url: string): void {
+    if (this.webview) {
+      this.webview.src = url;
+    }
+  }
+
+  public execScriptWithTimeout(code: string, timeoutMs = 1500): Promise<any> {
+    return new Promise((resolve) => {
+      if (!this.webview || typeof this.webview.executeScript !== 'function') {
+        resolve(null);
+        return;
+      }
+
+      let done = false;
+      const timer = setTimeout(() => {
+        if (!done) {
+          done = true;
+          resolve(null);
+        }
+      }, timeoutMs);
+
+      try {
+        this.webview.executeScript({ code }, (results: any[]) => {
+          if (!done) {
+            done = true;
+            clearTimeout(timer);
+            resolve(results && results[0] !== undefined ? results[0] : null);
+          }
+        });
+      } catch (_e) {
+        if (!done) {
+          done = true;
+          clearTimeout(timer);
+          resolve(null);
+        }
+      }
+    });
+  }
+
+  public async waitForScreenLoad(options: WaitForScreenLoadOptions = {}): Promise<boolean> {
+    const timeoutMs = options.timeoutMs ?? 4000;
+    const pollIntervalMs = options.pollIntervalMs ?? 100;
+    const requiredIds = options.requiredElementIds ?? [];
+    const requiredSelectors = options.requiredSelectors ?? [];
+    const customPredicate = options.customPredicateCode;
+
+    const maxAttempts = Math.max(1, Math.ceil(timeoutMs / pollIntervalMs));
+    const checkScript = `
+      (function() {
+        if (document.readyState !== 'complete' && document.readyState !== 'interactive') {
+          return false;
+        }
+        const reqIds = ${JSON.stringify(requiredIds)};
+        for (let i = 0; i < reqIds.length; i++) {
+          if (!document.getElementById(reqIds[i])) return false;
+        }
+        const reqSels = ${JSON.stringify(requiredSelectors)};
+        for (let i = 0; i < reqSels.length; i++) {
+          if (!document.querySelector(reqSels[i])) return false;
+        }
+        ${customPredicate ? `return Boolean(${customPredicate});` : 'return true;'}
+      })();
+    `;
+
+    for (let i = 0; i < maxAttempts; i++) {
+      const res = await this.execScriptWithTimeout(checkScript, Math.min(500, timeoutMs));
+      if (res === true || res === 'true') {
+        return true;
+      }
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+    return false;
+  }
+
+  public async executeWebviewTest(
+    codeOrFn: string | (() => Promise<void> | void),
+    timeoutMs = 4000
+  ): Promise<WebviewExecutionResult> {
+    const bodyExpr =
+      typeof codeOrFn === 'function' ? `await (${codeOrFn.toString()})();` : codeOrFn;
+
+    return new Promise<WebviewExecutionResult>((resolve) => {
+      let finished = false;
+
+      const timer = setTimeout(() => {
+        if (!finished) {
+          finished = true;
+          resolve({
+            ok: false,
+            errors: [`Test timed out after ${timeoutMs}ms`],
+            error: `Test timed out after ${timeoutMs}ms`
+          });
+        }
+      }, timeoutMs);
+
+      const wrappedCode = `
+        (function() {
+          window.__testDone = false;
+          window.__testErrors = [];
+          function runInMainWorld(jsBody) {
+            const s = document.createElement('script');
+            s.textContent = '(function(){ ' + jsBody + ' })();';
+            document.body.appendChild(s);
+            s.remove();
+          }
+          (async function() {
+            try {
+              ${bodyExpr}
+            } catch (e) {
+              window.__testErrors.push(e && (e.stack || e.message) ? (e.stack || e.message) : String(e));
+            } finally {
+              window.__testDone = true;
+            }
+          })();
+          return 'started';
+        })();
+      `;
+
+      this.execScriptWithTimeout(wrappedCode, 1000).then(() => {
+        const pollInterval = setInterval(async () => {
+          if (finished) {
+            clearInterval(pollInterval);
+            return;
+          }
+          const rawData = await this.execScriptWithTimeout(
+            `(function() { return JSON.stringify({ done: !!window.__testDone, errors: window.__testErrors || [] }); })();`,
+            500
+          );
+          try {
+            const data = rawData ? JSON.parse(rawData) : null;
+            if (data && data.done) {
+              finished = true;
+              clearTimeout(timer);
+              clearInterval(pollInterval);
+              resolve({
+                ok: Array.isArray(data.errors) && data.errors.length === 0,
+                errors: Array.isArray(data.errors) ? data.errors : []
+              });
+            }
+          } catch (_e) {}
+        }, 75);
+      });
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+export * from './types/test-runner-types';
+export { DeepEqualityHelper } from './matchers/deep-equality-helper';
+export { ExpectMatcherBuilder, expect } from './matchers/expect-matcher';
+export { JestMockFactory, jest } from './mock/jest-mock-factory';
+export {
+  SuiteBuilderScope,
+  TestRunner,
+  DescribeFunction,
+  ItFunction,
+  describe,
+  it,
+  test,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach,
+  installJestGlobals
+} from './core/test-runner';
+export { TestLogWriter } from './harness/test-log-writer';
+export { TestHttpServer } from './harness/test-http-server';
+export { GraphicalOverlayView } from './harness/graphical-overlay-view';
+export { WebviewTestController } from './harness/webview-test-controller';
+export {
+  NwjsGraphicalTestHarness,
+  runNwjsTestHarness
+} from './harness/nwjs-graphical-test-harness';
+export { HarnessConfigLoader } from './config/harness-config-loader';
+export { NwjsCliLauncher } from './cli/nwjs-cli-launcher';