testit-adapter-cypress 3.7.5

package/dist/browser/utils.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalTestRuntime = exports.setGlobalTestRuntime = exports.serialize = exports.isPromise = exports.getMessageAndTraceFromError = exports.resolveRenderProps = exports.resolveConsoleProps = exports.getStatusDataOfTestSkippedByHookError = exports.isLastRootAfterHook = exports.isRootAfterAllHook = exports.isTmsHook = exports.getTestMetadata = exports.generateApiStepId = exports.getSuiteTitlePath = exports.getSuitePath = exports.iterateTests = exports.iterateSuites = exports.isTestReported = exports.markTestAsReported = exports.getStepStopData = exports.getTestSkipData = exports.getTestStopData = exports.getTestStartData = exports.uint8ArrayToBase64 = exports.resolveSpecRelativePath = exports.getFileNameFromPath = void 0;
+const testit_js_commons_1 = require("testit-js-commons");
+const mocha_js_1 = require("./events/mocha.js");
+const state_js_1 = require("./state.js");
+const steps_js_1 = require("./steps.js");
+const types_js_1 = require("./types.js");
+const IS_WIN = Cypress.platform === "win32";
+const getFileNameFromPath = (path) => path.substring(path.lastIndexOf(IS_WIN ? "\\" : "/") + 1);
+exports.getFileNameFromPath = getFileNameFromPath;
+const resolveSpecRelativePath = (spec) => {
+    const projectDir = (0, state_js_1.getProjectDir)();
+    const specPath = projectDir ? spec.absolute.substring(projectDir.length + 1) : spec.relative;
+    return IS_WIN ? specPath.replaceAll("\\", "/") : specPath;
+};
+exports.resolveSpecRelativePath = resolveSpecRelativePath;
+const uint8ArrayToBase64 = (data) => {
+    // @ts-ignore
+    const u8arrayLike = Array.isArray(data) || data.buffer;
+    if (!u8arrayLike) {
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return btoa(String.fromCharCode.apply(null, data));
+};
+exports.uint8ArrayToBase64 = uint8ArrayToBase64;
+const getTestStartData = (test) => ({
+    ...(0, exports.getTestMetadata)(test),
+    start: typeof test.wallClockStartedAt === "string"
+        ? Date.parse(test.wallClockStartedAt)
+        : test.wallClockStartedAt?.getTime?.() || Date.now(),
+});
+exports.getTestStartData = getTestStartData;
+const getTestStopData = (test) => ({
+    duration: test.duration ?? 0,
+    retries: test._retries ?? 0,
+});
+exports.getTestStopData = getTestStopData;
+const getTestSkipData = () => ({
+    statusDetails: { message: "This is a pending test" },
+});
+exports.getTestSkipData = getTestSkipData;
+const getStepStopData = (step, status, statusDetails) => {
+    const data = {
+        id: step.id,
+        stop: Date.now(),
+        status: status ?? (0, steps_js_1.resolveStepStatus)(step),
+    };
+    if (statusDetails) {
+        data.statusDetails = statusDetails;
+    }
+    return data;
+};
+exports.getStepStopData = getStepStopData;
+const testReportedKey = Symbol("The test has been reported to Tms");
+const markTestAsReported = (test) => {
+    test[testReportedKey] = true;
+};
+exports.markTestAsReported = markTestAsReported;
+const isTestReported = (test) => test[testReportedKey] === true;
+exports.isTestReported = isTestReported;
+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 is used by Mocha & Cypress.
+        for (let i = s.suites.length - 1; i >= 0; i--) {
+            suiteStack.push(s.suites[i]);
+        }
+    }
+};
+exports.iterateSuites = iterateSuites;
+const iterateTests = function* (parent) {
+    for (const suite of (0, exports.iterateSuites)(parent)) {
+        yield* suite.tests;
+    }
+};
+exports.iterateTests = iterateTests;
+const getSuitePath = (test) => {
+    const suites = [];
+    for (let s = test.parent; s; s = s.parent) {
+        suites.push(s);
+    }
+    suites.reverse();
+    return suites;
+};
+exports.getSuitePath = getSuitePath;
+const getSuiteTitlePath = (test) => (0, exports.getSuitePath)(test)
+    .filter((s) => s.title)
+    .map((s) => s.title);
+exports.getSuiteTitlePath = getSuiteTitlePath;
+const generateApiStepId = () => ((0, state_js_1.getTmsState)().nextApiStepId++).toString();
+exports.generateApiStepId = generateApiStepId;
+const getTestMetadata = (test) => {
+    const suites = test.titlePath().slice(0, -1);
+    const fullNameSuffix = `${[...suites, test.title].join(" ")}`;
+    return { name: test.title, fullNameSuffix };
+};
+exports.getTestMetadata = getTestMetadata;
+const isTmsHook = (hook) => hook.title.includes(mocha_js_1.TMS_REPORT_SYSTEM_HOOK);
+exports.isTmsHook = isTmsHook;
+const isRootAfterAllHook = (hook) => hook.parent.root && hook.hookName === "after all";
+exports.isRootAfterAllHook = isRootAfterAllHook;
+const isLastRootAfterHook = (context) => {
+    const currentAfterAll = context.test;
+    const rootSuite = context.test.parent;
+    const hooks = rootSuite.hooks;
+    const lastAfterAll = hooks.findLast((h) => h.hookName === "after all");
+    return lastAfterAll?.hookId === currentAfterAll.hookId;
+};
+exports.isLastRootAfterHook = isLastRootAfterHook;
+const getStatusDataOfTestSkippedByHookError = (hookTitle, isEachHook, err, suite) => {
+    const status = isEachHook ? testit_js_commons_1.Status.SKIPPED : testit_js_commons_1.Status.FAILED;
+    const { message, trace } = (0, exports.getMessageAndTraceFromError)(err);
+    return {
+        status,
+        statusDetails: {
+            message: isEachHook ? getSkipReason(hookTitle, suite) : message,
+            trace,
+        },
+    };
+};
+exports.getStatusDataOfTestSkippedByHookError = getStatusDataOfTestSkippedByHookError;
+const getSkipReason = (hookTitle, suite) => {
+    const suiteName = suite.title ? `'${suite.title}'` : "root";
+    return `'${hookTitle}' defined in the ${suiteName} suite has failed`;
+};
+const resolveConsoleProps = (entry) => {
+    // consoleProps can be a function or an object(cy.origin just return an object)
+    return typeof entry.attributes.consoleProps === "function"
+        ? entry.attributes.consoleProps()
+        : entry.attributes.consoleProps;
+};
+exports.resolveConsoleProps = resolveConsoleProps;
+const resolveRenderProps = (entry) => {
+    // renderProps can be a function or an object(cy.origin just return an object)
+    return typeof entry?.attributes?.renderProps === "function"
+        ? entry.attributes.renderProps()
+        : entry.attributes?.renderProps;
+};
+exports.resolveRenderProps = resolveRenderProps;
+const getMessageAndTraceFromError = (error) => {
+    const message = error.message ?? undefined;
+    const trace = error.stack ?? undefined;
+    const v = error;
+    const actual = v.actual !== undefined ? (0, exports.serialize)(v.actual) : undefined;
+    const expected = v.expected !== undefined ? (0, exports.serialize)(v.expected) : undefined;
+    return { message, trace, actual, expected };
+};
+exports.getMessageAndTraceFromError = getMessageAndTraceFromError;
+const isPromise = (obj) => !!obj &&
+    (typeof obj === "object" || typeof obj === "function") &&
+    "then" in obj &&
+    typeof obj.then === "function";
+exports.isPromise = isPromise;
+const serialize = (value, opts = {}) => {
+    const { maxLength = 0 } = opts;
+    let stringValue;
+    if (typeof value === "object" && value !== null) {
+        try {
+            stringValue = JSON.stringify(value);
+        }
+        catch {
+            stringValue = String(value);
+        }
+    }
+    else {
+        stringValue = String(value);
+    }
+    if (maxLength && stringValue.length > maxLength) {
+        return stringValue.slice(0, maxLength) + "...";
+    }
+    return stringValue;
+};
+exports.serialize = serialize;
+const KEY = "tmsTestRuntime";
+const setGlobalTestRuntime = (r) => {
+    globalThis[KEY] = () => r;
+};
+exports.setGlobalTestRuntime = setGlobalTestRuntime;
+const getGlobalTestRuntime = () => {
+    const fn = globalThis[KEY];
+    return fn?.() ?? types_js_1.noopRuntime;
+};
+exports.getGlobalTestRuntime = getGlobalTestRuntime;

