@jahia/cypress 5.2.0 → 6.1.0

package/dist/support/index.d.ts

@@ -3,3 +3,5 @@ export * from './provisioning';
 export * from './login';
 export * from './logout';
 export * from './repeatUntil';
+export * from './testStep';
+export * from './jsErrorsLogger';

package/dist/support/index.js

@@ -15,3 +15,5 @@ __exportStar(require("./provisioning"), exports);
 __exportStar(require("./login"), exports);
 __exportStar(require("./logout"), exports);
 __exportStar(require("./repeatUntil"), exports);
+__exportStar(require("./testStep"), exports);
+__exportStar(require("./jsErrorsLogger"), exports);

package/dist/support/jsErrorsLogger.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Module for monitoring and reporting JavaScript errors and warnings in Cypress tests.
+ * Provides methods to enable, disable, and check logger status.
+ */
+/**
+ * Strategy for handling JavaScript errors and warnings in Cypress tests.
+ * - failFast: Fail *immediately* when an error is detected.
+ * - failAfterEach: Collect all errors and warnings *during test* execution and fail if any issues are found.
+ * - failAfterAll: Collect all errors and warnings *after all tests* and fail at the end of the test suite.
+ */
+declare enum STRATEGY {
+    failFast = 0,
+    failAfterAll = 1,
+    failAfterEach = 2
+}
+/**
+ * Sets the strategy for handling JavaScript errors and warnings in Cypress tests.
+ * @param {STRATEGY} strategy - Strategy for handling JavaScript errors and warnings.
+ * @throws {Error} If an invalid strategy is provided.
+ * @returns {void}
+ */
+declare function setStrategy(strategy: STRATEGY): void;
+/**
+ * Sets the list of allowed warnings that will not be reported by the logger.
+ * @param warnings {string[]} - Array of warning messages to be allowed.
+ * @return {void}
+ */
+declare function setAllowedJsWarnings(warnings: string[]): void;
+/**
+ * Attaches custom hooks to Cypress events to monitor and report JavaScript errors and warnings.
+ * This method is called automatically in registerSupport.ts#registerSupport
+ * It sets up listeners for console errors and warnings, collects them after each test,
+ * and throws an error if any issues are found after all tests are executed.
+ */
+declare function attachHooks(): void;
+/**
+ * Exports the jsLogger module with methods to attach hooks, enable/disable logging, and set allowed warnings.
+ */
+export declare const jsErrorsLogger: {
+    attachHooks: typeof attachHooks;
+    setAllowedJsWarnings: typeof setAllowedJsWarnings;
+    setStrategy: typeof setStrategy;
+    STRATEGY: typeof STRATEGY;
+};
+export {};

package/dist/support/jsErrorsLogger.js

