Merge pull request #4 from gemini-testing/FEI-18599.wait_page_open

feat: add wrapper over "url" in order to wait until the page is completely open

Author: DudaGod

.eslintrc.js

@@ -1,4 +1,5 @@
 module.exports = {
     extends: 'gemini-testing',
+    env: {browser: true},
     root: true
 };

README.md

@@ -37,6 +37,7 @@ module.exports = {
                 browsers: {
                     safari13: {
                         commands: [
+                            'url',
                             'swipe',
                             'touch',
                             'dragAndDrop'
@@ -53,6 +54,7 @@ module.exports = {
 ### Existing safari commands:
 
 Wrappers over existing commands:
+* **url** - wrapper over wdio "url" in order to wait until the page is completely open (used timeout from [`hermione.pageLoadTimeout`](https://github.com/gemini-testing/hermione#pageloadtimeout) or `30000` ms). In [appium-xcuitest-driver](https://github.com/appium/appium-xcuitest-driver) page is open with using the `xcrun` utility - `xcrun simctl openurl` which just tells the simulator to open the page and does not wait anything;
 * **swipe** - replaces wdio "swipe" in order to perform swipe by coordinates in native context;
 * **touch** - replaces wdio "touch" in order to perform touch click by coordinates in native context;
 * **dragAndDrop** - replaces wdio "dragAndDrop" in order to perform drag and drop elements by coordinates in native context.

lib/commands/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 module.exports = {
+    url: require('./url'),
     swipe: require('./swipe'),
     touch: require('./touch'),
     dragAndDrop: require('./dragAndDrop')

lib/commands/url.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const {PAGE_LOAD_TIMEOUT} = require('../constants');
+
+module.exports = (browser, config) => {
+    const baseUrlFn = browser.url;
+    const pageLoadTimeout = config.pageLoadTimeout || PAGE_LOAD_TIMEOUT;
+
+    browser.addCommand('url', async (uri) => {
+        if (!uri) {
+            return baseUrlFn.call(this, uri);
+        }
+
+        // in order to clear the page from previous search result
+        await browser.execute(() => document.body.remove());
+        await baseUrlFn.call(this, uri);
+
+        await browser.waitUntil(
+            () => browser.isVisible('body'),
+            pageLoadTimeout,
+            `The page did not load in ${pageLoadTimeout} ms`
+        );
+    }, true);
+};

lib/constants.js

@@ -2,5 +2,6 @@
 
 module.exports = {
     NATIVE_CONTEXT: 'NATIVE_APP',
-    WAIT_BETWEEN_ACTIONS_IN_MS: 100
+    WAIT_BETWEEN_ACTIONS_IN_MS: 100,
+    PAGE_LOAD_TIMEOUT: 30000
 };

test/lib/commands/url.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const _ = require('lodash');
+const wrapUrlCommand = require('lib/commands/url');
+const {PAGE_LOAD_TIMEOUT} = require('lib/constants');
+const {mkBrowser_} = require('../../utils');
+
+describe('"url" command', () => {
+    let browser, initialDocument;
+
+    const wrapUrlCommand_ = (browser, opts = {}) => {
+        opts = _.defaultsDeep(opts, {
+            pageLoadTimeout: null
+        });
+
+        wrapUrlCommand(browser, opts);
+    };
+
+    beforeEach(() => {
+        browser = mkBrowser_();
+        initialDocument = global.document;
+        global.document = {body: {remove: sinon.stub()}};
+    });
+
+    afterEach(() => {
+        sinon.restore();
+        global.document = initialDocument;
+    });
+
+    it('should wrap "url" command', () => {
+        wrapUrlCommand_(browser);
+
+        assert.calledOnceWith(browser.addCommand, 'url', sinon.match.func, true);
+    });
+
+    it('should call base "url" command if url is not passed', async () => {
+        const baseUrlFn = browser.url;
+        wrapUrlCommand_(browser);
+
+        await browser.url();
+
+        assert.calledOnce(baseUrlFn);
+        assert.notCalled(browser.execute);
+    });
+
+    it('should remove body element from the page before make request', async () => {
+        const baseUrlFn = browser.url;
+        wrapUrlCommand_(browser);
+
+        browser.execute.callsFake(() => {
+            browser.execute.firstCall.args[0]();
+        });
+
+        await browser.url('/?text=test');
+
+        assert.calledOnceWith(browser.execute, sinon.match.func);
+        assert.calledOnce(global.document.body.remove);
+        assert.callOrder(browser.execute, baseUrlFn);
+    });
+
+    it('should wait until request will be completed', async () => {
+        wrapUrlCommand_(browser, {pageLoadTimeout: 100500});
+
+        browser.waitUntil.callsFake(() => {
+            browser.waitUntil.firstCall.args[0]();
+        });
+
+        await browser.url('/?text=test');
+
+        assert.calledOnceWith(
+            browser.waitUntil,
+            sinon.match.func,
+            100500,
+            'The page did not load in 100500 ms'
+        );
+        assert.calledOnceWith(browser.isVisible, 'body');
+    });
+
+    it('should use default "pageLoadTimeout" if it does not specified in browser config', async () => {
+        wrapUrlCommand_(browser, {pageLoadTimeout: null});
+
+        await browser.url('/?text=test');
+
+        assert.calledOnceWith(
+            browser.waitUntil,
+            sinon.match.func,
+            PAGE_LOAD_TIMEOUT,
+            `The page did not load in ${PAGE_LOAD_TIMEOUT} ms`
+        );
+    });
+});

test/utils.js

@@ -20,11 +20,15 @@ exports.mkBrowser_ = () => {
     const session = Promise.resolve();
 
     session.executionContext = {};
+    session.url = sinon.stub().named('url').resolves();
     session.touchAction = sinon.stub().named('touchAction').resolves();
     session.getElementSize = sinon.stub().named('getElementSize').resolves({});
     session.getLocation = sinon.stub().named('getLocation').resolves({});
     session.context = sinon.stub().named('context').resolves({value: 'default-ctx'});
     session.contexts = sinon.stub().named('contexts').resolves({value: ['default-ctx-1', 'default-ctx-2']});
+    session.execute = sinon.stub().named('execute').resolves();
+    session.waitUntil = sinon.stub().named('waitUntil').resolves();
+    session.isVisible = sinon.stub().named('isVisible').resolves();
 
     session.addCommand = sinon.stub().callsFake((name, command) => {
         session[name] = command;