testit-adapter-cypress 3.7.5

package/dist/browser/serialize.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeAsObject = void 0;
+const state_js_1 = require("./state.js");
+const utils_js_1 = require("./utils.js");
+exports.default = (value) => {
+    return isDomObject(value) ? stringifyAsDom(value) : (0, exports.serializeAsObject)(value);
+};
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stripAncestorRefs = (value, ancestors = []) => {
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    const result = {};
+    ancestors.push(value);
+    for (const [key, prop] of Object.entries(value)) {
+        if (typeof prop === "object" && prop !== null) {
+            if (ancestors.includes(prop)) {
+                continue;
+            }
+            result[key] = stripAncestorRefs(prop, ancestors);
+        }
+        else {
+            result[key] = prop;
+        }
+    }
+    ancestors.pop();
+    return result;
+};
+const serializeAsObject = (value) => {
+    if (isPlainObject(value)) {
+        const cleaned = stripAncestorRefs(value);
+        return (0, utils_js_1.serialize)({ ...cleaned }, getSerializeOptions());
+    }
+    return (0, utils_js_1.serialize)(value, getSerializeOptions());
+};
+exports.serializeAsObject = serializeAsObject;
+const getSerializeOptions = () => {
+    const { stepsFromCommands: { maxArgumentDepth: maxDepth, maxArgumentLength: maxLength }, } = (0, state_js_1.getConfig)();
+    return { maxDepth, maxLength, replacer: nonNullReplacerWithDomSupport };
+};
+const isDomObject = (value) => typeof value === "object" && value !== null && Cypress.dom.isDom(value);
+// @ts-ignore
+const stringifyAsDom = (value) => Cypress.dom.stringify(value, "long");
+const nonNullReplacerWithDomSupport = (_, value) => {
+    if (typeof value === "object") {
+        // Exclude null properties to make the result more compact.
+        if (value === null) {
+            return undefined;
+        }
+        if (Cypress.dom.isDom(value)) {
+            // Window, document, and DOM element properties are serialized with Cypress.dom.stringify.
+            return stringifyAsDom(value);
+        }
+    }
+    return value;
+};

package/dist/browser/state.d.ts

@@ -0,0 +1,28 @@
+import type { TmsSpecState, CypressMessage, CypressTest, StepDescriptor, StepFinalizer } from "../models/types.js";
+export declare const getTmsState: () => TmsSpecState;
+export declare const isTmsInitialized: () => boolean;
+export declare const setTmsInitialized: () => void;
+export declare const getRuntimeMessages: () => CypressMessage[];
+export declare const setRuntimeMessages: (value: CypressMessage[]) => void;
+export declare const enqueueRuntimeMessage: (message: CypressMessage) => void;
+export declare const getTmsTestPlan: () => import("../models/types.js").TestPlanV1 | null | undefined;
+export declare const getProjectDir: () => string | undefined;
+export declare const getCurrentTest: () => CypressTest | undefined;
+export declare const setCurrentTest: (test: CypressTest) => void;
+export declare const dropCurrentTest: () => void;
+export declare const getConfig: () => {
+    stepsFromCommands: {
+        maxArgumentLength: number;
+        maxArgumentDepth: number;
+    };
+};
+export declare const getStepStack: () => StepDescriptor[];
+export declare const getCurrentStep: () => StepDescriptor | undefined;
+export declare const pushStep: (step: StepDescriptor) => number;
+export declare const popStep: () => StepDescriptor | undefined;
+export declare const popSteps: (index: number) => StepDescriptor[];
+export declare const popAllSteps: () => StepDescriptor[];
+export declare const clearStepStack: () => void;
+export declare const setupStepFinalization: <T extends StepDescriptor>(step: T, finalizer?: StepFinalizer) => number;
+export declare const getStepsToFinalize: () => [step: StepDescriptor, finalizer: StepFinalizer | undefined][];
+export declare const clearStepsToFinalize: () => void;