@@ -0,0 +1,280 @@
+"use strict";
+/* eslint-disable brace-style */
+/* eslint-disable max-statements-per-line */
+/**
+ * Module for monitoring and reporting JavaScript errors and warnings in Cypress tests.
+ * Provides methods to enable, disable, and check logger status.
+ */
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+exports.__esModule = true;
+exports.jsErrorsLogger = void 0;
+var envVarDisabled = 'JS_LOGGER_DISABLED';
+var envVarCollector = '__JS_LOGGER_FAILURES__';
+var envVarAllowedWarnings = '__JS_LOGGER_ALLOWED_WARNINGS__';
+var envVarStrategy = '__JS_LOGGER_STRATEGY__';
+/**
+ * Strategy for handling JavaScript errors and warnings in Cypress tests.
+ * - failFast: Fail *immediately* when an error is detected.
+ * - failAfterEach: Collect all errors and warnings *during test* execution and fail if any issues are found.
+ * - failAfterAll: Collect all errors and warnings *after all tests* and fail at the end of the test suite.
+ */
+var STRATEGY;
+(function (STRATEGY) {
+    STRATEGY[STRATEGY["failFast"] = 0] = "failFast";
+    STRATEGY[STRATEGY["failAfterAll"] = 1] = "failAfterAll";
+    STRATEGY[STRATEGY["failAfterEach"] = 2] = "failAfterEach";
+})(STRATEGY || (STRATEGY = {}));
+/**
+ * Returns the current strategy for handling JavaScript errors and warnings in Cypress tests.
+ * @returns {STRATEGY} - The current strategy for handling JavaScript errors and warnings.
+ * @note be careful with Cypress.env(envVarStrategy), since it might return `0` for `failFast` strategy,
+ *       which is falsy in JavaScript, so we need to check if the variable is undefined.
+ */
+function getStrategy() {
+    return typeof Cypress.env(envVarStrategy) === 'undefined' ? STRATEGY.failFast : Cypress.env(envVarStrategy);
+}
+/**
+ * Sets the strategy for handling JavaScript errors and warnings in Cypress tests.
+ * @param {STRATEGY} strategy - Strategy for handling JavaScript errors and warnings.
+ * @throws {Error} If an invalid strategy is provided.
+ * @returns {void}
+ */
+function setStrategy(strategy) { Cypress.env(envVarStrategy, strategy); }
+/**
+ * Checks if the js errors and warnings logger is disabled.
+ * @returns {boolean} - true if the logger is disabled, false otherwise.
+ */
+function isDisabled() { return Cypress.env(envVarDisabled) === true; }
+/**
+ * Sets the list of allowed warnings that will not be reported by the logger.
+ * @param warnings {string[]} - Array of warning messages to be allowed.
+ * @return {void}
+ */
+function setAllowedJsWarnings(warnings) { Cypress.env(envVarAllowedWarnings, warnings); }
+/**
+ * Attaches custom hooks to Cypress events to monitor and report JavaScript errors and warnings.
+ * This method is called automatically in registerSupport.ts#registerSupport
+ * It sets up listeners for console errors and warnings, collects them after each test,
+ * and throws an error if any issues are found after all tests are executed.
+ */
+function attachHooks() {
+    // Skip hook attachment if the logger is disabled (e.g. from CI/CD pipeline)
+    if (isDisabled()) {
+        return;
+    }
+    switch (getStrategy()) {
+        case STRATEGY.failAfterAll:
+            attachFailAfterAll();
+            break;
+        case STRATEGY.failAfterEach:
+            attachFailAfterEach();
+            break;
+        default:
+            attachFailFast();
+    }
+}
+/**
+ * Custom hook implementation which fails the test after all tests are executed if any JavaScript errors or warnings are found.
+ *
+ * Proc: Allows all tests to run, collects console errors and warnings, and fails the test suite at the end if any issues are found.
+ *       This is useful for reporting all issues at once after all tests are executed, rather than failing immediately on the first issue.
+ * Cons: Reporting might be confusing, e.g. - cypress will report the very last test as failed, while many tests might have issues.
+ *       This is because the hook is executed after all tests are completed, so the last test is reported as failed.
+ */
+function attachFailAfterAll() {
+    /**
+     * Custom 'window:before:load' hook to spy on console errors and warnings
+     * This hook is executed before the page is loaded, allowing us to capture console messages.
+     */
+    Cypress.on('window:before:load', function (window) {
+        // Skip 'window:before:load' hook if the logger is not enabled
+        // Double-check in case if functionality was disabled within the test-case code
+        // to skip js validations for some particular test and enable it afterward
+        if (isDisabled()) {
+            return;
+        }
+        cy.spy(window.console, 'error').as('errors');
+        cy.spy(window.console, 'warn').as('warnings');
+    });
+    /**
+     * Custom 'afterEach' hook to collect console errors and warnings
+     */
+    afterEach(function () {
+        // Skip 'afterEach' hook if the logger is not enabled
+        // Double-check in case if functionality was disabled within the test-case code
+        // to skip js validations for some particular test and enable it afterward
+        if (isDisabled()) {
+            return;
+        }
+        var consoleIssues = [];
+        var allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(function (calls) { consoleIssues = calls; });
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each(function (call) {
+            call.args.forEach(function (arg) {
+                if (!allowedWarnings.some(function (item) { return arg.includes(item); })) {
+                    consoleIssues.push(arg);
+                }
+            });
+        });
+        // Collect all issues and store them in the Cypress environment variable for later usage
+        cy.then(function () {
+            if (consoleIssues.length > 0) {
+                Cypress.env(envVarCollector, __spreadArray(__spreadArray([], (Cypress.env(envVarCollector) || [])), [{
+                        test: Cypress.currentTest.title,
+                        errors: consoleIssues
+                    }]));
+            }
+        });
+    });
+    /**
+     * Custom 'after' hook to analyze collected errors and warnings after all tests are executed.
+     */
+    after(function () {
+        // Skip 'after' hook if the logger is not enabled
+        // Double-check in case if functionality was disabled within the test-case code
+        // to skip js validations for some particular test and enable it afterward
+        if (isDisabled()) {
+            return;
+        }
+        // Analyze collected errors and warnings
+        var failures = Cypress.env(envVarCollector) || [];
+        cy.log('[JS ERRORS LOGGER] Analyze collected issues').then(function () {
+            if (failures.length > 0) {
+                // Format the error message for each test
+                var errorMessage = failures.map(function (failure) {
+                    return "TEST: " + failure.test + "\nISSUES:\n" + failure.errors.map(function (e) { return "- " + e; }).join('\n');
+                }).join('\n\n');
+                // Throw an error with the collected issues
+                throw new Error('CONSOLE ERRORS and WARNINGS FOUND:\n\n' + errorMessage);
+            }
+            else {
+                cy.log('[JS ERRORS LOGGER] No console errors or warnings found.');
+            }
+        });
+    });
+}
+/**
+ * Custom hook implementation which fails the test after each test execution if any JavaScript errors or warnings are found.
+ *
+ * Proc: Allows each test to run, collects console errors and warnings, and fails the particular test by the end of it's execution
+ *       if any issues are found.
+ * Cons: If errors or warnings were found during beforeEach or afterEach hook(s), the rest of spec will be ignored.
+ */
+function attachFailAfterEach() {
+    // Double-check in case if functionality was disabled within the test-case code
+    // to skip js validations for some particular test and enable it afterward
+    if (isDisabled()) {
+        return;
+    }
+    /**
+     * Custom 'window:before:load' hook to spy on console errors and warnings
+     * This hook is executed before the page is loaded, allowing us to capture console messages.
+     */
+    Cypress.on('window:before:load', function (window) {
+        cy.spy(window.console, 'error').as('errors');
+        cy.spy(window.console, 'warn').as('warnings');
+    });
+    /**
+     * Custom 'afterEach' hook to collect console errors and warnings
+     */
+    afterEach(function () {
+        var consoleIssues = [];
+        var allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(function (calls) { consoleIssues = calls; });
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each(function (call) {
+            call.args.forEach(function (arg) {
+                if (!allowedWarnings.some(function (item) { return arg.includes(item); })) {
+                    consoleIssues.push(arg);
+                }
+            });
+        });
+        // Analyze collected errors and warnings
+        cy.log('[JS ERRORS LOGGER] Analyze collected issues').then(function () {
+            if (consoleIssues.length > 0) {
+                // Format the error message for each test
+                var errorMessage = consoleIssues.map(function (e) { return "- " + e; }).join('\n');
+                // Throw an error with the collected issues
+                throw new Error('CONSOLE ERRORS and WARNINGS FOUND:\n\n' + errorMessage);
+            }
+            else {
+                cy.log('[JS ERRORS LOGGER] No console errors or warnings found.');
+            }
+        });
+    });
+}
+/**
+ * Custom hook implementation which fails the test immediately when a JavaScript error or warning is detected.
+ *
+ * Proc: Allows each test to run, looks for console errors and warnings, and fails the particular test IMMEDIATELLY
+ *       if any issues are found.
+ * Cons: If errors or warnings were found during beforeEach or afterEach hook(s), the rest of spec will be ignored.
+ */
+function attachFailFast() {
+    // Double-check in case if functionality was disabled within the test-case code
+    // to skip js validations for some particular test and enable it afterward
+    if (isDisabled()) {
+        return;
+    }
+    /**
+     * Custom 'window:before:load' hook to spy on console errors and warnings
+     * This hook is executed before the page is loaded, allowing us to capture console messages.
+     */
+    Cypress.on('window:before:load', function (window) {
+        cy.spy(window.console, 'error').as('errors');
+        cy.spy(window.console, 'warn').as('warnings');
+    });
+    Cypress.on('window:load', function () {
+        // DOM should be loaded and parsed by now, so we can check for console errors and warnings
+        var consoleIssues = [];
+        var allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(function (calls) { consoleIssues = calls; });
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each(function (call) {
+            call.args.forEach(function (arg) {
+                if (!allowedWarnings.some(function (item) { return arg.includes(item); })) {
+                    consoleIssues.push(arg);
+                }
+            });
+        }).then(function () {
+            if (consoleIssues.length > 0) {
+                // Format the error message for each test
+                var errorMessage = consoleIssues.map(function (e) { return "- " + e; }).join('\n');
+                // Throw an error with the collected issues
+                throw new Error('CONSOLE ERRORS and WARNINGS FOUND:\n' + errorMessage);
+            }
+            else {
+                cy.log('[JS ERRORS LOGGER] No console errors or warnings found.');
+            }
+        });
+    });
+}
+/**
+ * Exports the jsLogger module with methods to attach hooks, enable/disable logging, and set allowed warnings.
+ */
+exports.jsErrorsLogger = {
+    attachHooks: attachHooks,
+    setAllowedJsWarnings: setAllowedJsWarnings,
+    setStrategy: setStrategy,
+    STRATEGY: STRATEGY
+};

