@thinkwise/testwise 0.0.2-alpha.2

package/example-code/TestifyService.ts

@@ -0,0 +1,201 @@
+/* Ignore this file for reviewing, it is used for Testify integration and only serves as an example*/
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import axios, { type AxiosInstance } from 'axios';
+
+export class TestifyService {
+  private token: string;
+  private projectId: string;
+  private baseUrl: string;
+  private axiosInstance: AxiosInstance;
+  testRunId = '';
+
+  constructor() {
+    this.token = `Bearer ${process.env.TESTIFY_TOKEN}`;
+    this.projectId = process.env.TESTIFY_PROJECT_ID || '';
+    // biome-ignore lint/style/noNonNullAssertion: <explanation>
+    this.baseUrl = process.env.TESTIFY_BASE_URL!.replace(/\/$/, '');
+    this.axiosInstance = axios.create({
+      baseURL: this.baseUrl,
+      headers: {
+        Authorization: this.token,
+        accept: '*/*'
+      }
+    });
+  }
+
+  public async createTestRun(): Promise<void> {
+    try {
+      const projectName = await this.getProjectName();
+      const testRunName = `${projectName} ${new Date().toISOString()}`;
+
+      if (!this.testRunId) {
+        await this.createTestRunRequest(testRunName);
+        this.testRunId = await this.getTestRunId(testRunName);
+      }
+
+      await new Promise((res) => setTimeout(res, 1000));
+    } catch (err) {
+      console.error('createTestRun failed:', err);
+    }
+  }
+
+  private async getTestRunId(testRunName: string): Promise<string> {
+    try {
+      const url = `/api/v1/TestRun?projectId=${this.projectId}`;
+      const response = await this.axiosInstance.get(url, { headers: this.headers('text/plain') });
+      const testRunList = response.data;
+      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+      const found = testRunList.find((tr: any) => tr.name?.toLowerCase() === testRunName.toLowerCase());
+      return found?.id?.toString() ?? '';
+    } catch (err) {
+      console.error('getTestRunId failed:', err);
+      return '';
+    }
+  }
+
+  private async createTestRunRequest(testRunName: string) {
+    try {
+      const encodedName = encodeURIComponent(testRunName);
+      const url = `/api/v1/TestRun/Create?testRunName=${encodedName}&projectId=${this.projectId}`;
+      await this.axiosInstance.post(url, null, { headers: this.headers() });
+    } catch (err) {
+      console.error('createTestRunRequest failed:', err);
+    }
+  }
+
+  private async getProjectName(): Promise<string> {
+    try {
+      const url = `/api/v1/Project/${this.projectId}`;
+      const response = await this.axiosInstance.get(url, { headers: this.headers('text/plain') });
+      const project = response.data;
+      return project.name;
+    } catch (err) {
+      console.error('getProjectName failed:', err);
+      return '';
+    }
+  }
+
+  async reportTestResult(testName: string, passed: boolean) {
+    try {
+      const testCases = await this.getTestCases();
+      if (!this.testCaseExists(testCases, testName)) {
+        await this.createTestCase(testName);
+      }
+      const testCaseId = await this.getTestCaseId(testName);
+      if (!testCaseId) {
+        console.error(`Could not find or create test case ID for "${testName}"`);
+        return;
+      }
+      await this.addTestCaseToTestRun(testCaseId);
+      const testResultId = await this.getTestResultId(testCaseId);
+      if (!testResultId) {
+        console.error(`Could not find test result ID for test case "${testName}"`);
+        return;
+      }
+      await this.updateResult(testResultId, passed);
+
+      await new Promise((res) => setTimeout(res, 200));
+    } catch (err) {
+      console.error('reportTestResult failed:', err);
+    }
+  }
+
+  private async updateResult(testResultId: string, passed: boolean) {
+    try {
+      const status = passed ? '1' : '2';
+      const url = `/api/v1/Result/${testResultId}/UpdateStatus?newStatus=${status}`;
+      await this.axiosInstance.put(url, null, { headers: this.headers() });
+    } catch (err) {
+      console.error('updateResult failed:', err);
+    }
+  }
+
+  private async getTestResultId(testCaseId: string): Promise<string> {
+    try {
+      const url = `/api/v1/Result?testRunId=${this.testRunId}`;
+      const response = await this.axiosInstance.get(url, { headers: this.headers('text/plain') });
+      const results = response.data;
+      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+      const found = results.find((r: any) => r.testCaseId?.toString() === testCaseId);
+      return found?.id?.toString() ?? '';
+    } catch (err) {
+      console.error('getTestResultId failed:', err);
+      return '';
+    }
+  }
+
+  private async getTestCaseId(testCaseName: string): Promise<string> {
+    try {
+      const testCases = await this.getTestCases();
+      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+      const found = testCases.find((tc: any) => tc.name === testCaseName);
+      return found?.id?.toString() ?? '';
+    } catch (err) {
+      console.error('getTestCaseId failed:', err);
+      return '';
+    }
+  }
+
+  private async addTestCaseToTestRun(testCaseId: string) {
+    try {
+      const url = `/api/v1/Result/Create?caseId=${testCaseId}&testRunId=${this.testRunId}`;
+      await this.axiosInstance.post(url, null, { headers: this.headers() });
+    } catch (err) {
+      console.error('addTestCaseToTestRun failed:', err);
+    }
+  }
+
+  private async createTestCase(testCaseName: string) {
+    try {
+      const encodedName = encodeURIComponent(testCaseName);
+      const url = `/api/v1/TestCase/Create?testCaseName=${encodedName}&projectId=${this.projectId}`;
+      await this.axiosInstance.post(url, null, { headers: this.headers() });
+    } catch (err) {
+      console.error('createTestCase failed:', err);
+    }
+  }
+
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  private testCaseExists(testCases: any[], testName: string): boolean {
+    try {
+      return testCases.some((tc) => tc.name?.toLowerCase() === testName.toLowerCase());
+    } catch (err) {
+      console.error('testCaseExists failed:', err);
+      return false;
+    }
+  }
+
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  private async getTestCases(): Promise<any[]> {
+    try {
+      const url = `/api/v1/TestCase?projectId=${this.projectId}`;
+      const response = await this.axiosInstance.get(url, { headers: this.headers('text/plain') });
+      return response.data;
+    } catch (err) {
+      console.error('getTestCases failed:', err);
+      return [];
+    }
+  }
+
+  public async closeTestRun(): Promise<void> {
+    if (!this.testRunId) {
+      console.error('closeTestRun failed: testRunId is not set.');
+      return;
+    }
+    try {
+      const url = `/api/v1/TestRun/${this.testRunId}/Close`;
+      await this.axiosInstance.put(url, null, { headers: this.headers() });
+      console.info(`Test run ${this.testRunId} closed successfully.`);
+    } catch (err) {
+      console.error('closeTestRun failed:', err);
+    }
+  }
+
+  private headers(accept = '*/*') {
+    return {
+      accept,
+      Authorization: this.token
+    };
+  }
+}