package/dist/browser/state.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearStepsToFinalize = exports.getStepsToFinalize = exports.setupStepFinalization = exports.clearStepStack = exports.popAllSteps = exports.popSteps = exports.popStep = exports.pushStep = exports.getCurrentStep = exports.getStepStack = exports.getConfig = exports.dropCurrentTest = exports.setCurrentTest = exports.getCurrentTest = exports.getProjectDir = exports.getTmsTestPlan = exports.enqueueRuntimeMessage = exports.setRuntimeMessages = exports.getRuntimeMessages = exports.setTmsInitialized = exports.isTmsInitialized = exports.getTmsState = void 0;
+const utils_js_1 = require("../utils.js");
+const getTmsState = () => {
+    let state = Cypress.env("tms");
+    if (!state) {
+        state = {
+            config: utils_js_1.DEFAULT_RUNTIME_CONFIG,
+            initialized: false,
+            messages: [],
+            testPlan: undefined,
+            currentTest: undefined,
+            projectDir: undefined,
+            stepStack: [],
+            stepsToFinalize: [],
+            nextApiStepId: 0,
+        };
+        Cypress.env("tms", state);
+    }
+    return state;
+};
+exports.getTmsState = getTmsState;
+const isTmsInitialized = () => (0, exports.getTmsState)().initialized;
+exports.isTmsInitialized = isTmsInitialized;
+const setTmsInitialized = () => {
+    (0, exports.getTmsState)().initialized = true;
+};
+exports.setTmsInitialized = setTmsInitialized;
+const getRuntimeMessages = () => (0, exports.getTmsState)().messages;
+exports.getRuntimeMessages = getRuntimeMessages;
+const setRuntimeMessages = (value) => {
+    (0, exports.getTmsState)().messages = value;
+};
+exports.setRuntimeMessages = setRuntimeMessages;
+const enqueueRuntimeMessage = (message) => {
+    (0, exports.getRuntimeMessages)().push(message);
+};
+exports.enqueueRuntimeMessage = enqueueRuntimeMessage;
+const getTmsTestPlan = () => (0, exports.getTmsState)().testPlan;
+exports.getTmsTestPlan = getTmsTestPlan;
+const getProjectDir = () => (0, exports.getTmsState)().projectDir;
+exports.getProjectDir = getProjectDir;
+const getCurrentTest = () => (0, exports.getTmsState)().currentTest;
+exports.getCurrentTest = getCurrentTest;
+const setCurrentTest = (test) => {
+    (0, exports.getTmsState)().currentTest = test;
+};
+exports.setCurrentTest = setCurrentTest;
+const dropCurrentTest = () => {
+    (0, exports.getTmsState)().currentTest = undefined;
+};
+exports.dropCurrentTest = dropCurrentTest;
+const getConfig = () => (0, exports.getTmsState)().config;
+exports.getConfig = getConfig;
+const getStepStack = () => (0, exports.getTmsState)().stepStack;
+exports.getStepStack = getStepStack;
+const getCurrentStep = () => (0, utils_js_1.last)((0, exports.getStepStack)());
+exports.getCurrentStep = getCurrentStep;
+const pushStep = (step) => (0, exports.getStepStack)().push(step);
+exports.pushStep = pushStep;
+const popStep = () => (0, exports.getStepStack)().pop();
+exports.popStep = popStep;
+const popSteps = (index) => (0, utils_js_1.toReversed)((0, exports.getStepStack)().splice(index));
+exports.popSteps = popSteps;
+const popAllSteps = () => (0, exports.popSteps)(0);
+exports.popAllSteps = popAllSteps;
+const clearStepStack = () => {
+    (0, exports.getTmsState)().stepStack = [];
+};
+exports.clearStepStack = clearStepStack;
+const setupStepFinalization = (step, finalizer) => (0, exports.getTmsState)().stepsToFinalize.push([step, finalizer]);
+exports.setupStepFinalization = setupStepFinalization;
+const getStepsToFinalize = () => (0, exports.getTmsState)().stepsToFinalize;
+exports.getStepsToFinalize = getStepsToFinalize;
+const clearStepsToFinalize = () => {
+    const state = (0, exports.getTmsState)();
+    state.stepsToFinalize = [];
+};
+exports.clearStepsToFinalize = clearStepsToFinalize;

package/dist/browser/steps.d.ts

