@thinkwise/testwise 0.2.21 → 0.2.67

package/components/scheduler/Scheduler.ts

@@ -1,11 +1,11 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
 import { SchedulerObjects } from './SchedulerObjects.js';
 
 export class Scheduler {
   treeViewObjects: SchedulerObjects;
 
-  constructor(page: Page, context: Locator | null = null) {
-    this.treeViewObjects = new SchedulerObjects(page, context);
+  constructor(context: Locator) {
+    this.treeViewObjects = new SchedulerObjects(context.page(), context);
   }
 
   public get context(): Locator | null {

package/components/splitter/Splitter.ts

@@ -1,11 +1,11 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
 import { SplitterObjects } from './SplitterObjects.js';
 
 export class Splitter {
   splitterObjects: SplitterObjects;
 
   // ToDo: this is not the correct implementation, its temporary to allow generation to continue
-  constructor(page: Page, context: Locator | null = null) {
-    this.splitterObjects = new SplitterObjects(page, context);
+  constructor(context: Locator) {
+    this.splitterObjects = new SplitterObjects(context.page(), context);
   }
 }

package/components/tab/BaseTab.ts

@@ -1,11 +1,11 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
 import { BaseTabObjects } from './BaseTabObjects.js';
 
 export class BaseTab {
   protected _objects: BaseTabObjects;
 
-  constructor(page: Page, context: Locator | null = null) {
-    this._objects = new BaseTabObjects(page, context);
+  constructor(context: Locator) {
+    this._objects = new BaseTabObjects(context.page(), context);
   }
 
   // --- Common actions ---

package/components/tab/DetailTabPage.ts

@@ -1,13 +1,13 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
 import { BaseTab } from './BaseTab.js';
 import { DetailTabPageObjects } from './DetailTabPageObjects.js';
 
 export class DetailTabPage extends BaseTab {
   protected _objects: DetailTabPageObjects;
 
-  constructor(page: Page, context: Locator | null = null) {
-    super(page, context);
-    this._objects = new DetailTabPageObjects(page, context);
+  constructor(context: Locator) {
+    super(context);
+    this._objects = new DetailTabPageObjects(context.page(), context);
   }
 
   public getDetailTabPageById(name: string): Locator {

package/components/tab/Tab.ts

@@ -1,13 +1,13 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
 import { BaseTab } from './BaseTab.js';
 import { TabObjects } from './TabObjects.js';
 
 export class Tab extends BaseTab {
   protected _objects: TabObjects;
 
-  constructor(page: Page, context: Locator | null = null) {
-    super(page, context);
-    this._objects = new TabObjects(page, context);
+  constructor(context: Locator) {
+    super(context);
+    this._objects = new TabObjects(context.page(), context);
   }
 
   // --- Component-specific helpers ---

package/components/task/TaskBar.ts

@@ -1,4 +1,4 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
 import { TaskBarObjects } from './TaskBarObjects.js';
 
 export class TaskBar {
@@ -7,8 +7,8 @@ export class TaskBar {
   /**
    * @param taskBarContext the taskbar container element (same idea as Grid's context)
    */
-  constructor(page: Page, taskBarContext: Locator | null = null) {
-    this._taskBarObjects = new TaskBarObjects(page, taskBarContext);
+  constructor(taskBarContext: Locator) {
+    this._taskBarObjects = new TaskBarObjects(taskBarContext.page(), taskBarContext);
   }
 
   /** returns all task buttons */

package/components/task/TaskTiles.ts

@@ -1,4 +1,4 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
 import { TaskTilesObjects } from './TaskTilesObjects.js';
 
 export class TaskTiles {
@@ -7,8 +7,8 @@ export class TaskTiles {
   /**
    * @param taskTilesContext the taskTiles container element
    */
-  constructor(page: Page, taskTilesContext: Locator | null = null) {
-    this._taskTilesObjects = new TaskTilesObjects(page, taskTilesContext);
+  constructor(taskTilesContext: Locator) {
+    this._taskTilesObjects = new TaskTilesObjects(taskTilesContext.page(), taskTilesContext);
   }
 
   /** returns all task tile buttons */

package/components/topbar/TopBar.ts

@@ -11,4 +11,6 @@ export class TopBarComponent {
   public getTopBarTitle = () => this._objects.topBarTitle();
 
   public getTopBarBreadcrumb = () => this._objects.topBarBreadcrumb();
+
+  public getMainHeader = () => this._objects.mainHeader;
 }

package/components/tree-view/TreeView.ts

@@ -1,11 +1,11 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
 import { TreeViewObjects } from './TreeViewObjects.js';
 
 export class TreeView {
   treeViewObjects: TreeViewObjects;
 
-  constructor(page: Page, context: Locator | null = null) {
-    this.treeViewObjects = new TreeViewObjects(page, context);
+  constructor(context: Locator) {
+    this.treeViewObjects = new TreeViewObjects(context.page(), context);
   }
 
   public get context(): Locator | null {

package/controls/DateControl.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* biome-ignore-all lint/suspicious/noExplicitAny: reason42 */
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
+import { DateControlObjects } from './DateControlObjects.js';
 
 export type IDateControl = Locator & IDateControlCore;
 
@@ -12,12 +13,10 @@ export type IDateControlCore = {
 };
 
 export class DateControl implements IDateControlCore {
-  private _dateFieldLocator: Locator;
-  private _inputLocator: Locator;
+  private _objects: DateControlObjects;
 
-  constructor(page: Page, id: string) {
-    this._dateFieldLocator = page.getByTestId(`form-field__${id}`);
-    this._inputLocator = this._dateFieldLocator.locator('input');
+  constructor(context: Locator, id: string) {
+    this._objects = new DateControlObjects(context, id);
   }
 
   /**
@@ -30,26 +29,26 @@ export class DateControl implements IDateControlCore {
   public async fill(value: string): Promise<void> {
     const numbersOnlyValue = value.replace(/\D/g, '');
 
-    await this._inputLocator.focus();
-    await this._inputLocator.pressSequentially(numbersOnlyValue);
+    await this._objects.fieldInput().focus();
+    await this._objects.fieldInput().pressSequentially(numbersOnlyValue);
   }
 
   public async clear(): Promise<void> {
-    await this._inputLocator.fill('');
+    await this._objects.fieldInput().fill('');
   }
 
   public async inputValue(): Promise<string> {
-    return await this._inputLocator.inputValue();
+    return await this._objects.fieldInput().inputValue();
   }
 
   public inputElement(): Locator {
-    return this._inputLocator;
+    return this._objects.fieldInput();
   }
 }
 
-export function createDateControl(page: Page, id: string): IDateControl {
-  const inputFieldControl = new DateControl(page, id);
-  const locator = page.getByTestId(`form-field__${id}`);
+export function createDateControl(context: Locator, id: string): IDateControl {
+  const inputFieldControl = new DateControl(context, id);
+  const locator = context.getByTestId(`form-field__${id}`);
 
   return new Proxy(inputFieldControl, {
     get(target, prop, receiver) {

package/controls/DateControlObjects.ts

@@ -0,0 +1,15 @@
+import type { Locator } from '@playwright/test';
+
+export class DateControlObjects {
+  private _context: Locator;
+  private _id: string;
+
+  constructor(context: Locator, id: string) {
+    this._context = context;
+    this._id = id;
+  }
+
+  public fieldInput = (): Locator => this._context;
+
+  public dateField = (): Locator => this._context.getByTestId(`form-field__${this._id}`);
+}

package/controls/FormComboBox.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* biome-ignore-all lint/suspicious/noExplicitAny: Reason42 */
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
+import { FormComboBoxObjects } from './FormComboBoxObjects.js';
 
 export type IFormComboBox = Locator & IFormComboBoxCore;
 
@@ -12,50 +13,36 @@ export type IFormComboBoxCore = {
 };
 
 class FormComboBox implements IFormComboBoxCore {
-  private _formFieldLocator: Locator;
-  private _autoCompleteMenu: Locator;
-  private _id: string;
+  private _objects: FormComboBoxObjects;
 
-  constructor(page: Page, id: string) {
-    this._id = id;
-    this._formFieldLocator = page.getByTestId(`form-field__${id}`);
-    this._autoCompleteMenu = page.getByTestId(`form-field__${id}__select__options-list`);
+  constructor(context: Locator, id: string) {
+    this._objects = new FormComboBoxObjects(context, id);
   }
 
   async selectOption(optionText: string): Promise<void> {
-    await this._formFieldLocator.locator('input').click();
-
-    await this._autoCompleteMenu.waitFor({ state: 'visible' });
-
-    const optionTextLowercase = optionText.toLowerCase();
-
-    await this._autoCompleteMenu.getByTestId(`form-field__${this._id}__select__${optionTextLowercase}__text`).click();
+    await this._objects.fieldInput().click();
+    await this._objects.autoCompleteMenu().waitFor({ state: 'visible' });
+    await this._objects.option(optionText).click();
   }
 
   async getValidationMessage(): Promise<string> {
-    await this._formFieldLocator.locator('.TooltipContainer p').waitFor({ state: 'visible' });
-    return await this._formFieldLocator.locator('.TooltipContainer p').innerText();
+    await this._objects.validationMessage().waitFor({ state: 'visible' });
+    return await this._objects.validationMessage().innerText();
   }
   async clearByClick(): Promise<void> {
-    await this._formFieldLocator.locator('Button[aria-label="Clear"]').click();
+    await this._objects.clearButton().click();
   }
 
   async lookupSelect(optionToSelect: string): Promise<void> {
-    await this._formFieldLocator.locator('input').fill(optionToSelect);
-
-    await this._autoCompleteMenu.waitFor({ state: 'visible' });
-
-    const optionToSelectLowercase = optionToSelect.toLowerCase();
-
-    await this._autoCompleteMenu
-      .getByTestId(`form-field__${this._id}__select__${optionToSelectLowercase}__text`)
-      .click();
+    await this._objects.fieldInput().fill(optionToSelect);
+    await this._objects.autoCompleteMenu().waitFor({ state: 'visible' });
+    await this._objects.option(optionToSelect).click();
   }
 }
 
-export function createFormComboBox(page: Page, id: string): IFormComboBox {
-  const comboBox = new FormComboBox(page, id);
-  const locator = page.getByTestId(`form-field__${id}`);
+export function createFormComboBox(context: Locator, id: string): IFormComboBox {
+  const comboBox = new FormComboBox(context, id);
+  const locator = context.getByTestId(`form-field__${id}`);
 
   return new Proxy(comboBox, {
     get(target, prop, receiver) {

package/controls/FormComboBoxObjects.ts

@@ -0,0 +1,27 @@
+import type { Locator } from '@playwright/test';
+
+export class FormComboBoxObjects {
+  private _context: Locator;
+  private _id: string;
+
+  constructor(context: Locator, id: string) {
+    this._context = context;
+    this._id = id;
+  }
+
+  public field = (): Locator => this._context.getByTestId(`form-field__${this._id}`);
+
+  public autoCompleteMenu = (): Locator =>
+    this._context.page().getByTestId(`form-field__${this._id}__select__options-list`);
+
+  public option = (optionText: string): Locator => {
+    const optionTextLowercase = optionText.toLowerCase();
+    return this.autoCompleteMenu().getByTestId(`form-field__${this._id}__select__${optionTextLowercase}__text`);
+  };
+
+  public clearButton = (): Locator => this.field().locator('Button[aria-label="Clear"]');
+
+  public validationMessage = (): Locator => this.field().locator('.TooltipContainer p');
+
+  public fieldInput = (): Locator => this.field().locator('input');
+}

package/controls/GridColumnControl.ts

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* biome-ignore-all lint/suspicious/noExplicitAny: Reason42 */
+import type { Locator } from '@playwright/test';
+import { Grid } from '../components/grid/Grid.js';
+import { escapeRegex } from '../index.js';
+import { GridColumnControlObjects } from './GridColumnControlObjects.js';
+
+export type IGridColumnControl = Locator & IGridColumnControlCore;
+
+export type IGridColumnControlCore = {
+  getColumnHeader(): Promise<Locator>;
+  getCellByExactValue(value: string): Locator;
+  getCellValues(): Promise<string[]>;
+  filterByColumnValueExcelStyle(value: string, deselectAll?: boolean): Promise<void>;
+  openExcelStyleFilterPopup(): Promise<void>;
+};
+
+class GridColumnControl implements IGridColumnControlCore {
+  private _grid: Grid;
+  private _id: string;
+  private _objects: GridColumnControlObjects;
+
+  constructor(gridContext: Locator, id: string) {
+    this._id = id.replace(/-/g, '_');
+    this._objects = new GridColumnControlObjects(gridContext, this._id);
+    this._grid = new Grid(gridContext);
+  }
+
+  public async openExcelStyleFilterPopup(): Promise<void> {
+    await this._grid.openExcelStyleFilterPopup(this._id);
+  }
+
+  public async getColumnHeader(): Promise<Locator> {
+    return await this._objects.columnHeader();
+  }
+
+  public getCellByExactValue(value: string): Locator {
+    const valueToFindRegex = new RegExp(`^${escapeRegex(value)}$`);
+    return this._objects.cellByValue(valueToFindRegex);
+  }
+
+  public async getCellValues(): Promise<string[]> {
+    return await this._grid.getCellValuesByColId(this._id);
+  }
+
+  public async filterByColumnValueExcelStyle(value: string, deselectAll?: boolean): Promise<void> {
+    await this._grid.filterByColumnValueExcelStyle(this._objects.columnHeader(), value, deselectAll);
+  }
+}
+
+export function createGridColumnControl(gridContext: Locator, id: string): IGridColumnControl {
+  const columnControl = new GridColumnControl(gridContext, id);
+  const locator = gridContext.locator(`[col-id="${id}"]`);
+
+  return new Proxy(columnControl, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+
+      const value = (locator as any)[prop];
+      if (typeof value === 'function') {
+        return value.bind(locator);
+      }
+      return value;
+    }
+  }) as unknown as IGridColumnControl;
+}

package/controls/GridColumnControlObjects.ts

@@ -0,0 +1,20 @@
+import type { Locator } from '@playwright/test';
+import { BaseComponentObjects } from '../components/BaseComponentObjects.js';
+
+export class GridColumnControlObjects extends BaseComponentObjects {
+  private _id: string;
+
+  constructor(gridContext: Locator, columnId: string) {
+    super(gridContext.page(), gridContext);
+    this._id = columnId;
+  }
+
+  public column = () => this.context.locator(`[col-id="${this._id}"]`);
+
+  public columnHeader = () => this.context.locator(`[col-id="${this._id}"][role="columnheader"]`);
+
+  public cellByValue = (value: RegExp) =>
+    this.column().locator('[role="button"]', {
+      hasText: value
+    });
+}

package/controls/InputFieldControl.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /** biome-ignore-all lint/suspicious/noExplicitAny: reason42 */
-import type { Locator, Page } from '@playwright/test';
+import type { Locator } from '@playwright/test';
+import { InputFieldControlObjects } from './InputFieldControlObjects.js';
 
 export type IInputFieldControl = Locator & ICoreInputFieldControl;
 
@@ -15,43 +16,39 @@ export type ICoreInputFieldControl = {
 };
 
 export class InputFieldControl implements ICoreInputFieldControl {
-  private _formFieldLocator: Locator;
-  private _inputLocator: Locator;
-  private _id: string;
-
-  constructor(page: Page, id: string) {
-    this._id = id;
-    this._formFieldLocator = page.getByTestId(`form-field__${id}`);
-    this._inputLocator = this._formFieldLocator.locator('input');
+  private _objects: InputFieldControlObjects;
+
+  constructor(context: Locator, id: string) {
+    this._objects = new InputFieldControlObjects(context, id);
   }
 
   public async getValidationMessage(): Promise<string> {
-    await this._formFieldLocator.locator('.TooltipContainer p').waitFor({ state: 'visible' });
-    return await this._formFieldLocator.locator('.TooltipContainer p').innerText();
+    await this._objects.validationMessage().waitFor({ state: 'visible' });
+    return await this._objects.validationMessage().innerText();
   }
 
   public async fill(value: string): Promise<void> {
-    await this._inputLocator.fill(value);
+    await this._objects.fieldInput().fill(value);
   }
 
   public async click(): Promise<void> {
-    await this._inputLocator.click();
+    await this._objects.fieldInput().click();
   }
 
   public async clear(): Promise<void> {
-    await this._inputLocator.fill('');
+    await this._objects.fieldInput().fill('');
   }
 
   public async inputValue(): Promise<string> {
-    return await this._inputLocator.inputValue();
+    return await this._objects.fieldInput().inputValue();
   }
 
   public inputElement(): Locator {
-    return this._inputLocator;
+    return this._objects.fieldInput();
   }
 
   public async getLabelText(): Promise<string> {
-    let returnText = (await this._formFieldLocator.getByTestId(`form-field__${this._id}__label`).textContent()) || '';
+    let returnText = (await this._objects.fieldLabel().textContent()) || '';
 
     returnText = returnText.replace(/\s+/g, ' ').trim();
 
@@ -59,9 +56,9 @@ export class InputFieldControl implements ICoreInputFieldControl {
   }
 }
 
-export function createInputFieldControl(page: Page, id: string): IInputFieldControl {
-  const inputFieldControl = new InputFieldControl(page, id);
-  const locator = page.getByTestId(`form-field__${id}`);
+export function createInputFieldControl(context: Locator, id: string): IInputFieldControl {
+  const inputFieldControl = new InputFieldControl(context, id);
+  const locator = context.getByTestId(`form-field__${id}`);
 
   return new Proxy(inputFieldControl, {
     get(target, prop, receiver) {

package/controls/InputFieldControlObjects.ts

@@ -0,0 +1,19 @@
+import type { Locator } from '@playwright/test';
+
+export class InputFieldControlObjects {
+  private _context: Locator;
+  private _id: string;
+
+  constructor(context: Locator, id: string) {
+    this._context = context;
+    this._id = id;
+  }
+
+  public formField = (): Locator => this._context.getByTestId(`form-field__${this._id}`);
+
+  public fieldInput = (): Locator => this.formField().locator('input');
+
+  public fieldLabel = (): Locator => this.formField().getByTestId(`form-field__${this._id}__label`);
+
+  public validationMessage = (): Locator => this.formField().locator('.TooltipContainer p');
+}

package/controls/LookupDropdown.ts

@@ -2,60 +2,101 @@
 /** biome-ignore-all lint/suspicious/noExplicitAny: needed flexibility */
 import type { Locator } from '@playwright/test';
 import { escapeRegex } from '../helpers/RegexHelper.js';
+import { LookupDropdownObjects } from './LookupDropdownObjects.js';
 
 export type ILookupDropdown = Locator & ILookupDropdownCore;
 
 export type ILookupDropdownCore = {
   lookupSelect(optionToSelect: string): Promise<void>;
   selectOption(optionText: string): Promise<void>;
+  fill(value: string): Promise<void>;
+  getValidationMessage(): Promise<string>;
+  getLabelText(): Promise<string>;
+  inputValue(): Promise<string>;
+  clear(): Promise<void>;
 };
 
 class LookupDropdown implements ILookupDropdownCore {
-  private _locator: Locator;
+  private _objects: LookupDropdownObjects;
 
-  constructor(locator: Locator) {
-    this._locator = locator;
+  constructor(context: Locator, id: string) {
+    this._objects = new LookupDropdownObjects(context, id);
   }
 
-  async lookupSelect(optionToSelect: string): Promise<void> {
-    await Promise.all([this._locator.click(), this._locator.page().waitForResponse('**/list_**')]);
+  public async getLabelText(): Promise<string> {
+    let returnText = (await this._objects.label().textContent()) || '';
 
-    await this._locator.fill(optionToSelect);
-    await this._locator.page().waitEventHandler.setCanContinue(true);
+    returnText = returnText.replace(/\s+/g, ' ').trim();
 
+    return returnText;
+  }
+
+  public async lookupSelect(optionToSelect: string): Promise<void> {
+    await this._objects.input().fill(optionToSelect);
     await this.select(optionToSelect);
   }
 
-  async selectOption(optionText: string): Promise<void> {
-    await this._locator.click();
+  public async inputValue(): Promise<string> {
+    return await this._objects.input().inputValue();
+  }
+
+  public async clear(): Promise<void> {
+    await this._objects.input().fill('');
+  }
+
+  public async selectOption(optionText: string): Promise<void> {
+    await this._objects.input().click();
     await this.select(optionText);
   }
 
+  public async getValidationMessage(): Promise<string> {
+    await this._objects.validationMessage().waitFor({ state: 'visible' });
+    return await this._objects.validationMessage().innerText();
+  }
+
+  public async fill(value: string): Promise<void> {
+    await Promise.all([
+      this._objects
+        .input()
+        .page()
+        .waitForResponse((response) => response.url().includes('/list_') && response.request().method() === 'GET'),
+      this._objects.input().click()
+    ]);
+
+    await Promise.all([
+      this._objects
+        .input()
+        .page()
+        .waitForResponse((response) => response.url().includes('/list_') && response.request().method() === 'GET'),
+      this._objects.input().fill(value)
+    ]);
+  }
+
   private async select(optionToSelect: string) {
     const optionsToSelectRegex = new RegExp(`^${escapeRegex(optionToSelect)}$`, 'i');
 
-    await this._locator.page().getByTestId('autocomplete__menu').getByText(optionsToSelectRegex).click();
-    await this._locator
+    await this._objects.input().page().getByTestId('autocomplete__menu').getByText(optionsToSelectRegex).click();
+    await this._objects
+      .input()
       .page()
-      .waitForFunction((el) => document.activeElement === el, await this._locator.elementHandle());
+      .waitForFunction((el) => document.activeElement === el, await this._objects.input().elementHandle());
   }
 }
 
-export function createLookupDropdown(locator: Locator): ILookupDropdown {
-  const dropdown = new LookupDropdown(locator);
+export function createLookupDropdown(context: Locator, id: string): ILookupDropdown {
+  const dropdown = new LookupDropdown(context, id);
+  const customProps = new Set(Object.getOwnPropertyNames(LookupDropdown.prototype).filter((p) => p !== 'constructor'));
 
-  return new Proxy(dropdown, {
+  return new Proxy(context, {
     get(target, prop, receiver) {
-      if (prop in target) {
-        return Reflect.get(target, prop, receiver);
-      }
-
-      const value = (locator as any)[prop];
-
-      if (typeof value === 'function') {
-        return value.bind(locator);
+      if (customProps.has(prop as string)) {
+        const value = (dropdown as any)[prop];
+        if (typeof value === 'function') {
+          return value.bind(dropdown);
+        }
+        return value;
       }
-      return value;
+      return Reflect.get(target, prop, receiver);
     }
   }) as unknown as ILookupDropdown;
 }

package/controls/LookupDropdownObjects.ts

@@ -0,0 +1,19 @@
+import type { Locator } from '@playwright/test';
+
+export class LookupDropdownObjects {
+  private _id: string;
+  private _context: Locator;
+
+  constructor(context: Locator, id: string) {
+    this._context = context;
+    this._id = id;
+  }
+
+  public formField = (): Locator => this._context.getByTestId(`form-field__${this._id}`);
+
+  public label = (): Locator => this.formField().getByTestId(`form-field__${this._id}__label`);
+
+  public input = (): Locator => this.formField().locator('input');
+
+  public validationMessage = (): Locator => this.formField().locator('.TooltipContainer p');
+}