@jahia/cypress 7.4.0 → 8.1.0

package/src/support/jfaker.ts

@@ -0,0 +1,245 @@
+/* eslint-disable no-else-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * jfaker - A flexible data generator for Cypress tests, supporting both faker.js generated data and custom injection payloads.
+ *
+ * This module provides a unified interface to generate either faker data or custom injection payloads based on the method called and global settings.
+ * It uses a dynamic Proxy to handle method calls and determine whether to generate faker data or injection data.
+ *
+ * IMPORTANT:
+ * When using the generated strings from jfaker in Cypress commands like `.type()`, make sure to:
+ * use `parseSpecialCharSequences: false`, e.g.: `<input>.type(text, {parseSpecialCharSequences: false})`
+ * to prevent Cypress from interpreting special characters in the generated strings (e.g., {, }, [, ], etc.) as commands,
+ * which is especially important for injection payloads that may contain such characters.
+ */
+
+import {faker} from '@faker-js/faker';
+
+// Import injection data from corresponding files in injections-ts directory
+import {xssData} from '../injections/xss-data';
+import {sqlData} from '../injections/sql-data';
+import {bashData} from '../injections/bash-data';
+import {charsData} from '../injections/chars-data';
+import {htmlentitiesData} from '../injections/htmlentities-data';
+import {numbersData} from '../injections/numbers-data';
+
+const injectionData: Record<string, string[]> = {
+    xss: xssData,
+    sql: sqlData,
+    bash: bashData,
+    chars: charsData,
+    htmlentities: htmlentitiesData,
+    numbers: numbersData
+};
+
+// Environment variable key for storing injection type in Cypress env
+// Can be set either using corresponding FakeData method or as an env var from CI/CD pipeline
+const ENV_INJECTIONS_TYPE = 'JAHIA_CYPRESS_INJECTION_TYPE';
+
+// Default range for random length of injection payloads; used when length is undefined
+// Random items within the range will be picked and joined into a single string
+const injectionsDefaultLength = {min: 2, max: 5};
+
+/**
+ * Store FakeData type in Cypress env for persistence across specs
+ * @param {string} type FakeData type: 'faker' | 'xss' | 'sql' | 'bash' | 'chars' | 'htmlentities' | 'numbers'
+ * @returns void
+ */
+function setDataType(type: string): void {
+    Cypress.env(ENV_INJECTIONS_TYPE, type);
+}
+
+/**
+ * Retrieve FakeData type from Cypress env (defaults to 'faker' if not set)
+ * @returns {string} Type of FakeData to use
+ */
+function getDataType(): string | undefined {
+    return Cypress.env(ENV_INJECTIONS_TYPE) || 'faker';
+}
+
+/**
+ * Generate injection data based on the specified type and length
+ * @param {string} type Injection type to generate (xss, sql, bash, chars, htmlentities, numbers)
+ * @param {number} length Length of the generated injection (optional)
+ * @returns {string} Generated injection string
+ */
+function generateInjection(type: string, length?: number): string {
+    let result: string[] = [];
+
+    // Type is specified and exists in injectionData, use it to generate data
+    const data = injectionData[type];
+    if (!data || data.length === 0) {
+        throw new Error(`[jFaker EXCEPTION] No injection data found for type: ${type}.`);
+    }
+
+    if (length === -1) {
+        // If length is -1, use all available items from the data array
+        result = data;
+    } else if (length && length > 0) {
+        // If length is specified and greater than 0, pick random items until the combined length meets the requirement
+        while (result.join('').length < length) {
+            const randomIndex = Math.floor(Math.random() * data.length);
+            result.push(data[randomIndex]);
+        }
+
+        // Trim the combined string to the specified length
+        const combined = result.join('');
+        result = [combined.substring(0, length)];
+    } else {
+        // If length is not specified, pick a random number of items within the default range
+        const itemsCount = Math.floor(Math.random() * injectionsDefaultLength.max) + injectionsDefaultLength.min;
+        for (let i = 0; i < itemsCount; i++) {
+            const randomIndex = Math.floor(Math.random() * data.length);
+            result.push(data[randomIndex]);
+        }
+    }
+
+    return result.join('');
+}
+
+/**
+ * Generate faker data based on the specified entity and options
+ * @param {string} entity Faker entity to generate (e.g., "person.firstName")
+ * @param {Record<string, unknown> | string | number | boolean | undefined} options Options to pass to the faker method (optional)
+ * @returns {string} Generated faker string
+ */
+function generateFake(entity: string, options?: Record<string, unknown> | string | number | boolean | undefined): string {
+    let generator: () => string;
+    const result: string[] = [];
+    const parts: string[] = entity.split('.');
+    let fakerMethod: any = faker;
+
+    for (const part of parts) {
+        if (fakerMethod && typeof fakerMethod[part] !== 'undefined') {
+            fakerMethod = fakerMethod[part];
+        } else {
+            throw new Error(`[jFaker EXCEPTION] Invalid faker method: ${entity}`);
+        }
+    }
+
+    if (typeof fakerMethod === 'function') {
+        generator = (options && Object.keys(options).length > 0) ? () => fakerMethod(options) : () => fakerMethod();
+    } else {
+        throw new Error(`[jFaker EXCEPTION] ${entity} is not a function`);
+    }
+
+    result.push(generator());
+
+    return result.join('');
+}
+
+/**
+ * Escape string to prevent issues when used in contexts like HTML or JavaScript
+ * @param str
+ */
+function escape(str: string): string {
+    return JSON.stringify(str).slice(1, -1);
+}
+
+/**
+ * Simple DeepApi class to create a dynamic nested Proxy for generating fake data using faker or injection data based on method calls
+ */
+class DeepApi {
+    constructor(private handler: (path: string, args: any[]) => any) {
+        return this.createProxy([]);
+    }
+
+    private createProxy(path: string[]): any {
+        return new Proxy(
+            // The target is a function, so the proxy itself is callable
+            function () {},
+            {
+                // Handle property access - go deeper
+                get: (target, prop) => {
+                    return this.createProxy([...path, String(prop)]);
+                },
+
+                // Handle function call - execute handler
+                apply: (target, thisArg, args) => {
+                    return this.handler(path.join('.'), args);
+                }
+            }
+        );
+    }
+}
+
+/**
+ * Interface to Fake Data generator (using DeepApi proxy to handle dynamic method calls)
+ * @param {Record<string, unknown>} options Options for data generation (length for injections, faker options, safe flag), \
+ *                                          e.g.: `{length: 100}` for injections to specify desired length of the generated string, \
+ *                                          or `{provider: 'example.com'}` for faker to pass options to the faker method. \
+ *                                          For faker data generation, an additional option `safe` can be set to `true` \
+ *                                          to force faker generation regardless of global type settings \
+ *                                          (useful for specific cases where faker data is needed even when global type is set to injection).
+ * @remarks
+ * Available injection methods:
+ * - `.xss()` - Generate XSS injection payloads
+ * - `.sql()` - Generate SQL injection payloads
+ * - `.bash()` - Generate Bash injection payloads
+ * - `.chars()` - Generate random special characters
+ * - `.htmlentities()` - Generate HTML entities
+ * - `.numbers()` - Generate random numbers entities and edge cases
+ * - or any faker.js method can also be called (e.g., `person.firstName()`, `internet.email()`)
+ *
+ * @returns {string} Generated data string based on the method called and options provided
+ *
+ * @see https://fakerjs.dev/api/ for available faker methods and options
+ * @example
+ * ```typescript
+ *
+ * // Generate faker data with entity.
+ * const name = jfaker.person.firstName();
+ *
+ * // Entity will always be generated using faker (safe: true)
+ * const name = jfaker.person.firstName({safe: true});
+ *
+ * // Generate faker data with options.
+ * const email = jfaker.internet.email({provider: 'example.com'});
+ *
+ * // Generate injection payloads (random between min and max items joined into a single string)..
+ * // Entity will always be generated using 'xss'.
+ * const xssName = jfaker.xss();
+ *
+ * // Generate injection payloads with specific length.
+ * // Entity will always be generated using 'xss'.
+ * const xssName = jfaker.xss({length: 100});
+ *
+ * // Use all SQL injections.
+ * // Entity will always be generated using 'sql'.
+ * const allSql = jfaker.sql({length: -1});
+ * ```
+ */
+const jfaker = new DeepApi((path, args) => {
+    // Handle non-faker methods first (escape, setFakeDataType, getFakeDataType)
+    switch (path) {
+        case 'escape':
+            return escape(args[0]);
+        case 'setDataType':
+            return setDataType(args[0]);
+        case 'getDataType':
+            return getDataType();
+        case Object.prototype.hasOwnProperty.call(injectionData, path) ? path : 'default':
+            // If the path corresponds to a valid injection type, generate data using that type,
+            // or fallback to default case which treats the path as a faker entity.
+            // Keep (safe === true) logic in "default" case for a readability.
+            return generateInjection(path, args[0]?.length);
+        default: {
+            // For faker data generation, check if the generation should be persistent based on global settings and options passed.
+            const safe = args[0]?.safe === true;
+            // Delete the 'safe' property from options to avoid passing it to faker methods
+            delete args[0]?.safe;
+
+            // Here path represents a faker entity.
+            // Check desired data type and 'safe' option to determine whether to generate faker data or injection data.
+            // If global type is set to injection (to override faker data) but safe is explicitly set to true in options -
+            // generate faker data for this specific call regardless of global settings.
+            if (getDataType() === 'faker' || safe) {
+                return generateFake(path, args[0]);
+            } else {
+                return generateInjection(getDataType(), args[0]?.length);
+            }
+        }
+    }
+}) as any;
+
+export {jfaker};

