@thinkwise/testwise 0.0.2-alpha.2

package/page-overrides/ClickOverride.ts

@@ -0,0 +1,89 @@
+import { type Locator, expect } from '@playwright/test';
+import { InflightRequestsTracker } from '../helpers/InflightRequestTracker.js';
+import { testwiseConfig } from '../services/ConfigBuilder.js';
+import type { Test } from '../types/CoreTypes.js';
+
+export class ClickOverride {
+  private _test: Test;
+
+  constructor(test: Test) {
+    this._test = test.extend({
+      page: async ({ page }, use) => {
+        const overrideClickMethod = (locator: Locator) => {
+          const originalClickMethod = locator.click.bind(locator);
+
+          locator.click = async (options) => {
+            if (testwiseConfig().get<boolean>('InflightRequests.waitForRequestsToComplete') === true) {
+              const tracker = new InflightRequestsTracker(page);
+
+              await Promise.all([
+                originalClickMethod(options),
+
+                // Ensure at least one XHR request is issued
+                Promise.race([
+                  page.waitForRequest((request) => request.resourceType() === 'xhr'),
+                  new Promise((resolve) => setTimeout(resolve, 50)) // Wait briefly to ensure the XHR request is in flight
+                ])
+              ]);
+
+              // Wait for all XHR requests to finish
+              try {
+                await expect
+                  .poll(() => tracker.inflightRequests().filter((request) => request.resourceType() === 'xhr').length, {
+                    timeout: 3000
+                  })
+                  .toBe(0);
+              } catch (e) {
+                console.warn('Exception while waiting for inflight requests to finish:', e);
+
+                if (testwiseConfig().get<boolean>('InflightRequests.swallowPollingExceptions') === false) throw e;
+              }
+            } else {
+              await originalClickMethod(options);
+            }
+          };
+
+          return locator;
+        };
+
+        // Override the getByTestId.click method
+        const originalGetByTestId = page.getByTestId.bind(page);
+        page.getByTestId = (...args) => overrideClickMethod(originalGetByTestId(...args));
+
+        // Override the locator.click method
+        const originalLocator = page.locator.bind(page);
+        page.locator = (...args) => overrideClickMethod(originalLocator(...args));
+
+        // Override the getByAltText.click method
+        const originalGetByAltText = page.getByAltText.bind(page);
+        page.getByAltText = (...args) => overrideClickMethod(originalGetByAltText(...args));
+
+        // Override the getByLabel.click method
+        const originalGetByLabel = page.getByLabel.bind(page);
+        page.getByLabel = (...args) => overrideClickMethod(originalGetByLabel(...args));
+
+        // Override the getByRole.click method
+        const originalGetByRole = page.getByRole.bind(page);
+        page.getByRole = (...args) => overrideClickMethod(originalGetByRole(...args));
+
+        // Override the getByPlaceholder.click method
+        const originalGetByPlaceholder = page.getByPlaceholder.bind(page);
+        page.getByPlaceholder = (...args) => overrideClickMethod(originalGetByPlaceholder(...args));
+
+        // Override the getByText.click method
+        const originalGetByText = page.getByText.bind(page);
+        page.getByText = (...args) => overrideClickMethod(originalGetByText(...args));
+
+        // Override the getByTitle.click method
+        const originalGetByTitle = page.getByTitle.bind(page);
+        page.getByTitle = (...args) => overrideClickMethod(originalGetByTitle(...args));
+
+        await use(page);
+      }
+    });
+  }
+
+  get test() {
+    return this._test;
+  }
+}

