@wdio/jasmine-framework 7.17.0 → 7.19.0

package/build/index.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="node" />
+/// <reference types="expect-webdriverio/types/expect-webdriverio" />
+import Jasmine from 'jasmine';
+import { EventEmitter } from 'events';
+import type { Options, Services, Capabilities } from '@wdio/types';
+import type { JasmineOpts as jasmineNodeOpts, ResultHandlerPayload, FrameworkMessage, FormattedMessage } from './types';
+declare type HooksArray = {
+    [K in keyof Required<Services.HookFunctions>]: Required<Services.HookFunctions>[K][];
+};
+interface WebdriverIOJasmineConfig extends Omit<Options.Testrunner, keyof HooksArray>, HooksArray {
+    jasmineOpts: Omit<jasmineNodeOpts, 'cleanStack'>;
+}
+/**
+ * Jasmine runner
+ */
+declare class JasmineAdapter {
+    private _cid;
+    private _config;
+    private _specs;
+    private _capabilities;
+    private _jasmineOpts;
+    private _reporter;
+    private _totalTests;
+    private _hasTests;
+    private _lastTest?;
+    private _lastSpec?;
+    private _jrunner?;
+    constructor(_cid: string, _config: WebdriverIOJasmineConfig, _specs: string[], _capabilities: Capabilities.RemoteCapabilities, reporter: EventEmitter);
+    init(): Promise<this>;
+    _loadFiles(): void;
+    _grep(suite: jasmine.Suite): void;
+    hasTests(): boolean;
+    run(): Promise<unknown>;
+    customSpecFilter(spec: jasmine.Spec): boolean;
+    /**
+     * Hooks which are added as true Jasmine hooks need to call done() to notify async
+     */
+    wrapHook(hookName: keyof Services.HookFunctions): () => Promise<void | unknown[]>;
+    prepareMessage(hookName: keyof Services.HookFunctions): FormattedMessage;
+    formatMessage(params: FrameworkMessage): FormattedMessage;
+    getExpectationResultHandler(jasmine: jasmine.Jasmine): any;
+    expectationResultHandler(origHandler: Function): (this: jasmine.Spec, passed: boolean, data: ResultHandlerPayload) => any;
+}
+declare const adapterFactory: {
+    init?: Function;
+};
+export default adapterFactory;
+export { JasmineAdapter, adapterFactory };
+export * from './types';
+declare type jasmine = typeof Jasmine;
+declare global {
+    /**
+     * Define a single spec. A spec should contain one or more expectations that test the state of the code.
+     * A spec whose expectations all succeed will be passing and a spec with any failures will fail.
+     * @param expectation Textual description of what this spec is checking
+     * @param assertion Function that contains the code of your test. If not provided the test will be pending.
+     * @param timeout Custom timeout for an async spec.
+     * @param retries Custom retry count for this single spec (WebdriverIO specific)
+     */
+    function it(expectation: string, assertion?: jasmine.ImplementationCallback, timeout?: number, retries?: number): void;
+    /**
+     * A focused `it`. If suites or specs are focused, only those that are focused will be executed.
+     * @param expectation Textual description of what this spec is checking
+     * @param assertion Function that contains the code of your test. If not provided the test will be pending.
+     * @param timeout Custom timeout for an async spec.
+     * @param retries Custom retry count for this single spec (WebdriverIO specific)
+     */
+    function fit(expectation: string, assertion?: jasmine.ImplementationCallback, timeout?: number, retries?: number): void;
+    /**
+     * A temporarily disabled `it`. The spec will report as pending and will not be executed.
+     * @param expectation Textual description of what this spec is checking
+     * @param assertion Function that contains the code of your test. If not provided the test will be pending.
+     * @param timeout Custom timeout for an async spec.
+     * @param retries Custom retry count for this single spec (WebdriverIO specific)
+     */
+    function xit(expectation: string, assertion?: jasmine.ImplementationCallback, timeout?: number, retries?: number): void;
+    /**
+     * Run some shared setup before each of the specs in the describe in which it is called.
+     * @param action Function that contains the code to setup your specs.
+     * @param timeout Custom timeout for an async beforeEach.
+     * @param retries Custom retry count for this single hook (WebdriverIO specific)
+     */
+    function beforeEach(action: jasmine.ImplementationCallback, timeout?: number, retries?: number): void;
+    /**
+     * Run some shared teardown after each of the specs in the describe in which it is called.
+     * @param action Function that contains the code to teardown your specs.
+     * @param timeout Custom timeout for an async afterEach.
+     * @param retries Custom retry count for this single hook (WebdriverIO specific)
+     */
+    function afterEach(action: jasmine.ImplementationCallback, timeout?: number, retries?: number): void;
+    /**
+     * Run some shared setup once before all of the specs in the describe are run.
+     * Note: Be careful, sharing the setup from a beforeAll makes it easy to accidentally leak state between your specs so that they erroneously pass or fail.
+     * @param action Function that contains the code to setup your specs.
+     * @param timeout Custom timeout for an async beforeAll.
+     * @param retries Custom retry count for this single hook (WebdriverIO specific)
+     */
+    function beforeAll(action: jasmine.ImplementationCallback, timeout?: number, retries?: number): void;
+    /**
+     * Run some shared teardown once before all of the specs in the describe are run.
+     * Note: Be careful, sharing the teardown from a afterAll makes it easy to accidentally leak state between your specs so that they erroneously pass or fail.
+     * @param action Function that contains the code to teardown your specs.
+     * @param timeout Custom timeout for an async afterAll
+     * @param retries Custom retry count for this single hook (WebdriverIO specific)
+     */
+    function afterAll(action: jasmine.ImplementationCallback, timeout?: number, retries?: number): void;
+    namespace WebdriverIO {
+        interface JasmineOpts extends jasmineNodeOpts {
+        }
+    }
+    namespace jasmine {
+        interface Matchers<T> extends ExpectWebdriverIO.Matchers<any, T> {
+        }
+        interface AsyncMatchers<T, U> extends ExpectWebdriverIO.Matchers<Promise<void>, T> {
+        }
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/build/index.js

@@ -0,0 +1,320 @@
+"use strict";
+/// <reference types="expect-webdriverio/jasmine" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterFactory = exports.JasmineAdapter = void 0;
+const jasmine_1 = __importDefault(require("jasmine"));
+const utils_1 = require("@wdio/utils");
+const logger_1 = __importDefault(require("@wdio/logger"));
+const reporter_1 = __importDefault(require("./reporter"));
+const INTERFACES = {
+    bdd: ['beforeAll', 'beforeEach', 'it', 'xit', 'fit', 'afterEach', 'afterAll']
+};
+const TEST_INTERFACES = ['it', 'fit', 'xit'];
+const NOOP = function noop() { };
+const DEFAULT_TIMEOUT_INTERVAL = 60000;
+const log = (0, logger_1.default)('@wdio/jasmine-framework');
+/**
+ * Jasmine runner
+ */
+class JasmineAdapter {
+    constructor(_cid, _config, _specs, _capabilities, reporter) {
+        this._cid = _cid;
+        this._config = _config;
+        this._specs = _specs;
+        this._capabilities = _capabilities;
+        this._totalTests = 0;
+        this._hasTests = true;
+        this._jasmineOpts = Object.assign({
+            cleanStack: true
+        }, (this._config.jasmineOpts ||
+            // @ts-expect-error legacy option
+            this._config.jasmineNodeOpts));
+        this._reporter = new reporter_1.default(reporter, {
+            cid: this._cid,
+            specs: this._specs,
+            cleanStack: this._jasmineOpts.cleanStack
+        });
+        this._hasTests = true;
+    }
+    async init() {
+        const self = this;
+        this._jrunner = new jasmine_1.default({});
+        const { jasmine } = this._jrunner;
+        // @ts-ignore outdated
+        const jasmineEnv = jasmine.getEnv();
+        this._jrunner.projectBaseDir = '';
+        // @ts-ignore outdated
+        this._jrunner.specDir = '';
+        this._jrunner.addSpecFiles(this._specs);
+        // @ts-ignore only way to hack timeout into jasmine
+        jasmine.DEFAULT_TIMEOUT_INTERVAL = this._jasmineOpts.defaultTimeoutInterval || DEFAULT_TIMEOUT_INTERVAL;
+        jasmineEnv.addReporter(this._reporter);
+        /**
+         * Filter specs to run based on jasmineOpts.grep and jasmineOpts.invert
+         */
+        jasmineEnv.configure({
+            specFilter: this._jasmineOpts.specFilter || this.customSpecFilter.bind(this),
+            stopOnSpecFailure: Boolean(this._jasmineOpts.stopOnSpecFailure),
+            failSpecWithNoExpectations: Boolean(this._jasmineOpts.failSpecWithNoExpectations),
+            failFast: this._jasmineOpts.failFast,
+            random: Boolean(this._jasmineOpts.random),
+            seed: Boolean(this._jasmineOpts.seed),
+            oneFailurePerSpec: Boolean(
+            // depcrecated old property
+            this._jasmineOpts.stopSpecOnExpectationFailure ||
+                this._jasmineOpts.oneFailurePerSpec)
+        });
+        /**
+         * enable expectHandler
+         */
+        jasmine.Spec.prototype.addExpectationResult = this.getExpectationResultHandler(jasmine);
+        const hookArgsFn = (context) => [{ ...(self._lastTest || {}) }, context];
+        const emitHookEvent = (fnName, eventType) => (_test, _context, { error } = {}) => {
+            const title = `"${fnName === 'beforeAll' ? 'before' : 'after'} all" hook`;
+            const hook = {
+                id: '',
+                start: new Date(),
+                type: 'hook',
+                description: title,
+                fullName: title,
+                duration: null,
+                properties: {},
+                passedExpectations: [],
+                pendingReason: '',
+                failedExpectations: [],
+                deprecationWarnings: [],
+                status: '',
+                ...(error ? { error } : {})
+            };
+            this._reporter.emit('hook:' + eventType, hook);
+        };
+        /**
+         * wrap commands
+         */
+        INTERFACES['bdd'].forEach((fnName) => {
+            const isTest = TEST_INTERFACES.includes(fnName);
+            const beforeHook = [...this._config.beforeHook];
+            const afterHook = [...this._config.afterHook];
+            /**
+             * add beforeAll and afterAll hooks to reporter
+             */
+            if (fnName.includes('All')) {
+                beforeHook.push(emitHookEvent(fnName, 'start'));
+                afterHook.push(emitHookEvent(fnName, 'end'));
+            }
+            (0, utils_1.runTestInFiberContext)(isTest, isTest ? this._config.beforeTest : beforeHook, hookArgsFn, isTest ? this._config.afterTest : afterHook, hookArgsFn, fnName, this._cid);
+        });
+        /**
+         * for a clean stdout we need to avoid that Jasmine initialises the
+         * default reporter
+         */
+        jasmine_1.default.prototype.configureDefaultReporter = NOOP;
+        /**
+         * wrap Suite and Spec prototypes to get access to their data
+         */
+        // @ts-ignore
+        let beforeAllMock = jasmine.Suite.prototype.beforeAll;
+        // @ts-ignore
+        jasmine.Suite.prototype.beforeAll = function (...args) {
+            self._lastSpec = this.result;
+            beforeAllMock.apply(this, args);
+        };
+        let executeMock = jasmine.Spec.prototype.execute;
+        jasmine.Spec.prototype.execute = function (...args) {
+            self._lastTest = this.result;
+            // @ts-ignore overwrite existing type
+            self._lastTest.start = new Date().getTime();
+            executeMock.apply(this, args);
+        };
+        this._loadFiles();
+        /**
+         * import and set options for `expect-webdriverio` assertion lib once
+         * the framework was initiated so that it can detect the environment
+         */
+        const { setOptions } = require('expect-webdriverio');
+        setOptions({
+            wait: this._config.waitforTimeout,
+            interval: this._config.waitforInterval, // interval between attempts
+        });
+        return this;
+    }
+    _loadFiles() {
+        if (!this._jrunner) {
+            throw new Error('Jasmine not initiate yet');
+        }
+        try {
+            if (Array.isArray(this._jasmineOpts.requires)) {
+                // @ts-ignore outdated types
+                this._jrunner.addRequires(this._jasmineOpts.requires);
+            }
+            if (Array.isArray(this._jasmineOpts.helpers)) {
+                // @ts-ignore outdated types
+                this._jrunner.addHelperFiles(this._jasmineOpts.helpers);
+            }
+            // @ts-ignore outdated types
+            this._jrunner.loadRequires();
+            this._jrunner.loadHelpers();
+            this._jrunner.loadSpecs();
+            // @ts-ignore outdated types
+            this._grep(this._jrunner.env.topSuite());
+            this._hasTests = this._totalTests > 0;
+        }
+        catch (err) {
+            log.warn('Unable to load spec files quite likely because they rely on `browser` object that is not fully initialised.\n' +
+                '`browser` object has only `capabilities` and some flags like `isMobile`.\n' +
+                'Helper files that use other `browser` commands have to be moved to `before` hook.\n' +
+                `Spec file(s): ${this._specs.join(',')}\n`, 'Error: ', err);
+        }
+    }
+    _grep(suite) {
+        // @ts-ignore outdated types
+        suite.children.forEach((child) => {
+            if (Array.isArray(child.children)) {
+                return this._grep(child);
+            }
+            if (this.customSpecFilter(child)) {
+                this._totalTests++;
+            }
+        });
+    }
+    hasTests() {
+        return this._hasTests;
+    }
+    async run() {
+        const result = await new Promise((resolve, reject) => {
+            if (!this._jrunner) {
+                return reject(new Error('Jasmine not initiate yet'));
+            }
+            // @ts-expect-error
+            this._jrunner.env.beforeAll(this.wrapHook('beforeSuite'));
+            // @ts-expect-error
+            this._jrunner.env.afterAll(this.wrapHook('afterSuite'));
+            this._jrunner.onComplete(() => resolve(this._reporter.getFailedCount()));
+            this._jrunner.execute();
+        });
+        await (0, utils_1.executeHooksWithArgs)('after', this._config.after, [result, this._capabilities, this._specs]);
+        return result;
+    }
+    customSpecFilter(spec) {
+        const { grep, invertGrep } = this._jasmineOpts;
+        const grepMatch = !grep || spec.getFullName().match(new RegExp(grep)) !== null;
+        if (grepMatch === Boolean(invertGrep)) {
+            // @ts-ignore outdated types
+            spec.pend('grep');
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Hooks which are added as true Jasmine hooks need to call done() to notify async
+     */
+    wrapHook(hookName) {
+        return () => (0, utils_1.executeHooksWithArgs)(hookName, this._config[hookName], [this.prepareMessage(hookName)]).catch((e) => {
+            log.info(`Error in ${hookName} hook: ${e.stack.slice(7)}`);
+        });
+    }
+    prepareMessage(hookName) {
+        var _a, _b;
+        const params = { type: hookName };
+        switch (hookName) {
+            case 'beforeSuite':
+            case 'afterSuite':
+                params.payload = Object.assign({
+                    file: (_a = this._jrunner) === null || _a === void 0 ? void 0 : _a.specFiles[0]
+                }, this._lastSpec);
+                break;
+            case 'beforeTest':
+            case 'afterTest':
+                params.payload = Object.assign({
+                    file: (_b = this._jrunner) === null || _b === void 0 ? void 0 : _b.specFiles[0]
+                }, this._lastTest);
+                break;
+        }
+        return this.formatMessage(params);
+    }
+    formatMessage(params) {
+        var _a;
+        let message = {
+            type: params.type
+        };
+        if (params.payload) {
+            message.title = params.payload.description;
+            message.fullName = params.payload.fullName || null;
+            message.file = params.payload.file;
+            if (params.payload.failedExpectations && params.payload.failedExpectations.length) {
+                message.errors = params.payload.failedExpectations;
+                message.error = params.payload.failedExpectations[0];
+            }
+            if (params.payload.id && params.payload.id.startsWith('spec')) {
+                message.parent = (_a = this._lastSpec) === null || _a === void 0 ? void 0 : _a.description;
+                message.passed = params.payload.failedExpectations.length === 0;
+            }
+            if (params.type === 'afterTest') {
+                message.duration = new Date().getTime() - params.payload.start;
+            }
+            if (typeof params.payload.duration === 'number') {
+                message.duration = params.payload.duration;
+            }
+        }
+        return message;
+    }
+    getExpectationResultHandler(jasmine) {
+        let { expectationResultHandler } = this._jasmineOpts;
+        const origHandler = jasmine.Spec.prototype.addExpectationResult;
+        if (typeof expectationResultHandler !== 'function') {
+            return origHandler;
+        }
+        return this.expectationResultHandler(origHandler);
+    }
+    expectationResultHandler(origHandler) {
+        const { expectationResultHandler } = this._jasmineOpts;
+        return function (passed, data) {
+            try {
+                expectationResultHandler.call(this, passed, data);
+            }
+            catch (e) {
+                /**
+                 * propagate expectationResultHandler error if actual assertion passed
+                 * but the custom handler decides to throw
+                 */
+                if (passed) {
+                    passed = false;
+                    data = {
+                        passed,
+                        message: 'expectationResultHandlerError: ' + e.message,
+                        error: e
+                    };
+                }
+            }
+            return origHandler.call(this, passed, data);
+        };
+    }
+}
+exports.JasmineAdapter = JasmineAdapter;
+const adapterFactory = {};
+exports.adapterFactory = adapterFactory;
+adapterFactory.init = async function (...args) {
+    // @ts-ignore pass along parameters
+    const adapter = new JasmineAdapter(...args);
+    const instance = await adapter.init();
+    return instance;
+};
+exports.default = adapterFactory;
+__exportStar(require("./types"), exports);

package/build/reporter.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import type { EventEmitter } from 'events';
+import type { ReporterOptions, TestEvent, SuiteEvent } from './types';
+export default class JasmineReporter {
+    private _reporter;
+    startedSuite?: SuiteEvent;
+    private _cid;
+    private _specs;
+    private _shouldCleanStack;
+    private _parent;
+    private _failedCount;
+    private _suiteStart;
+    private _testStart;
+    constructor(_reporter: EventEmitter, params: ReporterOptions);
+    suiteStarted(suite: jasmine.SuiteResult): void;
+    specStarted(test: jasmine.SpecResult): void;
+    specDone(test: jasmine.SpecResult): void;
+    suiteDone(suite: jasmine.SuiteResult): void;
+    emit(event: string, payload: SuiteEvent | TestEvent): void;
+    getFailedCount(): number;
+    getUniqueIdentifier(target: Pick<TestEvent, 'description' | 'id'>): string;
+    cleanStack(error: jasmine.FailedExpectation): jasmine.FailedExpectation;
+}
+//# sourceMappingURL=reporter.d.ts.map

package/build/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C,OAAO,KAAK,EAAE,eAAe,EAAe,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAMlF,MAAM,CAAC,OAAO,OAAO,eAAe;IAY5B,OAAO,CAAC,SAAS;IAXd,YAAY,CAAC,EAAE,UAAU,CAAA;IAEhC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,UAAU,CAAa;gBAGnB,SAAS,EAAE,YAAY,EAC/B,MAAM,EAAE,eAAe;IAO3B,YAAY,CAAE,KAAK,EAAE,OAAO,CAAC,WAAW;IAwBxC,WAAW,CAAE,IAAI,EAAE,OAAO,CAAC,UAAU;IAyBrC,QAAQ,CAAE,IAAI,EAAE,OAAO,CAAC,UAAU;IAiClC,SAAS,CAAE,KAAK,EAAE,OAAO,CAAC,WAAW;IA8CrC,IAAI,CAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,SAAS;IAwBpD,cAAc;IAId,mBAAmB,CAAE,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI,CAAC;IAIlE,UAAU,CAAE,KAAK,EAAE,OAAO,CAAC,iBAAiB;CAU/C"}

package/build/reporter.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("@wdio/logger"));
+const log = (0, logger_1.default)('@wdio/jasmine-framework');
+const STACKTRACE_FILTER = /(node_modules(\/|\\)(\w+)*|@wdio\/sync\/(build|src)|- - - - -)/g;
+class JasmineReporter {
+    constructor(_reporter, params) {
+        this._reporter = _reporter;
+        this._parent = [];
+        this._failedCount = 0;
+        this._suiteStart = new Date();
+        this._testStart = new Date();
+        this._cid = params.cid;
+        this._specs = params.specs;
+        this._shouldCleanStack = typeof params.cleanStack === 'boolean' ? params.cleanStack : true;
+    }
+    suiteStarted(suite) {
+        this._suiteStart = new Date();
+        const newSuite = {
+            type: 'suite',
+            start: this._suiteStart,
+            ...suite
+        };
+        this.startedSuite = newSuite;
+        let fullName = suite.description;
+        for (const parent of this._parent.reverse()) {
+            fullName = parent.description + '.' + fullName;
+        }
+        newSuite.fullName = fullName;
+        this.emit('suite:start', newSuite);
+        this._parent.push({
+            description: suite.description,
+            id: suite.id,
+            tests: 0
+        });
+    }
+    specStarted(test) {
+        this._testStart = new Date();
+        const newTest = {
+            type: 'test',
+            start: this._testStart,
+            ...test
+        };
+        const parentSuite = this._parent[this._parent.length - 1];
+        /**
+         * if jasmine test has no root describe block, create one
+         */
+        if (!parentSuite) {
+            log.warn('No root suite was defined! This can cause reporters to malfunction. ' +
+                'Please always start a spec file with describe("...", () => { ... }).');
+        }
+        else {
+            parentSuite.tests++;
+        }
+        this.emit('test:start', newTest);
+    }
+    specDone(test) {
+        const newTest = {
+            ...test,
+            start: this._testStart,
+            type: 'test',
+            duration: Date.now() - this._testStart.getTime()
+        };
+        /**
+         * excluded tests are treated as pending tests
+         */
+        if (test.status === 'excluded') {
+            newTest.status = 'pending';
+        }
+        if (test.failedExpectations && test.failedExpectations.length) {
+            let errors = test.failedExpectations;
+            if (this._shouldCleanStack) {
+                errors = test.failedExpectations.map(x => this.cleanStack(x));
+            }
+            newTest.errors = errors;
+            // We maintain the single error property for backwards compatibility with reporters
+            // However, any reporter wanting to make use of Jasmine's 'soft assertion' type expects
+            // should default to looking at 'errors' if they are available
+            newTest.error = errors[0];
+        }
+        const e = 'test:' + (newTest.status ? newTest.status.replace(/ed/, '') : 'unknown');
+        this.emit(e, newTest);
+        this._failedCount += test.status === 'failed' ? 1 : 0;
+        this.emit('test:end', newTest);
+    }
+    suiteDone(suite) {
+        const parentSuite = this._parent[this._parent.length - 1];
+        const newSuite = {
+            ...suite,
+            type: 'suite',
+            start: this._suiteStart,
+            duration: Date.now() - this._suiteStart.getTime()
+        };
+        /**
+         * in case there is a runtime error within one of the specs
+         * create an empty test to attach the error to it
+         */
+        if (parentSuite.tests === 0 && suite.failedExpectations && suite.failedExpectations.length) {
+            const id = 'spec' + Math.random();
+            this.specStarted({
+                id,
+                description: '<unknown test>',
+                fullName: '<unknown test>',
+                duration: null,
+                properties: {},
+                failedExpectations: [],
+                deprecationWarnings: [],
+                passedExpectations: [],
+                status: 'unknown',
+                pendingReason: ''
+            });
+            this.specDone({
+                id,
+                description: '<unknown test>',
+                fullName: '<unknown test>',
+                failedExpectations: suite.failedExpectations,
+                deprecationWarnings: [],
+                passedExpectations: [],
+                status: 'failed',
+                duration: null,
+                properties: {},
+                pendingReason: ''
+            });
+        }
+        this._parent.pop();
+        this.emit('suite:end', newSuite);
+        delete this.startedSuite;
+    }
+    emit(event, payload) {
+        let message = {
+            cid: this._cid,
+            uid: this.getUniqueIdentifier(payload),
+            event: event,
+            title: payload.description,
+            fullTitle: payload.fullName,
+            pending: payload.status === 'pending',
+            pendingReason: payload.pendingReason,
+            parent: this._parent.length ? this.getUniqueIdentifier(this._parent[this._parent.length - 1]) : null,
+            type: payload.type,
+            // We maintain the single error property for backwards compatibility with reporters
+            // However, any reporter wanting to make use of Jasmine's 'soft assertion' type expects
+            // should default to looking at 'errors' if they are available
+            error: payload.error,
+            errors: payload.errors,
+            duration: payload.duration || 0,
+            specs: this._specs,
+            start: payload.start,
+        };
+        this._reporter.emit(event, message);
+    }
+    getFailedCount() {
+        return this._failedCount;
+    }
+    getUniqueIdentifier(target) {
+        return target.description + target.id;
+    }
+    cleanStack(error) {
+        if (!error.stack) {
+            return error;
+        }
+        let stack = error.stack.split('\n');
+        stack = stack.filter((line) => !line.match(STACKTRACE_FILTER));
+        error.stack = stack.join('\n');
+        return error;
+    }
+}
+exports.default = JasmineReporter;

package/build/types.d.ts

@@ -0,0 +1,139 @@
+export interface ReporterOptions {
+    cid: string;
+    specs: string[];
+    cleanStack?: boolean;
+}
+export interface ParentSuite {
+    description: string;
+    id: string;
+    tests: number;
+}
+export interface SuiteEvent extends jasmine.SuiteResult {
+    type: 'suite';
+    start: Date;
+    duration: number | null;
+    errors?: jasmine.FailedExpectation[];
+    error?: jasmine.FailedExpectation;
+}
+export interface TestEvent extends jasmine.SpecResult {
+    type: 'test' | 'hook';
+    start: Date;
+    duration: number | null;
+    errors?: jasmine.FailedExpectation[];
+    error?: jasmine.FailedExpectation;
+}
+export interface ResultHandlerPayload {
+    passed: boolean;
+    message?: string;
+    error?: Error;
+}
+export interface FrameworkMessage {
+    type: string;
+    payload?: any;
+    err?: jasmine.FailedExpectation;
+}
+export interface FormattedMessage {
+    type: string;
+    cid?: string;
+    specs?: string[];
+    uid?: string;
+    title?: string;
+    parent?: string;
+    fullTitle?: string;
+    pending?: boolean;
+    passed?: boolean;
+    file?: string;
+    duration?: number;
+    currentTest?: string;
+    error?: jasmine.FailedExpectation;
+    context?: any;
+    /**
+     * jasmine specific
+     */
+    fullName?: string;
+    errors?: jasmine.FailedExpectation[];
+}
+export interface JasmineOpts {
+    /**
+     * Default Timeout Interval for Jasmine operations.
+     * @default 60000
+     */
+    defaultTimeoutInterval?: number;
+    /**
+     * Array of filepaths (and globs) relative to spec_dir to include before jasmine specs.
+     * @default []
+     */
+    helpers?: string[];
+    /**
+     * The `requires` option is useful when you want to add or extend some basic functionality.
+     * @default []
+     */
+    requires?: string[];
+    /**
+     * Whether to randomize spec execution order.
+     * @default true
+     */
+    random?: boolean;
+    /**
+     * Seed to use as the basis of randomization. Null causes the seed to be determined randomly at the start of execution.
+     * @since v3.3.0
+     */
+    seed?: Function;
+    /**
+     * Whether to stop execution of the suite after the first spec failure.
+     * @default false
+     * @since v3.3.0
+     * @deprecated Use the `stopOnSpecFailure` config property instead.
+     */
+    failFast?: boolean;
+    /**
+     * Whether to fail the spec if it ran no expectations. By default a spec that ran no expectations is reported as passed.
+     * Setting this to true will report such spec as a failure.
+     * @default false
+     * @since v3.5.0
+     */
+    failSpecWithNoExpectations?: boolean;
+    /**
+     * Whether to cause specs to only have one expectation failure.
+     * @default false
+     * @since v3.3.0
+     */
+    oneFailurePerSpec?: boolean;
+    /**
+     * Function to use to filter specs.
+     * @since v3.3.0
+     */
+    specFilter?: () => boolean;
+    /**
+     * Only run tests matching this string or regexp. (Only applicable if no custom `specFilter` function is set)
+     */
+    grep?: string | RegExp;
+    /**
+     * If true it inverts the matching tests and only runs tests that don't match with the expression used in `grep`.
+     * (Only applicable if no custom `specFilter` function is set)
+     * @default false
+     */
+    invertGrep?: boolean;
+    /**
+     * Clean up stack trace and remove all traces of node module packages.
+     * @default false
+     */
+    cleanStack?: boolean;
+    /**
+     * Stops test suite (`describe`) execution on first spec (`it`) failure (other suites continue running)
+     * @default false
+     */
+    stopOnSpecFailure?: boolean;
+    /**
+     * Stops a spec (`it`) execution on a first expectation failure (other specs continue running)
+     * @default false
+     */
+    stopSpecOnExpectationFailure?: boolean;
+    /**
+     * The Jasmine framework allows it to intercept each assertion in order to log the state of the application
+     * or website depending on the result. For example it is pretty handy to take a screenshot every time
+     * an assertion fails.
+     */
+    expectationResultHandler?: (passed: boolean, data: ResultHandlerPayload) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@wdio/jasmine-framework",
-  "version": "7.17.0",
+  "version": "7.19.0",
   "description": "A WebdriverIO plugin. Adapter for Jasmine testing framework.",
-  "author": "Christian Bromann <christian@saucelabs.com>",
+  "author": "Christian Bromann <mail@bromann.dev>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-jasmine-framework",
   "license": "MIT",
   "main": "./build/index",
@@ -27,9 +27,9 @@
   "dependencies": {
     "@types/jasmine": "3.10.3",
     "@types/node": "^17.0.4",
-    "@wdio/logger": "7.16.0",
-    "@wdio/types": "7.16.14",
-    "@wdio/utils": "7.17.0",
+    "@wdio/logger": "7.19.0",
+    "@wdio/types": "7.19.0",
+    "@wdio/utils": "7.19.0",
     "expect-webdriverio": "^3.0.0",
     "jasmine": "3.10.0"
   },
@@ -40,5 +40,5 @@
     "access": "public"
   },
   "types": "./build/index.d.ts",
-  "gitHead": "e18d2cde6ff979758830bdff4c3bc82ca9818b24"
+  "gitHead": "a17ba0237dcbafa8f0215534c64ff9634caf4b43"
 }