@@ -0,0 +1,14 @@
+import type { StatusDetails } from "../models/types.js";
+import type { ApiStepDescriptor, LogStepDescriptor, StepDescriptor } from "../models/types.js";
+import { Status } from "../models/status.js";
+export declare const TMS_STEP_CMD_SUBJECT: {};
+export declare const isApiStep: (descriptor: StepDescriptor) => descriptor is ApiStepDescriptor;
+export declare const isLogStep: (descriptor: StepDescriptor) => descriptor is LogStepDescriptor;
+export declare const startTmsApiStep: (name: string) => void;
+export declare const pushTmsStep: () => string;
+export declare const reportStepError: (error: Error) => void;
+export declare const stopCurrentTmsApiStep: (status?: Status, statusDetails?: StatusDetails) => void;
+export declare const findAndStopStepWithSubsteps: (pred: (stepEntry: StepDescriptor) => boolean, status?: Status, statusDetails?: StatusDetails) => void;
+export declare const stopAllSteps: (status?: Status, statusDetails?: StatusDetails) => void;
+export declare const finalizeSteps: () => void;
+export declare const resolveStepStatus: (step: StepDescriptor) => Status.FAILED | Status.PASSED;

package/dist/browser/steps.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStepStatus = exports.finalizeSteps = exports.stopAllSteps = exports.findAndStopStepWithSubsteps = exports.stopCurrentTmsApiStep = exports.reportStepError = exports.pushTmsStep = exports.startTmsApiStep = exports.isLogStep = exports.isApiStep = exports.TMS_STEP_CMD_SUBJECT = void 0;
+const utils_js_1 = require("../utils.js");
+const lifecycle_js_1 = require("./lifecycle.js");
+const state_js_1 = require("./state.js");
+const utils_js_2 = require("./utils.js");
+const status_js_1 = require("../models/status.js");
+exports.TMS_STEP_CMD_SUBJECT = {};
+const isApiStep = (descriptor) => {
+    return descriptor.type === "api";
+};
+exports.isApiStep = isApiStep;
+const isLogStep = (descriptor) => {
+    return descriptor.type === "log";
+};
+exports.isLogStep = isLogStep;
+const startTmsApiStep = (name) => (0, lifecycle_js_1.reportStepStart)((0, exports.pushTmsStep)(), name);
+exports.startTmsApiStep = startTmsApiStep;
+const pushTmsStep = () => {
+    const id = (0, utils_js_2.generateApiStepId)();
+    (0, state_js_1.pushStep)({ id, type: "api" });
+    return id;
+};
+exports.pushTmsStep = pushTmsStep;
+const reportStepError = (error) => {
+    const status = status_js_1.Status.FAILED;
+    const statusDetails = (0, utils_js_2.getMessageAndTraceFromError)(error);
+    // Cypress will abort the test/hook execution soon. No subsequent commands will be run, including the ones that
+    // have been scheduled by `testit.step` to stop the currently running steps.
+    // Additionally, we can't tell in advance if the current command log steps will be stopped normally or not.
+    //
+    // Given that, this function will stop all consecutive Tms API steps at the tip of the step stack.
+    // The command log steps will be given a chance to stop normally to get the most correct timings.
+    //
+    // The command log steps that won't stop normally (and Tms API substeps thereof) will be stopped during the
+    // test/hook finalization phase.
+    stopTmsApiStepStackTip(status, statusDetails);
+    // It's not guaranteed for command log steps and intermediate Tms API steps to have access to the error at the
+    // moment they are stopped.
+    // Additionally, Cypress may not update the stack trace of the error at that time. Until that happens, the stack
+    // trace points deep in the bundled code, which is little to no use for the user. Therefore, we need to associate
+    // the remaining steps with the error object to grab the updated stack trace later.
+    associateErrorWithRunningSteps(error);
+};
+exports.reportStepError = reportStepError;
+const stopCurrentTmsApiStep = (status, statusDetails) => (0, exports.findAndStopStepWithSubsteps)((stepDescriptor) => (0, exports.isApiStep)(stepDescriptor), status, statusDetails);
+exports.stopCurrentTmsApiStep = stopCurrentTmsApiStep;
+const findAndStopStepWithSubsteps = (pred, status, statusDetails) => stopSelectedSteps((0, utils_js_1.popUntilFindIncluded)((0, state_js_1.getStepStack)(), pred), status, statusDetails);
+exports.findAndStopStepWithSubsteps = findAndStopStepWithSubsteps;
+const stopAllSteps = (status, statusDetails) => stopSelectedSteps((0, state_js_1.popAllSteps)(), status, statusDetails);
+exports.stopAllSteps = stopAllSteps;
+const finalizeSteps = () => {
+    // This will stop all dangling steps (like log groups with missing endGroup calls or logs that haven't been
+    // finished by Cypress due to an error).
+    (0, exports.stopAllSteps)();
+    (0, state_js_1.getStepsToFinalize)().forEach(finalizeOneStep);
+    (0, state_js_1.clearStepsToFinalize)();
+};
+exports.finalizeSteps = finalizeSteps;
+const resolveStepStatus = (step) => step.error ? status_js_1.Status.FAILED : status_js_1.Status.PASSED;
+exports.resolveStepStatus = resolveStepStatus;
+const finalizeOneStep = ([step, finalizer]) => {
+    const { id, error } = step;
+    const data = { id };
+    if (error) {
+        // Cypress rewrites the stack trace of an error to point to the location in the test file. Until then, the stack
+        // trace points inside the messy bundle, which is not helpful. There are circumstances when we can't be sure this
+        // has happened when a step is about to stop. That's why we defer setting the status details until we are sure
+        // Cypress does its job.
+        data.statusDetails = (0, utils_js_2.getMessageAndTraceFromError)(error);
+    }
+    finalizer?.(data);
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_step_finalize",
+        data,
+    });
+};
+const stopTmsApiStepStackTip = (status, statusDetails) => {
+    const stepStack = (0, state_js_1.getStepStack)();
+    const firstApiStepAfterLastLogStep = stepStack.at(stepStack.findLastIndex(exports.isLogStep) + 1);
+    if (firstApiStepAfterLastLogStep) {
+        (0, exports.findAndStopStepWithSubsteps)((logEntryOrMessage) => Object.is(logEntryOrMessage, firstApiStepAfterLastLogStep), status, statusDetails);
+    }
+};
+const propagateErrorToStepDescriptor = (step, errorOfSubstep) => {
+    if ((0, exports.isLogStep)(step)) {
+        const error = step.log.attributes.error;
+        if (error) {
+            return (step.error = error);
+        }
+    }
+    if (errorOfSubstep) {
+        step.error = errorOfSubstep;
+    }
+    return step.error;
+};
+const stopSelectedSteps = (steps, status, statusDetails) => {
+    let error;
+    for (const stepEntry of steps) {
+        error = propagateErrorToStepDescriptor(stepEntry, error);
+        stopStep(stepEntry, status, statusDetails);
+    }
+    if (error) {
+        associateErrorWithRunningSteps(error);
+    }
+};
+const associateErrorWithRunningSteps = (error) => (0, state_js_1.getStepStack)().forEach((step) => (step.error = error));
+const stopStep = (step, status, statusDetails) => {
+    (0, lifecycle_js_1.reportStepStop)(step, status, statusDetails);
+    if ((0, exports.isApiStep)(step) && step.error) {
+        (0, state_js_1.setupStepFinalization)(step);
+    }
+};