package/helpers/InflightRequestTracker.ts

@@ -0,0 +1,33 @@
+import type { Page, Request } from '@playwright/test';
+
+export class InflightRequestsTracker {
+  private _page: Page;
+  private _requests: Set<Request>;
+
+  constructor(page: Page) {
+    this._page = page;
+    this._requests = new Set();
+    this._onStarted = this._onStarted.bind(this);
+    this._onFinished = this._onFinished.bind(this);
+    this._page.on('request', this._onStarted);
+    this._page.on('requestfinished', this._onFinished);
+    this._page.on('requestfailed', this._onFinished);
+  }
+
+  _onStarted(request: Request) {
+    this._requests.add(request);
+  }
+  _onFinished(request: Request) {
+    this._requests.delete(request);
+  }
+
+  inflightRequests(): Request[] {
+    return Array.from(this._requests);
+  }
+
+  dispose() {
+    this._page.removeListener('request', this._onStarted);
+    this._page.removeListener('requestfinished', this._onFinished);
+    this._page.removeListener('requestfailed', this._onFinished);
+  }
+}

package/helpers/LoginHelper.ts

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { type Page, expect } from '@playwright/test';
+import { testwiseConfig } from '../services/ConfigBuilder.js';
+import type { UniversalConfigOptions, UniversalLoginOptions } from '../types/universal.js';
+
+const _dirname = path.dirname(fileURLToPath(import.meta.url));
+const configFixture = JSON.parse(fs.readFileSync(path.resolve(_dirname, '../config.json'), 'utf-8'));
+
+export class LoginHelper {
+  private _page: Page;
+  private _serviceUrl: string;
+  private _metaEndpoint: string;
+
+  constructor(page: Page) {
+    this._page = page;
+
+    const serviceUrl = testwiseConfig().get<string>('environmentSettings.serviceUrl');
+    const metaEndpoint = testwiseConfig().get<string>('environmentSettings.metaEndpoint');
+
+    if (!serviceUrl || !metaEndpoint)
+      throw new Error(
+        'Either environmentSettings.serviceUrl or environmentSettings.metaEndpoint is not defined in the configuration.'
+      );
+
+    this._serviceUrl = serviceUrl;
+    this._metaEndpoint = metaEndpoint;
+  }
+
+  /**
+   * Log in and go to a specified application
+   * @param applicationName - Application name to launch
+   */
+  public async logIn(applicationName: string = configFixture.defaultApplication) {
+    await this.logInAndConfigureApplication({
+      config: {
+        defaultApplication: applicationName
+      }
+    });
+  }
+
+  /**
+   * Log in with credentials
+   * @param username - The username to log in with
+   * @param password - The password to log in with
+   */
+  public async logInWithCredentials(username: string, password: string) {
+    const options: UniversalLoginOptions = {
+      username: username,
+      password: password
+    };
+
+    await this.logInWithOptions(options);
+  }
+
+  /**
+   * Log in with options
+   * @param options - The login options
+   */
+  public async logInWithOptions(options: UniversalLoginOptions) {
+    await this.logInAndConfigureApplication(options);
+  }
+
+  /**
+   * Navigate to the home page and wait for the menu to load
+   */
+  private async navigateHomeAndWaitForMenuToLoad() {
+    await this._page.goto('/');
+
+    await this._page.route('**/i_ui_menu?**', (route) => {
+      route.continue();
+    });
+
+    await expect.poll(async () => await this._page.url()).toContain('#application=');
+  }
+
+  /**
+   * Log in and configure the application
+   * @param options - The login options
+   */
+  private async logInAndConfigureApplication(options: UniversalLoginOptions = {}) {
+    const { serviceUrl, metaEndpoint, config } = options;
+
+    const username = options.username ?? process.env.SF_TEST_USERNAME;
+    const password = options.password ?? process.env.SF_TEST_PASSWORD;
+
+    if (!username || !password) {
+      throw new Error('Username and password are required for login.');
+    }
+
+    if (serviceUrl && metaEndpoint) {
+      this._serviceUrl = serviceUrl;
+      this._metaEndpoint = metaEndpoint;
+    }
+
+    const response = await this._page.request.post(`${this._serviceUrl}/account/api/login`, {
+      form: {
+        UserName: username,
+        Password: password
+      }
+    });
+
+    if (response.status() !== 204) {
+      console.error('Login failed', await response.status());
+    }
+
+    // Set the navigator.language property
+    await this._page.route('**/*', (route, request) => {
+      route.continue({
+        headers: {
+          ...request.headers(),
+          'Accept-Language': 'en-US'
+        }
+      });
+    });
+
+    await this.configureApplication(config ?? {});
+
+    await this.navigateHomeAndWaitForMenuToLoad();
+  }
+
+  /**
+   * Configure the application
+   * @param options - The configuration options
+   */
+  private async configureApplication(options: UniversalConfigOptions) {
+    await this._page.route('**/config.json', (route) => {
+      route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({
+          ...configFixture,
+          serviceUrl: `${this._serviceUrl}/iam/${this._metaEndpoint}`,
+          ...options
+        })
+      });
+    });
+  }
+}

