@jahia/cypress 6.0.0 → 6.2.0

package/src/support/jsErrorsLogger.ts

@@ -0,0 +1,281 @@
+/* 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.
+ */
+
+const envVarDisabled = 'JS_LOGGER_DISABLED';
+const envVarCollector = '__JS_LOGGER_FAILURES__';
+const envVarAllowedWarnings = '__JS_LOGGER_ALLOWED_WARNINGS__';
+const 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.
+ */
+enum STRATEGY { failFast, failAfterAll, failAfterEach }
+
+/**
+ * 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(): STRATEGY {
+    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: STRATEGY): void { 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(): boolean { 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: string[]): void { 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(): void {
+    // 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(): void {
+    /**
+     * 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', 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(() => {
+        // 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; }
+
+        let consoleIssues = [];
+        const allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(calls => { consoleIssues = calls; });
+
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each((call: { args: string[]}) => {
+                call.args.forEach((arg: string) => {
+                    if (!allowedWarnings.some((item: string) => arg.includes(item))) {
+                        consoleIssues.push(arg);
+                    }
+                });
+            });
+
+        // Collect all issues and store them in the Cypress environment variable for later usage
+        cy.then(() => {
+            if (consoleIssues.length > 0) {
+                Cypress.env(envVarCollector, [...(Cypress.env(envVarCollector) || []), {
+                    test: Cypress.currentTest.title,
+                    errors: consoleIssues
+                }]);
+            }
+        });
+    });
+
+    /**
+     * Custom 'after' hook to analyze collected errors and warnings after all tests are executed.
+     */
+    after(() => {
+        // 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
+        const failures = Cypress.env(envVarCollector) || [];
+        cy.log('[JS ERRORS LOGGER] Analyze collected issues').then(() => {
+            if (failures.length > 0) {
+                // Format the error message for each test
+                const errorMessage = failures.map((failure: { test: string; errors: string[]; }) => {
+                    return `TEST: ${failure.test}\nISSUES:\n${failure.errors.map((e: string) => `- ${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(): void {
+    // 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', 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(() => {
+        let consoleIssues = [];
+        const allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(calls => { consoleIssues = calls; });
+
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each((call: { args: string[]}) => {
+                call.args.forEach((arg: string) => {
+                    if (!allowedWarnings.some((item: string) => arg.includes(item))) {
+                        consoleIssues.push(arg);
+                    }
+                });
+            });
+
+        // Analyze collected errors and warnings
+        cy.log('[JS ERRORS LOGGER] Analyze collected issues').then(() => {
+            if (consoleIssues.length > 0) {
+                // Format the error message for each test
+                const errorMessage = consoleIssues.map((e: string) => `- ${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(): void {
+    // 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', window => {
+        cy.spy(window.console, 'error').as('errors');
+        cy.spy(window.console, 'warn').as('warnings');
+    });
+
+    Cypress.on('window:load', () => {
+        // DOM should be loaded and parsed by now, so we can check for console errors and warnings
+        let consoleIssues = [];
+        const allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(calls => { consoleIssues = calls; });
+
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each((call: { args: string[]}) => {
+                call.args.forEach((arg: string) => {
+                    if (!allowedWarnings.some((item: string) => arg.includes(item))) {
+                        consoleIssues.push(arg);
+                    }
+                });
+            }).then(() => {
+                if (consoleIssues.length > 0) {
+                    // Format the error message for each test
+                    const errorMessage = consoleIssues.map((e: string) => `- ${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.
+ */
+export const jsErrorsLogger = {
+    attachHooks,
+    setAllowedJsWarnings,
+    setStrategy,
+    STRATEGY
+};

package/src/support/provisioning/executeGroovy.ts

@@ -33,7 +33,8 @@ export const executeGroovy = function (scriptFile: string, replacements?: { [key
         files: [{
             fileName: scriptFile,
             replacements,
-            type: 'text/plain'
+            type: 'text/plain',
+            encoding: 'utf-8'
         }],
         jahiaServer
     }).then(r => r[0]);

package/src/support/provisioning/runProvisioningScript.ts

@@ -47,6 +47,15 @@ function processContent(formFile: 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);
 }
 

package/src/support/registerSupport.ts

@@ -5,6 +5,8 @@ import {logout} from './logout';
 import {fixture} from './fixture';
 import {repeatUntil} from './repeatUntil';
 import {step} from './testStep';
+// FUNCTIONALITY IS TEMPORARY DISABLED DUE TO UNEXPECTED ISSUES
+// import {jsErrorsLogger} from './jsErrorsLogger';
 
 export const registerSupport = (): void => {
     Cypress.Commands.add('apolloClient', apolloClient);
@@ -24,4 +26,11 @@ export const registerSupport = (): void => {
     Cypress.Commands.overwrite('fixture', fixture);
 
     Cypress.Commands.add('step', 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.
+    // FUNCTIONALITY IS TEMPORARY DISABLED DUE TO UNEXPECTED ISSUES
+    // jsErrorsLogger.attachHooks();
 };

package/src/utils/Logger.ts

@@ -1,78 +1,108 @@
 /**
- * Helper class to decorate Cypress log messages with different log levels (INFO and DEBUG at the moment).
- * Class contains only static methods and should not be instantiated.
+ * 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('DEBUG', myJSON);
+ *      Log.json(Log.LEVELS.DEBUG, myJSON);
  *      Log.info('My info message').then(() => { ... });
- * @note The log level can be set by changing the `Log.LEVEL` variable in the code (default is `INFO`).
+ *
+ * @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.
  */
-export class Log {
-    // The default log level is set to 'INFO' and can be changed by setting the Log.LEVEL variable in the code
-    static LEVEL = 'INFO';
-    // The log levels are defined in the levels array and are ordered from the lowest to the highest priority
-    private static levels = ['DEBUG', 'INFO'];
 
-    /**
-     * Logs INFO message
-     * @param {string} message - log message
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    static info(message: string): Cypress.Chainable {
-        return Log._send_('INFO', message);
-    }
+// ENV variable to store the logging verbosity level
+const envVarLoggingVerbosity = '__LOG_VERBOSITY__';
 
-    /**
-     * Logs DEBUG message
-     * @param {string} message - log message
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    static debug(message: string): Cypress.Chainable {
-        return Log._send_('DEBUG', message);
-    }
+/**
+ * Logging levels enumerator.
+ */
+enum LEVEL { DEBUG, INFO }
 
-    /**
-     * Logs JSON object with logging level given
-     * @param {string} level - log level (e.g. 'INFO', 'DEBUG')
-     * @param {string} json - json object to be logged
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    static json(level: string, json: string): Cypress.Chainable {
-        return Log._send_(level, JSON.stringify(json, null, 2));
-    }
+/**
+ * Return the current logging verbosity level.
+ * @returns {LEVEL} - current logging level set in Cypress environment variable `__LOG_VERBOSITY__`
+ * @note be careful with Cypress.env(envVarLoggingVerbosity), since it might return `0` for `DEBUG` level,
+ *       which is falsy in JavaScript, so we need to check if the variable is undefined.
+ */
+function getVerbosity(): LEVEL {
+    return typeof Cypress.env(envVarLoggingVerbosity) === 'undefined' ? LEVEL.INFO : Cypress.env(envVarLoggingVerbosity);
+}
+
+/**
+ * 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}
+ */
+function setVerbosity(level: LEVEL): void {
+    Cypress.env(envVarLoggingVerbosity, level);
+}
+
+/**
+ * Logs INFO message
+ * @param {string} message - log message
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+function info(message: string): Cypress.Chainable {
+    return _send_(Log.LEVEL.INFO, message);
+}
+
+/**
+ * Logs DEBUG message
+ * @param {string} message - log message
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+function debug(message: string): Cypress.Chainable {
+    return _send_(Log.LEVEL.DEBUG, message);
+}
+
+/**
+ * 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
+ */
+function json(level: LEVEL, text: string): Cypress.Chainable {
+    return _send_(level, JSON.stringify(text, null, 2));
+}
 
-    /**
-     * Private method to send the log message to Cypress log
-     * @param {string} level - log level (e.g. 'INFO', 'DEBUG')
-     * @param {string} message - log message
-     * @note The method checks if the log level is enabled before sending the message to Cypress log
-     *       and uses the Cypress.log method to display the message in the Cypress log
-     * @note The method is private and should not be called directly
-     *       Use the public methods (info, debug, error, warning) to send log messages
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     * @private
-     */
-    private static _send_(level: string, message: string): Cypress.Chainable {
-        // Check if the log level is valid
-        if (!Log.levels.includes(level.toUpperCase())) {
-            throw new Error(`Log level "${level}" is not supported. Supported levels are: ${Log.levels.join(', ')}`);
-        }
+/**
+ * Private method to send the log message to Cypress log
+ * @param {LEVEL} level - log level (e.g. 'INFO', 'DEBUG')
+ * @param {string} message - log message
+ * @note The method checks if the log level is enabled before sending the message to Cypress log
+ *       and uses the Cypress.log method to display the message in the Cypress log
+ * @note The method is private and should not be called directly
+ *       Use the public methods (info, debug, error, warning) to send log messages
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ * @private
+ */
+function _send_(level: LEVEL, message: string): Cypress.Chainable {
+    // Check if the log level is valid
+    if (!Object.values(Log.LEVEL).includes(level)) {
+        throw new Error(`Log level "${level}" is not supported. Supported levels are: ${Log.LEVEL}`);
+    }
 
-        // Check if the log level is enabled,
-        // take into account the log level set in Cypress.env('LOG_LEVEL') and the log level set in the Log.LEVEL variable.
-        // If the log level is enabled, send the message to Cypress log.
-        if (
-            (Log.levels.includes(Cypress.env('LOG_LEVEL')?.toUpperCase()) && Log.levels.indexOf(level.toUpperCase()) >= Log.levels.indexOf(Cypress.env('LOG_LEVEL')?.toUpperCase())) ||
-            Log.levels.indexOf(level.toUpperCase()) >= Log.levels.indexOf(Log.LEVEL)
-        ) {
-            // Send the message to Cypress log
-            // use cy.then() to ensure that the log message is sent in the correct order
-            // and use cy.wrap() to return the Cypress chainable object
-            return cy.then(() => {
-                Cypress.log({displayName: `[ ${level.toUpperCase()} ]`, message: `${message}`});
-            }).then(cy.wrap);
-        }
+    // Check if the log level is enabled,
+    // take into account the log level set in Cypress.env('LOG_LEVEL') and the log level set in the Log.LEVEL variable.
+    // If the log level is enabled, send the message to Cypress log.
+    if (level >= getVerbosity()) {
+        // Send the message to Cypress log
+        // use cy.then() to ensure that the log message is sent in the correct order
+        // and use cy.wrap() to return the Cypress chainable object
+        return cy.then(() => {
+            Cypress.log({displayName: `[ ${Log.LEVEL[level].toUpperCase()} ]`, message: `${message}`});
+        }).then(cy.wrap);
     }
 }
+
+// Export the Log module with methods to log messages and set the logging level
+export const Log = {
+    info,
+    debug,
+    json,
+    setVerbosity,
+    LEVEL
+};