package/dist/converter.d.ts

@@ -0,0 +1,43 @@
+import type { AutotestPost, AutotestResult, Outcome } from "testit-js-commons";
+import { Label, Link } from "testit-js-commons";
+export interface StepData {
+    id: string;
+    name: string;
+    start: number;
+    stop?: number;
+    duration?: number;
+    status?: Outcome;
+    statusDetails?: {
+        message?: string;
+        trace?: string;
+    };
+    attachmentIds: string[];
+    children: StepData[];
+}
+export interface TestData {
+    fullNameSuffix: string;
+    displayName: string;
+    description?: string;
+    title?: string;
+    namespace?: string;
+    classname?: string;
+    labels: Label[];
+    tags: string[];
+    links: Link[];
+    workItemIds: string[];
+    start?: number;
+    stop?: number;
+    outcome: Outcome;
+    duration?: number;
+    statusDetails?: {
+        message?: string;
+        trace?: string;
+    };
+    steps: StepData[];
+    attachmentIds: string[];
+    parameters?: Record<string, string>;
+    properties?: Record<string, string>;
+    externalKey: string;
+}
+export declare function toAutotestPost(specPath: string, t: TestData): AutotestPost;
+export declare function toAutotestResult(externalId: string, t: TestData, outcome: Outcome, extraAttachmentIds?: string[]): AutotestResult;

