@serenity-js/jasmine 3.37.2 → 3.39.0

package/src/SerenityReporterForJasmine.ts

@@ -46,6 +46,7 @@ import type {
     JasmineDoneInfo,
     JasmineReporter,
     JasmineStartedInfo,
+    Location,
     SpecResult,
     SuiteResult
 } from './jasmine/index.js';
@@ -62,11 +63,12 @@ export class SerenityReporterForJasmine implements JasmineReporter {
     private currentSceneId: CorrelationId = undefined;
 
     /**
-     * @param {Serenity} serenity
+     * @param serenity - The Serenity instance
+     * @param requirementsHierarchy - The requirements hierarchy for tagging
      */
     constructor(
         private readonly serenity: Serenity,
-        private readonly requirementsHierachy: RequirementsHierarchy
+        private readonly requirementsHierachy: RequirementsHierarchy,
     ) {
     }
 
@@ -112,12 +114,13 @@ export class SerenityReporterForJasmine implements JasmineReporter {
         if (result.failedExpectations.length > 1) {
             result.failedExpectations.forEach(failedExpectation => {
                 const sceneId = this.serenity.currentSceneId();
+                const location = this.locationOf(result);
                 const activityDetails = new ActivityDetails(
                     new Name('Expectation'),
                     new FileSystemLocation(
-                        Path.from(result.location.path),
-                        result.location.line,
-                        result.location.column,
+                        Path.from(location.path),
+                        location.line,
+                        location.column,
                     ),
                 );
 
@@ -136,6 +139,7 @@ export class SerenityReporterForJasmine implements JasmineReporter {
 
         this.emit(new SceneFinishes(
             this.currentSceneId,
+            outcome,
             this.serenity.currentTime(),
         ));
 
@@ -148,10 +152,14 @@ export class SerenityReporterForJasmine implements JasmineReporter {
                     this.serenity.currentTime(),
                 ));
             }, error => {
+                const errorOutcome = new ExecutionFailedWithError(error);
+
                 this.emit(new SceneFinished(
                     this.currentSceneId,
                     scenarioDetails,
-                    new ExecutionFailedWithError(error),
+                    errorOutcome.isWorseThan(outcome)
+                        ? errorOutcome
+                        : outcome,
                     this.serenity.currentTime(),
                 ));
 
@@ -180,6 +188,37 @@ export class SerenityReporterForJasmine implements JasmineReporter {
         events.forEach(event => this.serenity.announce(event));
     }
 
+    /**
+     * Extracts location information from a spec or suite result.
+     * Supports both Jasmine 5.x and 6.x (location object from monkey-patching).
+     *
+     * @private
+     * @param result - The spec or suite result
+     * @returns Location object with path, line, and column
+     */
+    private locationOf(result: SpecResult | SuiteResult): Location {
+        // Jasmine 5.x and 6.x with monkey-patching provides location object
+        if (result.location) {
+            return result.location;
+        }
+
+        // Fallback: use filename property if available (Jasmine 6.x without monkey-patching)
+        if (result.filename) {
+            return {
+                path: result.filename,
+                line: 0,
+                column: 0,
+            };
+        }
+
+        // Fallback for edge cases
+        return {
+            path: 'unknown',
+            line: 0,
+            column: 0,
+        };
+    }
+
     /**
      * @private
      * @param {SpecResult} spec
@@ -188,12 +227,17 @@ export class SerenityReporterForJasmine implements JasmineReporter {
     private scenarioDetailsOf(spec: SpecResult): { scenarioDetails: ScenarioDetails, scenarioTags: Tag[] } {
         const name = this.currentScenarioNameFor(spec.description);
         const featureName = this.currentFeatureNameFor(spec);
+        const location = this.locationOf(spec);
 
         return {
             scenarioDetails: new ScenarioDetails(
                 new Name(Tags.stripFrom(name)),
                 new Category(Tags.stripFrom(featureName)),
-                FileSystemLocation.fromJSON(spec.location as any),
+                new FileSystemLocation(
+                    Path.from(location.path),
+                    location.line,
+                    location.column,
+                ),
             ),
             scenarioTags: Tags.from(`${ featureName } ${ name }`)
         };
@@ -205,9 +249,15 @@ export class SerenityReporterForJasmine implements JasmineReporter {
      * @returns {TestSuiteDetails}
      */
     private testSuiteDetailsOf(result: SuiteResult): TestSuiteDetails {
+        const location = this.locationOf(result);
+
         return new TestSuiteDetails(
             new Name(result.description),
-            FileSystemLocation.fromJSON(result.location as any),
+            new FileSystemLocation(
+                Path.from(location.path),
+                location.line,
+                location.column,
+            ),
             new CorrelationId(result.id),
         );
     }
@@ -217,7 +267,8 @@ export class SerenityReporterForJasmine implements JasmineReporter {
      * @returns {string}
      */
     private currentFeatureNameFor(spec: SpecResult): string {
-        const path = new Path(spec.location.path);
+        const location = this.locationOf(spec);
+        const path = new Path(location.path);
 
         return this.describes[0]
             ? this.describes[0].description
@@ -249,7 +300,7 @@ export class SerenityReporterForJasmine implements JasmineReporter {
                 return new ImplementationPending(new ImplementationPendingError((result as any).pendingReason || ''));
             case 'excluded':
                 return new ExecutionSkipped();
-            case 'passed':  // eslint-disable-line unicorn/no-useless-switch-case
+            case 'passed':
             default:
                 return new ExecutionSuccessful();
         }

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;
     };