package/helpers/UserSimulationHelper.ts

@@ -0,0 +1,72 @@
+import { type Page, expect } from '@playwright/test';
+import { testwiseConfig } from '../services/ConfigBuilder.js';
+
+export class UserSimulationHelper {
+  private _page: Page;
+  private _serviceUrl: string;
+
+  constructor(page: Page) {
+    this._page = page;
+
+    const serviceUrl = testwiseConfig().get<string>('environmentSettings.serviceUrl');
+
+    if (!serviceUrl) throw new Error('environmentSettings.serviceUrl is not defined in the configuration.');
+
+    this._serviceUrl = serviceUrl;
+  }
+
+  /**
+   * Get the simulated user
+   * @returns The simulated user name
+   */
+  public async getSimulatedUser(): Promise<string> {
+    const response = await this._page.request.get(`${this._serviceUrl}/account/api/usersimulation`);
+
+    switch (response.status()) {
+      case 204:
+        console.error('User simulation not active', await response.status());
+        return '';
+      case 200:
+        return (await response.json()).simulated_user;
+      default:
+        throw new Error(`Get simulated user request failed with status: ${await response.status()}`);
+    }
+  }
+
+  /**
+   * Stop the user simulation
+   */
+  public async stopSimulation(): Promise<void> {
+    const response = await this._page.request.delete(`${this._serviceUrl}/account/api/usersimulation`);
+
+    if (response.status() === 204) {
+      console.info('STOP User simulation request is successful', await response.status());
+    } else {
+      throw new Error(`STOP User simulation has unexpected status: ${await response.status()}`);
+    }
+
+    await expect.poll(async () => await this.getSimulatedUser()).toBe('');
+  }
+
+  /**
+   * Simulate a user
+   * @param userName - The name of the user to simulate
+   */
+  public async simulateUser(userName: string): Promise<void> {
+    const response = await this._page.request.patch(`${this._serviceUrl}/account/api/usersimulation`, {
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      data: JSON.stringify({
+        simulated_user: userName
+      })
+    });
+
+    if (response.status() === 200) {
+      console.info('User simulation request is successful', await response.status());
+    } else {
+      throw new Error(`User simulation has unexpected status: ${await response.status()}`);
+    }
+  }
+}

