@qavajs/cypress 0.1.0

package/lib/mouseActions.js

@@ -0,0 +1,58 @@
+import { When } from '@qavajs/cypress-runner-adapter';
+import { parseCoords } from './utils';
+
+/**
+ * Press mouse key
+ * @param {string} button - button to press (left, right, middle)
+ * @example When I press left mouse button
+ */
+When('I press {mouseButton} mouse button on {string}', function (buttons, coords) {
+    const [x, y] = parseCoords(this.value(coords));
+    cy.get('body')
+        .trigger('mouseenter', x, y)
+        .trigger('mouseover', x, y)
+        .trigger('mousemove', x, y)
+        .trigger('mousedown', x, y, { buttons });
+});
+
+/**
+ * Release mouse key
+ * @param {string} button - button to release (left, right, middle)
+ * @example When I release left mouse button
+ */
+When('I release {mouseButton} mouse button on {string}', function (button, coords) {
+    const [x, y] = parseCoords(this.value(coords));
+    cy.get('body')
+        .trigger('mouseenter', x, y)
+        .trigger('mouseover', x, y)
+        .trigger('mousemove', x, y)
+        .trigger('mouseup', x, y, { button });
+});
+
+/**
+ * Move mouse to coordinates
+ * @param {string} coords - x, y coordinates to move
+ * @example When I move mouse to '10, 15'
+ */
+When('I move mouse to {string}', function (coords){
+    const [x, y] = parseCoords(this.value(coords));
+    cy.get('body')
+        .trigger('mouseenter', x, y)
+        .trigger('mouseover', x, y)
+        .trigger('mousemove', x, y);
+});
+
+/**
+ * Scroll mouse wheel by x, y offset
+ * @param {string} coords - x, y offset to scroll
+ * @example When I scroll mouse wheel by '0, 15'
+ */
+When('I scroll mouse wheel by {string} on {string}', function (offset, coords) {
+    const [x, y] = parseCoords(this.value(coords));
+    const [deltaX, deltaY] = parseCoords(this.value(offset));
+    cy.get('body')
+        .trigger('mouseenter', x, y)
+        .trigger('mouseover', x, y)
+        .trigger('mousemove', x, y)
+        .trigger('wheel', x, y, { deltaX, deltaY });
+});

package/lib/setup.js

@@ -0,0 +1,46 @@
+import {po} from '@qavajs/po-cypress';
+import App from '../test-e2e/page_object';
+import memory from '@qavajs/memory';
+import Memory from '../test-e2e/memory';
+import { setWorldConstructor } from '@qavajs/cypress-runner-adapter';
+
+export class QavajsCypressWorld {
+
+    constructor() {
+        po.init(cy, { logger: { log: (value) => {
+                    const [displayName, message] = value.split(/\s->\s/);
+                    Cypress.log({
+                        displayName,
+                        message
+                    })
+                }
+            }
+        });
+        po.register(window.pageObject);
+        memory.register(window.memory);
+        memory.setLogger({ log: (value) => {
+                const [displayName, message] = value.split(/\s->\s/);
+                Cypress.log({
+                    displayName,
+                    message
+                })
+            }
+        });
+        this.po = po;
+        this.memory = memory;
+    }
+
+    element(alias) {
+        return this.po.getElement(this.memory.getValue(alias));
+    }
+
+    value(expression) {
+        return this.memory.getValue(expression);
+    }
+
+    setValue(key, value) {
+        this.memory.setValue(key, value);
+    }
+}
+
+setWorldConstructor(QavajsCypressWorld);

package/lib/storage.js

