feat: first implementation

add wrapper over wdio commands: "swipe", "touch", "dragAndDrop"

Author: DudaGod

README.md

@@ -12,3 +12,59 @@ You can read more about hermione plugins [here](https://github.com/gemini-testin
 ```bash
 npm install hermione-safari-commands
 ```
+
+## Usage
+
+Plugin has following configuration:
+
+* **enabled** (optional) `Boolean` – enable/disable the plugin, by default plugin is enabled;
+* **browsers** (required) `Object` - the list of browsers to use for wrap commands;
+  * **commands** (required) `Array` - commands which will be wrapped.
+
+Also there is ability to override plugin parameters by CLI options or environment variables
+(see [configparser](https://github.com/gemini-testing/configparser)).
+Use `hermione_safari_commands_` prefix for the environment variables and `--hermione-safari-commands-` for the cli options.
+
+Add plugin to your `hermione` config file:
+
+```js
+module.exports = {
+    // ...
+    system: {
+        plugins: {
+            'hermione-safari-commands': {
+                enabled: true,
+                browsers: {
+                    safari13: {
+                        commands: [
+                            'swipe',
+                            'touch',
+                            'dragAndDrop'
+                        ]
+                    }
+                }
+            }
+        }
+    },
+    //...
+}
+```
+
+### Existing safari commands:
+
+Wrappers over existing commands:
+* **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.
+
+## Testing
+
+Run [mocha](http://mochajs.org) tests:
+```bash
+npm run test-unit
+```
+
+Run [eslint](http://eslint.org) codestyle verification
+```bash
+npm run lint
+```

lib/command-helpers/context-switcher.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const {NATIVE_CONTEXT} = require('../constants');
+
+exports.runInNativeContext = async function(browser, action, testCtx) {
+    if (!testCtx.webViewContext) {
+        const {value: contexts} = await browser.contexts();
+        testCtx.webViewContext = contexts[1];
+    }
+
+    await browser.context(NATIVE_CONTEXT);
+    const result = await action.fn.call(browser, ...[].concat(action.args));
+    await browser.context(testCtx.webViewContext);
+
+    return result;
+};

lib/command-helpers/element-utils.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const {getTestContext} = require('./test-context');
+const {runInNativeContext} = require('./context-switcher');
+const {TOP_TOOLBAR} = require('../native-locators');
+
+exports.getTopToolbarHeight = async (browser) => {
+    const testCtx = getTestContext(browser.executionContext);
+
+    if (!testCtx.topToolbarHeight || testCtx.isVerticalSwipePerformed) {
+        const {height} = await runInNativeContext(browser, {fn: browser.getElementSize, args: TOP_TOOLBAR}, testCtx);
+
+        testCtx.topToolbarHeight = height;
+        testCtx.isVerticalSwipePerformed = false;
+    }
+
+    return testCtx.topToolbarHeight;
+};
+
+exports.getElemCoords = async (browser, selector) => {
+    const [{width, height}, {x, y}] = await Promise.all([browser.getElementSize(selector), browser.getLocation(selector)]);
+    const topToolbarHeight = await exports.getTopToolbarHeight(browser);
+
+    return {width, height, x, y: y + topToolbarHeight};
+};
+
+exports.getElemCenterLocation = async (browser, selector) => {
+    const {width, height, x, y} = await exports.getElemCoords(browser, selector);
+
+    return {
+        x: x + width / 2,
+        y: y + height / 2
+    };
+};

lib/command-helpers/test-context.js

@@ -0,0 +1,7 @@
+'use strict';
+
+exports.getTestContext = (context) => {
+    return context.type === 'hook' && /^"before each"/.test(context.title)
+        ? context.ctx.currentTest
+        : context;
+};

lib/commands/dragAndDrop.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const {getElemCenterLocation} = require('../command-helpers/element-utils');
+const {WAIT_BETWEEN_ACTIONS_IN_MS} = require('../constants');
+
+module.exports = (browser) => {
+    browser.addCommand('dragAndDrop', async (srcSelector, destSelector) => {
+        const {x: srcX, y: srcY} = await getElemCenterLocation(browser, srcSelector);
+        const {x: destX, y: destY} = await getElemCenterLocation(browser, destSelector);
+
+        await browser.touchAction([
+            {action: 'tap', x: srcX, y: srcY},
+            {action: 'wait', ms: WAIT_BETWEEN_ACTIONS_IN_MS},
+            {action: 'moveTo', x: destX, y: destY},
+            {action: 'wait', ms: WAIT_BETWEEN_ACTIONS_IN_MS},
+            'release'
+        ]);
+    }, true);
+};

lib/commands/index.js

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

lib/commands/swipe.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const _ = require('lodash');
+const {getTestContext} = require('../command-helpers/test-context');
+const {getElemCenterLocation} = require('../command-helpers/element-utils');
+const {WAIT_BETWEEN_ACTIONS_IN_MS} = require('../constants');
+
+module.exports = (browser) => {
+    browser.addCommand('swipe', async (selector, xOffset = 0, yOffset = 0, speed = WAIT_BETWEEN_ACTIONS_IN_MS) => {
+        if (typeof selector === 'number') {
+            throw new TypeError(
+                'Method "swipe" does not implement the functionality "swipe(xspeed, yspeed)"' +
+                ' try to use "swipe(selector, xOffset, yOffset, speed)"'
+            );
+        }
+
+        if (!_.isNumber(xOffset) || !_.isNumber(yOffset) || !_.isNumber(speed)) {
+            throw new TypeError(
+                'Arguments "xOffset", "yOffset" and "speed" must be a numbers'
+            );
+        }
+
+        const {x, y} = await getElemCenterLocation(browser, selector);
+
+        await browser.touchAction([
+            {action: 'press', x, y},
+            {action: 'wait', ms: speed <= 0 ? WAIT_BETWEEN_ACTIONS_IN_MS : speed},
+            {action: 'moveTo', x: x + xOffset, y: y + yOffset},
+            'release'
+        ]);
+
+        const testCtx = getTestContext(browser.executionContext);
+        testCtx.isVerticalSwipePerformed = Boolean(yOffset);
+    }, true);
+};

lib/commands/touch.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const {getElemCenterLocation} = require('../command-helpers/element-utils');
+
+module.exports = (browser) => {
+    browser.addCommand('touch', async (selector) => {
+        const {x, y} = await getElemCenterLocation(browser, selector);
+
+        await browser.touchAction([
+            {action: 'tap', x, y}
+        ]);
+    }, true);
+};

lib/config/defaults.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+    enabled: true,
+    commands: null
+};

lib/config/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const _ = require('lodash');
+const configParser = require('gemini-configparser');
+const defaults = require('./defaults');
+
+const thr = (str) => {
+    throw new TypeError(str);
+};
+
+const {root, map, section, option} = configParser;
+
+const ENV_PREFIX = 'hermione_safari_commands_';
+const CLI_PREFIX = '--hermione-safari-commands-';
+
+const assertType = (name, validationFn, type) => {
+    return (v) => !validationFn(v) && thr(`"${name}" option must be ${type}, but got ${typeof v}`);
+};
+
+const assertBoolean = (name) => assertType(name, _.isBoolean, 'boolean');
+const assertArrayOfStrings = (value, name) => {
+    if (!(_.isArray(value) && value.every(_.isString))) {
+        throw new Error(`"${name}" must be an array of strings but got ${JSON.stringify(value)}`);
+    }
+};
+
+const getParser = () => {
+    return root(section({
+        enabled: option({
+            defaultValue: defaults.enabled,
+            parseEnv: JSON.parse,
+            parseCli: JSON.parse,
+            validate: assertBoolean('enabled')
+        }),
+        browsers: map(section({
+            commands: option({
+                defaultValue: defaults.commands,
+                parseEnv: JSON.parse,
+                parseCli: JSON.parse,
+                validate: (value) => {
+                    _.isNull(value)
+                        ? thr('Each browser must have "commands" option')
+                        : assertArrayOfStrings(value, 'commands');
+                }
+            })
+        }))
+    }), {envPrefix: ENV_PREFIX, cliPrefix: CLI_PREFIX});
+};
+
+module.exports = (options) => {
+    const {env, argv} = process;
+
+    return getParser()({options, env, argv});
+};