package/src/support/modSince.ts

@@ -0,0 +1,222 @@
+import {compare, validate} from 'compare-versions';
+// Intentionally keep explicit path to avoid edge case errors in runtime
+import {getJahiaVersion} from '../utils/JahiaPlatformHelper';
+
+/** Cypress environment variable key used to store the current Jahia version. */
+export const JAHIA_VERSION_ENV_VAR = 'CYPRESS_JAHIA_VERSION';
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace Mocha {
+        interface TestFunction {
+            since(requiredVersion: string, title: string, fn?: Func): Test;
+            since(requiredVersion: string, title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test;
+        }
+
+        interface ExclusiveTestFunction {
+            since(requiredVersion: string, title: string, fn?: Func): Test;
+            since(requiredVersion: string, title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test;
+        }
+
+        interface PendingTestFunction {
+            since(requiredVersion: string, title: string, fn?: Func): Test;
+            since(requiredVersion: string, title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test;
+        }
+
+        interface SuiteFunction {
+            since(requiredVersion: string, title: string, fn: (this: Suite) => void): Suite;
+        }
+
+        interface ExclusiveSuiteFunction {
+            since(requiredVersion: string, title: string, fn: (this: Suite) => void): Suite;
+        }
+
+        interface PendingSuiteFunction {
+            since(requiredVersion: string, title: string, fn: (this: Suite) => void): Suite;
+        }
+    }
+}
+
+// ─── Internal helpers ────────────────────────────────────────────────────────
+
+/**
+ * Returns `true` when `current` satisfies `>= required`.
+ * Treats missing, empty, or unparseable versions as unsupported.
+ * @param current - The running Jahia version read from `Cypress.env`.
+ * @param required - Minimum version the test or suite needs.
+ */
+const isSupported = (current: string | undefined, required: string): boolean => {
+    if (!current?.trim()) {
+        return false;
+    }
+
+    try {
+        return compare(String(current), required, '>=');
+    } catch {
+        return false;
+    }
+};
+
+/**
+ * Validates `since(...)` arguments and throws a descriptive error on misuse.
+ * Detects the common mistake of swapping `requiredVersion` and `title`.
+ * @param version - Version string passed as the first argument.
+ * @param title - Title string passed as the second argument.
+ * @param scope - Label used in the error message (e.g. `"it.since"`).
+ */
+const assertArgs = (version: string, title: string, scope: string): void => {
+    if (!validate(version)) {
+        const hint = validate(title) ? ' (arguments appear swapped)' : '';
+        throw new Error(`[${scope}] Invalid version: "${version}"${hint}.`);
+    }
+};
+
+/**
+ * Builds a human-readable message explaining why a test or suite was skipped.
+ * @param scope - Label for the helper (e.g. `"it.since"` or `"describe.since"`).
+ * @param title - Original test or suite title.
+ * @param required - Minimum version the test or suite needs.
+ * @param current - The running Jahia version; `undefined` when not yet fetched.
+ */
+const skipReason = (scope: string, title: string, required: string, current?: string): string =>
+    current ?
+        `[${scope}] Skipping "${title}" — ${JAHIA_VERSION_ENV_VAR}="${current}" < required ${required}.` :
+        `[${scope}] Skipping "${title}" — ${JAHIA_VERSION_ENV_VAR} is not set. Required: ${required}.`;
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Fetches the Jahia version from the GraphQL API, strips the `-SNAPSHOT` suffix,
+ * and caches the result in `Cypress.env(JAHIA_VERSION_ENV_VAR)`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const initializeVersionSupport = (): Cypress.Chainable<any> =>
+    getJahiaVersion().then(jahiaVersion => {
+        const version = jahiaVersion.release.replace('-SNAPSHOT', '');
+        Cypress.env(JAHIA_VERSION_ENV_VAR, version);
+        return version;
+    });
+
+/**
+ * Attaches `.since()` to `it`, `it.only`, `it.skip`, `describe`, `describe.only`,
+ * and `describe.skip`. Safe to call multiple times — subsequent calls are no-ops.
+ */
+export const registerVersionSupport = (): void => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mochaIt = globalThis.it as any;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mochaDescribe = globalThis.describe as any;
+
+    if (!mochaIt) {
+        throw new Error('Unable to register version support because Mocha `it` is not available.');
+    }
+
+    if (!mochaDescribe) {
+        throw new Error('Unable to register version support because Mocha `describe` is not available.');
+    }
+
+    // Attach .since() to it / it.only / it.skip
+    for (const target of [mochaIt, mochaIt.only, mochaIt.skip]) {
+        if (typeof target.since === 'function') {
+            continue;
+        }
+
+        const isSkip = target === mochaIt.skip;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        target.since = (version: string, title: string, configOrFn?: any, maybeFn?: any) => {
+            assertArgs(version, title, 'it.since');
+
+            if (isSkip) {
+                // It.skip.since: always skip unconditionally, preserve the title
+                return typeof configOrFn === 'function' || configOrFn === undefined ?
+                    target(title, configOrFn) :
+                    target(title, configOrFn, maybeFn);
+            }
+
+            const userFn = typeof configOrFn === 'function' ? configOrFn : maybeFn;
+            const wrappedFn = function (this: Mocha.Context) {
+                const current = Cypress.env(JAHIA_VERSION_ENV_VAR);
+                if (!isSupported(current, version)) {
+                    console.warn(skipReason('it.since', title, version, current));
+                    this.skip();
+                } else if (typeof userFn === 'function') {
+                    return userFn.call(this);
+                }
+            };
+
+            return typeof configOrFn === 'object' && configOrFn !== null ?
+                target(title, configOrFn, wrappedFn) :
+                target(title, wrappedFn);
+        };
+    }
+
+    // Attach .since() to describe / describe.only / describe.skip
+    for (const target of [mochaDescribe, mochaDescribe.only, mochaDescribe.skip]) {
+        if (typeof target.since === 'function') {
+            continue;
+        }
+
+        const isSkip = target === mochaDescribe.skip;
+        target.since = (version: string, title: string, fn: (this: Mocha.Suite) => void) => {
+            assertArgs(version, title, 'describe.since');
+
+            if (isSkip) {
+                // Describe.skip.since: always skip unconditionally, preserve the title
+                return target(title, fn);
+            }
+
+            return target(title, function (this: Mocha.Suite) {
+                // Suite-level runtime check runs after the global before() has fetched the version
+                before(function (this: Mocha.Context) {
+                    const current = Cypress.env(JAHIA_VERSION_ENV_VAR);
+                    if (!isSupported(current, version)) {
+                        console.warn(skipReason('describe.since', title, version, current));
+                        this.skip();
+                    }
+                });
+
+                fn.call(this);
+            });
+        };
+    }
+
+    // Compatibility shim: redirect accidental it.skip(version, title, fn) → it.skip.since(...)
+    const origItSkip = mochaIt.skip;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mochaIt.skip = Object.assign((title: string, configOrTitle?: any, maybeFn?: any) => {
+        if (validate(title) && typeof configOrTitle === 'string' && typeof maybeFn === 'function') {
+            return origItSkip.since(title, configOrTitle, maybeFn);
+        }
+
+        return typeof configOrTitle === 'function' || configOrTitle === undefined ?
+            origItSkip(title, configOrTitle) :
+            origItSkip(title, configOrTitle, maybeFn);
+    }, {since: origItSkip.since});
+
+    const origDescribeSkip = mochaDescribe.skip;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mochaDescribe.skip = Object.assign((title: string, fnOrTitle?: any, maybeFn?: any) => {
+        if (validate(title) && typeof fnOrTitle === 'string' && typeof maybeFn === 'function') {
+            return origDescribeSkip.since(title, fnOrTitle, maybeFn);
+        }
+
+        return origDescribeSkip(title, fnOrTitle);
+    }, {since: origDescribeSkip.since});
+};
+
+/**
+ * Enables version-gated testing for the Cypress suite.
+ * Registers `it.since`, `describe.since` (and their `.only`/`.skip` variants),
+ * then fetches the running Jahia version in a root `before()` hook.
+ *
+ * @example
+ * it.since('8.2.0', 'works on 8.2+', () => { ... });
+ * describe.since('8.2.0', 'suite for 8.2+', () => { ... });
+ */
+function enable(): void {
+    registerVersionSupport();
+    before(() => initializeVersionSupport());
+}
+
+/** Public API for Jahia version-gated testing. */
+export const modSince = {enable};

package/src/support/provisioning/executeGroovy.md

@@ -51,4 +51,10 @@ cy.executeGroovy("script.groovy").then(result => { console.log(result) })
 
 ## Command Log
 
-No log
+When clicking on `groovy` within the command log, the console outputs the following:
+
+- **Script**: The name of the Groovy script file executed.
+- **Replacements**: The replacement map applied to the script, if any.
+- **Server**: The Jahia server URL targeted.
+- **Duration**: Elapsed time from invocation to completion.
+- **Result**: The first operation result returned by the provisioning API.

package/src/support/provisioning/executeGroovy.ts

@@ -25,6 +25,41 @@ const serverDefaults = {
 };
 
 export const executeGroovy = function (scriptFile: string, replacements?: { [key: string]: string }, jahiaServer: JahiaServer = serverDefaults): void {
+    let result: any;
+    let duration: number;
+    let scriptContent: string;
+    const startTime = Date.now();
+
+    const replacementsLabel = replacements && Object.keys(replacements).length > 0 ?
+        ` — ${JSON.stringify(replacements)}` :
+        '';
+
+    const logger = Cypress.log({
+        autoEnd: false,
+        name: 'executeGroovy',
+        displayName: 'groovy',
+        message: `${scriptFile}${replacementsLabel}`,
+        consoleProps: () => ({
+            Script: scriptFile,
+            'Script Content': scriptContent ?? '(loading...)',
+            Replacements: replacements ?? {},
+            Server: jahiaServer.url,
+            Duration: duration === undefined ? 'pending' : `${duration}ms`,
+            Result: result
+        })
+    });
+
+    cy.fixture(scriptFile, 'utf-8').then((content: string) => {
+        let processed = content;
+        if (replacements) {
+            Object.keys(replacements).forEach(k => {
+                processed = processed.replaceAll(k, replacements[k]);
+            });
+        }
+
+        scriptContent = processed;
+    });
+
     cy.runProvisioningScript({
         script: {
             fileContent: '- executeScript: "' + scriptFile + '"',
@@ -36,6 +71,15 @@ export const executeGroovy = function (scriptFile: string, replacements?: { [key
             type: 'text/plain',
             encoding: 'utf-8'
         }],
-        jahiaServer
-    }).then(r => r[0]);
+        jahiaServer,
+        options: {log: false}
+    }).then(r => {
+        result = (r as any)?.[0];
+        duration = Date.now() - startTime;
+        const hasFailed = typeof result === 'string' && result.includes('.failed');
+        const prefix = hasFailed ? '❌ ' : '✅ ';
+        logger.set('message', `${prefix}${scriptFile}${replacementsLabel}`);
+        logger?.end();
+        return result;
+    });
 };

package/src/support/provisioning/runProvisioningScript.ts

@@ -82,16 +82,74 @@ const serverDefaults: JahiaServer = {
 };
 
 function isFormFile(script: FormFile | StringDictionary[]): script is FormFile {
-    return Boolean((script as FormFile).fileContent || (script as FormFile).fileName);
+    return Boolean((script as FormFile)?.fileContent || (script as FormFile)?.fileName);
 }
 
-export const runProvisioningScript = ({
-    script,
-    files,
-    jahiaServer = serverDefaults,
-    options = {log: true},
-    requestOptions = {}
-}: RunProvisioningScriptParams): void => {
+function getScriptSummary(script: FormFile | StringDictionary[]): string {
+    if (isFormFile(script)) {
+        if (script.fileName) {
+            return script.fileName;
+        }
+
+        if (script.fileContent) {
+            // Parse first operation and its value from YAML list: "- operationName: value"
+            const yamlMatch = script.fileContent.match(/^\s*-\s+(\w+)\s*:\s*"?([^"\n]+)"?/m);
+            if (yamlMatch) {
+                return `${yamlMatch[1]}: ${yamlMatch[2].trim()}`;
+            }
+
+            // Parse first operation name from JSON array: [{"operationName": ...}]
+            try {
+                const parsed = JSON.parse(script.fileContent);
+                if (Array.isArray(parsed) && parsed.length > 0) {
+                    const ops = parsed.map((op: Record<string, string>) => Object.keys(op)[0] ?? 'unknown');
+                    return ops.length === 1 ? ops[0] : `[${ops.join(', ')}]`;
+                }
+            } catch {
+                // Not valid JSON, fall through
+            }
+        }
+
+        return 'inline script';
+    }
+
+    if (!script || script.length === 0) {
+        return 'empty script';
+    }
+
+    const ops = script.map(op => Object.keys(op)[0] ?? 'unknown');
+    return ops.length === 1 ? ops[0] : `[${ops.join(', ')}]`;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const runProvisioningScript = (paramsOrScript: RunProvisioningScriptParams | FormFile | StringDictionary[], ...rest: any[]): void => {
+    // Backward-compatible: support old positional signature
+    // runProvisioningScript(script, files, jahiaServer, options, timeout)
+    let script: FormFile | StringDictionary[];
+    let files: FormFile[];
+    let jahiaServer: JahiaServer;
+    let options: Cypress.Loggable;
+    let requestOptions: Partial<Cypress.RequestOptions>;
+
+    const isLegacyCall = Array.isArray(paramsOrScript) ||
+        (paramsOrScript as FormFile).fileContent !== undefined ||
+        (paramsOrScript as FormFile).fileName !== undefined;
+
+    if (isLegacyCall) {
+        script = paramsOrScript as FormFile | StringDictionary[];
+        files = rest[0];
+        jahiaServer = rest[1] ?? serverDefaults;
+        options = rest[2] ?? {log: true};
+        requestOptions = {};
+    } else {
+        const params = paramsOrScript as RunProvisioningScriptParams;
+        script = params.script;
+        files = params.files;
+        jahiaServer = params.jahiaServer ?? serverDefaults;
+        options = params.options ?? {log: true};
+        requestOptions = params.requestOptions ?? {};
+    }
+
     const formData = new FormData();
 
     if (isFormFile(script)) {
@@ -115,18 +173,30 @@ export const runProvisioningScript = ({
     let result: any;
     let logger: Cypress.Log;
 
+    const scriptSummary = getScriptSummary(script);
+    const replacementsFromFiles = files
+        ?.filter(f => f.replacements && Object.keys(f.replacements).length > 0)
+        .map(f => `${f.fileName}: ${JSON.stringify(f.replacements)}`);
+
     if (options.log) {
         logger = Cypress.log({
             autoEnd: false,
             name: 'runProvisioningScript',
             displayName: 'provScript',
-            message: `Run ${isFormFile(script) && script.fileName ? script.fileName : 'inline script'} towards server: ${jahiaServer.url}`,
+            message: `${scriptSummary} @ ${jahiaServer.url}`,
             consoleProps: () => {
                 return {
                     Script: script,
-                    Files: files,
-                    Response: response,
-                    Yielded: result
+                    Operations: isFormFile(script) ?
+                        undefined :
+                        script?.map(op => `${Object.keys(op)[0]}: ${Object.values(op)[0]}`),
+                    Files: files?.map(f => f.fileName ?? 'inline file') ?? [],
+                    Replacements: replacementsFromFiles?.length > 0 ? replacementsFromFiles : undefined,
+                    Server: jahiaServer.url,
+                    'HTTP Status': response ? `${response.status} ${response.statusText}` : 'pending',
+                    Duration: response ? `${response.duration}ms` : 'pending',
+                    Result: result,
+                    Response: response
                 };
             }
         });
@@ -161,6 +231,13 @@ export const runProvisioningScript = ({
         }
 
         logger?.end();
+        if (logger) {
+            const hasFailed = res.status !== 200 ||
+                (Array.isArray(result) && result.some((r: any) => typeof r === 'string' && r.includes('.failed'))); // eslint-disable-line @typescript-eslint/no-explicit-any
+            const prefix = hasFailed ? '❌ ' : '✅ ';
+            logger.set('message', `${prefix}${scriptSummary} @ ${jahiaServer.url}`);
+        }
+
         return result;
     });
 };