@zohodesk/testinglibrary 0.0.62-n20-experimental → 0.0.64-n20-experimental

package/build/core/playwright/builtInFixtures/context.js

@@ -1,13 +1,19 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
 var _readConfigFile = require("../readConfigFile");
+var _logCollector = require("../helpers/logCollector");
 const {
-  testSetup
+  testSetup,
+  reportPath,
+  runtimeLogs = {}
 } = (0, _readConfigFile.generateConfigFromFile)();
+const LOGS_DIR = _path.default.join(reportPath, 'runtime-logs');
 async function performDefaultContextSteps({
   context
 }) {
@@ -20,13 +26,37 @@ async function performDefaultContextSteps({
 var _default = exports.default = {
   context: async ({
     context
-  }, use) => {
+  }, use, testInfo) => {
     await context.addInitScript(() =>
     // eslint-disable-next-line no-undef
     window.localStorage.setItem('isDnBannerHide', true));
     await performDefaultContextSteps({
       context
     });
-    await use(context);
+    const collector = new _logCollector.LogCollector(runtimeLogs.limits);
+    collector.attachToContext(context);
+    testInfo.runtimeLogs = collector;
+    try {
+      await use(context);
+    } finally {
+      collector.detach();
+      const failureOnly = runtimeLogs.mode === 'failure-only';
+      const isFailure = testInfo.status && testInfo.status !== testInfo.expectedStatus;
+      const shouldFlush = !failureOnly || isFailure;
+      const summary = collector.toSummary();
+      let filePath = null;
+      if (shouldFlush) {
+        const base = `w${testInfo.workerIndex}-${testInfo.testId}-${testInfo.retry}`;
+        filePath = collector.flushToFile(LOGS_DIR, base);
+      }
+      await testInfo.attach('runtime-log', {
+        contentType: 'application/json',
+        body: Buffer.from(JSON.stringify({
+          schemaVersion: 1,
+          summary,
+          file: filePath ? _path.default.relative(reportPath, filePath) : null
+        }))
+      });
+    }
   }
 };

package/build/core/playwright/constants/reporterConstants.js

@@ -11,6 +11,5 @@ const stage = (0, _ConfigurationHelper.getRunStage)();
 class ReporterConstants {
   static DEFAULT_REPORTER_PATH = `${_configConstants.default.TEST_SLICE_FOLDER}/${stage}/test-results/playwright-test-results.json`;
   static LAST_RUN_REPORTER_PATH = `${_configConstants.default.TEST_SLICE_FOLDER}/${stage}/test-results/.last-run.json`;
-  static DEFAULT_UNIT_TEST_REPORTER_PATH = `${_configConstants.default.TEST_SLICE_FOLDER}/unit-test/unit_reports/report.html`;
 }
 exports.default = ReporterConstants;

package/build/core/playwright/helpers/logCollector.js

@@ -0,0 +1,154 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogCollector = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+const DEFAULT_LIMITS = {
+  maxEvents: 2000,
+  maxBodyBytes: 0,
+  captureHeaders: false,
+  ignoreUrlPatterns: [/\.(png|jpe?g|gif|svg|webp|woff2?|ttf|css|map)(\?|$)/i, /google-analytics\.com|googletagmanager\.com|sentry\.io/i]
+};
+class LogCollector {
+  constructor(opts = {}) {
+    this.limits = {
+      ...DEFAULT_LIMITS,
+      ...opts
+    };
+    this.events = [];
+    this.truncated = false;
+    this.counts = {
+      console: 0,
+      consoleError: 0,
+      pageError: 0,
+      request: 0,
+      response: 0,
+      failed: 0,
+      crash: 0
+    };
+    this._bound = [];
+  }
+  _push(evt) {
+    if (this.events.length >= this.limits.maxEvents) {
+      this.truncated = true;
+      this.events.shift();
+    }
+    this.events.push({
+      ts: Date.now(),
+      ...evt
+    });
+  }
+  _shouldIgnore(url) {
+    return this.limits.ignoreUrlPatterns.some(re => re.test(url));
+  }
+  _bind(target, event, handler) {
+    target.on(event, handler);
+    this._bound.push([target, event, handler]);
+  }
+  attachToContext(context) {
+    context.pages().forEach(p => this._attachPage(p));
+    this._bind(context, 'page', p => this._attachPage(p));
+    this._bind(context, 'request', req => {
+      if (this._shouldIgnore(req.url())) return;
+      this.counts.request++;
+      this._push({
+        kind: 'request',
+        method: req.method(),
+        url: req.url(),
+        resourceType: req.resourceType(),
+        ...(this.limits.captureHeaders ? {
+          headers: req.headers()
+        } : {})
+      });
+    });
+    this._bind(context, 'response', res => {
+      const url = res.url();
+      if (this._shouldIgnore(url)) return;
+      this.counts.response++;
+      if (res.status() >= 400) {
+        this._push({
+          kind: 'response',
+          status: res.status(),
+          method: res.request().method(),
+          url,
+          fromCache: res.fromServiceWorker()
+        });
+      }
+    });
+    this._bind(context, 'requestfailed', req => {
+      var _req$failure;
+      this.counts.failed++;
+      this._push({
+        kind: 'requestfailed',
+        method: req.method(),
+        url: req.url(),
+        failure: (_req$failure = req.failure()) === null || _req$failure === void 0 ? void 0 : _req$failure.errorText,
+        resourceType: req.resourceType()
+      });
+    });
+  }
+  _attachPage(page) {
+    this._bind(page, 'console', msg => {
+      const type = msg.type();
+      this.counts.console++;
+      if (type === 'error') this.counts.consoleError++;
+      if (type !== 'error' && type !== 'warning') return;
+      this._push({
+        kind: 'console',
+        level: type,
+        text: msg.text(),
+        location: msg.location()
+      });
+    });
+    this._bind(page, 'pageerror', err => {
+      this.counts.pageError++;
+      this._push({
+        kind: 'pageerror',
+        name: err.name,
+        message: err.message,
+        stack: err.stack
+      });
+    });
+    this._bind(page, 'crash', () => {
+      this.counts.crash++;
+      this._push({
+        kind: 'crash',
+        url: page.url()
+      });
+    });
+  }
+  detach() {
+    for (const [target, event, handler] of this._bound) {
+      try {
+        target.removeListener(event, handler);
+      } catch {
+        // context may already be closed
+      }
+    }
+    this._bound.length = 0;
+  }
+  toSummary() {
+    return {
+      ...this.counts,
+      total: this.events.length,
+      truncated: this.truncated
+    };
+  }
+  flushToFile(dir, baseName) {
+    if (this.events.length === 0) return null;
+    _fs.default.mkdirSync(dir, {
+      recursive: true
+    });
+    const file = _path.default.join(dir, `${baseName}.jsonl`);
+    const stream = _fs.default.createWriteStream(file);
+    for (const evt of this.events) stream.write(JSON.stringify(evt) + '\n');
+    stream.end();
+    this.events.length = 0;
+    return file;
+  }
+}
+exports.LogCollector = LogCollector;

package/build/core/playwright/readConfigFile.js

@@ -55,7 +55,8 @@ function getDefaultConfig() {
     featureFilesFolder: 'feature-files',
     stepDefinitionsFolder: 'steps',
     testSetup: {},
-    editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise']
+    editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise'],
+    showCaseTimings: true
   };
 }
 function combineDefaultConfigWithUserConfig(userConfiguration) {
@@ -113,6 +114,7 @@ function combineDefaultConfigWithUserConfig(userConfiguration) {
  * @property {string} testIdAttribute: Change the default data-testid attribute. configure what attribute to search while calling getByTestId
  * @property {Array} editionOrder: Order in the form of larger editions in the back. Edition with the most privelages should be last
  * @property {testSetupConfig} testSetup: Specify page and context functions that will be called while intilaizing fixtures.
+ * @property {boolean} showCaseTimings: When true, the console reporter prints per-case start/end wall-clock times (h:mm:ss AM/PM) and a case-timings.json sidecar is written to reportPath for the HTML report addon. Default: true.
  */
 
 /**

package/build/core/playwright/report-generator.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateReport;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _rootPath = require("../../utils/rootPath");
+var _readConfigFile = require("./readConfigFile");
+async function generateReport() {
+  // await preProcessReport()
+  const userArgs = process.argv.slice(3);
+  const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+  const command = playwrightPath;
+  const {
+    reportPath: htmlPath
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  const args = ['show-report', htmlPath].concat(userArgs);
+  const childProcess = (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  });
+  childProcess.on('error', error => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+  });
+  childProcess.on('exit', (code, signal) => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Child Process Exited with Code ${code} and Signal ${signal}`);
+    process.exit();
+  });
+  process.on('exit', () => {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Terminating Playwright Process...');
+    childProcess.kill();
+    return;
+  });
+  process.on('SIGINT', () => {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Cleaning up...');
+    childProcess.kill();
+    process.exit();
+  });
+}

package/build/core/playwright/runner/SpawnRunner.js

@@ -46,7 +46,6 @@ class SpawnRunner extends _Runner.default {
         }
         _logger.Logger.log(_logger.Logger.INFO_TYPE, `Preprocessing failed (attempt ${attempt} of ${maxRetries + 1}). Retrying in ${delayMs}ms...`);
         await new Promise(resolve => setTimeout(resolve, delayMs));
-        process.exitCode = 1; // Set exit code to 1 to indicate failure, but allow retries to proceed
       }
     }
   }

package/build/core/playwright/setup/custom-reporter.js

@@ -12,6 +12,22 @@ var _readConfigFile = require("../readConfigFile");
 var _logger = require("../../../utils/logger");
 var _configFileNameProvider = require("../helpers/configFileNameProvider");
 var _mergeAbortedTests = _interopRequireDefault(require("../reporter/helpers/mergeAbortedTests"));
+function formatTime(date) {
+  return date.toLocaleTimeString('en-US', {
+    hour: 'numeric',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: true
+  });
+}
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  const totalSeconds = ms / 1000;
+  if (totalSeconds < 60) return `${totalSeconds.toFixed(2)}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = (totalSeconds - minutes * 60).toFixed(2);
+  return `${minutes}m ${seconds}s`;
+}
 class JSONSummaryReporter {
   constructor() {
     this.durationInMS = -1;
@@ -26,11 +42,22 @@ class JSONSummaryReporter {
     this.failedSteps = [];
     this.status = 'unknown';
     this.startedAt = 0;
-    this._open = (0, _readConfigFile.generateConfigFromFile)().openReportOn;
+    const config = (0, _readConfigFile.generateConfigFromFile)();
+    this._open = config.openReportOn;
+    this._showCaseTimings = config.showCaseTimings !== false;
+    this._caseTimings = [];
   }
   onBegin() {
     this.startedAt = Date.now();
   }
+  onTestBegin(test) {
+    if (!this._showCaseTimings) return;
+    const {
+      fullTitle
+    } = this.getTitle(test);
+    const startedAtLabel = formatTime(new Date());
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `▶ ${fullTitle} — started at ${startedAtLabel}`);
+  }
   getTitle(test) {
     const title = [];
     const fileName = [];
@@ -76,6 +103,55 @@ class JSONSummaryReporter {
       this[status].push(fileName);
     }
     this[status].push(fileName);
+    if (this._showCaseTimings && result.startTime) {
+      const startDate = new Date(result.startTime);
+      const endDate = new Date(startDate.getTime() + (result.duration || 0));
+      const startLabel = formatTime(startDate);
+      const endLabel = formatTime(endDate);
+      const durationLabel = formatDuration(result.duration || 0);
+      const statusGlyph = result.status === 'passed' ? '✓' : result.status === 'skipped' ? '○' : '✗';
+      const logType = result.status === 'passed' ? _logger.Logger.SUCCESS_TYPE : result.status === 'skipped' ? _logger.Logger.INFO_TYPE : _logger.Logger.FAILURE_TYPE;
+      _logger.Logger.log(logType, `${statusGlyph} ${fullTitle} — ended at ${endLabel} (started ${startLabel}, took ${durationLabel})`);
+      const isFailure = result.status !== 'passed' && result.status !== 'skipped';
+      if (isFailure) {
+        var _result$error;
+        const runtimeAttachment = (result.attachments || []).find(a => a.name === 'runtime-log' && a.body);
+        let runtime = null;
+        if (runtimeAttachment) {
+          try {
+            runtime = JSON.parse(runtimeAttachment.body.toString('utf8'));
+          } catch {
+            // malformed attachment; skip
+          }
+        }
+        this._caseTimings.push({
+          title: fullTitle,
+          fileName,
+          status: result.status,
+          retry: result.retry,
+          startTime: startDate.toISOString(),
+          endTime: endDate.toISOString(),
+          startTimeFormatted: startLabel,
+          endTimeFormatted: endLabel,
+          duration: result.duration || 0,
+          durationFormatted: durationLabel,
+          errorMessage: (_result$error = result.error) === null || _result$error === void 0 ? void 0 : _result$error.message,
+          failedSteps: (result.steps || []).filter(step => step.error).map(step => {
+            var _step$error;
+            return {
+              title: step.title,
+              error: (_step$error = step.error) === null || _step$error === void 0 ? void 0 : _step$error.message
+            };
+          }),
+          ...(runtime ? {
+            runtime: {
+              summary: runtime.summary,
+              logFile: runtime.file
+            }
+          } : {})
+        });
+      }
+    }
   }
   onError(error) {
     this.errored.push({
@@ -122,6 +198,16 @@ class JSONSummaryReporter {
       reportPath
     } = (0, _readConfigFile.generateConfigFromFile)();
     (0, _fileUtils.writeFileContents)(_path.default.join(reportPath, './', (0, _configFileNameProvider.getReportFileName)()), JSON.stringify(this, null, '  '));
+    if (this._showCaseTimings && this._caseTimings.length > 0) {
+      const timingsPayload = {
+        suiteStartedAt: new Date(this.startedAt).toISOString(),
+        suiteEndedAt: new Date(this.startedAt + this.durationInMS).toISOString(),
+        suiteDurationMs: this.durationInMS,
+        failedCount: this._caseTimings.length,
+        cases: this._caseTimings
+      };
+      (0, _fileUtils.writeFileContents)(_path.default.join(reportPath, 'case-timings.json'), JSON.stringify(timingsPayload, null, '  '));
+    }
   }
   onExit() {
     // Update .last-run.json with aborted tests due to timing out or interruption

package/build/lib/cli.js

@@ -2,9 +2,7 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _testRunner = _interopRequireDefault(require("../core/playwright/test-runner"));
-var _unitTestingFramework = require("@zohodesk/unit-testing-framework");
-var _PlaywrightReporter = _interopRequireDefault(require("../core/playwright/reporter/PlaywrightReporter"));
-var _UnitReporter = _interopRequireDefault(require("../core/playwright/reporter/UnitReporter"));
+var _reportGenerator = _interopRequireDefault(require("../core/playwright/report-generator"));
 var _codegen = _interopRequireDefault(require("../core/playwright/codegen"));
 var _logger = require("../utils/logger");
 var _setupProject = _interopRequireDefault(require("../setup-folder-structure/setupProject"));
@@ -13,25 +11,15 @@ var _clearCaches = _interopRequireDefault(require("../core/playwright/clear-cach
 var _helper = _interopRequireDefault(require("../setup-folder-structure/helper"));
 var _parseUserArgs = _interopRequireDefault(require("../core/playwright/helpers/parseUserArgs"));
 var _validateFeature = _interopRequireDefault(require("../core/playwright/validateFeature"));
-var _commonUtils = require("../utils/commonUtils");
+// import createJestRunner from '../core/jest/runner/jest-runner';
+
 const [,, option, ...otherOptions] = process.argv;
 switch (option) {
   case 'test':
     {
       _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Running Tests..');
       (0, _testRunner.default)();
-      break;
-    }
-  case 'unit-test':
-    {
-      const testFile = process.argv[3];
-      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Running Unit Tests..');
-      const options = {};
-      if (testFile) {
-        _logger.Logger.log(_logger.Logger.INFO_TYPE, `Filtering tests with pattern: ${testFile}`);
-        options.testPathPattern = testFile;
-      }
-      (0, _unitTestingFramework.createJestRunner)(options);
+      //createJestRunner();
       break;
     }
   case 'validate':
@@ -52,14 +40,9 @@ switch (option) {
     }
   case 'report':
     {
-      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating UAT Reports...');
-      _PlaywrightReporter.default.generate();
-      break;
-    }
-  case 'ut-report':
-    {
-      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating Unit Test Reports...');
-      _UnitReporter.default.generate();
+      // console.log('\x1b[36mGenerating Reports...\x1b[0m');
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Generating Reports...');
+      (0, _reportGenerator.default)();
       break;
     }
   case 'codegen':
@@ -86,12 +69,6 @@ switch (option) {
       (0, _clearCaches.default)();
       break;
     }
-  case 'stepsGenerator':
-    {
-      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Created agents and prompts md files under .github folder...');
-      (0, _commonUtils.copyGithubFolder)();
-      break;
-    }
   case 'help':
   default:
     {

package/build/utils/commonUtils.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.copyCommonSpecs = copyCommonSpecs;
-exports.copyGithubFolder = copyGithubFolder;
 var _fileUtils = require("./fileUtils");
 var _path = _interopRequireDefault(require("path"));
 var _configConstants = _interopRequireDefault(require("../core/playwright/constants/configConstants"));
@@ -18,12 +17,4 @@ function copyCommonSpecs() {
   const destDirectory = _path.default.resolve(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules', '.testingLib-common');
   (0, _fileUtils.deleteFolder)(destDirectory);
   (0, _fileUtils.copyDirectory)(commonSpecPath, destDirectory);
-}
-function copyGithubFolder() {
-  const libraryPath = require.resolve("@zohodesk/testinglibrary");
-  // libraryPath will be build/index.js, go two levels up to reach the package root where .github lives
-  const githubSrcPath = _path.default.resolve(libraryPath, '../../', '.github');
-  const destDirectory = _path.default.resolve(process.cwd(), '../../', '.github');
-  (0, _fileUtils.deleteFolder)(destDirectory);
-  (0, _fileUtils.copyDirectory)(githubSrcPath, destDirectory);
 }