package/index.ts

@@ -0,0 +1,28 @@
+import { logger } from './services/Logger.js';
+
+const originalLog = console.log;
+const originalInfo = console.info;
+const originalWarn = console.warn;
+const originalError = console.error;
+const originalDebug = console.debug;
+
+console.log = (...args: unknown[]) => logger.info(args.join(' '));
+console.info = (...args: unknown[]) => logger.info(args.join(' '));
+console.warn = (...args: unknown[]) => logger.warn(args.join(' '));
+console.error = (...args: unknown[]) => logger.error(args.join(' '));
+console.debug = (...args: unknown[]) => logger.debug(args.join(' '));
+
+export { originalLog, originalInfo, originalWarn, originalError, originalDebug };
+export * from './services/ConfigBuilder.js';
+export * from './Testwise.js';
+export * from './helpers/LoginHelper.js';
+export * from './page-extensions/GoToDeepLink.js';
+export * from './page-extensions/LoginFeatures.js';
+export * from './page-extensions/UserSimulation.js';
+export * from './page-overrides/ClickOverride.js';
+export * from './types/CoreTypes.js';
+export * from './types/universal.js';
+export * from './enums/ButtonEnums.js';
+export * from './enums/ActionbarRegions.js';
+export * from './enums/ExportFormat.js';
+export * from './components/index.js';

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@thinkwise/testwise",
+  "version": "0.0.2-alpha.2",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "testwise": "./scripts/add-config.js",
+    "testwise-credentials": "./promptCredentials.js"
+  },
+  "scripts": {
+    "lint": "eslint ./ --cache --ignore-pattern .gitignore",
+    "format:fix": "run-s \"lint --fix\" && biome check --fix --unsafe",
+    "format:check": "run-s \"lint \" && biome check"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@types/node": "^22.15.29",
+    "axios": "^1.9.0",
+    "chalk": "^5.4.1",
+    "csv-parse": "^5.6.0",
+    "prompts": "^2.4.2"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.52.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@eslint/js": "^9.28.0",
+    "@playwright/test": "^1.52.0",
+    "biome": "^0.3.3",
+    "eslint": "^9.28.0",
+    "eslint-plugin-playwright": "^2.2.0",
+    "npm-run-all": "^4.1.5",
+    "typescript-eslint": "^8.34.0"
+  },
+  "publishConfig": { "access": "public" }
+}

