testit-adapter-cypress 3.7.5

package/README.md

@@ -0,0 +1,240 @@
+# Test IT TMS adapters for Cypress
+![Test IT](https://raw.githubusercontent.com/testit-tms/adapters-js/master/images/banner.png)
+
+## Getting Started
+
+### Installation
+```
+npm install testit-adapter-cypress
+```
+
+## Usage
+
+### Configuration
+
+| Description                                                                                                                                                                                                                                                                                                                                                                            | File property                     | Environment variable                       |
+|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------|--------------------------------------------|
+| Location of the TMS instance                                                                                                                                                                                                                                                                                                                                                           | url                               | TMS_URL                                    |
+| API secret key [How to getting API secret key?](https://github.com/testit-tms/.github/tree/main/configuration#privatetoken)                                                                                                                                                                                                                                                            | privateToken                      | TMS_PRIVATE_TOKEN                          |
+| ID of project in TMS instance [How to getting project ID?](https://github.com/testit-tms/.github/tree/main/configuration#projectid)                                                                                                                                                                                                                                                    | projectId                         | TMS_PROJECT_ID                             |
+| ID of configuration in TMS instance [How to getting configuration ID?](https://github.com/testit-tms/.github/tree/main/configuration#configurationid)                                                                                                                                                                                                                                  | configurationId                   | TMS_CONFIGURATION_ID                       |
+| ID of the created test run in TMS instance.<br/>It's necessary for **adapterMode** 1                                                                                                                                                                                                                                                                                                | testRunId                         | TMS_TEST_RUN_ID                            |
+| Parameter for specifying the name of test run in TMS instance (**It's optional**). If it is not provided, it is created automatically                                                                                                                                                                                                                                                  | testRunName                       | TMS_TEST_RUN_NAME                          |
+| Adapter mode. Default value - 1. The adapter supports following modes:<br>1 - in this mode, the adapter sends all results to the test run without filtering or [with filtering CLI](#run-with-filter)<br/>2 - in this mode, the adapter creates a new test run and sends results to the new test run | adapterMode                       | TMS_ADAPTER_MODE                           |
+| It enables/disables certificate validation (**It's optional**). Default value - true                                                                                                                                                                                                                                                                                                   | certValidation                    | TMS_CERT_VALIDATION                        |
+| Mode of automatic creation test cases (**It's optional**). Default value - false. The adapter supports following modes:<br/>true - in this mode, the adapter will create a test case linked to the created autotest (not to the updated autotest)<br/>false - in this mode, the adapter will not create a test case                                                                    | automaticCreationTestCases        | TMS_AUTOMATIC_CREATION_TEST_CASES          |
+| Mode of automatic updation links to test cases (**It's optional**). Default value - false. The adapter supports following modes:<br/>true - in this mode, the adapter will update links to test cases<br/>false - in this mode, the adapter will not update link to test cases                                                                                                         | automaticUpdationLinksToTestCases | TMS_AUTOMATIC_UPDATION_LINKS_TO_TEST_CASES |
+
+Add Adapter to Cypress file configuration:
+
+```ts
+import { tmsCypress } from "testit-adapter-cypress/reporter";
+
+export default {
+  e2e: {
+    setupNodeEvents(on, config) {
+      tmsCypress(on, config);
+
+      return config;
+    },
+  },
+};
+```
+
+Add Adapter to `cypress/support/e2e.js`:
+```ts
+import "testit-adapter-cypress";
+```
+
+#### File
+
+Create .env config or file config with default name tms.config.json in the root directory of the project
+
+```json
+{
+  "url": "URL",
+  "privateToken": "USER_PRIVATE_TOKEN",
+  "projectId": "PROJECT_ID",
+  "configurationId": "CONFIGURATION_ID",
+  "testRunId": "TEST_RUN_ID",
+  "testRunName": "TEST_RUN_NAME",
+  "adapterMode": "ADAPTER_MODE",
+  "automaticCreationTestCases": "AUTOMATIC_CREATION_TEST_CASES",
+  "automaticUpdationLinksToTestCases": "AUTOMATIC_UPDATION_LINKS_TO_TEST_CASES"
+}
+```
+
+#### Parallel run
+To create and complete TestRun you can use the Test IT CLI (use adapterMode 1 for parallel run):
+
+```
+$ export TMS_TOKEN=<YOUR_TOKEN>
+$ testit testrun create
+  --url https://tms.testit.software \
+  --project-id 5236eb3f-7c05-46f9-a609-dc0278896464 \
+  --testrun-name "New test run" \
+  --output tmp/output.txt
+
+$ export TMS_TEST_RUN_ID=$(cat tmp/output.txt)  
+
+$ npx cypress run
+
+$ testit testrun complete
+  --url https://tms.testit.software \
+  --testrun-id $(cat tmp/output.txt) 
+```
+
+#### Run with filter
+It is necessary to use test filtering in cypress. This example uses the "@cypress/grep" plugin.
+To create filter by autotests you can use the Test IT CLI (use adapterMode 1 for run with filter):
+
+```
+$ export TMS_TOKEN=<YOUR_TOKEN>
+$ testit autotests_filter 
+  --url https://tms.testit.software \
+  --configuration-id 5236eb3f-7c05-46f9-a609-dc0278896464 \
+  --testrun-id 6d4ac4b7-dd67-4805-b879-18da0b89d4a8 \
+  --framework cypress \
+  --output tmp/filter.txt
+
+$ export TMS_TEST_RUN_ID=6d4ac4b7-dd67-4805-b879-18da0b89d4a8
+$ export TMS_ADAPTER_MODE=1
+
+$ npx cypress run --expose grep="$(cat tmp/filter.txt)"
+```
+
+#### Launch using GitLab repository
+To run your Cypress test's from GitLab to TestIT or in reverse order using "testit-adapter-cypress", you can take this .gitlab-ci.yml file example:
+
+```
+image: node:latest
+
+stages:
+  - run
+
+first-job:
+  stage: run
+  script:
+    - npm install
+    - npx cypress run
+  artifacts:
+    paths:
+      - node_modules/
+```
+
+
+### Methods
+
+Methods can be used to specify information about autotest.
+
+Description of methods:
+- `tms.addWorkItemIds` - a dynamic method that links autotests with manual tests. Receives the array of manual tests' IDs
+- `tms.addDisplayName` - a dynamic method for adding internal autotest name (used in Test IT)
+- `tms.addTitle` - a dynamic method for adding autotest name specified in the autotest card. If not specified, the name from the displayName method is used
+- `tms.addDescription` - a dynamic method for adding autotest description specified in the autotest card
+- `tms.addLabels` - a dynamic method for adding labels listed in the autotest card
+- `tms.addTags` - a dynamic method for adding tags listed in the autotest card
+- `tms.addLinks` - links in the autotest result
+- `tms.addAttachments` - uploading files in the autotest result
+- `tms.addMessage` - information about autotest in the autotest result
+- `tms.addNameSpace` - a dynamic method for adding directory in the TMS system (default - file's name of test)
+- `tms.addClassName` - a dynamic method for adding subdirectory in the TMS system (default - class's name of test)
+- `tms.addParameter` - a dynamic method for adding parameter in the autotest result
+- `tms.step` - usage in the "with" construct to designation a step in the body of the test
+
+### Examples
+
+#### Simple test
+```ts
+import { getTestRuntime } from "testit-adapter-cypress/runtime";
+
+describe('example to-do app', () => {
+  it('displays two todo items by default', () => {
+    const tms = getTestRuntime();
+
+    tms.addWorkItemIds('123', '321');
+    tms.addDisplayName('display name');
+    tms.addTitle('test title');
+    tms.addDescription('Test description');
+    tms.addLabels('label1', 'label2');
+    tms.addTags('tag1', 'tag2');
+    tms.addLinks([
+      {
+        url: 'https://www.google.com',
+        title: 'Google',
+        description: 'This is a link to Google',
+        type: 'Related',
+      },
+    ]);
+    tms.addParameter("name", "value");
+    tms.addNameSpace("namespace");
+    tms.addClassName("classname");
+
+    tms.step("step title", () => {
+      // ...
+    }).then((user) => {
+      tms.step("inner step title", () => {
+        // ...
+      });
+    });
+  });
+});
+```
+
+### Parameterized test
+
+> [!WARNING]
+> When linking a parameterized autotest to a parameterized test case, please consider the problematic points:
+> - In TMS test cases have a table with parameters, but autotests do not. They are not equal entities, so there may be incompatibility in terms of parameters
+> - Running a parameterized test case, TMS expects the results of all related autotests with all the parameters specified in the test case table
+> - In TMS, the parameters are limited to the string type, so the adapter transmits absolutely all the autotest parameters as a string. This implies the following problematic point for the test case table
+> - TMS expects a complete **textual** match of the name and value of the parameters of the test case table with the autotest parameters
+
+```ts
+import { getTestRuntime } from "testit-adapter-cypress/runtime";
+
+describe('example to-do app', () => {
+  const tests = [2, 3, "string", false];
+
+  tests.forEach((value) => {
+    it(`3 is ${value}`, () => {
+      const tms = getTestRuntime();
+
+      tms.addParameter("name", value);
+      // ...
+    });
+  });
+});
+```
+
+#### Content types
+```
+  TEXT = "text/plain",
+  XML = "application/xml",
+  HTML = "text/html",
+  CSV = "text/csv",
+  TSV = "text/tab-separated-values",
+  CSS = "text/css",
+  URI = "text/uri-list",
+  SVG = "image/svg+xml",
+  PNG = "image/png",
+  JSON = "application/json",
+  ZIP = "application/zip",
+  WEBM = "video/webm",
+  JPEG = "image/jpeg",
+  MP4 = "video/mp4",
+```
+
+# Contributing
+
+You can help to develop the project. Any contributions are **greatly appreciated**.
+
+* If you have suggestions for adding or removing projects, feel free to [open an issue](https://github.com/testit-tms/adapters-js/issues/new) to discuss it, or directly create a pull request after you edit the *README.md* file with necessary changes.
+* Please make sure you check your spelling and grammar.
+* Create individual PR for each suggestion.
+* Please also read through the [Code Of Conduct](https://github.com/testit-tms/adapters-js/blob/master/CODE_OF_CONDUCT.md) before posting your first idea as well.
+
+# License
+
+Distributed under the Apache-2.0 License. See [LICENSE](https://github.com/testit-tms/adapters-js/blob/master/LICENSE.md) for more information.
+

package/dist/browser/commandLog.d.ts

@@ -0,0 +1,10 @@
+import type { CypressLogEntry } from "../models/types.js";
+export declare const shouldCreateStepFromCommandLogEntry: (entry: CypressLogEntry) => boolean;
+/**
+ * Checks if the current step represents a cy.screenshot command log entry. If this is the case, associates the name
+ * of the screenshot with the step. Later, that will allow converting the step with the attachment into the attachment
+ * step.
+ */
+export declare const setupScreenshotAttachmentStep: (originalName: string | undefined, name: string) => void;
+export declare const startCommandLogStep: (entry: CypressLogEntry) => void;
+export declare const stopCommandLogStep: (entryId: string) => void;

package/dist/browser/commandLog.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopCommandLogStep = exports.startCommandLogStep = exports.setupScreenshotAttachmentStep = exports.shouldCreateStepFromCommandLogEntry = void 0;
+const utils_js_1 = require("../utils.js");
+const lifecycle_js_1 = require("./lifecycle.js");
+const serialize_js_1 = __importDefault(require("./serialize.js"));
+const state_js_1 = require("./state.js");
+const steps_js_1 = require("./steps.js");
+const utils_js_2 = require("./utils.js");
+const shouldCreateStepFromCommandLogEntry = (entry) => {
+    const { event, instrument } = entry.attributes;
+    if (instrument !== "command") {
+        // We are interested in the "TEST BODY" panel only for now.
+        // Other instruments are logged in separate panels.
+        return false;
+    }
+    if (event) {
+        // Events are tricky to report as they may span across commands and even leave the test's scope.
+        // We ignore them for now.
+        return false;
+    }
+    if (isApiStepErrorLogEntry(entry)) {
+        // Cypress don't create a log message for 'cy.then' except when it throws an error.
+        // This is in particularly happens when the function passed to 'testit.step' throws. In such a case however,
+        // creating an extra step from the log entry is redundant because the error is already included in the report as
+        // a part of the step.
+        return false;
+    }
+    return true;
+};
+exports.shouldCreateStepFromCommandLogEntry = shouldCreateStepFromCommandLogEntry;
+/**
+ * Checks if the current step represents a cy.screenshot command log entry. If this is the case, associates the name
+ * of the screenshot with the step. Later, that will allow converting the step with the attachment into the attachment
+ * step.
+ */
+const setupScreenshotAttachmentStep = (originalName, name) => {
+    const step = (0, state_js_1.getCurrentStep)();
+    if (step && (0, steps_js_1.isLogStep)(step)) {
+        const { name: commandName, props: { name: nameFromProps }, } = (0, utils_js_2.resolveConsoleProps)(step.log);
+        if (commandName === "screenshot" && nameFromProps === originalName) {
+            step.attachmentName = name;
+        }
+    }
+};
+exports.setupScreenshotAttachmentStep = setupScreenshotAttachmentStep;
+const startCommandLogStep = (entry) => {
+    const currentLogEntry = getCurrentLogEntry();
+    if (typeof currentLogEntry !== "undefined" && shouldStopCurrentLogStep(currentLogEntry.log, entry)) {
+        (0, exports.stopCommandLogStep)(currentLogEntry.log.attributes.id);
+    }
+    pushLogEntry(entry);
+    (0, lifecycle_js_1.reportStepStart)(entry.attributes.id, getCommandLogStepName(entry));
+    scheduleCommandLogStepStop(entry);
+};
+exports.startCommandLogStep = startCommandLogStep;
+const stopCommandLogStep = (entryId) => (0, steps_js_1.findAndStopStepWithSubsteps)(({ id }) => id === entryId);
+exports.stopCommandLogStep = stopCommandLogStep;
+const pushLogEntry = (entry) => {
+    const id = entry.attributes.id;
+    const stepDescriptor = { id, type: "log", log: entry };
+    (0, state_js_1.pushStep)(stepDescriptor);
+    // Some properties of some Command Log entries are undefined at the time the entry is stopped. An example is the
+    // Yielded property of some queries. We defer converting them to Tms step parameters until the test/hook ends.
+    (0, state_js_1.setupStepFinalization)(stepDescriptor, (data) => {
+        data.parameters = getCommandLogStepParameters(entry);
+        if (stepDescriptor.attachmentName) {
+            // Rename the step to match the attachment name. Once the names are the same, Tms will render the
+            // attachment in the place of the step.
+            data.name = stepDescriptor.attachmentName;
+        }
+    });
+};
+/**
+ * Wraps `entry.endGroup` so that the Tms step created for a Command Log group
+ * is always stopped when Cypress finishes that group.
+ *
+* Behavior:
+* - Retains the original `entry.endGroup` handler.
+ * - Replaces it with a wrapper function that:
+* - first calls `stopCommandLogStep(id)`, completing the step in our state;
+ * - then calls the original `entry.endGroup` with the same `this` so as not to break Cypress.
+ */
+const overrideEntryEndGroup = (entry, id) => {
+    const originalEndGroup = entry.endGroup;
+    entry.endGroup = function () {
+        (0, exports.stopCommandLogStep)(id);
+        return originalEndGroup.call(this);
+    };
+};
+/**
+* Wraps `entry.end` for single Command Log entries to synchronize
+ * the lifecycle of a step in Tms with the completion of a log entry in Cypress.
+ *
+* Behavior:
+* - Saves the original `entry.end` (without context binding).
+* - Sets a new `entry.end`, which:
+* - first calls `stopCommandLogStep(id)` to stop the step;
+ * - then calls the original `end` with the correct `this', while maintaining the standard behavior of Cypress.
+ */
+const overrideEntryEnd = (entry, id) => {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalEnd = entry.end;
+    entry.end = function () {
+        (0, exports.stopCommandLogStep)(id);
+        return originalEnd.call(this);
+    };
+};
+const scheduleCommandLogStepStop = (entry) => {
+    const { groupStart, end, id } = entry.attributes;
+    if (end) {
+        // Some entries are already completed (this is similar to the idea behind tms.logStep).
+        // Cypress won't call entry.end() in such a case, so we need to stop such a step now.
+        // Example: cy.log
+        (0, exports.stopCommandLogStep)(id);
+    }
+    else if (groupStart) {
+        // A logging group must be stopped be the user via the Cypress.Log.endGroup() call.
+        // If the call is missing, the corresponding step will be stopped either at the test's (the hook's) end.
+        overrideEntryEndGroup(entry, id);
+    }
+    else {
+        // Regular log entries are finalized by Cypress via the Cypress.Log.end() call. We're hooking into this function
+        // to complete the step at the same time.
+        overrideEntryEnd(entry, id);
+    }
+};
+const isApiStepErrorLogEntry = (entry) => {
+    const { name } = entry.attributes;
+    return name === "then" && Object.is((0, utils_js_2.resolveConsoleProps)(entry).props["Applied To"], steps_js_1.TMS_STEP_CMD_SUBJECT);
+};
+const getCommandLogStepName = (entry) => {
+    const { name, message, displayName } = entry.attributes;
+    const resolvedName = (displayName ?? name).trim();
+    const resolvedMessage = (maybeGetAssertionLogMessage(entry) ??
+        maybeGetCucumberLogMessage(entry) ??
+        (0, utils_js_2.resolveRenderProps)(entry).message ??
+        message).trim();
+    const stepName = [resolvedName, resolvedMessage].filter(Boolean).join(" ");
+    return stepName;
+};
+const getCommandLogStepParameters = (entry) => getLogProps(entry)
+    .map(([k, v]) => ({
+    name: k.toString(),
+    value: (0, serialize_js_1.default)(v),
+}))
+    .filter(getPropValueSetFilter(entry));
+const WELL_KNOWN_CUCUMBER_LOG_NAMES = ["Given", "When", "Then", "And"];
+const maybeGetCucumberLogMessage = (entry) => {
+    const { attributes: { name, message }, } = entry;
+    if (WELL_KNOWN_CUCUMBER_LOG_NAMES.includes(name.trim()) && message.startsWith("**") && message.endsWith("**")) {
+        return message.substring(2, message.length - 2);
+    }
+};
+const getLogProps = (entry) => {
+    const isAssertionWithMessage = !!maybeGetAssertionLogMessage(entry);
+    const { props, name } = (0, utils_js_2.resolveConsoleProps)(entry);
+    // accessing LocalStorage after the page reload can stick the test runner
+    // to avoid the issue, we just need to log the command manually
+    // the problem potentially can happen with other storage related commands, like `clearAllLocalStorage`, `clearAllSessionStorage`, `getAllLocalStorage`, `getAllSessionStorage`, `setLocalStorage`, `setSessionStorage`
+    // but probably, we don't need to silent them all at this moment
+    if (["clearLocalStorage"].includes(name)) {
+        return [];
+    }
+    // For assertion logs, we interpolate the 'Message' property, which contains unformatted assertion description,
+    // directly into the step's name.
+    // No need to keep the exact same information in the step's parameters.
+    const entries = Object.entries(props);
+    return entries.filter(([key, value]) => isLogPropIncludedInParameters({ key, value, isAssertionWithMessage }));
+};
+const isLogPropIncludedInParameters = ({ key, value, isAssertionWithMessage, }) => {
+    if (!(0, utils_js_1.isDefined)(value)) {
+        return false;
+    }
+    if (isAssertionWithMessage && key === "Message") {
+        // The same text is already included into the step's name.
+        // No need to duplicate it in parameters.
+        return false;
+    }
+    return true;
+};
+const maybeGetAssertionLogMessage = (entry) => {
+    if (isAssertLog(entry)) {
+        const message = (0, utils_js_2.resolveConsoleProps)(entry).props.Message;
+        if (message && typeof message === "string") {
+            return message;
+        }
+    }
+};
+const isAssertLog = ({ attributes: { name } }) => name === "assert";
+const getCurrentLogEntry = () => (0, state_js_1.getStepStack)().findLast(steps_js_1.isLogStep);
+const shouldStopCurrentLogStep = (currentLogEntry, newLogEntry) => {
+    const { groupStart: currentEntryIsGroup, type: currentEntryType } = currentLogEntry.attributes;
+    const { type: newEntryType } = newLogEntry.attributes;
+    return !currentEntryIsGroup && (currentEntryType === "child" || newEntryType !== "child");
+};
+/**
+ * Returns a predicate that decides whether a step parameter should be included.
+ * For "wrap" commands we include all parameters; for others we drop "Yielded" when it's "{}".
+ */
+const getPropValueSetFilter = (entry) => {
+    const isWrapCommand = entry.attributes.name === "wrap";
+    if (isWrapCommand) {
+        return () => true;
+    }
+    return ({ name, value }) => shouldIncludeParameter(name, value);
+};
+const shouldIncludeParameter = (name, value) => {
+    return name !== "Yielded" || value !== "{}";
+};

package/dist/browser/events/cypress.d.ts

@@ -0,0 +1,2 @@
+export declare const registerCypressEventListeners: () => Cypress.Cypress;
+export declare const enableReportingOfCypressScreenshots: () => void;

package/dist/browser/events/cypress.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableReportingOfCypressScreenshots = exports.registerCypressEventListeners = void 0;
+const commandLog_js_1 = require("../commandLog.js");
+const lifecycle_js_1 = require("../lifecycle.js");
+const steps_js_1 = require("../steps.js");
+const utils_js_1 = require("../utils.js");
+const registerCypressEventListeners = () => Cypress.on("fail", onFail).on("log:added", onLogAdded);
+exports.registerCypressEventListeners = registerCypressEventListeners;
+const enableReportingOfCypressScreenshots = () => Cypress.Screenshot.defaults({ onAfterScreenshot });
+exports.enableReportingOfCypressScreenshots = enableReportingOfCypressScreenshots;
+const onAfterScreenshot = (...[, { name: originalName, path }]) => {
+    const name = originalName ?? (0, utils_js_1.getFileNameFromPath)(path);
+    (0, lifecycle_js_1.reportScreenshot)(path, name);
+    (0, commandLog_js_1.setupScreenshotAttachmentStep)(originalName, name);
+};
+const onLogAdded = (_, entry) => {
+    if ((0, commandLog_js_1.shouldCreateStepFromCommandLogEntry)(entry)) {
+        (0, commandLog_js_1.startCommandLogStep)(entry);
+    }
+};
+const onFail = (error) => {
+    (0, steps_js_1.reportStepError)(error);
+    if (noSubsequentFailListeners()) {
+        throw error;
+    }
+};
+/**
+ * Returns true if this handler is the last registered "fail" listener in Cypress.
+ *
+ * In that case we rethrow the error so that Cypress can apply its default error handling.
+ * If there are other listeners after ours, we assume they will handle the error.
+ */
+const noSubsequentFailListeners = () => {
+    const failListeners = Cypress.listeners("fail");
+    const lastFailListener = failListeners.at(-1);
+    return Object.is(lastFailListener, onFail);
+};

package/dist/browser/events/index.d.ts

@@ -0,0 +1,2 @@
+export declare const enableTms: () => void;
+export { enableReportingOfCypressScreenshots } from "./cypress.js";

package/dist/browser/events/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableReportingOfCypressScreenshots = exports.enableTms = void 0;
+const patching_js_1 = require("../patching.js");
+const cypress_js_1 = require("./cypress.js");
+const mocha_js_1 = require("./mocha.js");
+const enableTms = () => {
+    (0, mocha_js_1.registerMochaEventListeners)();
+    (0, cypress_js_1.registerCypressEventListeners)();
+    (0, mocha_js_1.injectFlushMessageHooks)();
+    (0, patching_js_1.enableScopeLevelAfterHookReporting)();
+};
+exports.enableTms = enableTms;
+var cypress_js_2 = require("./cypress.js");
+Object.defineProperty(exports, "enableReportingOfCypressScreenshots", { enumerable: true, get: function () { return cypress_js_2.enableReportingOfCypressScreenshots; } });

package/dist/browser/events/mocha.d.ts

@@ -0,0 +1,3 @@
+export declare const TMS_REPORT_SYSTEM_HOOK = "__tms_report_system_hook__";
+export declare const registerMochaEventListeners: () => void;
+export declare const injectFlushMessageHooks: () => void;

package/dist/browser/events/mocha.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectFlushMessageHooks = exports.registerMochaEventListeners = exports.TMS_REPORT_SYSTEM_HOOK = void 0;
+const lifecycle_js_1 = require("../lifecycle.js");
+const runtime_js_1 = require("../runtime.js");
+const testplan_js_1 = require("../testplan.js");
+const utils_js_1 = require("../utils.js");
+exports.TMS_REPORT_SYSTEM_HOOK = "__tms_report_system_hook__";
+const registerMochaEventListeners = () => {
+    Cypress.mocha.getRunner()
+        .on("start", onStart)
+        .on("suite", onSuite)
+        .on("suite end", lifecycle_js_1.reportSuiteEnd)
+        .on("hook", onHook)
+        .on("hook end", onHookEnd)
+        .on("test", onTest)
+        .on("pass", lifecycle_js_1.reportTestPass)
+        .on("fail", onFail)
+        .on("pending", lifecycle_js_1.reportTestSkip)
+        .on("test end", lifecycle_js_1.reportTestEnd);
+};
+exports.registerMochaEventListeners = registerMochaEventListeners;
+const injectFlushMessageHooks = () => {
+    afterEach(exports.TMS_REPORT_SYSTEM_HOOK, lifecycle_js_1.flushRuntimeMessages);
+    after(exports.TMS_REPORT_SYSTEM_HOOK, onAfterAll);
+};
+exports.injectFlushMessageHooks = injectFlushMessageHooks;
+const onStart = () => {
+    (0, runtime_js_1.initTestRuntime)();
+    (0, lifecycle_js_1.reportRunStart)();
+};
+const onSuite = (suite) => {
+    if (suite.root) {
+        (0, testplan_js_1.applyTestPlan)(Cypress.spec, suite);
+    }
+    (0, lifecycle_js_1.reportSuiteStart)(suite);
+};
+const onHook = (hook) => {
+    if ((0, utils_js_1.isTmsHook)(hook)) {
+        return;
+    }
+    (0, lifecycle_js_1.reportHookStart)(hook);
+};
+const onHookEnd = (hook) => {
+    if ((0, utils_js_1.isTmsHook)(hook)) {
+        return;
+    }
+    (0, lifecycle_js_1.reportHookEnd)(hook);
+};
+const onTest = (test) => {
+    // Cypress emits an extra EVENT_TEST_BEGIN if the test is skipped.
+    // reportTestSkip does that already, so we need to filter the extra event out.
+    if (!(0, utils_js_1.isTestReported)(test)) {
+        (0, lifecycle_js_1.reportTestStart)(test);
+    }
+};
+const onFail = (testOrHook, err) => {
+    const isHook = "hookName" in testOrHook;
+    if (isHook && (0, utils_js_1.isRootAfterAllHook)(testOrHook)) {
+        // Errors in spec-level 'after all' hooks are handled by Tms wrappers.
+        return;
+    }
+    const isTmsHookFailure = isHook && (0, utils_js_1.isTmsHook)(testOrHook);
+    if (isTmsHookFailure) {
+        // Normally, Tms hooks are skipped from the report.
+        // In case of errors, it will be helpful to see them.
+        (0, lifecycle_js_1.reportHookStart)(testOrHook, Date.now() - (testOrHook.duration ?? 0));
+    }
+    // This will mark the fixture and the test (if any) as failed/broken.
+    (0, lifecycle_js_1.reportTestOrHookFail)(err);
+    if (isHook) {
+        // This will end the fixture and test (if any) and will report the remaining
+        // tests in the hook's suite (the ones that will be skipped by Cypress/Mocha).
+        (0, lifecycle_js_1.completeHookErrorReporting)(testOrHook, err);
+    }
+};
+const onAfterAll = function () {
+    (0, lifecycle_js_1.flushRuntimeMessages)();
+    (0, lifecycle_js_1.completeSpecIfNoAfterHookLeft)(this);
+};

package/dist/browser/index.d.ts

@@ -0,0 +1 @@
+export declare const initializeTms: () => void;

package/dist/browser/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeTms = void 0;
+const index_js_1 = require("./events/index.js");
+const state_js_1 = require("./state.js");
+const initializeTms = () => {
+    if ((0, state_js_1.isTmsInitialized)()) {
+        return;
+    }
+    (0, state_js_1.setTmsInitialized)();
+    (0, index_js_1.enableTms)();
+    (0, index_js_1.enableReportingOfCypressScreenshots)();
+};
+exports.initializeTms = initializeTms;

package/dist/browser/lifecycle.d.ts

@@ -0,0 +1,21 @@
+import type { CypressHook, CypressSuite, CypressTest, StepDescriptor, StatusDetails } from "../models/types.js";
+import { Status } from "../models/status.js";
+export declare const reportRunStart: () => void;
+export declare const reportSuiteStart: (suite: CypressSuite) => void;
+export declare const reportSuiteEnd: (suite: CypressSuite) => void;
+export declare const reportHookStart: (hook: CypressHook, start?: number) => void;
+export declare const reportHookEnd: (hook: CypressHook) => void;
+export declare const reportTestStart: (test: CypressTest) => void;
+export declare const reportStepStart: (id: string, name: string) => void;
+export declare const reportStepStop: (step: StepDescriptor, status?: Status, statusDetails?: StatusDetails) => void;
+export declare const reportTestPass: () => void;
+export declare const reportTestOrHookFail: (err: Error) => void;
+export declare const completeHookErrorReporting: (hook: CypressHook, err: Error) => void;
+export declare const reportTestSkip: (test: CypressTest) => void;
+export declare const reportTestEnd: (test: CypressTest) => void;
+export declare const reportScreenshot: (path: string, name: string) => void;
+export declare const completeSpecIfNoAfterHookLeft: (context: Mocha.Context) => Cypress.Chainable<unknown> | undefined;
+export declare const completeSpecOnAfterHookFailure: (context: Mocha.Context, hookError: Error) => Cypress.Chainable<unknown> | undefined;
+export declare const throwAfterSpecCompletion: (context: Mocha.Context, err: any) => void;
+export declare const flushRuntimeMessages: () => void;
+export declare const completeSpecAsync: () => Cypress.Chainable<unknown> | undefined;