package/dist/browser/testplan.d.ts

@@ -0,0 +1,2 @@
+import type { CypressSuite } from "../models/types.js";
+export declare const applyTestPlan: (spec: Cypress.Spec, root: CypressSuite) => void;

package/dist/browser/testplan.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTestPlan = void 0;
+const utils_js_1 = require("./utils.js");
+const testit_js_commons_1 = require("testit-js-commons");
+const applyTestPlan = (spec, root) => {
+    const testsInRun = Cypress.env("tmsTestsInRun") ?? undefined;
+    if (!testsInRun || !testsInRun.length)
+        return;
+    const specPath = (0, utils_js_1.resolveSpecRelativePath)(spec);
+    let testsBefore = 0;
+    for (const suite of iterateSuites(root)) {
+        testsBefore += suite.tests.length;
+    }
+    for (const suite of iterateSuites(root)) {
+        const indicesToRemove = getIndicesOfDeselectedTests(testsInRun, specPath, suite.tests);
+        removeSortedIndices(suite.tests, indicesToRemove);
+    }
+    let testsAfter = 0;
+    for (const suite of iterateSuites(root)) {
+        testsAfter += suite.tests.length;
+    }
+    if (testsBefore > 0 && testsAfter === 0) {
+        throw new Error("[testit-adapter-cypress] No Cypress tests matched externalIds from tests in run. ");
+    }
+};
+exports.applyTestPlan = applyTestPlan;
+const iterateSuites = function* (parent) {
+    const suiteStack = [];
+    for (let s = parent; s; s = suiteStack.pop()) {
+        yield s;
+        // Pushing in reverse allows us to maintain depth-first pre-order traversal -
+        // the same order as used by Mocha & Cypress.
+        for (let i = s.suites.length - 1; i >= 0; i--) {
+            suiteStack.push(s.suites[i]);
+        }
+    }
+};
+const getIndicesOfDeselectedTests = (testsInRun, specPath, tests) => {
+    const indicesToRemove = [];
+    tests.forEach((test, index) => {
+        const { fullNameSuffix } = (0, utils_js_1.getTestMetadata)(test);
+        const fullName = `${specPath}#${fullNameSuffix}`;
+        const externalId = testit_js_commons_1.Utils.getHash(fullName);
+        if (!testsInRun.includes(externalId)) {
+            indicesToRemove.push(index);
+        }
+    });
+    return indicesToRemove;
+};
+const removeSortedIndices = (arr, indices) => {
+    for (let i = indices.length - 1; i >= 0; i--) {
+        arr.splice(indices[i], 1);
+    }
+};

