new version

tests/lib/PromiseElement.js

@@ -0,0 +1,78 @@
+let PromiseElementList = null;
+
+class PromiseElement {
+
+    constructor(promiseResolvingToElement) {
+        this._internalPromise = promiseResolvingToElement;
+    }
+
+    $(selector){
+        return new PromiseElement(this.getPromise().then(elem => elem.$(selector)));
+    }
+
+    $$(selector){
+        return new PromiseElementList(this.getPromise().then(elem => elem.$$(selector)));
+    }
+
+    async getPromise(){
+        return await this._internalPromise;
+    }
+
+    async isDisplayed(){
+        let elem = await this.getPromise();
+        return elem.isDisplayed();
+    }
+
+    async isExisting(){
+        return (await this.getPromise()).isExisting();
+    }
+
+    async isDisplayedInViewport(){
+        return (await this.getPromise()).isDisplayedInViewport();
+    }
+
+    async click(){
+        return (await this.getPromise()).click();
+    }
+
+    async getText(){
+        return (await this.getPromise()).getText();
+    }
+
+    async getAttribute(attr){
+        return (await this.getPromise()).getAttribute(attr);
+    }
+
+    async setValue(value){
+        return (await this.getPromise()).setValue(value);
+    }
+
+    async getTagName(){
+        return (await this.getPromise()).getTagName();
+    }
+
+    async isTag(tag){
+        return (await this.getTagName() === tag);
+    }
+
+    async isSelected(){
+        return (await this.getPromise()).isSelected();
+    }
+
+    async selectByAttribute(attribute, value){
+        return (await this.getPromise()).selectByAttribute(attribute, value);
+    }
+
+    async getValue(){
+        return (await this.getPromise()).getValue();
+    }
+
+    pause(miliseconds){
+        return new PromiseElement(this.getPromise().then(async res => {
+            await browser.pause(miliseconds);
+            return res;
+        }));
+    }
+}
+module.exports = PromiseElement;
+PromiseElementList = require("./PromiseElementList");

tests/lib/PromiseElementList.js

@@ -0,0 +1,61 @@
+const PromiseElement = require("./PromiseElement");
+
+class PromiseElementList extends PromiseElement {
+    async getLength() {
+        return (await this.getPromise()).length;
+    }
+
+    get(index) {
+        return new PromiseElement(this.getPromise().then(res => res[index]));
+    }
+
+    filter(filterFunc) {
+        return new PromiseElementList(this.getPromise().then(async res => {
+            let results = [];
+            res.forEach(elem => {
+                results.push(new Promise(res => {
+                    res(filterFunc(new PromiseElement(elem)));
+                }).catch((e) => {
+                    console.error(e);
+                    return false
+                }));
+            });
+            results = await Promise.all(results);
+            let filteredRes = [];
+
+            results.forEach((result, i) => {
+                if (result) {
+                    filteredRes.push(res[i]);
+                }
+            });
+            return filteredRes;
+        }));
+    }
+
+    async forEach(callback, simultaneously) {
+        const length = await this.getLength();
+        let promises = []
+        for (let i = 0; i < length; i++) {
+            const promise = callback(await this.get(i));
+            if (simultaneously !== false){
+                await promise;
+            }
+            else {
+                promises.push(promise);
+            }
+        }
+        await Promise.all(promises);
+        return this;
+
+    }
+
+    async click() {
+        return this.forEach(e => e.click());
+    }
+
+    filterOne(filterFunc) {
+        return this.filter(filterFunc).get(0);
+    }
+}
+
+module.exports = PromiseElementList;

tests/lib/PromiseSelector.js

@@ -0,0 +1,20 @@
+const PromiseElement = require("./PromiseElement");
+const PromiseElementList = require("./PromiseElementList");
+
+function find(selector) {
+    return new PromiseElement($(selector));
+}
+
+function findCustom(strategy, selector) {
+    return new PromiseElement(custom$(strategy, selector));
+}
+
+function findMultiple(selector) {
+    return new PromiseElementList($$(selector, 200));
+}
+
+function findMultipleCustom(strategy, selector) {
+    return new PromiseElementList(custom$$(strategy, selector));
+}
+
+module.exports = {one: find, multiple: findMultiple, oneCustom: findCustom, multipleCustom: findMultipleCustom};

tests/lib/functions.js