package/promptCredentials.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import prompts from 'prompts';
+
+const packageScripts = JSON.parse(readFileSync('./package.json')).scripts;
+
+function exitWithError(error) {
+  console.log(chalk.red(error));
+  process.exit(1);
+}
+
+function startTestSolution() {
+  console.log('Now starting test solution...');
+  spawnSync(`yarn --cwd ../ ${args.join(' ')}`, { shell: true, stdio: 'inherit' });
+  process.exit();
+}
+
+const args = process.argv.slice(2);
+
+if (!args.length) {
+  exitWithError('Error: Got too few parameters. Usage: yarn test:credentials test');
+}
+
+const yarnScriptToExec = args[0];
+
+if (!packageScripts[yarnScriptToExec]) {
+  exitWithError(`Error: Given script "${yarnScriptToExec}" doesn't exist in package.json.`);
+}
+
+// INCOMING HACK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// temp fix to be reworked when converting this file to TS
+import fs from 'node:fs';
+import path from 'node:path';
+
+const indiciumURL = (() => {
+  try {
+    const configPath = path.resolve(process.cwd(), './Testwise.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return config.environmentSettings?.serviceUrl || '';
+  } catch (error) {
+    console.error('Error reading Testwise.json:', error);
+    return '';
+  }
+})();
+
+// END OF HACK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+if (process.env.SF_TEST_USERNAME && process.env.SF_TEST_PASSWORD) {
+  console.log('Using SF_TEST_USERNAME and SF_TEST_PASSWORD environment variables.');
+  startTestSolution();
+}
+
+const questions = [{
+  type: 'text',
+  name: 'username',
+  message: 'Username:',
+  validate: (value) => {
+    if (!value?.length) {
+      return 'Username is required';
+    }
+
+    if (value.toLowerCase() === 'demo') {
+      return 'Running tests locally with demo is forbidden as it results in dataset concurrency problems'
+    }
+
+    return true;
+  }
+}, {
+  type: 'invisible',
+  name: 'password',
+  message: 'Password:',
+  validate: (value) => !value?.length ? 'Password is required' : true
+}];
+
+(async () => {
+  const credentialsResponse = await prompts(questions);
+
+  if (!credentialsResponse || !credentialsResponse.username || !credentialsResponse.password) {
+    exitWithError('Username or password was not given');
+  }
+
+  const { password, username } = credentialsResponse;
+  const params = new URLSearchParams();
+
+  params.append('UserName', username);
+  params.append('Password', password);
+
+  const fetch = (await import('node-fetch')).default;
+  const authResponse = await fetch(`${indiciumURL}/account/api/login`, { method: 'POST', body: params });
+
+  if (authResponse.status === 204) {
+    console.log('Confirmed credentials work @', indiciumURL);
+  } else {
+    const confirmResponse = await prompts([{
+      type: 'confirm',
+      name: 'value',
+      message: `Can't login to ${indiciumURL} with the given credentials. Continue anyways?`,
+      initial: true
+    }]);
+
+    if (!confirmResponse.value) {
+      return;
+    }
+  }
+
+  process.env.SF_TEST_USERNAME = username;
+  process.env.SF_TEST_PASSWORD = password;
+
+  startTestSolution();
+})();

package/scripts/Testwise.template.json

@@ -0,0 +1,19 @@
+{
+  "environmentSettings" :{
+    "baseUrl" : "https://develop.example.app",
+    "serviceUrl" : "https://develop.example.app/service",
+    "metaEndpoint" : "iam"
+  },
+  "featureSettings" :{
+    "logger" : {
+      "logDir" : "logs",
+      "logLevel" : "info",
+      "logByDay" : true,
+      "bufferSizeLimit" : -1
+    },
+    "InflightRequests" : {
+      "waitForRequestsToComplete" : true,
+      "swallowPollingExceptions" : true
+    }
+  }
+}

package/scripts/add-config.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+if (process.argv[2] === 'install') {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const configFile = path.resolve(process.cwd(), 'Testwise.json');
+  const templateFile = path.join(__dirname, 'Testwise.template.json');
+  
+  if (!fs.existsSync(configFile)) {
+    fs.copyFileSync(templateFile, configFile);
+    console.log('Testwise.json config file created.');
+  } else {
+    console.log('Testwise.json already exists, skipping creation.');
+  }
+} else {
+  console.log('Unknown or missing command. Usage: npx testwise install');
+}

package/services/ConfigBuilder.ts

