Locators E2e FE tests

Last patch to refactor locators for FE tests

Change-Id: I21cb98a316d4c7d7cb4e9a5cd4940eca3766ef0d

Author: Guilherme Saraiva

gui/extension/tests/e2e/tests/ui-shell.ts

@@ -164,6 +164,7 @@ describe("MYSQL SHELL CONSOLES", () => {
 
         it("Connect to host", async () => {
             let connUri = `\\c ${username}:${password}@${hostname}:${port}/${schema}`;
+            await driver.wait(waitUntil.shellSessionIsOpened(shellConn), constants.wait15seconds);
             await commandExecutor.execute(connUri);
             connUri = `Creating a session to '${username}@${hostname}:${port}/${schema}'`;
             expect(commandExecutor.getResultMessage(), errors.queryResultError(connUri,

gui/frontend/src/tests/e2e/lib/dbNotebooks.ts

@@ -21,8 +21,9 @@
  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-import { By, until, WebElement, Key, error, WebDriver } from "selenium-webdriver";
+import { until, WebElement, Key, error, WebDriver } from "selenium-webdriver";
 import { explicitWait, IDBConnection } from "./misc.js";
+import * as locator from "../lib/locators.js";
 
 export const execFullBlockSql = "Execute the selection or everything in the current block and create a new block";
 export const execFullBlockJs = "Execute everything in the current block and create a new block";
@@ -43,11 +44,11 @@ export class DBNotebooks {
      * @returns Promise resolving when the select is made
      */
     public static selectDBType = async (driver: WebDriver, value: string): Promise<void> => {
-        await driver.findElement(By.id("databaseType")).click();
-        const dropDownList = await driver.findElement(By.css(".dropdownList"));
-        const els = await dropDownList.findElements(By.css("div"));
+        await driver.findElement(locator.databaseConnectionConfiguration.databaseType.exists).click();
+        const dropDownList = await driver.findElement(locator.databaseConnectionConfiguration.databaseType.list);
+        const els = await dropDownList.findElements(locator.htmlTag.div);
         if (els.length > 0) {
-            await dropDownList.findElement(By.id(value)).click();
+            await dropDownList.findElement(locator.searchById(value)).click();
         }
     };
 
@@ -58,9 +59,9 @@ export class DBNotebooks {
      * @returns Promise resolving when the select is made
      */
     public static setProtocol = async (driver: WebDriver, value: string): Promise<void> => {
-        await driver.findElement(By.id("scheme")).click();
-        const dropDownList = await driver.findElement(By.css(".dropdownList"));
-        await dropDownList.findElement(By.id(value)).click();
+        await driver.findElement(locator.databaseConnectionConfiguration.mysql.basic.protocol.exists).click();
+        const dropDownList = await driver.findElement(locator.databaseConnectionConfiguration.mysql.basic.protocol.list);
+        await dropDownList.findElement(locator.searchById(value)).click();
     };
 
     /**
@@ -70,9 +71,9 @@ export class DBNotebooks {
      * @returns Promise resolving when the select is made
      */
     public static setSSLMode = async (driver: WebDriver, value: string): Promise<void> => {
-        await driver.findElement(By.id("sslMode")).click();
-        const dropDownList = await driver.findElement(By.css(".dropdownList"));
-        await dropDownList.findElement(By.id(value)).click();
+        await driver.findElement(locator.databaseConnectionConfiguration.mysql.ssl.mode).click();
+        const dropDownList = await driver.findElement(locator.databaseConnectionConfiguration.mysql.ssl.modeList.exists);
+        await dropDownList.findElement(locator.searchById(value)).click();
     };
 
     /**
@@ -83,16 +84,16 @@ export class DBNotebooks {
      * @returns Promise resolving with the connection created
      */
     public static createDBconnection = async (driver: WebDriver, dbConfig: IDBConnection): Promise<WebElement | undefined> => {
-        const ctx = await driver.wait(until.elementLocated(By.css(".connectionBrowser")),
+        const ctx = await driver.wait(until.elementLocated(locator.dbConnections.browser),
             explicitWait, "DB Connection Overview page was not loaded");
 
         await driver.wait(async () => {
-            const isDialogVisible = (await driver.findElements(By.css(".valueEditDialog"))).length > 0;
+            const isDialogVisible = (await driver.findElements(locator.databaseConnectionConfiguration.exists)).length > 0;
             if (isDialogVisible) {
                 return true;
             } else {
                 try {
-                    await ctx.findElement(By.id("-1")).click();
+                    await ctx.findElement(locator.dbConnections.newConnection).click();
                 } catch (e) {
                     if (!(e instanceof error.ElementClickInterceptedError)) {
                         throw e;
@@ -103,56 +104,56 @@ export class DBNotebooks {
             }
         }, explicitWait, "Connection dialog was not displayed");
 
-        const newConDialog = await driver.findElement(By.css(".valueEditDialog"));
+        const newConDialog = await driver.findElement(locator.databaseConnectionConfiguration.exists);
 
         await driver.wait(async () => {
-            await newConDialog.findElement(By.id("caption")).clear();
+            await newConDialog.findElement(locator.databaseConnectionConfiguration.caption).clear();
 
             return !(await driver.executeScript("return document.querySelector('#caption').value"));
         }, 3000, "caption was not cleared in time");
-        await newConDialog.findElement(By.id("caption")).sendKeys(dbConfig.caption);
-        await newConDialog.findElement(By.id("description")).clear();
+        await newConDialog.findElement(locator.databaseConnectionConfiguration.caption).sendKeys(dbConfig.caption);
+        await newConDialog.findElement(locator.databaseConnectionConfiguration.description).clear();
         await newConDialog
-            .findElement(By.id("description"))
+            .findElement(locator.databaseConnectionConfiguration.description)
             .sendKeys(dbConfig.description);
-        await newConDialog.findElement(By.id("hostName")).clear();
-        await newConDialog.findElement(By.id("hostName")).sendKeys(String(dbConfig.hostname));
+        await newConDialog.findElement(locator.databaseConnectionConfiguration.mysql.basic.hostname).clear();
+        await newConDialog.findElement(locator.databaseConnectionConfiguration.mysql.basic.hostname).sendKeys(String(dbConfig.hostname));
         await DBNotebooks.setProtocol(driver, dbConfig.protocol);
-        await driver.findElement(By.css("#port input")).clear();
-        await driver.findElement(By.css("#port input")).sendKeys(String(dbConfig.port));
-        await newConDialog.findElement(By.id("userName")).sendKeys(String(dbConfig.username));
+        await driver.findElement(locator.databaseConnectionConfiguration.mysql.basic.port).clear();
+        await driver.findElement(locator.databaseConnectionConfiguration.mysql.basic.port).sendKeys(String(dbConfig.port));
+        await newConDialog.findElement(locator.databaseConnectionConfiguration.mysql.basic.username).sendKeys(String(dbConfig.username));
         await newConDialog
-            .findElement(By.id("defaultSchema"))
+            .findElement(locator.databaseConnectionConfiguration.mysql.basic.schema)
             .sendKeys(String(dbConfig.schema));
 
         if (dbConfig.dbType) {
             await DBNotebooks.selectDBType(driver, dbConfig.dbType);
         }
 
         if (dbConfig.sslMode) {
-            await newConDialog.findElement(By.id("page1")).click();
-            await newConDialog.findElement(By.id("sslMode")).click();
-            const dropDownList = await driver.findElement(By.css(".noArrow.dropdownList"));
-            await dropDownList.findElement(By.id(dbConfig.sslMode)).click();
-            expect(await newConDialog.findElement(By.css("#sslMode label")).getText())
+            await newConDialog.findElement(locator.databaseConnectionConfiguration.sslTab).click();
+            await newConDialog.findElement(locator.databaseConnectionConfiguration.mysql.ssl.mode).click();
+            const dropDownList = await driver.findElement(locator.databaseConnectionConfiguration.mysql.ssl.modeList.exists);
+            await dropDownList.findElement(locator.searchById(dbConfig.sslMode)).click();
+            expect(await newConDialog.findElement(locator.databaseConnectionConfiguration.mysql.ssl.modeLabel).getText())
                 .toBe(dbConfig.sslMode);
 
             const certsPath = process.env.SSLCERTSPATH as string;
-            const paths = await newConDialog.findElements(By.css(".tabview.top input.msg"));
+            const paths = await newConDialog.findElements(locator.databaseConnectionConfiguration.mysql.ssl.inputs);
             await paths[0].sendKeys(`${certsPath}/ca-cert.pem`);
             await paths[1].sendKeys(`${certsPath}/client-cert.pem`);
             await paths[2].sendKeys(`${certsPath}/client-key.pem`);
         }
 
-        const okBtn = await driver.findElement(By.id("ok"));
+        const okBtn = await driver.findElement(locator.databaseConnectionConfiguration.ok);
         await driver.executeScript("arguments[0].scrollIntoView(true)", okBtn);
         await okBtn.click();
-        expect((await driver.findElements(By.css(".valueEditDialog"))).length).toBe(0);
+        expect((await driver.findElements(locator.databaseConnectionConfiguration.exists)).length).toBe(0);
 
         return driver.wait(async () => {
-            const connections = await driver.findElements(By.css("#tilesHost .connectionTile"));
+            const connections = await driver.findElements(locator.dbConnections.connections.item);
             for (const connection of connections) {
-                const el = await connection.findElement(By.css(".textHost .tileCaption"));
+                const el = await connection.findElement(locator.dbConnections.connections.caption);
                 if ((await el.getAttribute("innerHTML")).includes(dbConfig.caption)) {
                     return connection;
                 }
@@ -170,9 +171,9 @@ export class DBNotebooks {
     public static getConnection = async (driver: WebDriver, name: string): Promise<WebElement | undefined> => {
 
         return driver.wait(async () => {
-            const connections = await driver.findElements(By.css("#tilesHost .connectionTile"));
+            const connections = await driver.findElements(locator.dbConnections.connections.item);
             for (const connection of connections) {
-                const el = await connection.findElement(By.css(".textHost .tileCaption"));
+                const el = await connection.findElement(locator.dbConnections.connections.caption);
                 if ((await el.getAttribute("innerHTML")).includes(name)) {
                     return connection;
                 }
@@ -182,35 +183,36 @@ export class DBNotebooks {
     };
 
     public static clickConnectionItem = async (driver: WebDriver, conn: WebElement, item: string): Promise<void> => {
-        const moreActions = await conn.findElement(By.id("tileMoreActionsAction"));
+        const moreActions = await conn.findElement(locator.dbConnections.connections.actions.moreActions);
         const moreActionsRect = await moreActions.getRect();
         await driver.actions().move({
             x: parseInt(`${moreActionsRect.x}`, 10),
             y: parseInt(`${moreActionsRect.y}`, 10),
         }).perform();
         switch (item) {
             case "notebook": {
-                await conn.findElement(By.id("tileNewNotebookAction")).click();
+                await conn.findElement(locator.dbConnections.connections.actions.newNotebook).click();
                 break;
             }
             case "script": {
-                await conn.findElement(By.id("tileNewScriptAction")).click();
+                await conn.findElement(locator.dbConnections.connections.actions.newScript).click();
                 break;
             }
             case "edit": {
                 await moreActions.click();
-                await driver.wait(until.elementLocated(By.id("edit")), explicitWait, "Edit button not found").click();
+                await driver.wait(until.elementLocated(locator.dbConnections.connections.actions.edit),
+                    explicitWait, "Edit button not found").click();
                 break;
             }
             case "duplicate": {
                 await moreActions.click();
-                await driver.wait(until.elementLocated(By.id("duplicate")),
+                await driver.wait(until.elementLocated(locator.dbConnections.connections.actions.duplicate),
                     explicitWait, "Duplicate button not found").click();
                 break;
             }
             case "remove": {
                 await moreActions.click();
-                await driver.wait(until.elementLocated(By.id("remove")),
+                await driver.wait(until.elementLocated(locator.dbConnections.connections.actions.remove),
                     explicitWait, "Remove button not found").click();
                 break;
             }
@@ -227,7 +229,7 @@ export class DBNotebooks {
      */
     public static getAutoCompleteMenuItems = async (driver: WebDriver,): Promise<string[]> => {
         const els = [];
-        let items = await driver.wait(until.elementsLocated(By.css(".monaco-list .monaco-highlighted-label")),
+        let items = await driver.wait(until.elementsLocated(locator.notebook.codeEditor.autoCompleteItems),
             explicitWait, "Auto complete items were not displayed");
 
         for (const item of items) {
@@ -236,15 +238,14 @@ export class DBNotebooks {
 
         await driver.actions().sendKeys(Key.ARROW_UP).perform();
 
-        items = await driver.wait(until.elementsLocated(By.css(".monaco-list .monaco-highlighted-label")),
+        items = await driver.wait(until.elementsLocated(locator.notebook.codeEditor.autoCompleteItems),
             explicitWait, "Auto complete items were not displayed");
 
         for (const item of items) {
             els.push(await item.getText());
         }
 
         return [...new Set(els)];
-
     };
 
     /**
@@ -253,9 +254,9 @@ export class DBNotebooks {
      * @returns A promise resolving with the line number
      */
     public static getMouseCursorLine = async (driver: WebDriver): Promise<number | undefined> => {
-        const lines = await driver.findElements(By.css(".view-overlays > div"));
+        const lines = await driver.findElements(locator.notebook.codeEditor.editor.cursorLine);
         for (let i = 0; i <= lines.length - 1; i++) {
-            const curLine = await lines[i].findElements(By.className("current-line"));
+            const curLine = await lines[i].findElements(locator.notebook.codeEditor.editor.currentLine);
             if (curLine.length > 0) {
                 return i;
             }
@@ -277,7 +278,7 @@ export class DBNotebooks {
         let line;
         await driver.wait(async () => {
             try {
-                const lines = await driver.findElements(By.css(".view-lines.monaco-mouse-cursor-text > div"));
+                const lines = await driver.findElements(locator.notebook.codeEditor.editor.editorPrompt);
                 for (let i = 0; i <= lines.length - 1; i++) {
                     const lineContent = await lines[i].getAttribute("innerHTML");
                     if (lineContent.match(regex)) {
@@ -308,11 +309,9 @@ export class DBNotebooks {
      */
     public static setMouseCursorAt = async (driver: WebDriver, word: string): Promise<void> => {
         const mouseCursorIs = await DBNotebooks.getMouseCursorLine(driver);
-        console.log(`mouseCursorIs: ${mouseCursorIs}`);
         const mouseCursorShouldBe = await DBNotebooks.getLineFromWord(driver, word);
-        console.log(`mouseCursorShouldBe: ${mouseCursorShouldBe}`);
         const taps = mouseCursorShouldBe - mouseCursorIs!;
-        const textArea = await driver.findElement(By.css("textarea"));
+        const textArea = await driver.findElement(locator.notebook.codeEditor.textArea);
         if (taps > 0) {
             for (let i = 0; i < taps; i++) {
                 await textArea.sendKeys(Key.ARROW_DOWN);

gui/frontend/src/tests/e2e/lib/guiConsole.ts

@@ -21,7 +21,8 @@
  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-import { By, until, WebElement, WebDriver } from "selenium-webdriver";
+import { until, WebElement, WebDriver, error } from "selenium-webdriver";
+import * as locator from "../lib/locators.js";
 
 export class GuiConsole {
 
@@ -35,19 +36,19 @@ export class GuiConsole {
      */
     public static openSession = async (driver: WebDriver, id?: number): Promise<void> => {
         if (id) {
-            const buttons = await driver.findElements(By.css("#shellModuleHost #tilesHost button"));
+            const buttons = await driver.findElements(locator.shellPage.sessions.open);
             for (const button of buttons) {
                 if ((await button.getAttribute("id")) === String(id)) {
                     await button.click();
                     break;
                 }
             }
         } else {
-            await driver.findElement(By.css("#shellModuleHost #\\-1")).click();
+            await driver.findElement(locator.shellPage.sessions.newSession).click();
         }
 
         await driver.wait(
-            until.elementLocated(By.id("shellEditorHost")),
+            until.elementLocated(locator.shellSession.exists),
             15000,
             "Session was not opened",
         );
@@ -61,16 +62,14 @@ export class GuiConsole {
      */
     public static getSession = async (driver: WebDriver, sessionNbr: string): Promise<WebElement | undefined> => {
         try {
-            const buttons = await driver.findElements(By.css("#shellModuleHost #tilesHost .sessionTile"));
+            const buttons = await driver.findElements(locator.shellPage.sessions.tile);
             for (const button of buttons) {
                 if ((await button.getAttribute("id")) === sessionNbr) {
                     return button;
                 }
             }
         } catch (e) {
-            if (typeof e === "object" && String(e).includes("StaleElementReferenceError")) {
-                return undefined;
-            } else {
+            if (!(e instanceof error.StaleElementReferenceError)) {
                 throw e;
             }
         }