testcafe-reporter-testit 2.2.2

package/README.md

@@ -0,0 +1,158 @@
+# Test IT TMS adapters for TestCafe
+![Test IT](https://raw.githubusercontent.com/testit-tms/adapters-js/master/images/banner.png)
+
+## Getting Started
+
+### Installation
+```
+npm install testcafe-reporter-testit
+```
+
+## Configuration
+
+| Description                                                                                                                                                | File property              | Environment variable              |
+|------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------|-----------------------------------|
+| Location of the TMS instance                                                                                                                               | url                        | TMS_URL                           |
+| API secret key <br/>[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 <br/>[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 <br/>[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** 0 or 1                                                                  | testRunId                  | TMS_TEST_RUN_ID                   |
+| Parameter for specifying the name of test run in TMS instance (**It's optional**). <br/>If it is not provided, it is created automatically                 | testRunName                | TMS_TEST_RUN_NAME                 |
+| Adapter mode *                                                                                                                                             | adapterMode                | TMS_ADAPTER_MODE                  |
+| Mode of automatic creation test cases ** (**It's optional**).                                                                                              | automaticCreationTestCases | TMS_AUTOMATIC_CREATION_TEST_CASES |
+
+*The adapter supports following modes:
+* 0 - in this mode, the adapter filters tests by external id and sends the results to the test run. **Default value**.
+* 1 - in this mode, the adapter sends all results to the test run without filtering
+* 2 - in this mode, the adapter creates a new test run and sends results to the new test run
+
+**The adapter supports following modes:
+* true - in this mode, the adapter will create a test case linked to the created autotest (not to the updated autotest)
+* false - in this mode, the adapter will not create a test case. **Default value**.
+
+### File
+
+1. Adapter configuration file: `tms.config.json`
+
+```json
+{
+  "url": "URL",
+  "privateToken": "USER_PRIVATE_TOKEN",
+  "projectId": "PROJECT_ID",
+  "configurationId": "CONFIGURATION_ID",
+  "testRunId": "TEST_RUN_ID",
+  "adapterMode": 0,
+  "automaticCreationTestCases": false
+}
+```
+
+2. You can set adapter config to environment variables: `.env`.
+
+```dotenv
+TMS_PRIVATE_TOKEN=YourPrivateToken
+TMS_URL=URL
+TMS_PROJECT_ID=YourProjectId;
+TMS_CONFIGURATION_ID=YourConfigurationId;
+TMS_TEST_RUN_ID=TestRunId;
+TMS_TEST_RUN_NAME=TestRunName; # optional
+TMS_ADAPTER_MODE=0; # or 1, or 2
+TMS_CONFIG_FILE=pathToAnotherConfigFile; #optional
+TMS_AUTOMATIC_CREATION_TEST_CASES=false; # or true, optional
+```
+
+### 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 testcafe chrome tests/test.spec.ts -r testit
+
+$ testit testrun complete
+  --url https://tms.testit.software \
+  --testrun-id $(cat tmp/output.txt)
+```
+
+## Usage
+
+Methods and properties can be used to specify information about autotest.
+
+### Properties
+
+Description of metadata properties:
+- `workItemsIds` - a method that links autotests with manual tests. Receives the array of manual tests' IDs
+- `displayName` - internal autotest name (used in Test IT)
+- `externalId` - unique internal autotest ID (used in Test IT)
+- `title` - autotest name specified in the autotest card. If not specified, the name from the displayName method is used
+- `description` - autotest description specified in the autotest card
+- `labels` - tags listed in the autotest card
+- `links` - links listed in the autotest card
+- `nameSpace` - directory in the TMS system (default - directory's name of test)
+- `className` - subdirectory in the TMS system (default - file's name of test)
+
+### Methods
+
+Description of methods:
+- `adapter.addLinks` - links in the autotest result
+- `adapter.addAttachments` - uploading files in the autotest result or step result
+- `adapter.addMessage` - information about autotest in the autotest result
+
+## Examples
+
+### Simple test
+
+```ts
+// annotations.spec.ts
+const adapter = require('testcafe-reporter-testit')();
+import { Selector } from 'testcafe';
+import { Link } from 'testit-js-commons';
+import { join } from "path";
+
+fixture('TestCafé Example Fixture - Documentation').page('http://devexpress.github.io/testcafe/example');
+
+const links: Link[] = [
+    { url: "https://test01.example", title: "Example01", description: "Example01 description", type: "Issue" },
+    { url: "https://test02.example", title: "Example02", description: "Example02 description", type: "Issue" },
+];
+
+const paths = [
+  join(__dirname, "../attachments/file.txt"),
+  join(__dirname, "../attachments/image.jpg")
+];
+
+test.meta({
+  externalId: 'externalId',
+  displayName: 'displayName',
+  description: 'description',
+  title: 'title',
+  namespace: 'namespace',
+  classname: 'classname',
+  workItemIds: ['123', '321'],
+  labels: ['label1', 'label2'],
+})('test', async t => {
+  adapter.addMessage(t, "Message");
+  adapter.addAttachments(t, paths);
+  adapter.addLinks(t, links);
+});
+```
+
+# 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/lib/converter.d.ts

@@ -0,0 +1,19 @@
+import { AutotestPost, AutotestResult } from "testit-js-commons";
+import Metadata from "./metadata";
+import { TestRunInfo } from "./types";
+declare enum Status {
+    PASSED = "Passed",
+    FAILED = "Failed",
+    SKIPPED = "Skipped"
+}
+export declare class Converter {
+    static convertTestCaseToAutotestPost(autotestData: Metadata): AutotestPost;
+    static convertAutotestPostToAutotestResult(autotestData: Metadata, testRunInfo: TestRunInfo): AutotestResult;
+    static convertStatus(testRunInfo: TestRunInfo): Status;
+}
+export declare type StatusDetails = {
+    message?: string;
+    trace?: string;
+};
+export declare const stripAscii: (str: string) => string;
+export {};

package/lib/converter.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAscii = exports.Converter = void 0;
+const utils_1 = __importDefault(require("./utils"));
+var Status;
+(function (Status) {
+    Status["PASSED"] = "Passed";
+    Status["FAILED"] = "Failed";
+    Status["SKIPPED"] = "Skipped";
+})(Status || (Status = {}));
+class Converter {
+    static convertTestCaseToAutotestPost(autotestData) {
+        return {
+            externalId: autotestData.externalId,
+            name: autotestData.displayName,
+            title: autotestData.title,
+            description: autotestData.description,
+            labels: autotestData.labels?.map((label) => ({ name: label })),
+            links: autotestData.links,
+            namespace: autotestData.namespace,
+            classname: autotestData.classname,
+            workItemIds: autotestData.workItemIds,
+        };
+    }
+    static convertAutotestPostToAutotestResult(autotestData, testRunInfo) {
+        const autotestResult = {
+            autoTestExternalId: autotestData.externalId,
+            outcome: this.convertStatus(testRunInfo),
+            duration: testRunInfo.durationMs ?? 0,
+        };
+        if (!!testRunInfo.errs && !!testRunInfo.errs.length) {
+            const status = getStatusDetails(testRunInfo);
+            autotestResult.message = status.message;
+            autotestResult.traces = status.trace;
+        }
+        return autotestResult;
+    }
+    static convertStatus(testRunInfo) {
+        const hasErrors = !!testRunInfo.errs && !!testRunInfo.errs.length;
+        const isSkipped = testRunInfo.skipped;
+        if (isSkipped) {
+            return Status.SKIPPED;
+        }
+        if (hasErrors) {
+            return Status.FAILED;
+        }
+        return Status.PASSED;
+    }
+    ;
+}
+exports.Converter = Converter;
+const getStatusDetails = (testRunInfo) => {
+    const mergedErrors = mergeErrors(testRunInfo.errs);
+    let testMessages = '';
+    let testDetails = '';
+    mergedErrors.forEach((error) => {
+        if (error.errMsg) {
+            testMessages = (0, utils_1.default)(testMessages, error.errMsg);
+        }
+        const callSite = error.callsite;
+        let stacktrace = 'NO_STACKTRACE_DATA_FOUND';
+        if (callSite) {
+            if (callSite.filename) {
+                testDetails = (0, utils_1.default)(testDetails, `File name: ${callSite.filename}`);
+            }
+            if (callSite.lineNum) {
+                testDetails = (0, utils_1.default)(testDetails, `Line number: ${callSite.lineNum}`);
+            }
+            try {
+                const noColorRenderer = require('callsite-record').renderers.noColor;
+                stacktrace = error.callsite.renderSync({
+                    renderer: noColorRenderer,
+                });
+                testDetails = (0, utils_1.default)(testDetails, `Stacktrace:\n${stacktrace}`);
+            }
+            catch (err) {
+                console.error(`Error in callsite.renderSync in reporting:\n${err}`);
+            }
+        }
+        if (error.userAgent) {
+            testDetails = (0, utils_1.default)(testDetails, `User Agent(s): ${error.userAgent}`);
+        }
+    });
+    return {
+        message: testMessages,
+        trace: testDetails,
+    };
+};
+const mergeErrors = (errors) => {
+    const mergedErrors = [];
+    errors.forEach((error) => {
+        if (error && error.errMsg) {
+            let errorExists = false;
+            mergedErrors.forEach((mergedError) => {
+                if (error.errMsg === mergedError.errMsg) {
+                    errorExists = true;
+                    if (error.userAgent && mergedError.userAgent !== error.userAgent) {
+                        mergedError.userAgent = `${mergedError.userAgent}, ${error.userAgent}`;
+                    }
+                }
+            });
+            if (!errorExists) {
+                mergedErrors.push(error);
+            }
+        }
+    });
+    return mergedErrors;
+};
+const stripAscii = (str) => {
+    return str.replace(asciiRegex, "");
+};
+exports.stripAscii = stripAscii;
+const asciiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const reporter_1 = __importDefault(require("./reporter"));
+const testsData = {};
+module.exports = function () {
+    return {
+        reporter: null,
+        async reportTaskStart(startTime, userAgents) {
+            this.reporter = new reporter_1.default();
+        },
+        async reportFixtureStart(name, path, meta) {
+            await this.reporter.onFixtureBegin(name, path, meta);
+        },
+        async reportTestDone(name, testRunInfo, meta) {
+            await this.reporter.onTestEnd(name, testRunInfo, meta, testsData[testRunInfo.testId]);
+        },
+        async reportTaskDone() {
+            await this.reporter.onEnd();
+        },
+        addMessage(t, message) {
+            if (t === undefined) {
+                return;
+            }
+            if (t.testRun === undefined) {
+                return;
+            }
+            if (t.testRun.test === undefined) {
+                return;
+            }
+            if (t.testRun.test.id === undefined) {
+                return;
+            }
+            const id = t.testRun.test.id;
+            if (testsData[id] === undefined) {
+                testsData[id] = {};
+            }
+            testsData[id].message = message;
+        },
+        addAttachments(t, paths) {
+            if (t === undefined) {
+                return;
+            }
+            if (t.testRun === undefined) {
+                return;
+            }
+            if (t.testRun.test === undefined) {
+                return;
+            }
+            if (t.testRun.test.id === undefined) {
+                return;
+            }
+            const id = t.testRun.test.id;
+            if (testsData[id] === undefined) {
+                testsData[id] = {};
+            }
+            if (Array.isArray(paths)) {
+                testsData[id].attachments = paths;
+            }
+            else if (testsData[id].attachments !== undefined) {
+                testsData[id].attachments.append(paths);
+            }
+            else {
+                testsData[id].attachments = [paths];
+            }
+        },
+        addLinks(t, links) {
+            if (t === undefined) {
+                return;
+            }
+            if (t.testRun === undefined) {
+                return;
+            }
+            if (t.testRun.test === undefined) {
+                return;
+            }
+            if (t.testRun.test.id === undefined) {
+                return;
+            }
+            const id = t.testRun.test.id;
+            if (testsData[id] === undefined) {
+                testsData[id] = {};
+            }
+            testsData[id].links = links;
+        },
+    };
+};

package/lib/metadata.d.ts

@@ -0,0 +1,17 @@
+import { Link } from 'testit-js-commons';
+export default class Metadata {
+    externalId: string | undefined;
+    displayName: string | undefined;
+    title: string | undefined;
+    description: string | undefined;
+    links: Link[] | undefined;
+    labels: string[] | undefined;
+    workItemIds: string[] | undefined;
+    namespace: string | undefined;
+    classname: string | undefined;
+    otherMeta: Map<string, string>;
+    constructor(meta?: any, path?: string, name?: string);
+    mergeMetadata(metadata: Metadata): void;
+    private isString;
+    private generateExternalId;
+}

package/lib/metadata.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testit_js_commons_1 = require("testit-js-commons");
+class Metadata {
+    constructor(meta, path, name) {
+        this.otherMeta = new Map();
+        if (meta) {
+            const { externalId, displayName, title, description, links, labels, workItemIds, namespace, classname, ...otherMeta } = meta;
+            if (this.isString(externalId)) {
+                this.externalId = externalId;
+            }
+            else if (path !== undefined && name !== undefined) {
+                this.externalId = this.generateExternalId(name, path);
+            }
+            if (this.isString(displayName)) {
+                this.displayName = displayName;
+            }
+            else if (name !== undefined) {
+                this.displayName = name;
+            }
+            if (this.isString(title)) {
+                this.title = title;
+            }
+            if (this.isString(description)) {
+                this.description = description;
+            }
+            if (Array.isArray(links)) {
+                this.links = links;
+            }
+            else if (this.isString(links)) {
+                this.links = [links];
+            }
+            if (Array.isArray(labels)) {
+                this.labels = labels;
+            }
+            else if (this.isString(labels)) {
+                this.labels = [labels];
+            }
+            if (Array.isArray(workItemIds)) {
+                this.workItemIds = workItemIds;
+            }
+            else if (this.isString(workItemIds)) {
+                this.workItemIds = [workItemIds];
+            }
+            if (this.isString(namespace)) {
+                this.namespace = namespace;
+            }
+            if (this.isString(classname)) {
+                this.classname = classname;
+            }
+            Object.keys(otherMeta).forEach((key) => {
+                if (this.isString(otherMeta[key])) {
+                    this.otherMeta.set(key, otherMeta[key]);
+                }
+            });
+        }
+    }
+    mergeMetadata(metadata) {
+        if (!this.externalId && metadata.externalId) {
+            this.externalId = metadata.externalId;
+        }
+        if (!this.displayName && metadata.displayName) {
+            this.displayName = metadata.displayName;
+        }
+        if (!this.title && metadata.title) {
+            this.title = metadata.title;
+        }
+        if (!this.description && metadata.description) {
+            this.description = metadata.description;
+        }
+        if (!this.links && metadata.links) {
+            this.links = metadata.links;
+        }
+        if (!this.labels && metadata.labels) {
+            this.labels = metadata.labels;
+        }
+        if (!this.workItemIds && metadata.workItemIds) {
+            this.workItemIds = metadata.workItemIds;
+        }
+        if (!this.namespace && metadata.namespace) {
+            this.namespace = metadata.namespace;
+        }
+        if (!this.classname && metadata.classname) {
+            this.classname = metadata.classname;
+        }
+        if (metadata.otherMeta.size > 0) {
+            Array.from(metadata.otherMeta.entries()).map((entry) => {
+                if (!this.otherMeta.has(entry[0])) {
+                    this.otherMeta.set(entry[0], entry[1]);
+                }
+            });
+        }
+    }
+    isString(value) {
+        if (!value) {
+            return false;
+        }
+        return typeof value === 'string';
+    }
+    generateExternalId(testName, testPath) {
+        return testit_js_commons_1.Utils.getHash(JSON.stringify({
+            path: testPath,
+            name: testName,
+        }));
+    }
+}
+exports.default = Metadata;

package/lib/reporter.d.ts

@@ -0,0 +1,17 @@
+import { IStrategy } from "testit-js-commons";
+import { TestRunInfo } from "./types";
+export default class TmsReporter {
+    strategy: IStrategy;
+    private readonly additions;
+    private testCache;
+    private loadTestPromises;
+    private groupMetadata;
+    private groupPath;
+    constructor();
+    onFixtureBegin(name: string, path: string, meta: object): void;
+    onTestBegin(meta: object): void;
+    onTestEnd(name: string, testRunInfo: TestRunInfo, meta: object, testData: any): Promise<void>;
+    onEnd(): Promise<void>;
+    private loadTest;
+    private addAttachments;
+}

package/lib/reporter.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const testit_js_commons_1 = require("testit-js-commons");
+const converter_1 = require("./converter");
+const metadata_1 = __importDefault(require("./metadata"));
+class TmsReporter {
+    constructor() {
+        this.testCache = new Array();
+        this.loadTestPromises = new Array();
+        const config = new testit_js_commons_1.ConfigComposer().compose();
+        const client = new testit_js_commons_1.Client(config);
+        this.strategy = testit_js_commons_1.StrategyFactory.create(client, config);
+        this.additions = new testit_js_commons_1.Additions(client);
+    }
+    onFixtureBegin(name, path, meta) {
+        this.groupMetadata = new metadata_1.default(meta);
+        this.groupPath = path;
+    }
+    onTestBegin(meta) {
+        this.testCache.push(meta);
+    }
+    async onTestEnd(name, testRunInfo, meta, testData) {
+        await this.loadTestPromises.push(this.loadTest(name, testRunInfo, meta, testData));
+    }
+    async onEnd() {
+        await Promise.all(this.loadTestPromises);
+    }
+    async loadTest(name, testRunInfo, meta, testData) {
+        const autotestData = new metadata_1.default(meta, this.groupPath, name);
+        autotestData.mergeMetadata(this.groupMetadata);
+        const autotest = converter_1.Converter.convertTestCaseToAutotestPost(autotestData);
+        const autotestResult = converter_1.Converter.convertAutotestPostToAutotestResult(autotestData, testRunInfo);
+        autotestResult.links = this.additions.links;
+        autotestResult.message = this.additions.messages.join("\n");
+        if (testData !== undefined) {
+            if (testData.message !== undefined) {
+                autotestResult.message = testData.message;
+            }
+            if (testData.links !== undefined) {
+                autotestResult.links = testData.links;
+            }
+            if (testData.attachments !== undefined) {
+                autotestResult.attachments = await this.addAttachments(testData.attachments);
+            }
+        }
+        await this.strategy.loadAutotest(autotest, true);
+        await this.strategy.loadTestRun([autotestResult]);
+    }
+    addAttachments(paths) {
+        const promise = typeof paths === "string"
+            ? this.additions.addAttachments([paths])
+            : this.additions.addAttachments(paths);
+        return promise;
+    }
+    ;
+}
+exports.default = TmsReporter;

package/lib/types.d.ts

@@ -0,0 +1,45 @@
+import { CallsiteRecord } from 'callsite-record';
+export {};
+declare global {
+    interface TestController {
+        testRun: TestRun;
+    }
+    interface TestRun {
+        test: Test;
+    }
+    interface Test {
+        meta: object;
+    }
+}
+export interface Screenshot {
+    screenshotPath?: string;
+    thumbnailPath?: string;
+    userAgent?: string;
+    quarantineAttempt?: number;
+    takenOnFail?: boolean;
+}
+export declare type TestCafeError = {
+    errMsg: string;
+    originError?: string;
+    callsite?: CallsiteRecord;
+};
+export interface TestRunInfo {
+    errs?: TestCafeError[];
+    warnings?: string[];
+    durationMs?: number;
+    unstable?: boolean;
+    screenshotPath?: string;
+    screenshots?: Screenshot[];
+    quarantine?: object;
+    skipped?: boolean;
+    testId: string;
+}
+export interface ErrorObject {
+    errMsg?: string;
+    callsite?: CallSite;
+    userAgent?: string;
+}
+export interface CallSite extends CallsiteRecord {
+    filename?: string;
+    lineNum?: string;
+}

package/lib/types.js

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

package/lib/utils.d.ts

@@ -0,0 +1 @@
+export default function addNewLine(text: string, line: string): string;

package/lib/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function addNewLine(text, line) {
+    if (text === null || text.length === 0) {
+        return line;
+    }
+    return `${text}\n${line}`;
+}
+exports.default = addNewLine;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "testcafe-reporter-testit",
+  "version": "2.2.2",
+  "description": "TestCafe adapter for Test IT",
+  "keywords": [],
+  "author": {
+    "name": "Integration team",
+    "email": "integrations@testit.software"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/testit-tms/adapters-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/testit-tms/adapters-js/issues"
+  },
+  "homepage": "https://github.com/testit-tms/adapters-js",
+  "main": "lib/index",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "prebuild": "npm --prefix ../testit-js-commons run build && npm link ../testit-js-commons",
+    "build": "tsc -p tsconfig.json",
+    "watch": "tsc -p tsconfig.json -w"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.9.0",
+    "@babel/preset-env": "^7.9.5",
+    "@babel/eslint-parser": "^7.22.9",
+    "babel-plugin-add-module-exports": "^1.0.2",
+    "callsite-record": "^4.1.3",
+    "del": "^5.1.0",
+    "gulp": "^4.0.2",
+    "gulp-babel": "^8.0.0",
+    "gulp-eslint": "^6.0.0",
+    "gulp-mocha": "^7.0.2",
+    "lodash.findlastindex": "^4.6.0",
+    "normalize-newline": "^3.0.0",
+    "read-file-relative": "^1.2.0",
+    "testcafe": "^3.0.1"
+  },
+  "dependencies": {
+    "testit-js-commons": "~2.2.2"
+  }
+}