@jahia/cypress 1.0.8 → 1.0.9

package/README.md

@@ -14,6 +14,8 @@
 
 [`.logout()`](./src/support/logout.md)
 
+[`.repeatUntil()`](./src/support/repeatUntil.md)
+
 ## Page / component objects
 
 In Page Object Model, a set of object is provided to handle known and reused web elements. 

package/dist/support/index.d.ts

@@ -2,3 +2,4 @@ export * from './apollo';
 export * from './provisioning';
 export * from './login';
 export * from './logout';
+export * from './repeatUntil';

package/dist/support/index.js

@@ -14,3 +14,4 @@ __exportStar(require("./apollo"), exports);
 __exportStar(require("./provisioning"), exports);
 __exportStar(require("./login"), exports);
 __exportStar(require("./logout"), exports);
+__exportStar(require("./repeatUntil"), exports);

package/dist/support/registerSupport.js

@@ -10,6 +10,7 @@ var login_1 = require("./login");
 var logout_1 = require("./logout");
 var installLogsCollector_1 = __importDefault(require("cypress-terminal-report/src/installLogsCollector"));
 var fixture_1 = require("./fixture");
+var repeatUntil_1 = require("./repeatUntil");
 var registerSupport = function () {
     Cypress.Commands.add('apolloClient', apollo_1.apolloClient);
     Cypress.Commands.add('apollo', { prevSubject: 'optional' }, apollo_1.apollo);
@@ -17,6 +18,7 @@ var registerSupport = function () {
     Cypress.Commands.add('executeGroovy', provisioning_1.executeGroovy);
     Cypress.Commands.add('login', login_1.login);
     Cypress.Commands.add('logout', logout_1.logout);
+    Cypress.Commands.add('repeatUntil', repeatUntil_1.repeatUntil);
     Cypress.Commands.overwrite('fixture', fixture_1.fixture);
     installLogsCollector_1["default"]();
 };

package/dist/support/reloadUntil.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="cypress" />
+declare type ReloadUntilOptions = {
+    attempts: number;
+    reloadCallback: () => void;
+    delay: number;
+};
+declare global {
+    namespace Cypress {
+        interface Chainable<Subject> {
+            reloadUntil(selector: string, options: Partial<ReloadUntilOptions>): Chainable<Cypress.Response<any>>;
+        }
+    }
+}
+export declare const reloadUntil: (selector: string, options: Partial<ReloadUntilOptions>) => void;
+export {};

package/dist/support/reloadUntil.js

@@ -0,0 +1,50 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.reloadUntil = void 0;
+var defaultOptions = {
+    attempts: 10,
+    reloadCallback: function () { return cy.reload({ log: false }); },
+    delay: 1000
+};
+var reloadUntil = function (selector, options) {
+    options = __assign(__assign({}, defaultOptions), options);
+    var log = Cypress.log({
+        name: 'reloadUntil',
+        message: "Reload until " + selector + ", remaining attempts : " + options.attempts,
+        consoleProps: function () {
+            return {
+                attempts: options.attempts
+            };
+        }
+    });
+    var items = Cypress.$(selector);
+    if (items.length) {
+        log.set({ $el: items });
+        return;
+    }
+    if (options.attempts > 1) {
+        log.end();
+        options.reloadCallback();
+        // eslint-disable-next-line cypress/no-unnecessary-waiting
+        cy.wait(options.delay);
+        cy.reloadUntil(selector, __assign(__assign({}, options), { attempts: options.attempts - 1 }));
+    }
+    else {
+        var err = Error('Items not found.');
+        log.error(err);
+        throw err;
+    }
+};
+exports.reloadUntil = reloadUntil;

package/dist/support/repeatUntil.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="cypress" />
+declare type RepeatUntilOptions = {
+    attempts: number;
+    callback: () => void;
+    delay: number;
+};
+declare global {
+    namespace Cypress {
+        interface Chainable<Subject> {
+            repeatUntil(selector: string, options?: Partial<RepeatUntilOptions>): Chainable<JQuery>;
+        }
+    }
+}
+export declare const repeatUntil: (selector: string, options?: Partial<RepeatUntilOptions>) => void;
+export {};

package/dist/support/repeatUntil.js

@@ -0,0 +1,52 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.repeatUntil = void 0;
+var defaultOptions = {
+    attempts: 10,
+    callback: function () { return cy.reload({ log: false }); },
+    delay: 1000
+};
+var repeatUntil = function (selector, options) {
+    if (options === void 0) { options = {}; }
+    options = __assign(__assign({}, defaultOptions), options);
+    var log = Cypress.log({
+        name: 'repeatUntil',
+        message: "Reload until " + selector + ", remaining attempts : " + options.attempts,
+        consoleProps: function () {
+            return {
+                attempts: options.attempts
+            };
+        }
+    });
+    var items = Cypress.$(selector);
+    if (items.length) {
+        log.set({ $el: items });
+        cy.wrap(items, { log: false });
+        return;
+    }
+    if (options.attempts > 1) {
+        log.end();
+        options.callback();
+        // eslint-disable-next-line cypress/no-unnecessary-waiting
+        cy.wait(options.delay);
+        cy.repeatUntil(selector, __assign(__assign({}, options), { attempts: options.attempts - 1 }));
+    }
+    else {
+        var err = Error('Items not found.');
+        log.error(err);
+        throw err;
+    }
+};
+exports.repeatUntil = repeatUntil;

package/dist/support/waitUntil.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="cypress" />
+declare type ReloadUntilOptions = {
+    attempts: number;
+    reloadCallback: () => void;
+    delay: number;
+};
+declare global {
+    namespace Cypress {
+        interface Chainable<Subject> {
+            reloadUntil(selector: string, options: Partial<ReloadUntilOptions>): Chainable<Cypress.Response<any>>;
+        }
+    }
+}
+export declare const reloadUntil: (selector: string, options: Partial<ReloadUntilOptions>) => void;
+export {};

package/dist/support/waitUntil.js

@@ -0,0 +1,44 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.reloadUntil = void 0;
+var defaultOptions = {
+    attempts: 10,
+    reloadCallback: function () { return cy.reload({ log: false }); },
+    delay: 1000
+};
+var reloadUntil = function (selector, options) {
+    options = __assign(__assign({}, defaultOptions), options);
+    var log = Cypress.log({
+        name: 'reloadUntil',
+        message: "Reload until " + selector + ", remaining attempts : " + options.attempts
+    });
+    var $items = Cypress.$(selector);
+    if ($items.length) {
+        return;
+    }
+    if (options.attempts > 1) {
+        log.finish();
+        options.reloadCallback();
+        // eslint-disable-next-line cypress/no-unnecessary-waiting
+        cy.wait(1000, { log: false });
+        cy.reloadUntil(selector, __assign(__assign({}, options), { attempts: options.attempts - 1 }));
+    }
+    else {
+        var err = Error('Items not found.');
+        log.error(err);
+        throw err;
+    }
+};
+exports.reloadUntil = reloadUntil;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jahia/cypress",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "scripts": {
     "build": "tsc",
     "lint": "eslint src -c .eslintrc.json --ext .ts"

package/src/support/index.ts

@@ -2,3 +2,4 @@ export * from './apollo'
 export * from './provisioning'
 export * from './login'
 export * from './logout'
+export * from './repeatUntil'

package/src/support/registerSupport.ts

@@ -4,6 +4,7 @@ import {login} from "./login"
 import {logout} from "./logout"
 import installLogsCollector from 'cypress-terminal-report/src/installLogsCollector'
 import {fixture} from "./fixture";
+import {repeatUntil} from "./repeatUntil";
 
 export const registerSupport = (): void => {
     Cypress.Commands.add('apolloClient', apolloClient)
@@ -14,6 +15,7 @@ export const registerSupport = (): void => {
 
     Cypress.Commands.add('login', login)
     Cypress.Commands.add('logout', logout)
+    Cypress.Commands.add('repeatUntil', repeatUntil)
 
     Cypress.Commands.overwrite('fixture', fixture)
 

package/src/support/repeatUntil.md

@@ -0,0 +1,40 @@
+# repeatUntil
+
+This commands reload or repeat a function until an item is visible in the page
+
+## Syntax
+
+### Usage
+
+```
+cy.repeatUntil('div:contains("some text")')
+cy.repeatUntil('div:contains("some text")', {attempts: 10, reloadCallback: () => { cy.reload() }, delay: 1000})
+```
+
+### Arguments
+
+#### > selector (`string`)
+
+The selector that is being searched in the page
+
+#### > options (`RepeatUntilOptions`)
+
+- `attempts`: max number of attempts
+- `callback`: the callback to execute if the item is not found. By default, do a `cy.reload()`
+- `delay`: time to wait between each attemps (ms)
+
+### Yields
+
+The found element
+
+## Rules
+
+### Requirements
+
+- `cy.repeatUntil()` requires being chained off of `cy`.
+
+### Assertions
+
+### Timeouts
+
+## Command Log

package/src/support/repeatUntil.ts

@@ -0,0 +1,59 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+
+// Load type definitions that come with Cypress module
+/// <reference types="cypress" />
+
+type RepeatUntilOptions = {
+    attempts: number,
+    callback: () => void,
+    delay: number,
+}
+
+const defaultOptions: RepeatUntilOptions = {
+    attempts: 10,
+    callback: () => cy.reload({log:false}),
+    delay: 1000
+}
+
+declare global {
+    namespace Cypress {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        interface Chainable<Subject> {
+            repeatUntil(selector: string, options?: Partial<RepeatUntilOptions>): Chainable<JQuery>
+        }
+    }
+}
+
+export const repeatUntil = (selector: string, options: Partial<RepeatUntilOptions> = {}): void => {
+    options = { ...defaultOptions, ...options }
+
+    const log = Cypress.log({
+        name: 'repeatUntil',
+        message: `Reload until ${selector}, remaining attempts : ${options.attempts}`,
+        consoleProps: () => {
+            return {
+                attempts: options.attempts,
+            }
+        },
+    })
+
+    const items = Cypress.$(selector)
+    if (items.length) {
+        log.set({ $el: items })
+        cy.wrap(items, {log: false})
+        return
+    }
+
+    if (options.attempts > 1) {
+        log.end()
+        options.callback()
+
+        // eslint-disable-next-line cypress/no-unnecessary-waiting
+        cy.wait(options.delay)
+        cy.repeatUntil(selector, {...options, attempts: options.attempts - 1})
+    } else {
+        const err = Error('Items not found.')
+        log.error(err)
+        throw err
+    }
+}