@redhat-developer/page-objects 1.0.0

package/out/components/editor/SettingsEditor.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkSetting = exports.CheckboxSetting = exports.TextSetting = exports.ComboSetting = exports.Setting = exports.SettingsEditor = void 0;
+const Editor_1 = require("./Editor");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const AbstractElement_1 = require("../AbstractElement");
+const __1 = require("../..");
+/**
+ * Page object representing the internal VSCode settings editor
+ */
+class SettingsEditor extends Editor_1.Editor {
+    divider = SettingsEditor.versionInfo.version >= '1.83.0' ? '›' : ' › ';
+    constructor(view = new __1.EditorView()) {
+        super(view);
+    }
+    /**
+     * Search for a setting with a particular title and category.
+     * Returns an appropriate Setting object if the label is found,
+     * undefined otherwise.
+     *
+     * If your setting has nested categories (i.e `example.general.test`),
+     * pass in each category as a separate string.
+     *
+     * @param title title of the setting
+     * @param categories category of the setting
+     * @returns Promise resolving to a Setting object if found, undefined otherwise
+     */
+    async findSetting(title, ...categories) {
+        const category = categories.join(this.divider);
+        const searchBox = await this.findElement(SettingsEditor.locators.Editor.inputArea);
+        await searchBox.sendKeys(selenium_webdriver_1.Key.chord(SettingsEditor.ctlKey, 'a'));
+        await searchBox.sendKeys(`${category}${this.divider}${title}`);
+        return await this._getSettingItem(title, category);
+    }
+    /**
+     * Search for a setting with a precise ID.
+     * Returns an appropriate Setting object if it exists,
+     * undefined otherwise.
+     *
+     * @param id of the setting
+     * @returns Promise resolving to a Setting object if found, undefined otherwise
+     */
+    async findSettingByID(id) {
+        const searchBox = await this.findElement(SettingsEditor.locators.Editor.inputArea);
+        await searchBox.sendKeys(selenium_webdriver_1.Key.chord(SettingsEditor.ctlKey, 'a'));
+        await searchBox.sendKeys(id);
+        const title = id.split('.').pop();
+        return await this._getSettingItem(title);
+    }
+    async _getSettingItem(title = '', category = '') {
+        const count = await this.findElement(SettingsEditor.locators.SettingsEditor.itemCount);
+        let textCount = await count.getText();
+        await this.getDriver().wait(async function () {
+            await new Promise(res => setTimeout(res, 1500));
+            const text = await count.getText();
+            if (text !== textCount) {
+                textCount = text;
+                return false;
+            }
+            return true;
+        });
+        let setting;
+        const items = await this.findElements(SettingsEditor.locators.SettingsEditor.itemRow);
+        for (const item of items) {
+            try {
+                const _category = (await (await item.findElement(SettingsEditor.locators.SettingsEditor.settingCategory)).getText()).replace(':', '');
+                const _title = await (await item.findElement(SettingsEditor.locators.SettingsEditor.settingLabel)).getText();
+                if (category !== '') {
+                    if (category.toLowerCase().replace(this.divider, '').replace(/\s/g, '').trim() !== _category.toLowerCase().replace(this.divider, '').replace(/\s/g, '').trim()) {
+                        continue;
+                    }
+                }
+                if (title !== '') {
+                    if (title.toLowerCase().replace(/\s/g, '').trim() !== _title.toLowerCase().replace(/\s/g, '').trim()) {
+                        continue;
+                    }
+                }
+                return await (await this.createSetting(item, _title, _category)).wait();
+            }
+            catch (err) {
+            }
+        }
+        return setting;
+    }
+    /**
+     * Switch between settings perspectives
+     * Works only if your vscode instance has both user and workspace settings available
+     *
+     * @param perspective User or Workspace
+     * @returns Promise that resolves when the appropriate button is clicked
+     */
+    async switchToPerspective(perspective) {
+        const actions = await this.findElement(SettingsEditor.locators.SettingsEditor.header)
+            .findElement(SettingsEditor.locators.SettingsEditor.tabs)
+            .findElement(SettingsEditor.locators.SettingsEditor.actions);
+        await actions.findElement(SettingsEditor.locators.SettingsEditor.action(perspective)).click();
+    }
+    /**
+     * Context menu is disabled in this editor, throw an error
+     */
+    async openContextMenu() {
+        throw new Error('Operation not supported');
+    }
+    async createSetting(element, title, category) {
+        await element.findElement(SettingsEditor.locators.SettingsEditor.settingConstructor(title, category));
+        try {
+            // try a combo setting
+            await element.findElement(SettingsEditor.locators.SettingsEditor.comboSetting);
+            return new ComboSetting(SettingsEditor.locators.SettingsEditor.settingConstructor(title, category), this);
+        }
+        catch (err) {
+            try {
+                // try text setting
+                await element.findElement(SettingsEditor.locators.SettingsEditor.textSetting);
+                return new TextSetting(SettingsEditor.locators.SettingsEditor.settingConstructor(title, category), this);
+            }
+            catch (err) {
+                try {
+                    // try checkbox setting
+                    await element.findElement(SettingsEditor.locators.SettingsEditor.checkboxSetting);
+                    return new CheckboxSetting(SettingsEditor.locators.SettingsEditor.settingConstructor(title, category), this);
+                }
+                catch (err) {
+                    // try link setting
+                    try {
+                        await element.findElement(SettingsEditor.locators.SettingsEditor.linkButton);
+                        return new LinkSetting(SettingsEditor.locators.SettingsEditor.settingConstructor(title, category), this);
+                    }
+                    catch (err) {
+                        throw new Error('Setting type not supported');
+                    }
+                }
+            }
+        }
+    }
+}
+exports.SettingsEditor = SettingsEditor;
+/**
+ * Abstract item representing a Setting with title, description and
+ * an input element (combo/textbox/checkbox/link)
+ */
+class Setting extends AbstractElement_1.AbstractElement {
+    constructor(settingsConstructor, settings) {
+        super(settingsConstructor, settings);
+    }
+    /**
+     * Get the category of the setting
+     * All settings are labeled as Category: Title
+     */
+    async getCategory() {
+        return await (await this.findElement(SettingsEditor.locators.SettingsEditor.settingCategory)).getText();
+    }
+    /**
+     * Get description of the setting
+     * @returns Promise resolving to setting description
+     */
+    async getDescription() {
+        return await (await this.findElement(SettingsEditor.locators.SettingsEditor.settingDesctiption)).getText();
+    }
+    /**
+     * Get title of the setting
+     */
+    async getTitle() {
+        return await (await this.findElement(SettingsEditor.locators.SettingsEditor.settingLabel)).getText();
+    }
+}
+exports.Setting = Setting;
+/**
+ * Setting with a combo box
+ */
+class ComboSetting extends Setting {
+    async getValue() {
+        const combo = await this.findElement(SettingsEditor.locators.SettingsEditor.comboSetting);
+        return await combo.getAttribute(SettingsEditor.locators.SettingsEditor.comboValue);
+    }
+    async setValue(value) {
+        const rows = await this.getOptions();
+        for (let row of rows) {
+            if ((await row.getAttribute('class')).indexOf('disabled') < 0) {
+                const text = await (await row.findElement(SettingsEditor.locators.SettingsEditor.comboOption)).getText();
+                if (value === text) {
+                    return await row.click();
+                }
+            }
+        }
+    }
+    /**
+     * Get the labels of all options from the combo
+     * @returns Promise resolving to array of string values
+     */
+    async getValues() {
+        const values = [];
+        const rows = await this.getOptions();
+        for (const row of rows) {
+            values.push(await (await row.findElement(SettingsEditor.locators.SettingsEditor.comboOption)).getText());
+        }
+        return values;
+    }
+    async getOptions() {
+        const menu = await this.openCombo();
+        return await menu.findElements(SettingsEditor.locators.SettingsEditor.itemRow);
+    }
+    async openCombo() {
+        const combo = await this.findElement(SettingsEditor.locators.SettingsEditor.comboSetting);
+        const workbench = await this.getDriver().findElement(SettingsEditor.locators.Workbench.constructor);
+        const menus = await workbench.findElements(SettingsEditor.locators.ContextMenu.contextView);
+        let menu;
+        if (menus.length < 1) {
+            await combo.click();
+            menu = await workbench.findElement(SettingsEditor.locators.ContextMenu.contextView);
+            return menu;
+        }
+        else if (await menus[0].isDisplayed()) {
+            await combo.click();
+            await this.getDriver().sleep(200);
+        }
+        await combo.click();
+        menu = await workbench.findElement(SettingsEditor.locators.ContextMenu.contextView);
+        return menu;
+    }
+}
+exports.ComboSetting = ComboSetting;
+/**
+ * Setting with a text box input
+ */
+class TextSetting extends Setting {
+    async getValue() {
+        const input = await this.findElement(SettingsEditor.locators.SettingsEditor.textSetting);
+        return await input.getAttribute('value');
+    }
+    async setValue(value) {
+        const input = await this.findElement(SettingsEditor.locators.SettingsEditor.textSetting);
+        await input.clear();
+        await input.sendKeys(value);
+    }
+}
+exports.TextSetting = TextSetting;
+/**
+ * Setting with a checkbox
+ */
+class CheckboxSetting extends Setting {
+    async getValue() {
+        const checkbox = await this.findElement(SettingsEditor.locators.SettingsEditor.checkboxSetting);
+        const checked = await checkbox.getAttribute(SettingsEditor.locators.SettingsEditor.checkboxChecked);
+        if (checked === 'true') {
+            return true;
+        }
+        return false;
+    }
+    async setValue(value) {
+        const checkbox = await this.findElement(SettingsEditor.locators.SettingsEditor.checkboxSetting);
+        if (await this.getValue() !== value) {
+            await checkbox.click();
+        }
+    }
+}
+exports.CheckboxSetting = CheckboxSetting;
+/**
+ * Setting with no value, with a link to settings.json instead
+ */
+class LinkSetting extends Setting {
+    async getValue() {
+        throw new Error('Method getValue is not available for LinkSetting');
+    }
+    async setValue(value) {
+        throw new Error('Method setValue is not available for LinkSetting');
+    }
+    /**
+     * Open the link that leads to the value in settings.json
+     * @returns Promise resolving when the link has been clicked
+     */
+    async openLink() {
+        const link = await this.findElement(SettingsEditor.locators.SettingsEditor.linkButton);
+        await link.click();
+    }
+}
+exports.LinkSetting = LinkSetting;
+//# sourceMappingURL=SettingsEditor.js.map