package/dist/support/provisioning/executeGroovy.js

@@ -18,7 +18,8 @@ var executeGroovy = function (scriptFile, replacements, jahiaServer) {
         files: [{
                 fileName: scriptFile,
                 replacements: replacements,
-                type: 'text/plain'
+                type: 'text/plain',
+                encoding: 'utf-8'
             }],
         jahiaServer: jahiaServer
     }).then(function (r) { return r[0]; });

package/dist/support/provisioning/index.d.ts

@@ -1,4 +1,4 @@
 export * from './executeGroovy';
 export * from './runProvisioningScript';
-export * from './installBundle';
-export * from './uninstallBundle';
+export * from './installModule';
+export * from './uninstallModule';

package/dist/support/provisioning/index.js

@@ -12,5 +12,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 exports.__esModule = true;
 __exportStar(require("./executeGroovy"), exports);
 __exportStar(require("./runProvisioningScript"), exports);
-__exportStar(require("./installBundle"), exports);
-__exportStar(require("./uninstallBundle"), exports);
+__exportStar(require("./installModule"), exports);
+__exportStar(require("./uninstallModule"), exports);

package/dist/support/provisioning/installModule.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="cypress" />
+declare global {
+    namespace Cypress {
+        interface Chainable<Subject> {
+            installModule(moduleFile: string): Chainable<Cypress.Response<any>>;
+            installAndStartModule(moduleFile: string): Chainable<Cypress.Response<any>>;
+        }
+    }
+}
+export declare const installModule: (moduleFile: string) => void;
+export declare const installAndStartModule: (moduleFile: string) => void;