@@ -0,0 +1,40 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+class ConfigBuilder {
+  private config: Record<string, unknown>;
+
+  constructor() {
+    const configFilePath = path.resolve(process.cwd(), 'Testwise.json');
+
+    if (!fs.existsSync(configFilePath)) {
+      throw new Error(`Config file not found at path: ${configFilePath}`);
+    }
+
+    const fileContent = fs.readFileSync(configFilePath, 'utf-8');
+    this.config = JSON.parse(fileContent);
+  }
+
+  /**
+   * Retrieves a value from the config using a dot-separated key.
+   * @param key - The dot-separated key to retrieve the value.
+   * @returns The value associated with the key, or undefined if not found.
+   */
+  public get<T>(key: string): T | undefined {
+    return key
+      .split('.')
+      .reduce(
+        (obj: Record<string, unknown> | undefined, segment) => obj?.[segment] as Record<string, unknown>,
+        this.config
+      ) as T;
+  }
+}
+
+let instance: ConfigBuilder | null = null;
+
+export function testwiseConfig(): ConfigBuilder {
+  if (!instance) {
+    instance = new ConfigBuilder();
+  }
+  return instance;
+}

package/services/Logger.ts

@@ -0,0 +1,125 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { LogLevel } from '../enums/LogLevel.js';
+import { originalDebug, originalError, originalInfo, originalLog, originalWarn } from '../index.js';
+import { testwiseConfig } from './ConfigBuilder.js';
+
+const logDir = path.resolve(process.cwd(), testwiseConfig().get<string>('featureSettings.logger.logDir') ?? 'logs');
+
+fs.mkdirSync(logDir, { recursive: true });
+
+const sanitizedTimestamp = new Date().toISOString().split('T')[0];
+const logFilePath = path.join(
+  logDir,
+  testwiseConfig().get<boolean>('featureSettings.logger.logByDay') === true
+    ? `test-log-${sanitizedTimestamp}.log`
+    : 'test-log.log'
+);
+
+let logBuffer: string[] = [];
+const bufferSizeLimit = testwiseConfig().get<number>('featureSettings.logger.bufferSizeLimit') ?? 1000;
+
+let linesAlreadyWritten = 0;
+
+if (fs.existsSync(logFilePath)) {
+  const existingLogs = fs.readFileSync(logFilePath, 'utf-8').split('\n').filter(Boolean);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  linesAlreadyWritten = existingLogs.length;
+}
+
+/**
+ * Flushes the log buffer to the log file.
+ * @returns {void}
+ * @throws {Error} If the log buffer cannot be flushed.
+ */
+function flushLogs() {
+  try {
+    if (logBuffer.length > 0) {
+      const existingLogs = fs.existsSync(logFilePath)
+        ? fs.readFileSync(logFilePath, 'utf-8').split('\n').filter(Boolean)
+        : [];
+
+      const combinedLogs = [...existingLogs, ...logBuffer];
+      const trimmedLogs = bufferSizeLimit > -1 ? combinedLogs.slice(-bufferSizeLimit) : combinedLogs;
+
+      fs.writeFileSync(logFilePath, `${trimmedLogs.join('\n')}\n`);
+
+      logBuffer = [];
+    }
+  } catch (err) {
+    console.error('Failed to flush:', err);
+  }
+}
+
+/**
+ * Logs a message to the console and a log file.
+ * @param message
+ * @param level
+ * @param optionalParams
+ */
+function log(message?: string, level: LogLevel = LogLevel.INFO, ...optionalParams: unknown[]): void {
+  const timestamp = new Date().toISOString();
+  const origin = getCallerInfo();
+  const formatted = `[${timestamp}] [${level}] [${origin}] ${message}`;
+
+  switch (level) {
+    case LogLevel.FATAL:
+    case LogLevel.ERROR:
+      originalError(formatted, ...optionalParams);
+      break;
+    case LogLevel.WARN:
+      originalWarn(formatted, ...optionalParams);
+      break;
+    case LogLevel.DEBUG:
+      originalDebug(formatted, ...optionalParams);
+      break;
+    case LogLevel.INFO:
+      originalInfo(formatted, ...optionalParams);
+      break;
+    default:
+      originalLog(formatted, ...optionalParams);
+      break;
+  }
+
+  logBuffer.push(`${formatted} ${optionalParams}`);
+  flushLogs();
+}
+
+/**
+ * Retrieves the caller information from the stack trace.
+ * @returns {string} The caller information in the format "file:line:column"
+ */
+function getCallerInfo(): string {
+  const stack = new Error().stack;
+  if (!stack) return 'unknown origin';
+
+  const stackLines = stack.split('\n');
+
+  for (const line of stackLines) {
+    if (!line.includes('Logger.ts') && !line.includes('index.ts')) {
+      const match = line.match(/\((.*):(\d+):(\d+)\)/);
+      if (match) {
+        let file = match[1];
+        const lineNumber = match[2];
+        const columnNumber = match[3];
+
+        if (file.startsWith('file:///')) {
+          file = decodeURI(file.replace('file:///', ''));
+        }
+        return `${file}:${lineNumber}:${columnNumber}`;
+      }
+    }
+  }
+
+  return 'unknown origin';
+}
+
+export const logger = {
+  // Order by severity level
+  fatal: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.FATAL, ...optionalParams),
+  error: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.ERROR, ...optionalParams),
+  warn: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.WARN, ...optionalParams),
+  step: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.STEP, ...optionalParams),
+  info: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.INFO, ...optionalParams),
+  debug: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.DEBUG, ...optionalParams)
+};