package/dist/browser/types.d.ts

@@ -0,0 +1,35 @@
+import type { StatusDetails } from "../models/types.js";
+import { Label, Link, Status } from "testit-js-commons";
+export declare enum ContentType {
+    PNG = "image/png",
+    MP4 = "video/mp4",
+    JSON = "application/json",
+    TEXT = "text/plain"
+}
+export interface AttachmentOptions {
+    contentType: ContentType | string;
+    encoding?: BufferEncoding;
+    fileExtension?: string;
+    path?: string;
+    body?: Buffer;
+}
+export interface TestRuntime {
+    addLabels(...labels: Label[]): PromiseLike<void>;
+    addTags(...tags: String[]): PromiseLike<void>;
+    addLinks(...links: Link[]): PromiseLike<void>;
+    addWorkItemIds(...workItemIds: string[]): PromiseLike<void>;
+    addParameter(name: string, value: string): PromiseLike<void>;
+    addDescription(markdown: string): PromiseLike<void>;
+    addTitle(markdown: string): PromiseLike<void>;
+    addDisplayName(name: string): PromiseLike<void>;
+    addAttachments(name: string, content: Buffer | string, options: AttachmentOptions): PromiseLike<void>;
+    addAttachmentsFromPath(name: string, path: string, options: Omit<AttachmentOptions, "encoding">): PromiseLike<void>;
+    addGlobalAttachments(name: string, content: Buffer | string, options: AttachmentOptions): PromiseLike<void>;
+    addGlobalAttachmentsFromPath(name: string, path: string, options: Omit<AttachmentOptions, "encoding">): PromiseLike<void>;
+    addMessage(details: StatusDetails): PromiseLike<void>;
+    logStep(name: string, status?: Status, error?: Error): PromiseLike<void>;
+    step<T>(name: string, body: () => T | PromiseLike<T>): PromiseLike<T>;
+    stepDisplayName(name: string): PromiseLike<void>;
+    stepParameter(name: string, value: string): PromiseLike<void>;
+}
+export declare const noopRuntime: TestRuntime;