@@ -0,0 +1,59 @@
+import { When } from '@qavajs/cypress-runner-adapter';
+
+/**
+ * Set cookie
+ * @param {string} cookie - cookie name
+ * @param {string} value - value to set
+ * @example I set 'userID' cookie 'user1'
+ * @example I set 'userID' cookie '$userIdCookie'
+ */
+When('I set {string} cookie as {string}', function (cookie, value) {
+    const cookieValue = this.value(value);
+    const cookieObject = typeof cookieValue === 'object' ? cookieValue : { value: cookieValue };
+    cy.setCookie(cookie, cookieObject.value, cookieObject);
+});
+
+/**
+ * Save cookie value to memory
+ * @param {string} cookie - cookie name
+ * @param {string} key - memory key
+ * @example I save value of 'auth' cookie as 'authCookie'
+ */
+When('I save value of {string} cookie as {string}', function (cookie, key) {
+    const cookieName = this.value(cookie);
+    cy.getCookie(cookieName).then((cookie) => {
+        this.setValue(key, cookie);
+    });
+});
+
+
+/**
+ * Set value of local/session storage
+ * @param {string} storageKey - local/session storage key to set value
+ * @param {string} storageType - storage type (local or session)
+ * @param {string} value - value to set
+ * @example I set 'username' local storage value as 'user1'
+ * @example I set '$sessionStorageKey' session storage value as '$sessionStorageValue'
+ */
+When('I set {string} {word} storage value as {string}', function (storageKey, storageType, value) {
+    const resolvedValue = this.value(value);
+    cy.window().then((win) => {
+        console.log(win)
+        win[storageType + 'Storage'].setItem(storageKey, resolvedValue);
+    });
+});
+
+/**
+ * Save value of local/session storage to memory
+ * @param {string} storageKey - local/session storage key to set value
+ * @param {string} storageType - storage type (local or session)
+ * @param {string} key - memory key
+ * @example I save value of 'username' local storage as 'localStorageValue'
+ * @example I save value of '$sessionStorageKey' session storage value as 'sessionStorageValue'
+ */
+When('I save value of {string} {word} storage as {string}', function (storageKey, storageType, key) {
+    const resolvedStorageKey = this.value(storageKey);
+    cy.window().then((win) => {
+        this.setValue(key, win[storageType + 'Storage'].getItem(resolvedStorageKey));
+    });
+});

package/lib/types.js

@@ -0,0 +1,32 @@
+import { defineParameterType } from '@qavajs/cypress-runner-adapter';
+
+defineParameterType({
+    name: 'validation',
+    regexp: /((?:is |do |does |to )?(not |to not )?(?:to )?(?:be )?(equal|strictly equal|deeply equal|have member|match|contain|above|below|greater than|less than|have type)(?:s|es)?)/,
+    useForSnippets: false
+});
+
+defineParameterType({
+    name: 'conditionExpect',
+    regexp: /((not )?to (?:be )?(present|clickable|visible|invisible|enabled|disabled|in viewport))/,
+    useForSnippets: false
+});
+
+defineParameterType({
+    name: 'poType',
+    regexp: /(element|collection)/,
+    useForSnippets: false
+});
+
+defineParameterType({
+    name: 'mouseButton',
+    regexp: /(left|right|middle)/,
+    transformer: button => ({ left: 1, right: 2, middle: 4 }[button]),
+    useForSnippets: false
+});
+
+defineParameterType({
+    name: 'browserButton',
+    regexp: /(back|forward)/,
+    useForSnippets: false
+});

package/lib/utils.js

@@ -0,0 +1,49 @@
+/**
+ * Parse 'x, y' string to coordinates array
+ * @param {string} coords - 'x, y' string
+ * @return {number[]} - coords array
+ */
+export function parseCoords(coords) {
+    return coords.split(/\s?,\s?/).map(c => parseFloat(c ?? 0))
+}
+
+export function equalOrIncludes(value, argument) {
+    return Array.isArray(value)
+        ? value.includes(argument)
+        : value === argument;
+}
+
+export async function throwTimeoutError(fn, message) {
+    try {
+        await fn()
+    } catch (err) {
+        if (err.message.includes('exceeded while waiting on the predicate')) {
+            throw new Error(message);
+        }
+        throw err
+    }
+}
+
+/**
+ * Transform key-value data table to JS object
+ * @param ctx
+ * @param dataTable
+ * @return {Object}
+ */
+export async function dataTable2Object(ctx, dataTable) {
+    const obj = {};
+    for (const [key, value] of dataTable.raw()) {
+        obj[key] = await ctx.value(value);
+    }
+    return obj;
+}
+
+/**
+ * Transform key-value data table to array
+ * @param ctx
+ * @param dataTable
+ * @return {any[]}
+ */
+export function dataTable2Array(ctx, dataTable) {
+    return dataTable.raw().map(([value]) => ctx.value(value));
+}

