@jahia/cypress 1.0.5 → 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/plugins/env.js

@@ -1,10 +1,20 @@
 "use strict";
 exports.__esModule = true;
 var env = function (on, config) {
-    console.log('Setting env', process.env.JAHIA_URL);
-    config.baseUrl = process.env.JAHIA_URL;
-    config.env.JAHIA_URL = process.env.JAHIA_URL;
-    config.env.SUPER_USER_PASSWORD = process.env.SUPER_USER_PASSWORD;
+    if (!process.env.JAHIA_URL && !process.env.SUPER_USER_PASSWORD) {
+        console.warn('No environment set, will use default values');
+        config.baseUrl = 'http://localhost:8080';
+        config.env.JAHIA_URL = 'http://localhost:8080';
+        config.env.SUPER_USER_PASSWORD = 'root1234';
+    }
+    else {
+        console.log('Setting environment');
+        config.baseUrl = process.env.JAHIA_URL;
+        config.env.JAHIA_URL = process.env.JAHIA_URL;
+        config.env.SUPER_USER_PASSWORD = process.env.SUPER_USER_PASSWORD;
+    }
+    console.log('JAHIA_URL =', config.env.JAHIA_URL);
+    console.log('SUPER_USER_PASSWORD =', config.env.SUPER_USER_PASSWORD);
     return config;
 };
 exports["default"] = env;

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/provisioning/runProvisioningScript.js

@@ -3,31 +3,39 @@
 exports.__esModule = true;
 exports.runProvisioningScript = void 0;
 /// <reference types="cypress" />
-function getBlob(formFile) {
-    return new Promise(function (resolve) {
-        if (formFile.fileContent) {
-            resolve(new Blob([formFile.fileContent], { type: formFile.type }));
-        }
-        else {
-            cy.fixture(formFile.fileName, (formFile.encoding ? formFile.encoding : 'binary')).then(function (content) {
-                if (formFile.replacements) {
-                    Object.keys(formFile.replacements).forEach(function (k) { return content = content.replaceAll(k, formFile.replacements[k]); });
-                }
+function processContent(formFile) {
+    var content = formFile.fileContent;
+    if (formFile.replacements) {
+        Object.keys(formFile.replacements).forEach(function (k) { return content = content.replaceAll(k, formFile.replacements[k]); });
+    }
+    formFile.fileContent = content;
+    return Cypress.Blob.binaryStringToBlob(content, formFile.type);
+}
+function append(formFile, formData, key) {
+    if (formFile.fileContent) {
+        formData.append(key, processContent(formFile), formFile.fileName);
+    }
+    else {
+        cy.fixture(formFile.fileName, (formFile.encoding ? formFile.encoding : 'binary')).then(function (content) {
+            if (typeof content === 'object') {
+                formFile.fileContent = JSON.stringify(content);
+            }
+            else {
                 formFile.fileContent = content;
-                resolve(Cypress.Blob.binaryStringToBlob(content, formFile.type));
-            });
-        }
-    });
+            }
+            formData.append(key, processContent(formFile), formFile.fileName);
+        });
+    }
 }
 var runProvisioningScript = function (script, files, options) {
     if (options === void 0) { options = { log: true }; }
     var formData = new FormData();
-    getBlob(script).then(function (blob) { return formData.append("script", blob); });
-    files.forEach(function (f) {
-        getBlob(f).then(function (blob) {
-            formData.append("file", blob, f.fileName);
+    append(script, formData, "script");
+    if (files) {
+        files.forEach(function (f) {
+            append(f, formData, "file");
         });
-    });
+    }
     var response;
     var result;
     var logger;

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.5",
+  "version": "1.0.9",
   "scripts": {
     "build": "tsc",
     "lint": "eslint src -c .eslintrc.json --ext .ts"

package/src/custom.d.ts

@@ -0,0 +1,3 @@
+interface String {
+    replaceAll(input: string, output : string): any;
+}

package/src/plugins/env.ts

@@ -1,8 +1,17 @@
 const env = (on:Cypress.PluginEvents, config: Cypress.PluginConfigOptions):Cypress.PluginConfigOptions => {
-    console.log('Setting env', process.env.JAHIA_URL)
-    config.baseUrl = process.env.JAHIA_URL
-    config.env.JAHIA_URL = process.env.JAHIA_URL
-    config.env.SUPER_USER_PASSWORD = process.env.SUPER_USER_PASSWORD
+    if (!process.env.JAHIA_URL && !process.env.SUPER_USER_PASSWORD) {
+        console.warn('No environment set, will use default values')
+        config.baseUrl = 'http://localhost:8080'
+        config.env.JAHIA_URL = 'http://localhost:8080'
+        config.env.SUPER_USER_PASSWORD = 'root1234'
+    } else {
+        console.log('Setting environment');
+        config.baseUrl = process.env.JAHIA_URL
+        config.env.JAHIA_URL = process.env.JAHIA_URL
+        config.env.SUPER_USER_PASSWORD = process.env.SUPER_USER_PASSWORD
+    }
+    console.log('JAHIA_URL =', config.env.JAHIA_URL)
+    console.log('SUPER_USER_PASSWORD =', config.env.SUPER_USER_PASSWORD)
 
     return config
 }

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/provisioning/runProvisioningScript.ts

@@ -22,31 +22,39 @@ type FormFile = {
     replacements?: { [key: string]: string }
 }
 
-function getBlob(formFile: FormFile): Promise<Blob> {
-    return new Promise(resolve => {
-        if (formFile.fileContent) {
-            resolve(new Blob([formFile.fileContent], {type: formFile.type}))
-        } else {
-            cy.fixture(formFile.fileName, (formFile.encoding ? formFile.encoding : 'binary')).then(content => {
-                if (formFile.replacements) {
-                    Object.keys(formFile.replacements).forEach(k => content = content.replaceAll(k, formFile.replacements[k]))
-                }
-                formFile.fileContent = content
-                resolve(Cypress.Blob.binaryStringToBlob(content, formFile.type))
-            })
-        }
-    })
+function processContent(formFile: FormFile) {
+    let content = formFile.fileContent;
+    if (formFile.replacements) {
+        Object.keys(formFile.replacements).forEach(k => content = content.replaceAll(k, formFile.replacements[k]))
+    }
+    formFile.fileContent = content
+    return Cypress.Blob.binaryStringToBlob(content, formFile.type);
+}
+
+function append(formFile: FormFile, formData: FormData, key: string) {
+    if (formFile.fileContent) {
+        formData.append(key, processContent(formFile), formFile.fileName);
+    } else {
+        cy.fixture(formFile.fileName, (formFile.encoding ? formFile.encoding : 'binary')).then(content => {
+            if (typeof content === 'object') {
+                formFile.fileContent = JSON.stringify(content);
+            } else {
+                formFile.fileContent = content;
+            }
+            formData.append(key, processContent(formFile), formFile.fileName);
+        })
+    }
 }
 
 export const runProvisioningScript = (script: FormFile, files?: FormFile[], options: Cypress.Loggable = {log:true}): void => {
     const formData = new FormData()
 
-    getBlob(script).then(blob => formData.append("script", blob))
-    files.forEach((f) => {
-        getBlob(f).then(blob => {
-            formData.append("file", blob, f.fileName)
+    append(script, formData, "script")
+    if (files) {
+        files.forEach((f) => {
+            append(f, formData, "file")
         })
-    })
+    }
 
     let response: Cypress.Response<any>
     let result: any

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
+    }
+}