package/dist/support/provisioning/installModule.js

@@ -0,0 +1,25 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+exports.__esModule = true;
+exports.installAndStartModule = exports.installModule = void 0;
+/// <reference types="cypress" />
+var installModule = function (moduleFile) {
+    cy.runProvisioningScript({
+        script: [{ installModule: moduleFile }],
+        files: [{
+                fileName: moduleFile,
+                type: 'text/plain'
+            }]
+    });
+};
+exports.installModule = installModule;
+var installAndStartModule = function (moduleFile) {
+    cy.runProvisioningScript({
+        script: [{ installAndStartModule: moduleFile }],
+        files: [{
+                fileName: moduleFile,
+                type: 'text/plain'
+            }]
+    });
+};
+exports.installAndStartModule = installAndStartModule;

package/dist/support/provisioning/runProvisioningScript.js

@@ -20,6 +20,14 @@ function processContent(formFile) {
         });
     }
     formFile.fileContent = content;
+    // If the file has an encoding, create a Blob with the new Blob constructor. It handle correctly the encoding
+    // for the groovy scripts
+    // Did not change for all files because jar files can be added as well, which are binary files
+    // In that case the function binaryStringToBlob will be used
+    if (formFile.encoding) {
+        return new Blob([content], { type: formFile.type });
+    }
+    // Default to binary string to blob conversion
     return Cypress.Blob.binaryStringToBlob(content, formFile.type);
 }
 function append(formFile, formData, key) {

package/dist/support/provisioning/{uninstallBundle.d.ts → uninstallModule.d.ts}

@@ -2,8 +2,8 @@
 declare global {
     namespace Cypress {
         interface Chainable<Subject> {
-            uninstallBundle(bundleSymbolicName: string): Chainable<Cypress.Response<any>>;
+            uninstallModule(moduleSymbolicName: string): Chainable<Cypress.Response<any>>;
         }
     }
 }
-export declare const uninstallBundle: (bundleSymbolicName: string) => void;
+export declare const uninstallModule: (moduleSymbolicName: string) => void;

package/dist/support/provisioning/{uninstallBundle.js → uninstallModule.js}

@@ -1,14 +1,14 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
 exports.__esModule = true;
-exports.uninstallBundle = void 0;
+exports.uninstallModule = void 0;
 /// <reference types="cypress" />
-var uninstallBundle = function (bundleSymbolicName) {
+var uninstallModule = function (moduleSymbolicName) {
     cy.runProvisioningScript({
         script: {
-            fileContent: '- uninstallBundle: "' + bundleSymbolicName + '"\n',
+            fileContent: '- uninstallModule: "' + moduleSymbolicName + '"\n',
             type: 'application/yaml'
         }
     });
 };
-exports.uninstallBundle = uninstallBundle;
+exports.uninstallModule = uninstallModule;

package/dist/support/registerSupport.js

@@ -7,16 +7,26 @@ var login_1 = require("./login");
 var logout_1 = require("./logout");
 var fixture_1 = require("./fixture");
 var repeatUntil_1 = require("./repeatUntil");
+var testStep_1 = require("./testStep");
+var jsErrorsLogger_1 = require("./jsErrorsLogger");
 var registerSupport = function () {
     Cypress.Commands.add('apolloClient', apollo_1.apolloClient);
     Cypress.Commands.add('apollo', { prevSubject: 'optional' }, apollo_1.apollo);
     Cypress.Commands.add('runProvisioningScript', provisioning_1.runProvisioningScript);
     Cypress.Commands.add('executeGroovy', provisioning_1.executeGroovy);
-    Cypress.Commands.add('installBundle', provisioning_1.installBundle);
+    Cypress.Commands.add('installModule', provisioning_1.installModule);
+    Cypress.Commands.add('installAndStartModule', provisioning_1.installAndStartModule);
+    Cypress.Commands.add('uninstallModule', provisioning_1.uninstallModule);
     Cypress.Commands.add('login', login_1.login);
     Cypress.Commands.add('loginAndStoreSession', login_1.loginAndStoreSession);
     Cypress.Commands.add('logout', logout_1.logout);
     Cypress.Commands.add('repeatUntil', repeatUntil_1.repeatUntil);
     Cypress.Commands.overwrite('fixture', fixture_1.fixture);
+    Cypress.Commands.add('step', testStep_1.step);
+    // Since registerSupport() function is called in each repo from e2e.js,
+    // attaching the JavaScript errors logger hooks here ensures that logger is initialized automatically
+    // for all tests without needing to call it explicitly in each test file.
+    // This is useful for capturing and logging JavaScript errors across all tests.
+    jsErrorsLogger_1.jsErrorsLogger.attachHooks();
 };
 exports.registerSupport = registerSupport;

package/dist/support/testStep.d.ts

@@ -0,0 +1,27 @@
+/**
+ *  Extends global Cypress Chainable interface with custom commands from 'commands.js' to avoid TypeScript errors when using them.
+ */
+declare global {
+    namespace Cypress {
+        interface Chainable<Subject> {
+            /**
+             * Creates a foldable test-case step with corresponding message in Cypress log
+             * @param {string} message - folder's message
+             * @param {() => void} func - function to be executed and wrapped into the folder
+             * @returns void
+             * @example
+             *         cy.step('Navigate to the destination point', () => {
+             *              cy.get('selector').click();
+             *              ...
+             *         });
+             *
+             *        cy.step('Do something', () => {
+             *              cy.get('element').click();
+             *              ...
+             *         });
+             */
+            step(message: string, func: () => void): void;
+        }
+    }
+}
+export declare const step: (message: string, func: () => void) => void;

package/dist/support/testStep.js

@@ -0,0 +1,15 @@
+"use strict";
+exports.__esModule = true;
+exports.step = void 0;
+var step = function (message, func) {
+    cy.then(function () {
+        // @ts-ignore
+        Cypress.log({ groupStart: true, displayName: '[ STEP ]', message: "" + message });
+    }).then(function () {
+        func();
+    }).then(function () {
+        // @ts-ignore
+        Cypress.log({ groupEnd: true, emitOnly: true });
+    });
+};
+exports.step = step;

package/dist/utils/Logger.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Helper module to decorate Cypress log messages with different log levels (INFO and DEBUG at the moment).
+ * @example
+ *      // Switch default logging verbosity to DEBUG
+ *      Log.setVerbosity(Log.LEVELS.DEBUG);
+ *
+ *      Log.info('This is an info message');
+ *      Log.debug('This is a debug message');
+ *      Log.json(Log.LEVELS.DEBUG, myJSON);
+ *      Log.info('My info message').then(() => { ... });
+ *
+ * @note The log verbosity can be set by calling `Log.setVerbosity(Log.LEVELS.DEBUG)` in the code (default is `INFO`).
+ *       It tells the logger to log only messages with the given level and above.
+ */
+/**
+ * Logging levels enumerator.
+ */
+declare enum LEVEL {
+    DEBUG = 0,
+    INFO = 1
+}
+/**
+ * Sets the logging verbosity level for the logger. Messages with a level lower than the set level will not be logged.
+ * @param {LEVEL} level - log level to be set (e.g. 'DEBUG', 'INFO')
+ * @return {void}
+ */
+declare function setVerbosity(level: LEVEL): void;
+/**
+ * Logs INFO message
+ * @param {string} message - log message
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+declare function info(message: string): Cypress.Chainable;
+/**
+ * Logs DEBUG message
+ * @param {string} message - log message
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+declare function debug(message: string): Cypress.Chainable;
+/**
+ * Logs JSON object with logging level given
+ * @param {LEVEL} level - log level (e.g. 'INFO', 'DEBUG')
+ * @param {string} text - json object to be logged
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+declare function json(level: LEVEL, text: string): Cypress.Chainable;
+export declare const Log: {
+    info: typeof info;
+    debug: typeof debug;
+    json: typeof json;
+    setVerbosity: typeof setVerbosity;
+    LEVEL: typeof LEVEL;
+};
+export {};