@serenity-js/jasmine 3.38.0 → 3.39.0

package/src/bootstrap.ts

@@ -5,8 +5,13 @@ import { monkeyPatched } from './monkeyPatched.js';
 import { SerenityReporterForJasmine } from './SerenityReporterForJasmine.js';
 
 /**
- * Monkey-patches Jasmine's Suite and Spec so that they provide more accurate information,
- * and returns a bootstrapped instance of the [`SerenityReporterForJasmine`](https://serenity-js.org/api/jasmine/function/default/) to be registered with Jasmine.
+ * Bootstraps the Serenity/JS reporter for Jasmine.
+ *
+ * This function monkey-patches Jasmine's Suite and Spec constructors
+ * so that they provide more accurate location information.
+ *
+ * For Jasmine 5.x, Suite and Spec are on the jasmine object directly.
+ * For Jasmine 6.x, Suite and Spec are in jasmine.private.
  *
  * ## Registering the reporter from the command line
  *
@@ -27,20 +32,42 @@ import { SerenityReporterForJasmine } from './SerenityReporterForJasmine.js';
  *  the global.jasmine instance
  */
 export function bootstrap(config: SerenityReporterForJasmineConfig = {}, jasmine = (global as any).jasmine): SerenityReporterForJasmine {
-    const wrappers = {
-        expectationResultFactory: originalExpectationResultFactory => ((attributes: { passed: boolean, error: Error }) => {
-            const result = originalExpectationResultFactory(attributes);
 
-            if (! attributes.passed && attributes.error instanceof RuntimeError) {
-                result.stack = attributes.error.stack;
-            }
+    // Jasmine 6+ moved Suite and Spec to jasmine.private,
+    // so we check both locations for backwards compatibility
+    const Suite = jasmine.Suite || jasmine.private?.Suite;
+    const Spec = jasmine.Spec || jasmine.private?.Spec;
 
-            return result;
-        }),
-    };
+    if (Suite && Spec) {
+        // Monkey-patch Suite and Spec to capture location info
+        const wrappers = {
+            expectationResultFactory: originalExpectationResultFactory => ((attributes: { passed: boolean, error: Error }) => {
+                const result = originalExpectationResultFactory(attributes);
+
+                if (! attributes.passed && attributes.error instanceof RuntimeError) {
+                    result.stack = attributes.error.stack;
+                }
 
-    jasmine.Suite = monkeyPatched(jasmine.Suite, wrappers);
-    jasmine.Spec = monkeyPatched(jasmine.Spec, wrappers);
+                return result;
+            }),
+        };
+
+        // Jasmine 5.x: Suite and Spec are on jasmine directly
+        if (jasmine.Suite && jasmine.Spec) {
+            jasmine.Suite = monkeyPatched(jasmine.Suite, wrappers);
+            jasmine.Spec = monkeyPatched(jasmine.Spec, wrappers);
+        }
+        // Jasmine 6+: Suite and Spec are in jasmine.private
+        else if (jasmine.private?.Suite && jasmine.private?.Spec) {
+            jasmine.private.Suite = monkeyPatched(jasmine.private.Suite, wrappers);
+            jasmine.private.Spec = monkeyPatched(jasmine.private.Spec, wrappers);
+        }
+    }
+
+    // For Jasmine 6+, patch the Expector and buildExpectationResult to restore expected/actual values
+    // This is needed because Jasmine 6 removed these from expectation results
+    patchBuildExpectationResultForExpectedActual(jasmine);
+    patchExpectorForExpectedActual(jasmine);
 
     const cwd = Path.from(process.cwd());
     const requirementsHierarchy = new RequirementsHierarchy(
@@ -51,6 +78,78 @@ export function bootstrap(config: SerenityReporterForJasmineConfig = {}, jasmine
     return new SerenityReporterForJasmine(serenity, requirementsHierarchy);
 }
 
+/**
+ * Patches Jasmine's buildExpectationResult to include expected/actual values
+ * in the expectation result. This restores functionality that was removed in Jasmine 6.
+ *
+ * In Jasmine 6, the buildExpectationResult function no longer includes expected/actual
+ * values in the result object. This patch wraps the function to preserve these values
+ * when they are provided.
+ *
+ * @param jasmine - The global jasmine instance
+ */
+function patchBuildExpectationResultForExpectedActual(jasmine: any): void {
+    // Access the private buildExpectationResult function
+    const originalBuildExpectationResult = jasmine?.private?.buildExpectationResult;
+
+    if (!originalBuildExpectationResult) {
+        // buildExpectationResult not available, skip
+        return;
+    }
+
+    jasmine.private.buildExpectationResult = function(options: any): any {
+        const result = originalBuildExpectationResult(options);
+
+        // Restore expected/actual values that Jasmine 6 removed
+        if (options.expected !== undefined) {
+            result.expected = options.expected;
+        }
+        if (options.actual !== undefined) {
+            result.actual = options.actual;
+        }
+
+        return result;
+    };
+}
+
+/**
+ * Patches Jasmine's Expector.prototype.processResult to include expected/actual values
+ * when calling addExpectationResult. This ensures the values are passed to
+ * buildExpectationResult.
+ *
+ * @param jasmine - The global jasmine instance
+ */
+function patchExpectorForExpectedActual(jasmine: any): void {
+    // Access the private Expector class through jasmine's internal structure
+    // In Jasmine 6+, Expector is in jasmine.private.Expector
+    const Expector = jasmine?.private?.Expector;
+
+    if (!Expector || !Expector.prototype || !Expector.prototype.processResult) {
+        // Expector not available, skip
+        return;
+    }
+
+    Expector.prototype.processResult = function(result: any, errorForStack?: Error): void {
+        const message = this.buildMessage(result);
+
+        let expected = this.expected;
+        if (Array.isArray(expected) && expected.length === 1) {
+            expected = expected[0];
+        }
+
+        this.addExpectationResult(result.pass, {
+            matcherName: this.matcherName,
+            passed: result.pass,
+            message: message,
+            error: errorForStack ? undefined : result.error,
+            errorForStack: errorForStack || undefined,
+            // Include expected/actual values that Jasmine 6 removed
+            expected: expected,
+            actual: this.actual,
+        });
+    };
+}
+
 export interface SerenityReporterForJasmineConfig {
     specDirectory?: string;
 }

package/src/jasmine/SpecResult.ts

@@ -29,5 +29,15 @@ export interface SpecResult {
     /** The time in ms used by the spec execution, including any before/afterEach. */
     duration: number | null;
 
-    location: Location;
+    /**
+     * The file system location of the spec.
+     * Available in Jasmine 5.x and earlier when monkey-patched by Serenity/JS.
+     */
+    location?: Location;
+
+    /**
+     * The filename where the spec is defined.
+     * Available in Jasmine 6.x and later.
+     */
+    filename?: string;
 }

package/src/jasmine/SuiteResult.ts

@@ -28,5 +28,15 @@ export interface SuiteResult extends Result {
     /** The time in ms for Suite execution, including any before/afterAll, before/afterEach. */
     duration: number | null;
 
-    location: Location;
+    /**
+     * The file system location of the suite.
+     * Available in Jasmine 5.x and earlier when monkey-patched by Serenity/JS.
+     */
+    location?: Location;
+
+    /**
+     * The filename where the suite is defined.
+     * Available in Jasmine 6.x and later.
+     */
+    filename?: string;
 }

package/src/jasmine/index.ts

@@ -2,6 +2,7 @@ export * from './Expectation.js';
 export * from './JasmineDoneInfo.js';
 export * from './JasmineReporter.js';
 export * from './JasmineStartedInfo.js';
+export * from './Location.js';
 export * from './Order.js';
 export * from './SpecResult.js';
 export * from './SuiteResult.js';

package/src/monkeyPatched.ts

@@ -2,7 +2,7 @@ import { ErrorStackParser } from '@serenity-js/core/lib/errors/index.js';
 
 const parser = new ErrorStackParser();
 
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 
 /**
  * Monkey-patches Jasmine domain model constructors so that they
@@ -10,6 +10,10 @@ const parser = new ErrorStackParser();
  *
  * This helps to make reporting more accurate.
  *
+ * For Jasmine 5.x, the location is stored on instance.result.location.
+ * For Jasmine 6.x, the location is stored on instance._serenityLocation and
+ * injected into the result events via patched startedEvent/doneEvent methods.
+ *
  * @param jasmineConstructor - A Jasmine constructor function to be patched
  * @param {object} wrappers - Attributes to wrap when the monkey-patched Jasmine constructor is invoked
  */
@@ -23,7 +27,40 @@ export function monkeyPatched(
         });
 
         const instance = new jasmineConstructor(attrs);
-        instance.result.location = callerLocation();
+        const location = callerLocation();
+
+        // Jasmine 5.x: instance.result exists, store location there
+        if (instance.result) {
+            instance.result.location = location;
+        }
+        // Jasmine 6.x: store location on instance and patch event methods
+        else {
+            instance._serenityLocation = location;
+
+            // Patch startedEvent to include location
+            if (typeof instance.startedEvent === 'function') {
+                const originalStartedEvent = instance.startedEvent.bind(instance);
+                instance.startedEvent = function() {
+                    const event = originalStartedEvent();
+                    if (event && instance._serenityLocation) {
+                        event.location = instance._serenityLocation;
+                    }
+                    return event;
+                };
+            }
+
+            // Patch doneEvent to include location
+            if (typeof instance.doneEvent === 'function') {
+                const originalDoneEvent = instance.doneEvent.bind(instance);
+                instance.doneEvent = function() {
+                    const event = originalDoneEvent();
+                    if (event && instance._serenityLocation) {
+                        event.location = instance._serenityLocation;
+                    }
+                    return event;
+                };
+            }
+        }
 
         return instance;
     };