@@ -0,0 +1,241 @@
+const find = require("../lib/PromiseSelector");
+const $ = find.one;
+const fs = require("fs");
+
+async function login(email, password) {
+    await browser.url(await getBaseUrl() + "?s=login");
+
+    await browser.waitUntil(async () => {
+        let element = $("#main-content");
+        return await element.isDisplayed()
+    });
+    await acceptCookies();
+
+    await browser.pause(1000);
+    await $("input[name=email]").setValue(email);
+    await $("input[name=password]").setValue(password);
+    await $("button=Login").click();
+    await browser.pause(3000);
+}
+
+async function logout() {
+    await $(".footer .icon.home").click();
+    await $("span=Logout").click();
+}
+
+async function pause(delay) {
+    await browser.pause(delay * browser.config.delayFactor);
+}
+
+async function queryDatabase(query) {
+
+    let mysql = browser.config.mysqlConnection;
+    return new Promise(resolve => {
+        mysql.query(query, function (err, result) {
+            if (!err) {
+                resolve(result);
+            } else {
+                console.error(err);
+                resolve(err);
+            }
+        });
+    });
+}
+
+async function setCurrentDate(date) {
+
+    if (!(date instanceof Date)) {
+        date = new Date(2019, 5, 26, 14, 30, 42);
+    }
+
+    const time = date.getTime();
+    await browser.execute((time) => {
+        const OldDate = window["Date"];
+
+        class Date extends OldDate {
+            constructor(...args) {
+                if (arguments.length === 0) {
+                    super(time);
+                } else {
+                    super(...arguments)
+                }
+            }
+        }
+
+        window["Date"] = Date;
+    }, time);
+}
+
+async function setFormValues(values, useSelector) {
+    if (useSelector === undefined) {
+        useSelector = false;
+    }
+
+    let promise = Promise.resolve();
+    Object.keys(values).forEach(selector => {
+        promise = promise.then(async () => {
+            let elem;
+            if (useSelector) {
+                elem = $(selector)
+            } else {
+                elem = $("[name=" + selector + "]");
+            }
+
+            if (await elem.isTag("select")) {
+                await elem.selectByAttribute("value", values[selector]);
+            } else if (await elem.getAttribute("type") === "checkbox" || await elem.getAttribute("type") === "radio") {
+                if (!await elem.isSelected()) {
+                    return elem.click();
+                }
+            } else {
+                return elem.setValue(values[selector]);
+            }
+        });
+    });
+    return promise;
+}
+
+async function acceptCookies() {
+    if (!browser.config.isMobile) {
+        try {
+            await $("#accept-all").click();
+        } catch (e) {
+            console.error(e);
+        }
+    }
+}
+
+async function verifyFormValues(values, useSelector) {
+    if (useSelector === undefined) {
+        useSelector = false;
+    }
+
+    let promise = Promise.resolve();
+    Object.keys(values).forEach(selector => {
+        promise = promise.then(async () => {
+            if (useSelector) {
+                expect(await $(selector).getValue()).toEqual(values[selector]);
+            } else {
+                expect(await $("[name=" + selector + "]").getValue()).toEqual(values[selector]);
+            }
+        });
+    });
+    return promise;
+}
+
+async function addCustomChildSelector() {
+    await browser.addLocatorStategy("selectParent", (parentSelector, childSelector) => {
+        let children = document.querySelectorAll(childSelector);
+        let parents = [];
+        children.forEach(child => {
+            let parent = child.closest(parentSelector);
+            if (parent) {
+                parents.push(parent);
+            }
+        });
+        return parents;
+    });
+}
+
+async function getBaseUrl() {
+    if (browser.config.baseUrl.trim() !== "") {
+        return browser.config.baseUrl;
+    } else {
+        return browser.getUrl();
+    }
+}
+
+async function acceptAlert() {
+    if (browser.config.hasAlertDialogs !== false) {
+        try {
+            await pause(1500);
+            await browser.acceptAlert();
+            await pause(500);
+            // await browser.acceptAlert();
+            // await pause(500);
+        } catch (e) {
+            if (e.message !== "An attempt was made to operate on a modal dialog when one was not open." && !e.message.startsWith("no such alert")) {
+                expect(e.message).toEqual("error message");
+                throw e;
+            }
+        }
+    }
+}
+
+async function compareFiles(originalPath, expectedPath) {
+    let filePromises = [
+        new Promise((res, rej) => fs.readFile(originalPath, (err, data) => err ? rej(err) : res(data))),
+        new Promise((res, rej) => fs.readFile(expectedPath, (err, data) => err ? rej(err) : res(data)))
+    ];
+
+    let fileData = await Promise.all(filePromises);
+    expect(fileData[0]).toEqual(fileData[1]);
+}
+
+async function deactivateTranslationLogging() {
+    await browser.execute(() => {
+        window["shouldConsoleMissingTranslation"] = false;
+    });
+}
+
+async function logErrors() {
+    await browser.execute(() => {
+        window["loggedErrors"] = [];
+        window.addEventListener("error", event => {
+            window["loggedErrors"].push(event.message);
+        }, true);
+        window.onunhandledrejection = (e) => {
+            window["loggedErrors"].push(e.reason);
+        }
+    });
+}
+
+async function getLoggedErrors() {
+    return await browser.execute(() => {
+        return window["loggedErrors"];
+    });
+}
+
+async function asyncExecute(func, ...args){
+    // console.log(func+"");
+
+    let index = await browser.execute((funcString, args) => {
+        let func = eval(funcString);
+        let res = func(...args);
+        if (!window["testValIndex"]){
+            window["testValIndex"] = 0;
+        }
+        window["testValIndex"]++;
+        let index = window["testValIndex"];
+        Promise.resolve(res).then(r => window["test-res-"+index] = r);
+        return index;
+        // return args;
+    }, func+"", args);
+
+    // console.log(index);
+
+    //
+    await pause(1000);
+    return await browser.execute((i) => window["test-res-"+i], index);
+    // return index;
+}
+
+
+module.exports = {
+    login: login,
+    logout: logout,
+    queryDatabase: queryDatabase,
+    setCurrentDate: setCurrentDate,
+    setFormValues: setFormValues,
+    verifyFormValues: verifyFormValues,
+    addCustomChildSelector: addCustomChildSelector,
+    getBaseUrl: getBaseUrl,
+    pause: pause,
+    acceptAlert: acceptAlert,
+    acceptCookies: acceptCookies,
+    compareFiles: compareFiles,
+    deactivateTranslationLogging: deactivateTranslationLogging,
+    logErrors: logErrors,
+    getLoggedErrors: getLoggedErrors,
+    asyncExecute: asyncExecute,
+};