package/dist/browser/types.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noopRuntime = exports.ContentType = void 0;
+var ContentType;
+(function (ContentType) {
+    ContentType["PNG"] = "image/png";
+    ContentType["MP4"] = "video/mp4";
+    ContentType["JSON"] = "application/json";
+    ContentType["TEXT"] = "text/plain";
+})(ContentType || (exports.ContentType = ContentType = {}));
+const noop = { then: () => noop, catch: () => noop };
+exports.noopRuntime = {
+    addLabels: () => noop,
+    addTags: () => noop,
+    addLinks: () => noop,
+    addWorkItemIds: () => noop,
+    addParameter: () => noop,
+    addDescription: () => noop,
+    addTitle: () => noop,
+    addDisplayName: () => noop,
+    addAttachments: () => noop,
+    addAttachmentsFromPath: () => noop,
+    addGlobalAttachments: () => noop,
+    addGlobalAttachmentsFromPath: () => noop,
+    addMessage: () => noop,
+    logStep: () => noop,
+    step: (_, body) => Promise.resolve(body()),
+    stepDisplayName: () => noop,
+    stepParameter: () => noop,
+};

package/dist/browser/utils.d.ts

@@ -0,0 +1,65 @@
+import { Status } from "testit-js-commons";
+import type { CypressConsoleProps, CypressHook, CypressLogEntry, CypressRenderProps, CypressSuite, CypressTest, StepDescriptor, StatusDetails } from "../models/types.js";
+import { TestRuntime } from "./types.js";
+export declare const getFileNameFromPath: (path: string) => string;
+export declare const resolveSpecRelativePath: (spec: Cypress.Spec) => string;
+export declare const uint8ArrayToBase64: (data: unknown) => string;
+export declare const getTestStartData: (test: CypressTest) => {
+    start: number;
+    name: string;
+    fullNameSuffix: string;
+};
+export declare const getTestStopData: (test: CypressTest) => {
+    duration: number;
+    retries: any;
+};
+export declare const getTestSkipData: () => {
+    statusDetails: {
+        message: string;
+    };
+};
+export declare const getStepStopData: (step: StepDescriptor, status?: Status, statusDetails?: StatusDetails) => {
+    id: string;
+    status: Status;
+    statusDetails?: StatusDetails;
+    stop: number;
+};
+export declare const markTestAsReported: (test: CypressTest) => void;
+export declare const isTestReported: (test: CypressTest) => boolean;
+export declare const iterateSuites: (parent: CypressSuite) => Generator<CypressSuite, void, unknown>;
+export declare const iterateTests: (parent: CypressSuite) => Generator<Mocha.Test & {
+    wallClockStartedAt?: Date;
+    parent: CypressSuite | undefined;
+}, void, unknown>;
+export declare const getSuitePath: (test: CypressTest) => CypressSuite[];
+export declare const getSuiteTitlePath: (test: CypressTest) => string[];
+export declare const generateApiStepId: () => string;
+export declare const getTestMetadata: (test: CypressTest) => {
+    name: string;
+    fullNameSuffix: string;
+};
+export declare const isTmsHook: (hook: CypressHook) => boolean;
+export declare const isRootAfterAllHook: (hook: CypressHook) => boolean;
+export declare const isLastRootAfterHook: (context: Mocha.Context) => boolean;
+export declare const getStatusDataOfTestSkippedByHookError: (hookTitle: string, isEachHook: boolean, err: Error, suite: CypressSuite) => {
+    status: Status;
+    statusDetails: {
+        message: string | undefined;
+        trace: string | undefined;
+    };
+};
+export declare const resolveConsoleProps: (entry: CypressLogEntry) => CypressConsoleProps;
+export declare const resolveRenderProps: (entry: CypressLogEntry) => CypressRenderProps;
+export declare const getMessageAndTraceFromError: (error: Error | {
+    message?: string;
+    stack?: string;
+}) => StatusDetails;
+export declare const isPromise: (obj: unknown) => obj is PromiseLike<unknown>;
+export type SerializeOptions = {
+    maxDepth?: number;
+    maxLength?: number;
+    replacer?: (key: string, value: unknown) => unknown;
+};
+export declare const serialize: (value: unknown, opts?: SerializeOptions) => string;
+export declare const setGlobalTestRuntime: (r: TestRuntime) => void;
+export declare const getGlobalTestRuntime: () => TestRuntime;