@jahia/cypress 8.0.0 → 8.1.0

package/dist/support/modSince.d.ts

@@ -0,0 +1,52 @@
+/** Cypress environment variable key used to store the current Jahia version. */
+export declare const JAHIA_VERSION_ENV_VAR = "CYPRESS_JAHIA_VERSION";
+declare global {
+    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;
+        }
+    }
+}
+/**
+ * Fetches the Jahia version from the GraphQL API, strips the `-SNAPSHOT` suffix,
+ * and caches the result in `Cypress.env(JAHIA_VERSION_ENV_VAR)`.
+ */
+export declare const initializeVersionSupport: () => Cypress.Chainable<any>;
+/**
+ * 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 declare const registerVersionSupport: () => void;
+/**
+ * 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+', () => { ... });
+ */
+declare function enable(): void;
+/** Public API for Jahia version-gated testing. */
+export declare const modSince: {
+    enable: typeof enable;
+};
+export {};

package/dist/support/modSince.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modSince = exports.registerVersionSupport = exports.initializeVersionSupport = exports.JAHIA_VERSION_ENV_VAR = void 0;
+var compare_versions_1 = require("compare-versions");
+// Intentionally keep explicit path to avoid edge case errors in runtime
+var JahiaPlatformHelper_1 = require("../utils/JahiaPlatformHelper");
+/** Cypress environment variable key used to store the current Jahia version. */
+exports.JAHIA_VERSION_ENV_VAR = 'CYPRESS_JAHIA_VERSION';
+// ─── 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.
+ */
+var isSupported = function (current, required) {
+    if (!(current === null || current === void 0 ? void 0 : current.trim())) {
+        return false;
+    }
+    try {
+        return (0, compare_versions_1.compare)(String(current), required, '>=');
+    }
+    catch (_a) {
+        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"`).
+ */
+var assertArgs = function (version, title, scope) {
+    if (!(0, compare_versions_1.validate)(version)) {
+        var hint = (0, compare_versions_1.validate)(title) ? ' (arguments appear swapped)' : '';
+        throw new Error("[".concat(scope, "] Invalid version: \"").concat(version, "\"").concat(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.
+ */
+var skipReason = function (scope, title, required, current) {
+    return current ?
+        "[".concat(scope, "] Skipping \"").concat(title, "\" \u2014 ").concat(exports.JAHIA_VERSION_ENV_VAR, "=\"").concat(current, "\" < required ").concat(required, ".") :
+        "[".concat(scope, "] Skipping \"").concat(title, "\" \u2014 ").concat(exports.JAHIA_VERSION_ENV_VAR, " is not set. Required: ").concat(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
+var initializeVersionSupport = function () {
+    return (0, JahiaPlatformHelper_1.getJahiaVersion)().then(function (jahiaVersion) {
+        var version = jahiaVersion.release.replace('-SNAPSHOT', '');
+        Cypress.env(exports.JAHIA_VERSION_ENV_VAR, version);
+        return version;
+    });
+};
+exports.initializeVersionSupport = initializeVersionSupport;
+/**
+ * Attaches `.since()` to `it`, `it.only`, `it.skip`, `describe`, `describe.only`,
+ * and `describe.skip`. Safe to call multiple times — subsequent calls are no-ops.
+ */
+var registerVersionSupport = function () {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var mochaIt = globalThis.it;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var mochaDescribe = globalThis.describe;
+    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.');
+    }
+    var _loop_1 = function (target) {
+        if (typeof target.since === 'function') {
+            return "continue";
+        }
+        var isSkip = target === mochaIt.skip;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        target.since = function (version, title, configOrFn, maybeFn) {
+            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);
+            }
+            var userFn = typeof configOrFn === 'function' ? configOrFn : maybeFn;
+            var wrappedFn = function () {
+                var current = Cypress.env(exports.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 it / it.only / it.skip
+    for (var _i = 0, _a = [mochaIt, mochaIt.only, mochaIt.skip]; _i < _a.length; _i++) {
+        var target = _a[_i];
+        _loop_1(target);
+    }
+    var _loop_2 = function (target) {
+        if (typeof target.since === 'function') {
+            return "continue";
+        }
+        var isSkip = target === mochaDescribe.skip;
+        target.since = function (version, title, fn) {
+            assertArgs(version, title, 'describe.since');
+            if (isSkip) {
+                // Describe.skip.since: always skip unconditionally, preserve the title
+                return target(title, fn);
+            }
+            return target(title, function () {
+                // Suite-level runtime check runs after the global before() has fetched the version
+                before(function () {
+                    var current = Cypress.env(exports.JAHIA_VERSION_ENV_VAR);
+                    if (!isSupported(current, version)) {
+                        console.warn(skipReason('describe.since', title, version, current));
+                        this.skip();
+                    }
+                });
+                fn.call(this);
+            });
+        };
+    };
+    // Attach .since() to describe / describe.only / describe.skip
+    for (var _b = 0, _c = [mochaDescribe, mochaDescribe.only, mochaDescribe.skip]; _b < _c.length; _b++) {
+        var target = _c[_b];
+        _loop_2(target);
+    }
+    // Compatibility shim: redirect accidental it.skip(version, title, fn) → it.skip.since(...)
+    var origItSkip = mochaIt.skip;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mochaIt.skip = Object.assign(function (title, configOrTitle, maybeFn) {
+        if ((0, compare_versions_1.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 });
+    var origDescribeSkip = mochaDescribe.skip;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mochaDescribe.skip = Object.assign(function (title, fnOrTitle, maybeFn) {
+        if ((0, compare_versions_1.validate)(title) && typeof fnOrTitle === 'string' && typeof maybeFn === 'function') {
+            return origDescribeSkip.since(title, fnOrTitle, maybeFn);
+        }
+        return origDescribeSkip(title, fnOrTitle);
+    }, { since: origDescribeSkip.since });
+};
+exports.registerVersionSupport = registerVersionSupport;
+/**
+ * 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() {
+    (0, exports.registerVersionSupport)();
+    before(function () { return (0, exports.initializeVersionSupport)(); });
+}
+/** Public API for Jahia version-gated testing. */
+exports.modSince = { enable: enable };

package/dist/support/provisioning/executeGroovy.js

@@ -10,6 +10,36 @@ var serverDefaults = {
 };
 var executeGroovy = function (scriptFile, replacements, jahiaServer) {
     if (jahiaServer === void 0) { jahiaServer = serverDefaults; }
+    var result;
+    var duration;
+    var scriptContent;
+    var startTime = Date.now();
+    var replacementsLabel = replacements && Object.keys(replacements).length > 0 ?
+        " \u2014 ".concat(JSON.stringify(replacements)) :
+        '';
+    var logger = Cypress.log({
+        autoEnd: false,
+        name: 'executeGroovy',
+        displayName: 'groovy',
+        message: "".concat(scriptFile).concat(replacementsLabel),
+        consoleProps: function () { return ({
+            Script: scriptFile,
+            'Script Content': scriptContent !== null && scriptContent !== void 0 ? scriptContent : '(loading...)',
+            Replacements: replacements !== null && replacements !== void 0 ? replacements : {},
+            Server: jahiaServer.url,
+            Duration: duration === undefined ? 'pending' : "".concat(duration, "ms"),
+            Result: result
+        }); }
+    });
+    cy.fixture(scriptFile, 'utf-8').then(function (content) {
+        var processed = content;
+        if (replacements) {
+            Object.keys(replacements).forEach(function (k) {
+                processed = processed.replaceAll(k, replacements[k]);
+            });
+        }
+        scriptContent = processed;
+    });
     cy.runProvisioningScript({
         script: {
             fileContent: '- executeScript: "' + scriptFile + '"',
@@ -21,7 +51,16 @@ var executeGroovy = function (scriptFile, replacements, jahiaServer) {
                 type: 'text/plain',
                 encoding: 'utf-8'
             }],
-        jahiaServer: jahiaServer
-    }).then(function (r) { return r[0]; });
+        jahiaServer: jahiaServer,
+        options: { log: false }
+    }).then(function (r) {
+        result = r === null || r === void 0 ? void 0 : r[0];
+        duration = Date.now() - startTime;
+        var hasFailed = typeof result === 'string' && result.includes('.failed');
+        var prefix = hasFailed ? '❌ ' : '✅ ';
+        logger.set('message', "".concat(prefix).concat(scriptFile).concat(replacementsLabel));
+        logger === null || logger === void 0 ? void 0 : logger.end();
+        return result;
+    });
 };
 exports.executeGroovy = executeGroovy;

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

@@ -29,4 +29,4 @@ export type JahiaServer = {
     username: string;
     password: string;
 };
-export declare const runProvisioningScript: ({ script, files, jahiaServer, options, requestOptions }: RunProvisioningScriptParams) => void;
+export declare const runProvisioningScript: (paramsOrScript: RunProvisioningScriptParams | FormFile | StringDictionary[], ...rest: any[]) => void;

package/dist/support/provisioning/runProvisioningScript.js

@@ -52,10 +52,71 @@ var serverDefaults = {
     password: Cypress.env('SUPER_USER_PASSWORD')
 };
 function isFormFile(script) {
-    return Boolean(script.fileContent || script.fileName);
+    return Boolean((script === null || script === void 0 ? void 0 : script.fileContent) || (script === null || script === void 0 ? void 0 : script.fileName));
 }
-var runProvisioningScript = function (_a) {
-    var script = _a.script, files = _a.files, _b = _a.jahiaServer, jahiaServer = _b === void 0 ? serverDefaults : _b, _c = _a.options, options = _c === void 0 ? { log: true } : _c, _d = _a.requestOptions, requestOptions = _d === void 0 ? {} : _d;
+function getScriptSummary(script) {
+    if (isFormFile(script)) {
+        if (script.fileName) {
+            return script.fileName;
+        }
+        if (script.fileContent) {
+            // Parse first operation and its value from YAML list: "- operationName: value"
+            var yamlMatch = script.fileContent.match(/^\s*-\s+(\w+)\s*:\s*"?([^"\n]+)"?/m);
+            if (yamlMatch) {
+                return "".concat(yamlMatch[1], ": ").concat(yamlMatch[2].trim());
+            }
+            // Parse first operation name from JSON array: [{"operationName": ...}]
+            try {
+                var parsed = JSON.parse(script.fileContent);
+                if (Array.isArray(parsed) && parsed.length > 0) {
+                    var ops_1 = parsed.map(function (op) { var _a; return (_a = Object.keys(op)[0]) !== null && _a !== void 0 ? _a : 'unknown'; });
+                    return ops_1.length === 1 ? ops_1[0] : "[".concat(ops_1.join(', '), "]");
+                }
+            }
+            catch (_a) {
+                // Not valid JSON, fall through
+            }
+        }
+        return 'inline script';
+    }
+    if (!script || script.length === 0) {
+        return 'empty script';
+    }
+    var ops = script.map(function (op) { var _a; return (_a = Object.keys(op)[0]) !== null && _a !== void 0 ? _a : 'unknown'; });
+    return ops.length === 1 ? ops[0] : "[".concat(ops.join(', '), "]");
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var runProvisioningScript = function (paramsOrScript) {
+    var _a, _b, _c, _d, _e;
+    var rest = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rest[_i - 1] = arguments[_i];
+    }
+    // Backward-compatible: support old positional signature
+    // runProvisioningScript(script, files, jahiaServer, options, timeout)
+    var script;
+    var files;
+    var jahiaServer;
+    var options;
+    var requestOptions;
+    var isLegacyCall = Array.isArray(paramsOrScript) ||
+        paramsOrScript.fileContent !== undefined ||
+        paramsOrScript.fileName !== undefined;
+    if (isLegacyCall) {
+        script = paramsOrScript;
+        files = rest[0];
+        jahiaServer = (_a = rest[1]) !== null && _a !== void 0 ? _a : serverDefaults;
+        options = (_b = rest[2]) !== null && _b !== void 0 ? _b : { log: true };
+        requestOptions = {};
+    }
+    else {
+        var params = paramsOrScript;
+        script = params.script;
+        files = params.files;
+        jahiaServer = (_c = params.jahiaServer) !== null && _c !== void 0 ? _c : serverDefaults;
+        options = (_d = params.options) !== null && _d !== void 0 ? _d : { log: true };
+        requestOptions = (_e = params.requestOptions) !== null && _e !== void 0 ? _e : {};
+    }
     var formData = new FormData();
     if (isFormFile(script)) {
         append(script, formData, 'script');
@@ -76,18 +137,28 @@ var runProvisioningScript = function (_a) {
     // eslint-disable-next-line  @typescript-eslint/no-explicit-any
     var result;
     var logger;
+    var scriptSummary = getScriptSummary(script);
+    var replacementsFromFiles = files === null || files === void 0 ? void 0 : files.filter(function (f) { return f.replacements && Object.keys(f.replacements).length > 0; }).map(function (f) { return "".concat(f.fileName, ": ").concat(JSON.stringify(f.replacements)); });
     if (options.log) {
         logger = Cypress.log({
             autoEnd: false,
             name: 'runProvisioningScript',
             displayName: 'provScript',
-            message: "Run ".concat(isFormFile(script) && script.fileName ? script.fileName : 'inline script', " towards server: ").concat(jahiaServer.url),
+            message: "".concat(scriptSummary, " @ ").concat(jahiaServer.url),
             consoleProps: function () {
+                var _a;
                 return {
                     Script: script,
-                    Files: files,
-                    Response: response,
-                    Yielded: result
+                    Operations: isFormFile(script) ?
+                        undefined :
+                        script === null || script === void 0 ? void 0 : script.map(function (op) { return "".concat(Object.keys(op)[0], ": ").concat(Object.values(op)[0]); }),
+                    Files: (_a = files === null || files === void 0 ? void 0 : files.map(function (f) { var _a; return (_a = f.fileName) !== null && _a !== void 0 ? _a : 'inline file'; })) !== null && _a !== void 0 ? _a : [],
+                    Replacements: (replacementsFromFiles === null || replacementsFromFiles === void 0 ? void 0 : replacementsFromFiles.length) > 0 ? replacementsFromFiles : undefined,
+                    Server: jahiaServer.url,
+                    'HTTP Status': response ? "".concat(response.status, " ").concat(response.statusText) : 'pending',
+                    Duration: response ? "".concat(response.duration, "ms") : 'pending',
+                    Result: result,
+                    Response: response
                 };
             }
         });
@@ -113,6 +184,12 @@ var runProvisioningScript = function (_a) {
             result = res;
         }
         logger === null || logger === void 0 ? void 0 : logger.end();
+        if (logger) {
+            var hasFailed = res.status !== 200 ||
+                (Array.isArray(result) && result.some(function (r) { return typeof r === 'string' && r.includes('.failed'); })); // eslint-disable-line @typescript-eslint/no-explicit-any
+            var prefix = hasFailed ? '❌ ' : '✅ ';
+            logger.set('message', "".concat(prefix).concat(scriptSummary, " @ ").concat(jahiaServer.url));
+        }
         return result;
     });
 };

package/dist/support/registerSupport.js

@@ -1,4 +1,15 @@
 "use strict";
+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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerSupport = void 0;
 var apollo_1 = require("./apollo");
@@ -8,6 +19,8 @@ var logout_1 = require("./logout");
 var fixture_1 = require("./fixture");
 var repeatUntil_1 = require("./repeatUntil");
 var testStep_1 = require("./testStep");
+var jfaker_1 = require("./jfaker");
+var modSince_1 = require("./modSince");
 var registerSupport = function () {
     Cypress.Commands.add('apolloClient', apollo_1.apolloClient);
     Cypress.Commands.add('apollo', { prevSubject: 'optional' }, apollo_1.apollo);
@@ -22,5 +35,26 @@ var registerSupport = function () {
     Cypress.Commands.add('repeatUntil', repeatUntil_1.repeatUntil);
     Cypress.Commands.overwrite('fixture', fixture_1.fixture);
     Cypress.Commands.add('step', testStep_1.step);
+    // Register it.since()/describe.since()
+    modSince_1.modSince.enable();
+    /**
+     * Override Cypress `type()` command to interpret special characters (e.g., {, }, etc.) either literally or as commands.
+     * The behavior is controlled by the `parseSpecialCharSequences` option, which can be set to `true`
+     * to enable command parsing or `false` to treat special characters as literal input.
+     *
+     * Since Cypress `clear()` command is an alias for `.type('{selectall}{del}')`,
+     * such case has to be handled to ensure that the special character sequences are properly interpreted when clearing the input.
+     * Also cover older Cypress versions which were using {backspace} was used instead of {del} .
+     */
+    Cypress.Commands.overwrite('type', function (originalFn, element, text, options) {
+        if (options === void 0) { options = {}; }
+        // Check if this is Cypress `.clear() call
+        var isCypressClearSequence = ['{selectall}{del}', '{selectall}{backspace}'].includes(text.toString());
+        // Do not override if this is `.clear()` call or data type is `faker`
+        var parseSpecialCharSequences = isCypressClearSequence || jfaker_1.jfaker.getDataType() === 'faker';
+        // Merge options with passed ones (if any)
+        var newOptions = __assign({ parseSpecialCharSequences: parseSpecialCharSequences }, options);
+        return originalFn(element, text, newOptions);
+    });
 };
 exports.registerSupport = registerSupport;

package/docs/browser-helper.md

@@ -0,0 +1,158 @@
+# Browser Helpers
+
+## Overview
+
+The Browser Helpers module provides exported helper functions for debugging and managing browser storage (`cookies`, `localStorage`, `sessionStorage`) in Cypress tests.
+
+Warning: These helpers log full storage/cookie values by design. Use carefully in automated runs to avoid leaking tokens, credentials, or session identifiers in logs.
+
+## Import and Usage Model
+
+```typescript
+import {BrowserHelper} from '@jahia/cypress';
+
+it('inspects browser state', () => {
+  cy.login();
+  BrowserHelper.logCookies();
+  BrowserHelper.logLocalStorage();
+});
+```
+
+## Available Helpers
+
+### `BrowserHelper.logCookies()`
+
+Logs all available cookies with metadata and values.
+
+- Returns: `Cypress.Chainable<void>`
+- Typical use: inspect authentication and security cookie attributes during debugging
+
+### `BrowserHelper.logCookie(cookieName)`
+
+Logs one cookie by name in a detailed format.
+
+- Parameters: `cookieName: string`
+- Returns: `Cypress.Chainable<void>`
+
+### `BrowserHelper.clearSessionCookies()`
+
+Clears only session cookies.
+
+- Returns: `Cypress.Chainable<void>`
+
+### `BrowserHelper.clearPersistentCookies()`
+
+Clears only persistent cookies.
+
+- Returns: `Cypress.Chainable<void>`
+
+### `BrowserHelper.simulateClose()`
+
+Simulates a browser close by clearing `sessionStorage` and session cookies only.
+
+- Returns: `void`
+- Clears: session cookies + all `sessionStorage`
+- Keeps: persistent cookies + `localStorage`
+
+### `BrowserHelper.resetState()`
+
+Resets browser client-side state by clearing all cookies and all storages.
+
+- Returns: `void`
+- Clears: all cookies + all `localStorage` + all `sessionStorage`
+
+### `BrowserHelper.logSessionStorage()`
+
+Logs all `sessionStorage` entries grouped by origin.
+
+- Returns: `Cypress.Chainable<void>`
+
+### `BrowserHelper.logLocalStorage()`
+
+Logs all `localStorage` entries grouped by origin.
+
+- Returns: `Cypress.Chainable<void>`
+
+## Integration Examples
+
+### Authentication Debugging
+
+```typescript
+import {BrowserHelper} from '@jahia/cypress';
+
+describe('Authentication Flow', () => {
+  it('keeps session after reload', () => {
+    cy.step('Login', () => {
+      cy.login('testuser@example.com', 'password');
+      BrowserHelper.logCookie('JSESSIONID');
+      cy.get('[data-testid="dashboard"]').should('be.visible');
+    });
+
+    cy.step('Reload page', () => {
+      cy.reload();
+      BrowserHelper.logCookie('JSESSIONID');
+      cy.get('[data-testid="dashboard"]').should('be.visible');
+    });
+  });
+});
+```
+
+### Simulate Browser Close
+
+```typescript
+import {BrowserHelper} from '@jahia/cypress';
+
+it('validates behavior after browser close', () => {
+  cy.login();
+  BrowserHelper.logCookies();
+
+  // Simulate browser close (clears session cookies and session storage)
+  BrowserHelper.simulateClose();
+
+  // Visit the app again to see the effect of reset
+  cy.visit(url);
+
+  BrowserHelper.logCookies();
+  BrowserHelper.logSessionStorage();
+});
+```
+
+### Simulate Browser Reset (clear all cookies and storages)
+
+```typescript
+import {BrowserHelper} from '@jahia/cypress';
+
+it('validates behavior after full browser reset', () => {
+    cy.login();
+    BrowserHelper.logCookies();
+
+    // Reset all browser state
+    BrowserHelper.resetState();
+
+    // Visit the app again to see the effect of reset
+    cy.visit(url); 
+
+    BrowserHelper.logCookies();
+    BrowserHelper.logSessionStorage();
+});
+```
+
+## Best Practices
+
+1. Use these helpers for interactive debugging, not as regular test assertions.
+2. Avoid running full storage/cookie logging in CI unless required.
+3. Prefer targeted checks (`logCookie`) over full dumps (`logCookies`) for sensitive environments.
+4. Use `resetState()` for hard test isolation, and `simulateClose()` for realistic session lifecycle checks.
+
+## API Reference
+
+| Helper | Parameters | Returns | Description |
+|--------|------------|---------|-------------|
+| `BrowserHelper.logCookies()` | - | `Cypress.Chainable<void>` | Logs all cookies with full metadata |
+| `BrowserHelper.logCookie(cookieName)` | `string` | `Cypress.Chainable<void>` | Logs one cookie by name |
+| `BrowserHelper.clearSessionCookies()` | - | `Cypress.Chainable<void>` | Clears session cookies only |
+| `BrowserHelper.clearPersistentCookies()` | - | `Cypress.Chainable<void>` | Clears persistent cookies only |
+| `BrowserHelper.simulateClose()` | - | `void` | Clears session storage and session cookies |
+| `BrowserHelper.resetState()` | - | `void` | Clears all storages and all cookies |
+| `BrowserHelper.logSessionStorage()` | - | `Cypress.Chainable<void>` | Logs all session storage data |
+| `BrowserHelper.logLocalStorage()` | - | `Cypress.Chainable<void>` | Logs all local storage data |