package/services/ReportingService.ts

@@ -0,0 +1,41 @@
+// This is tightly coupled to the Testify reporting service integration and is subject to change.
+
+import type { FullResult, Reporter, TestCase, TestResult } from '@playwright/test/reporter';
+import { TestifyService } from '../example-code/TestifyService.js';
+
+interface StoredTestResult {
+  title: string;
+  status: TestResult['status'];
+}
+
+class ReportingService implements Reporter {
+  private _testifyService: TestifyService | null = null;
+  private _results: StoredTestResult[] = [];
+
+  onTestEnd(test: TestCase, result: TestResult) {
+    console.info(`Test ended: ${test.title}, status: ${result.status}`);
+
+    if (process.env.REPORTING_ENABLED !== 'true') return;
+
+    this._results.push({ title: test.title, status: result.status });
+  }
+
+  async onEnd(result: FullResult) {
+    if (process.env.REPORTING_ENABLED !== 'true') return;
+
+    this._testifyService = new TestifyService();
+
+    await this._testifyService.createTestRun();
+
+    if (this._testifyService) {
+      for (const testResult of this._results) {
+        await this._testifyService.reportTestResult(testResult.title, testResult.status === 'passed');
+      }
+    }
+
+    if (result.status === 'passed' && process.env.AUTO_CLOSE_PASSING_RUNS === 'true')
+      await this._testifyService?.closeTestRun();
+  }
+}
+
+export default ReportingService;

package/types/CoreTypes.ts

@@ -0,0 +1,9 @@
+import type {
+  PlaywrightTestArgs,
+  PlaywrightTestOptions,
+  PlaywrightWorkerArgs,
+  PlaywrightWorkerOptions,
+  TestType
+} from '@playwright/test';
+
+export type Test = TestType<PlaywrightTestArgs & PlaywrightTestOptions, PlaywrightWorkerArgs & PlaywrightWorkerOptions>;

package/types/universal.ts

@@ -0,0 +1,26 @@
+export type UniversalConfigOptions = {
+  barcodeScannerSymbologies?: string;
+  cortexEnabledSymbologies?: string[];
+  cortexLicense?: string;
+  debugMode?: boolean;
+  devDisableProcessFlows?: boolean;
+  useFormFieldBackgroundColor?: boolean;
+  defaultApplication?: string;
+  defaultPlatform?: number;
+  loginOptionsDisabled?: boolean;
+  loginOptionsHidden?: boolean;
+  installNotificationDisabled?: boolean;
+  enableDragDrop?: boolean;
+  installNotificationExpirationInDays?: number;
+  spacingMode?: string;
+  serviceUrl?: string;
+  useServiceWorker?: boolean;
+};
+
+export type UniversalLoginOptions = {
+  username?: string;
+  password?: string;
+  serviceUrl?: string;
+  metaEndpoint?: string;
+  config?: UniversalConfigOptions;
+};