package/lib/validation.js

@@ -0,0 +1,259 @@
+import { Then } from '@qavajs/cypress-runner-adapter';
+import { getValidation } from './valueExpect';
+import { getConditionExpect } from './conditionExpect';
+
+/**
+ * Verify element condition
+ * @param {string} alias - element to wait condition
+ * @param {string} condition - wait condition
+ * @example I expect 'Header' to be visible
+ * @example I expect 'Loading' not to be present
+ * @example I expect 'Search Bar > Submit Button' to be clickable
+ */
+Then('I expect {string} {conditionExpect}', function (alias, condition) {
+    const chainer = getConditionExpect(condition);
+    const element = this.element(alias);
+    element.should(chainer)
+});
+
+/**
+ * Verify that text of element satisfies condition
+ * @param {string} alias - element to get text
+ * @param {string} validationType - validation
+ * @param {string} value - expected result
+ * @example I expect text of '#1 of Search Results' equals to 'google'
+ * @example I expect text of '#2 of Search Results' does not contain 'yandex'
+ */
+Then(
+    'I expect text of {string} {validation} {string}',
+    function (alias, validationType, value) {
+        const expectedValue = this.value(value);
+        const element = this.element(alias);
+        const validation = getValidation(validationType);
+        element.should((e) => {
+            validation(e.text(), expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that value of element satisfies condition
+ * @param {string} alias - element to get text
+ * @param {string} validationType - validation
+ * @param {string} value - expected result
+ * @example I expect value of '#1 of Search Results' equals to 'google'
+ * @example I expect value of '#2 of Search Results' does not contain 'yandex'
+ */
+Then(
+    'I expect value of {string} {validation} {string}',
+    function (alias, validationType, value) {
+        const expectedValue = this.value(value);
+        const element = this.element(alias);
+        const validation = getValidation(validationType);
+        element.should((e) => {
+            validation(e.val(), expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that property of element satisfies condition
+ * @param {string} property - element to verify
+ * @param {string} alias - element to verify
+ * @param {string} validationType - validation
+ * @param {string} value - expected value
+ * @example I expect 'value' property of 'Search Input' to be equal 'text'
+ * @example I expect 'innerHTML' property of 'Label' to contain '<b>'
+ */
+Then(
+    'I expect {string} property of {string} {validation} {string}',
+    function (property, alias, validationType, value) {
+        const propertyName = this.value(property);
+        const expectedValue = this.value(value);
+        const element = this.element(alias);
+        const validation = getValidation(validationType);
+        element.should((e) => {
+            validation(e.prop(propertyName), expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that attribute of element satisfies condition
+ * @param {string} attribute - element to verify
+ * @param {string} alias - element to verify
+ * @param {string} validationType - validation
+ * @param {string} value - expected value
+ * @example I expect 'href' attribute of 'Home Link' to contain '/home'
+ */
+Then(
+    'I expect {string} attribute of {string} {validation} {string}',
+    function (attribute, alias, validationType, value) {
+        const attributeName = this.value(attribute);
+        const expectedValue = this.value(value);
+        const element = this.element(alias);
+        const validation = getValidation(validationType);
+        element.should((e) => {
+            validation(e.attr(attributeName), expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that current url satisfies condition
+ * @param {string} validationType - validation
+ * @param {string} expected - expected value
+ * @example I expect current url contains 'wikipedia'
+ * @example I expect current url equals 'https://wikipedia.org'
+ */
+Then(
+    'I expect current url {validation} {string}',
+    function (validationType, expected) {
+        const validation = getValidation(validationType);
+        const expectedUrl = this.value(expected);
+        cy.url().should((actualUrl) => {
+            validation(actualUrl, expectedUrl);
+        });
+    }
+);
+
+/**
+ * Verify that number of element in collection satisfies condition
+ * @param {string} alias - collection to verify
+ * @param {string} validationType - validation
+ * @param {string} value - expected value
+ * @example I expect number of elements in 'Search Results' collection to be equal '50'
+ * @example I expect number of elements in 'Search Results' collection to be above '49'
+ * @example I expect number of elements in 'Search Results' collection to be below '51'
+ */
+Then(
+    'I expect number of elements in {string} collection {validation} {string}',
+    function (alias, validationType, value) {
+        const expectedValue = this.value(value);
+        const collection = this.element(alias);
+        const validation = getValidation(validationType);
+        collection.should((collection) => {
+            validation(collection.length, expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that page title satisfies condition
+ * @param {string} validationType - validation
+ * @param {string} expected - expected value
+ * @example I expect page title equals 'Wikipedia'
+ */
+Then(
+    'I expect page title {validation} {string}',
+    function (validationType, expected) {
+        const validation = getValidation(validationType);
+        const expectedTitle = this.value(expected);
+        cy.title().should((actualTitle) => {
+            validation(actualTitle, expectedTitle);
+        });
+    }
+);
+
+/**
+ * Verify that all texts in collection satisfy condition
+ * @param {string} alias - collection to get texts
+ * @param {string} validationType - validation
+ * @param {string} value - expected result
+ * @example I expect text of every element in 'Search Results' collection equals to 'google'
+ * @example I expect text of every element in 'Search Results' collection does not contain 'yandex'
+ */
+Then(
+    'I expect text of every element in {string} collection {validation} {string}',
+    function (alias, validationType, value) {
+        const expectedValue = this.value(value);
+        const collection = this.element(alias);
+        const validation = getValidation(validationType);
+        collection.each((element) => {
+            validation(element.text(), expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that all particular attributes in collection satisfy condition
+ * @param {string} alias - collection to get attrs
+ * @param {string} validationType - validation
+ * @param {string} value - expected result
+ * @example I expect 'href' attribute of every element in 'Search Results' collection to contain 'google'
+ */
+Then(
+    'I expect {string} attribute of every element in {string} collection {validation} {string}',
+    function (attribute, alias, validationType, value) {
+        const expectedValue = this.value(value);
+        const collection = this.element(alias);
+        const validation = getValidation(validationType);
+        collection.each((element) => {
+            validation(element.attr(attribute), expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that all particular properties in collection satisfy condition
+ * @param {string} alias - collection to get props
+ * @param {string} validationType - validation
+ * @param {string} value - expected result
+ * @example I expect 'href' property of every element in 'Search Results' collection to contain 'google'
+ */
+Then(
+    'I expect {string} property of every element in {string} collection {validation} {string}',
+    function (property, alias, validationType, value) {
+        const expectedValue = this.value(value);
+        const collection = this.element(alias);
+        const validation = getValidation(validationType);
+        collection.each((element) => {
+            validation(element.prop(property), expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that css property of element satisfies condition
+ * @param {string} property - element to verify
+ * @param {string} alias - element to verify
+ * @param {string} validationType - validation
+ * @param {string} value - expected value
+ * @example I expect 'color' css property of 'Search Input' to be equal 'rgb(42, 42, 42)'
+ * @example I expect 'font-family' css property of 'Label' to contain 'Fira'
+ */
+Then(
+    'I expect {string} css property of {string} {validation} {string}',
+    function (property, alias, validationType, value) {
+        const propertyName = this.value(property);
+        const expectedValue = this.value(value);
+        const element = this.element(alias);
+        const validation = getValidation(validationType);
+        element.should((e) => {
+            validation(e.css(propertyName), expectedValue);
+        });
+    }
+);
+
+/**
+ * Verify that text of an alert meets expectation
+ * @param {string} validationType - validation
+ * @param {string} value - expected text value
+ * @example I expect text of alert does not contain 'coffee'
+ */
+Then(
+    'I expect text of alert {validation} {string}',
+    function (validationType, expectedValue) {
+        const validation = getValidation(validationType);
+        const alertHandler = new Cypress.Promise((resolve, reject) => {
+            cy.on('window:alert', (alertText)=> {
+                resolve(alertText)
+            });
+            cy.on('window:confirm', (alertText)=> {
+                resolve(alertText)
+            });
+        });
+        return alertHandler.then(alertText => { validation(alertText, expectedValue) })
+    }
+);
+

package/lib/valueExpect.js

@@ -0,0 +1,84 @@
+chai.Assertion.addMethod('notStrictEqual', function (ER) {
+    const obj = this._obj;
+
+    this.assert(
+        obj == ER,
+        'expected #{this} to equal #{exp}',
+        'expected #{this} to not equal #{exp}',
+        ER,
+        obj
+    );
+});
+
+export const validations = {
+    EQUAL: 'equal',
+    DEEPLY_EQUAL: 'deeply equal',
+    STRICTLY_EQUAL: 'strictly equal',
+    HAVE_MEMBERS: 'have member',
+    MATCH: 'match',
+    CONTAIN: 'contain',
+    ABOVE: 'above',
+    BELOW: 'below',
+    GREATER: 'greater than',
+    LESS: 'less than',
+    HAVE_TYPE: 'have type',
+    INCLUDE_MEMBERS: 'include member',
+    HAVE_PROPERTY: 'have property'
+};
+
+const isClause = '(?:is |do |does |to )?';
+const notClause = '(?<reverse>not |to not )?';
+const toBeClause = '(?:to )?(?:be )?';
+const validationClause = `(?:(?<validation>${Object.values(validations).join('|')})(?:s|es)?)`;
+
+export const validationExtractRegexp = new RegExp(`^${isClause}${notClause}${toBeClause}${validationClause}$`);
+export const validationRegexp = new RegExp(`(${isClause}${notClause}${toBeClause}${validationClause})`);
+
+const aboveFn = (expectClause, ER) => expectClause.above(toNumber(ER));
+const belowFn = (expectClause, ER) => expectClause.below(toNumber(ER));
+const validationFns = {
+    [validations.EQUAL]: (expectClause, ER) => expectClause.notStrictEqual(ER),
+    [validations.STRICTLY_EQUAL]: (expectClause, ER) => expectClause.equal(ER),
+    [validations.DEEPLY_EQUAL]: (expectClause, ER) => expectClause.eql(ER),
+    [validations.HAVE_MEMBERS]: (expectClause, ER) => expectClause.have.members(ER),
+    [validations.MATCH]: (expectClause, ER) => expectClause.match(toRegexp(ER)),
+    [validations.CONTAIN]: (expectClause, ER) => expectClause.contain(ER),
+    [validations.ABOVE]: aboveFn,
+    [validations.BELOW]: belowFn,
+    [validations.GREATER]: aboveFn,
+    [validations.LESS]: belowFn,
+    [validations.HAVE_TYPE]: (expectClause, ER) => expectClause.a(ER),
+    [validations.INCLUDE_MEMBERS]: (expectClause, ER) => expectClause.include.members(ER),
+    [validations.HAVE_PROPERTY]: (expectClause, ER) => expectClause.have.property(ER),
+};
+
+/**
+ * Basic verification function
+ * @param {Object} object with all needed data for validation
+ */
+export function verify({ AR, ER, validation, reverse }) {
+    const expectClause = reverse ? expect(AR).to.not : expect(AR).to;
+    const validate = validationFns[validation];
+    validate(expectClause, ER);
+}
+
+export function getValidation(validationType) {
+    const match = validationExtractRegexp.exec(validationType);
+    if (!match) throw new Error(`validation '${validationType}' is not supported`);
+    const { reverse, validation } = match.groups;
+    return function (AR, ER) {
+        verify({ AR, ER, validation, reverse: Boolean(reverse) });
+    };
+}
+
+function toNumber(n) {
+    const parsedNumber = parseFloat(n);
+    if (Number.isNaN(parsedNumber)) {
+        throw new Error(`${n} is not a number`);
+    }
+    return parsedNumber
+}
+
+function toRegexp(r) {
+    return r instanceof RegExp ? r : RegExp(r)
+}