package/dist/converter.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAutotestPost = toAutotestPost;
+exports.toAutotestResult = toAutotestResult;
+const testit_js_commons_1 = require("testit-js-commons");
+function stepDataToStep(s) {
+    const step = {
+        title: s.name,
+        outcome: s.status,
+        attachments: s.attachmentIds.map((id) => ({ id })),
+        steps: s.children.length ? s.children.map(stepDataToStep) : undefined,
+    };
+    if (s.start != null)
+        step.startedOn = new Date(s.start);
+    if (s.stop != null)
+        step.completedOn = new Date(s.stop);
+    if (s.duration != null)
+        step.duration = s.duration;
+    else if (s.start != null && s.stop != null)
+        step.duration = s.stop - s.start;
+    if (s.statusDetails?.message)
+        step.info = s.statusDetails.message;
+    return step;
+}
+function stepDataToShortStep(s) {
+    return {
+        title: s.name,
+        steps: s.children.length ? s.children.map(stepDataToShortStep) : undefined,
+    };
+}
+function toAutotestPost(specPath, t) {
+    const fullName = `${specPath}#${t.fullNameSuffix}`;
+    const externalId = testit_js_commons_1.Utils.getHash(fullName);
+    const name = (t.displayName ?? t.fullNameSuffix).replace(/#/g, " > ");
+    const labels = t.labels?.map((l) => ({ name: l.name })) ?? [];
+    return {
+        externalId,
+        name,
+        title: t.title,
+        description: t.description,
+        workItemIds: t.workItemIds,
+        namespace: t.namespace,
+        classname: t.classname,
+        links: t.links?.length ? t.links : undefined,
+        labels: labels.length ? labels : undefined,
+        tags: t.tags?.length ? t.tags : undefined,
+        steps: t.steps.map(s => stepDataToShortStep(s)),
+        externalKey: t.externalKey,
+    };
+}
+function toAutotestResult(externalId, t, outcome, extraAttachmentIds = []) {
+    const result = {
+        autoTestExternalId: externalId,
+        outcome,
+        attachments: [...t.attachmentIds, ...extraAttachmentIds].map((id) => ({ id })),
+        stepResults: t.steps.map(s => stepDataToStep(s)),
+    };
+    if (t.links?.length) {
+        result.links = t.links;
+    }
+    if (t.duration != null) {
+        result.duration = t.duration;
+    }
+    if (t.start != null) {
+        result.startedOn = new Date(t.start);
+        if (t.duration != null) {
+            result.completedOn = new Date(t.start + t.duration);
+        }
+        else if (t.stop != null) {
+            result.completedOn = new Date(t.stop);
+        }
+    }
+    if (t.parameters) {
+        result.parameters = t.parameters;
+    }
+    if (t.properties) {
+        result.properties = t.properties;
+    }
+    if (t.statusDetails?.message)
+        result.message = t.statusDetails.message;
+    if (t.statusDetails?.trace)
+        result.traces = t.statusDetails.trace;
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { initializeTms } from "./browser/index.js";
+export { initializeTms };

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeTms = void 0;
+const index_js_1 = require("./browser/index.js");
+Object.defineProperty(exports, "initializeTms", { enumerable: true, get: function () { return index_js_1.initializeTms; } });
+(0, index_js_1.initializeTms)();

package/dist/models/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/models/status.d.ts

@@ -0,0 +1,5 @@
+export declare enum Status {
+    FAILED = "Failed",
+    PASSED = "Passed",
+    SKIPPED = "Skipped"
+}

package/dist/models/status.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = void 0;
+var Status;
+(function (Status) {
+    Status["FAILED"] = "Failed";
+    Status["PASSED"] = "Passed";
+    Status["SKIPPED"] = "Skipped";
+})(Status || (exports.Status = Status = {}));

package/dist/models/types.d.ts

@@ -0,0 +1,280 @@
+import type { Label, Link, Status } from "testit-js-commons";
+export interface Parameter {
+    name: string;
+    value: string;
+}
+export interface StatusDetails {
+    message?: string;
+    trace?: string;
+    actual?: string;
+    expected?: string;
+}
+export type ReporterConfig = {
+    resultsDir?: string;
+};
+export type TmsCypressConfig = ReporterConfig & {
+    videoOnFailOnly?: boolean;
+    stepsFromCommands?: Partial<TmsSpecState["config"]["stepsFromCommands"]>;
+};
+export type CypressSuite = Mocha.Suite & {
+    id: string;
+    parent: CypressSuite | undefined;
+    tests: CypressTest[];
+    suites: CypressSuite[];
+};
+export type CypressTest = Mocha.Test & {
+    wallClockStartedAt?: Date;
+    parent: CypressSuite | undefined;
+};
+export type CypressHook = Mocha.Hook & {
+    hookId: string;
+    hookName: string;
+    parent: CypressSuite | undefined;
+};
+export type CypressCommand = {
+    attributes: {
+        name: string;
+        id: string;
+        args: any[];
+    };
+    state: "passed" | "failed" | "queued";
+};
+export type CypressRenderProps = {
+    message?: string;
+};
+export type CypressConsoleProps = {
+    name: string;
+    props: Record<string, unknown>;
+};
+export type CypressLogEntry = ReturnType<typeof Cypress.log> & {
+    attributes: {
+        id: string;
+        error?: Error;
+        name: string;
+        message: string;
+        displayName?: string;
+        event: boolean;
+        type: string;
+        instrument: string;
+        groupStart: boolean;
+        createdAtTimestamp: number;
+        updatedAtTimestamp: number;
+        end?: boolean;
+        renderProps: (() => CypressRenderProps) | CypressRenderProps;
+        consoleProps: (() => CypressConsoleProps) | CypressConsoleProps;
+    };
+    endGroup: () => unknown;
+};
+export type CupressRunStart = {
+    type: "cypress_run_start";
+    data: object;
+};
+export type CypressSuiteStartMessage = {
+    type: "cypress_suite_start";
+    data: {
+        id: string;
+        name: string;
+        root: boolean;
+        start: number;
+    };
+};
+export type CypressSuiteEndMessage = {
+    type: "cypress_suite_end";
+    data: {
+        root: boolean;
+        stop: number;
+    };
+};
+export type CypressHookStartMessage = {
+    type: "cypress_hook_start";
+    data: {
+        name: string;
+        scopeType: "each" | "all";
+        position: "before" | "after";
+        start: number;
+    };
+};
+export type CypressHookEndMessage = {
+    type: "cypress_hook_end";
+    data: {
+        duration: number;
+    };
+};
+export type CypressTestStartMessage = {
+    type: "cypress_test_start";
+    data: {
+        name: string;
+        fullNameSuffix: string;
+        start: number;
+        labels: Label[];
+        tags: string[];
+        links: Link[];
+        workItemIds: string[];
+    };
+};
+export type CypressFailMessage = {
+    type: "cypress_fail";
+    data: {
+        status: Status;
+        statusDetails: StatusDetails;
+    };
+};
+export type CypressTestSkipMessage = {
+    type: "cypress_test_skip";
+    data: {
+        statusDetails?: StatusDetails;
+    };
+};
+export type CypressTestPassMessage = {
+    type: "cypress_test_pass";
+    data: object;
+};
+export type CypressSkippedTestMessage = {
+    type: "cypress_skipped_test";
+    data: CypressTestStartMessage["data"] & CypressFailMessage["data"] & CypressTestEndMessage["data"] & {
+        suites: string[];
+    };
+};
+export type CypressTestEndMessage = {
+    type: "cypress_test_end";
+    data: {
+        duration: number;
+        retries: number;
+    };
+};
+export type CypressStepStartMessage = {
+    type: "cypress_step_start";
+    data: {
+        id: string;
+        name: string;
+        start: number;
+    };
+};
+export type CypressStepStopMessage = {
+    type: "cypress_step_stop";
+    data: {
+        id: string;
+        status: Status;
+        statusDetails?: StatusDetails;
+        stop: number;
+    };
+};
+export type CypressStepFinalizeMessage = {
+    type: "cypress_step_finalize";
+    data: {
+        id: string;
+        name?: string;
+        parameters?: Parameter[];
+        statusDetails?: StatusDetails;
+    };
+};
+type RuntimeMessageBase<T extends string> = {
+    type: T;
+};
+export type RuntimeMetadataMessage = RuntimeMessageBase<"metadata"> & {
+    data: {
+        labels?: Label[];
+        links?: Link[];
+        tags?: string[];
+        workItemIds?: string[];
+        parameters?: Parameter[];
+        description?: string;
+        displayName?: string;
+        title?: string;
+        namespace?: string;
+        classname?: string;
+    };
+};
+export type RuntimeStartStepMessage = RuntimeMessageBase<"step_start"> & {
+    data: {
+        name: string;
+        start: number;
+    };
+};
+export type RuntimeStopStepMessage = RuntimeMessageBase<"step_stop"> & {
+    data: {
+        stop: number;
+        status: Status;
+        statusDetails?: StatusDetails;
+    };
+};
+export type RuntimeAttachmentContentMessage = RuntimeMessageBase<"attachment_content"> & {
+    data: {
+        name: string;
+        content: string;
+        encoding: BufferEncoding;
+        contentType: string;
+        fileExtension?: string;
+    };
+};
+export type RuntimeAttachmentPathMessage = RuntimeMessageBase<"attachment_path"> & {
+    data: {
+        name: string;
+        path: string;
+        contentType: string;
+        fileExtension?: string;
+    };
+};
+export type RuntimeMessage = RuntimeMetadataMessage | RuntimeStartStepMessage | RuntimeStopStepMessage | RuntimeAttachmentContentMessage | RuntimeAttachmentPathMessage | (RuntimeMessageBase<string> & {
+    data?: unknown;
+});
+export interface TestPlanV1 {
+    version: "1.0";
+    tests: Array<{
+        id?: string | number;
+        selector?: string;
+    }>;
+}
+export type CypressMessage = Exclude<RuntimeMessage, RuntimeStartStepMessage | RuntimeStopStepMessage> | CupressRunStart | CypressSuiteStartMessage | CypressSuiteEndMessage | CypressHookStartMessage | CypressHookEndMessage | CypressTestStartMessage | CypressStepStartMessage | CypressStepStopMessage | CypressStepFinalizeMessage | CypressTestPassMessage | CypressFailMessage | CypressTestSkipMessage | CypressSkippedTestMessage | CypressTestEndMessage;
+export type SpecContext = {
+    specPath: string;
+    test: string | undefined;
+    fixture: string | undefined;
+    stepsByFrontEndId: Map<string, string>;
+    videoScope: string;
+    suiteIdToScope: Map<string, string>;
+    suiteScopeToId: Map<string, string>;
+    suiteScopes: string[];
+    testScope: string | undefined;
+    suiteNames: string[];
+    failed: boolean;
+};
+type StepDescriptorBase = {
+    id: string;
+    error?: Error;
+};
+export type LogStepDescriptor = StepDescriptorBase & {
+    type: "log";
+    attachmentName?: string;
+    log: CypressLogEntry;
+};
+export type ApiStepDescriptor = StepDescriptorBase & {
+    type: "api";
+};
+export type StepDescriptor = LogStepDescriptor | ApiStepDescriptor;
+export type StepFinalizer = (message: CypressStepFinalizeMessage["data"]) => void;
+export type TmsSpecState = {
+    config: {
+        stepsFromCommands: {
+            maxArgumentLength: number;
+            maxArgumentDepth: number;
+        };
+    };
+    initialized: boolean;
+    testPlan: TestPlanV1 | null | undefined;
+    projectDir?: string;
+    messages: CypressMessage[];
+    currentTest?: CypressTest;
+    stepStack: StepDescriptor[];
+    stepsToFinalize: [step: StepDescriptor, finalizer: StepFinalizer | undefined][];
+    nextApiStepId: number;
+};
+export type TmsCypressTaskArgs = {
+    absolutePath: string;
+    messages: readonly CypressMessage[];
+    isInteractive: boolean;
+};
+export type CypressSuiteFunction = (title: string, configOrFn?: Cypress.SuiteConfigOverrides | ((this: Mocha.Suite) => void), fn?: (this: Mocha.Suite) => void) => Mocha.Suite;
+export type DirectHookImplementation = Mocha.AsyncFunc | ((this: Mocha.Context) => void);
+export type HookImplementation = Mocha.Func | DirectHookImplementation;
+export {};

package/dist/models/types.js

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

package/dist/node-utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Helpers that use Node.js built-in modules. Import only in Node context (e.g. reporter, plugins).
+ * Do not import in browser bundle (Cypress support/specs).
+ */
+export declare function getProjectRoot(): string;
+export declare function getRelativePath(absolutePath: string): string;
+export declare function getPosixPath(filepath: string): string;
+export interface TestPlanV1 {
+    version: "1.0";
+    tests: Array<{
+        id?: string | number;
+        selector?: string;
+    }>;
+}
+export declare function parseTestPlan(): TestPlanV1 | undefined;