package/page-extensions/GoToDeepLink.ts

@@ -0,0 +1,29 @@
+import type { Test } from '../types/CoreTypes.js';
+
+declare module '@playwright/test' {
+  interface Page {
+    goToDeepLink(deepLink: string): Promise<null | import('@playwright/test').Response>;
+  }
+}
+
+export class GoToDeepLink {
+  private _test: Test;
+
+  constructor(test: Test) {
+    this._test = test.extend({
+      page: async ({ page }, use) => {
+        page.goToDeepLink = async (deepLink: string): Promise<null | import('@playwright/test').Response> => {
+          const url = new URL(await page.url());
+
+          return await page.goto(`${url}/${deepLink}`);
+        };
+
+        await use(page);
+      }
+    });
+  }
+
+  get test() {
+    return this._test;
+  }
+}

package/page-extensions/LoginFeatures.ts

@@ -0,0 +1,50 @@
+import { LoginHelper } from '../helpers/LoginHelper.js';
+import type { Test } from '../types/CoreTypes.js';
+import type { UniversalLoginOptions } from '../types/universal.js';
+
+declare module '@playwright/test' {
+  interface Page {
+    logIn(): Promise<void>;
+    logInWithCredentials(username: string, password: string): Promise<void>;
+    logInWithOptions(options: UniversalLoginOptions): Promise<void>;
+  }
+}
+
+export class LoginFeatures {
+  private _loginHelper: LoginHelper | undefined;
+  private _test: Test;
+
+  constructor(test: Test) {
+    this._test = test.extend({
+      page: async ({ page }, use) => {
+        this._loginHelper = new LoginHelper(page);
+
+        page.logIn = async () => {
+          await this.loginHelper.logIn();
+        };
+
+        page.logInWithCredentials = async (username: string, password: string) => {
+          await this.loginHelper.logInWithCredentials(username, password);
+        };
+
+        page.logInWithOptions = async (options: UniversalLoginOptions) => {
+          await this.loginHelper.logInWithOptions(options);
+        };
+
+        await use(page);
+      }
+    });
+  }
+
+  private get loginHelper(): LoginHelper {
+    if (!this._loginHelper) {
+      throw new Error('LoginHelper is not initialized');
+    }
+
+    return this._loginHelper;
+  }
+
+  get test() {
+    return this._test;
+  }
+}

package/page-extensions/UserSimulation.ts

@@ -0,0 +1,49 @@
+import { UserSimulationHelper } from '../helpers/UserSimulationHelper.js';
+import type { Test } from '../types/CoreTypes.js';
+
+declare module '@playwright/test' {
+  interface Page {
+    simulateUser(username: string): Promise<void>;
+    getSimulatedUser(): Promise<string>;
+    stopSimulation(): Promise<void>;
+  }
+}
+
+export class UserSimulation {
+  private _userSimulationHelper: UserSimulationHelper | undefined;
+  private _test: Test;
+
+  constructor(test: Test) {
+    this._test = test.extend({
+      page: async ({ page }, use) => {
+        this._userSimulationHelper = new UserSimulationHelper(page);
+
+        page.simulateUser = async (username: string) => {
+          await this.userSimulationHelper.simulateUser(username);
+        };
+
+        page.getSimulatedUser = async () => {
+          return await this.userSimulationHelper.getSimulatedUser();
+        };
+
+        page.stopSimulation = async () => {
+          await this.userSimulationHelper.stopSimulation();
+        };
+
+        await use(page);
+      }
+    });
+  }
+
+  private get userSimulationHelper(): UserSimulationHelper {
+    if (!this._userSimulationHelper) {
+      throw new Error('UserSimulationHelper is not initialized');
+    }
+
+    return this._userSimulationHelper;
+  }
+
+  get test() {
+    return this._test;
+  }
+}