package/out/components/editor/TextEditor.d.ts

@@ -0,0 +1,265 @@
+import { ContentAssist, ContextMenu, InputBox } from "../..";
+import { WebElement } from "selenium-webdriver";
+import { Editor } from "./Editor";
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+import { AbstractElement } from "../AbstractElement";
+import { Breakpoint } from "./Breakpoint";
+export declare class BreakpointError extends Error {
+}
+/**
+ * Page object representing the active text editor
+ */
+export declare class TextEditor extends Editor {
+    breakPoints: number[];
+    /**
+     * Find whether the active editor has unsaved changes
+     * @returns Promise resolving to true/false
+     */
+    isDirty(): Promise<boolean>;
+    /**
+     * Saves the active editor
+     * @returns Promise resolving when ctrl+s is invoked
+     */
+    save(): Promise<void>;
+    /**
+     * Open the Save as prompt
+     *
+     * @returns InputBox serving as a simple file dialog
+     */
+    saveAs(): Promise<InputBox>;
+    /**
+     * Retrieve the Uri of the file opened in the active editor
+     * @returns Promise resolving to editor's underlying Uri
+     */
+    getFileUri(): Promise<string>;
+    /**
+     * Retrieve the path to the file opened in the active editor
+     * @returns Promise resolving to editor's underlying file path
+     */
+    getFilePath(): Promise<string>;
+    /**
+     * Open/Close the content assistant at the current position in the editor by sending the default
+     * keyboard shortcut signal
+     * @param open true to open, false to close
+     * @returns Promise resolving to ContentAssist object when opening, void otherwise
+     */
+    toggleContentAssist(open: boolean): Promise<ContentAssist | void>;
+    /**
+     * Get all text from the editor
+     * @returns Promise resolving to editor text
+     */
+    getText(): Promise<string>;
+    /**
+     * Replace the contents of the editor with a given text
+     * @param text text to type into the editor
+     * @param formatText format the new text, default false
+     * @returns Promise resolving once the new text is copied over
+     */
+    setText(text: string, formatText?: boolean): Promise<void>;
+    /**
+     * Deletes all text within the editor
+     * @returns Promise resolving once the text is deleted
+     */
+    clearText(): Promise<void>;
+    /**
+     * Get text from a given line
+     * @param line number of the line to retrieve
+     * @returns Promise resolving to text at the given line number
+     */
+    getTextAtLine(line: number): Promise<string>;
+    /**
+     * Replace the contents of a line with a given text
+     * @param line number of the line to edit
+     * @param text text to set at the line
+     * @returns Promise resolving when the text is typed in
+     */
+    setTextAtLine(line: number, text: string): Promise<void>;
+    /**
+     * Get line number that contains the given text. Not suitable for multi line inputs.
+     *
+     * @param text text to search for
+     * @param occurrence select which occurrence of the search text to look for in case there are multiple in the document, defaults to 1 (the first instance)
+     *
+     * @returns Number of the line that contains the start of the given text. -1 if no such text is found.
+     * If occurrence number is specified, searches until it finds as many instances of the given text.
+     * Returns the line number that holds the last occurrence found this way.
+     */
+    getLineOfText(text: string, occurrence?: number): Promise<number>;
+    /**
+     * Find and select a given text. Not usable for multi line selection.
+     *
+     * @param text text to select
+     * @param occurrence specify which onccurrence of text to select if multiple are present in the document
+     */
+    selectText(text: string, occurrence?: number): Promise<void>;
+    /**
+     * Get the text that is currently selected as string
+     */
+    getSelectedText(): Promise<string>;
+    /**
+     * Get the selection block as a page object
+     * @returns Selection page object
+     */
+    getSelection(): Promise<Selection | undefined>;
+    openFindWidget(): Promise<FindWidget>;
+    /**
+     * Add the given text to the given coordinates
+     * @param line number of the line to type into
+     * @param column number of the column to start typing at
+     * @param text text to add
+     * @returns Promise resolving when the text is typed in
+     */
+    typeTextAt(line: number, column: number, text: string): Promise<void>;
+    /**
+     * Type given text at the current coordinates
+     * @param text text to type
+     * @returns promise resolving when the text is typed in
+     */
+    typeText(text: string): Promise<void>;
+    /**
+     * Move the cursor to the given coordinates
+     * @param line line number to move to
+     * @param column column number to move to
+     * @returns Promise resolving when the cursor has reached the given coordinates
+     */
+    moveCursor(line: number, column: number): Promise<void>;
+    /**
+     * Get number of lines in the editor
+     * @returns Promise resolving to number of lines
+     */
+    getNumberOfLines(): Promise<number>;
+    /**
+     * Use the built-in 'Format Document' option to format the text
+     * @returns Promise resolving when the Format Document command is invoked
+     */
+    formatDocument(): Promise<void>;
+    openContextMenu(): Promise<ContextMenu>;
+    /**
+     * Get the cursor's coordinates as an array of two numbers: `[line, column]`
+     *
+     * **Caution** line & column coordinates do not start at `0` but at `1`!
+     */
+    getCoordinates(): Promise<[number, number]>;
+    /**
+     * Toggle breakpoint on a given line
+     *
+     * @param line target line number
+     * @returns promise resolving to True when a breakpoint was added, False when removed
+     */
+    toggleBreakpoint(line: number): Promise<boolean>;
+    /**
+     * Get paused breakpoint if available. Otherwise, return undefined.
+     * @returns promise which resolves to either Breakpoint page object or undefined
+     */
+    getPausedBreakpoint(): Promise<Breakpoint | undefined>;
+    /**
+     * Get all code lenses within the editor
+     * @returns list of CodeLens page objects
+     */
+    getCodeLenses(): Promise<CodeLens[]>;
+    /**
+     * Get a code lens based on title, or zero based index
+     *
+     * @param indexOrTitle zero based index (counting from the top of the editor), or partial title of the code lens
+     * @returns CodeLens object if such a code lens exists, undefined otherwise
+     */
+    getCodeLens(indexOrTitle: number | string): Promise<CodeLens | undefined>;
+}
+/**
+ * Text selection block
+ */
+declare class Selection extends ElementWithContexMenu {
+    constructor(el: WebElement, editor: TextEditor);
+    openContextMenu(): Promise<ContextMenu>;
+}
+/**
+ * Page object for Code Lens inside a text editor
+ */
+export declare class CodeLens extends AbstractElement {
+    /**
+     * Get tooltip of the code lens
+     * @returns tooltip as string
+     */
+    getTooltip(): Promise<string>;
+}
+/**
+ * Text Editor's Find Widget
+ */
+export declare class FindWidget extends AbstractElement {
+    constructor(element: WebElement, editor: TextEditor);
+    /**
+     * Toggle between find and replace mode
+     * @param replace true for replace, false for find
+     */
+    toggleReplace(replace: boolean): Promise<void>;
+    /**
+     * Set text in the search box
+     * @param text text to fill in
+     */
+    setSearchText(text: string): Promise<void>;
+    /**
+     * Get text from Find input box
+     * @returns value of find input as string
+     */
+    getSearchText(): Promise<string>;
+    /**
+     * Set text in the replace box. Will toggle replace mode on if called in find mode.
+     * @param text text to fill in
+     */
+    setReplaceText(text: string): Promise<void>;
+    /**
+     * Get text from Replace input box
+     * @returns value of replace input as string
+     */
+    getReplaceText(): Promise<string>;
+    /**
+     * Click 'Next match'
+     */
+    nextMatch(): Promise<void>;
+    /**
+     * Click 'Previous match'
+     */
+    previousMatch(): Promise<void>;
+    /**
+     * Click 'Replace'. Only works in replace mode.
+     */
+    replace(): Promise<void>;
+    /**
+     * Click 'Replace All'. Only works in replace mode.
+     */
+    replaceAll(): Promise<void>;
+    /**
+     * Close the widget.
+     */
+    close(): Promise<void>;
+    /**
+     * Get the number of results as an ordered pair of numbers
+     * @returns pair in form of [current result index, total number of results]
+     */
+    getResultCount(): Promise<[number, number]>;
+    /**
+     * Toggle the search to match case
+     * @param toggle true to turn on, false to turn off
+     */
+    toggleMatchCase(toggle: boolean): Promise<void>;
+    /**
+     * Toggle the search to match whole words
+     * @param toggle true to turn on, false to turn off
+     */
+    toggleMatchWholeWord(toggle: boolean): Promise<void>;
+    /**
+     * Toggle the search to use regular expressions
+     * @param toggle true to turn on, false to turn off
+     */
+    toggleUseRegularExpression(toggle: boolean): Promise<void>;
+    /**
+     * Toggle the replace to preserve case
+     * @param toggle true to turn on, false to turn off
+     */
+    togglePreserveCase(toggle: boolean): Promise<void>;
+    private toggleControl;
+    private clickButton;
+    private setText;
+    private getInputText;
+}
+export {};