testit-adapter-playwright 2.0.1

package/README.md

@@ -0,0 +1,151 @@
+# Test IT TMS adapters for Playwright
+![Test IT](https://raw.githubusercontent.com/testit-tms/adapters-js/master/images/banner.png)
+
+## Getting Started
+
+### Installation
+```
+npm install testit-adapter-playwright
+```
+
+## Usage
+
+### Configuration
+
+| Description                                                                                                                                                                                                                                                                                                                                                                            | Property                   | Environment variable              | CLI argument                  |
+|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------|-----------------------------------|-------------------------------|
+| Location of the TMS instance                                                                                                                                                                                                                                                                                                                                                           | url                        | TMS_URL                           | tmsUrl                        |
+| API secret key [How to getting API secret key?](https://github.com/testit-tms/.github/tree/main/configuration#privatetoken)                                                                                                                                                                                                                                                            | privateToken               | TMS_PRIVATE_TOKEN                 | tmsPrivateToken               |
+| 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                    | tmsProjectId                  |
+| 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              | tmsConfigurationId            |
+| ID of the created test run in TMS instance.<br/>It's necessary for **adapterMode** 0 or 1                                                                                                                                                                                                                                                                                              | testRunId                  | TMS_TEST_RUN_ID                   | tmsTestRunId                  |
+| 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                 | tmsTestRunName                |
+| Adapter mode. Default value - 0. The adapter supports following modes:<br/>0 - in this mode, the adapter filters tests by test run ID and configuration ID, and sends the results to the test run<br/>1 - in this mode, the adapter sends all results to the test run without filtering<br/>2 - in this mode, the adapter creates a new test run and sends results to the new test run | adapterMode                | TMS_ADAPTER_MODE                  | tmsAdapterMode                |
+| It enables/disables certificate validation (**It's optional**). Default value - true                                                                                                                                                                                                                                                                                                   | certValidation             | TMS_CERT_VALIDATION               | tmsCertValidation             |
+| 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 | tmsAutomaticCreationTestCases |
+
+Add Adapter to Playwright file configuration:
+
+```ts
+import { PlaywrightTestConfig } from '@playwright/test';
+
+const config: PlaywrightTestConfig = {
+  reporter: [
+    ['testit-adapter-playwright']
+  ],
+};
+
+export default config;
+```
+
+#### 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"
+}
+```
+
+#### Parallel run
+To create and complete TestRun you can use the Test IT CLI:
+
+```
+$ export TMS_TOKEN=<YOUR_TOKEN>
+$ testit \
+  --mode 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 output.txt)  
+
+$ npx playwright test
+
+$ testit \
+  --mode finish
+  --url https://tms.testit.software \
+  --testrun-id $(cat tmp/output.txt) 
+```
+
+### Methods
+
+Methods can be used to specify information about autotest.
+
+Description of metadata methods:
+- `testit.workItemIds` - linking an autotest to a test case
+- `testit.displayName` - name of the autotest in the Test IT system (can be replaced with documentation strings)
+- `testit.externalId` - ID of the autotest within the project in the Test IT System
+- `testit.title` - title in the autotest card
+- `testit.description` - description in the autotest card
+- `testit.labels` - tags in the work item
+- `testit.links` - links in the autotest card
+- `testit.namespace` - directory in the TMS system (default - directory's name of test)
+- `testit.classname` - subdirectory in the TMS system (default - file's name of test)
+
+Description of methods:
+- `testit.addLinks` - links in the autotest result
+- `testit.addAttachments` - uploading files in the autotest result
+- `testit.addMessage` - information about autotest in the autotest result
+
+### Examples
+
+#### Simple test
+```js
+import { test } from "@playwright/test";
+import { testit } from "testit-adapter-playwright";
+
+test('All annotations', async () => {
+  testit.externalId('all_annotations');
+  testit.displayName('All annotations');
+  testit.title('All annotations title');
+  testit.description('Test with all annotations');
+  testit.labels(['label1', 'label2']);
+
+  testit.addMessage('This is a message');
+  testit.addLinks([
+    {
+      url: 'https://www.google.com',
+      title: 'Google',
+      description: 'This is a link to Google',
+      type: 'Related',
+    },
+  ]);
+
+  testit.addAttachment('file01.txt', 'Content', {contentType: "text/markdown",});
+});
+```
+
+#### Parameterized test
+```js
+const people = ['Alice', 'Bob'];
+for (const name of people) {
+  test(`testing with ${name}`, async () => {
+    testit.params(people);
+  });
+}
+```
+
+
+# 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/converter.d.ts

@@ -0,0 +1,20 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { TestStatus } from "@playwright/test";
+import { AutotestPost, AutotestResult } from "testit-js-commons";
+import { MetadataMessage } from "./labels";
+declare enum Status {
+    PASSED = "Passed",
+    FAILED = "Failed",
+    SKIPPED = "Skipped"
+}
+export declare class Converter {
+    static convertTestCaseToAutotestPost(autotestData: MetadataMessage): AutotestPost;
+    static convertAutotestPostToAutotestResult(autotestData: MetadataMessage, test: TestCase, result: TestResult): AutotestResult;
+    static convertStatus(status: TestStatus, expectedStatus: TestStatus): Status;
+}
+export type StatusDetails = {
+    message?: string;
+    trace?: string;
+};
+export declare const stripAscii: (str: string) => string;
+export {};

package/dist/converter.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAscii = exports.Converter = void 0;
+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,
+            links: autotestData.links,
+            namespace: autotestData.namespace,
+            classname: autotestData.classname,
+        };
+    }
+    static convertAutotestPostToAutotestResult(autotestData, test, result) {
+        const autotestResult = {
+            autoTestExternalId: autotestData.externalId,
+            outcome: this.convertStatus(result.status, test.expectedStatus),
+            links: autotestData.addLinks,
+            duration: result.duration,
+            parameters: autotestData.params,
+            attachments: autotestData.addAttachments,
+            message: autotestData.addMessage,
+        };
+        if (result.error) {
+            const status = getStatusDetails(result.error);
+            autotestResult.message = status.message;
+            autotestResult.traces = status.trace;
+        }
+        return autotestResult;
+    }
+    static convertStatus(status, expectedStatus) {
+        if (status === "skipped") {
+            return Status.SKIPPED;
+        }
+        if (status === expectedStatus) {
+            return Status.PASSED;
+        }
+        return Status.FAILED;
+    }
+    ;
+}
+exports.Converter = Converter;
+const getStatusDetails = (error) => {
+    const message = error.message && (0, exports.stripAscii)(error.message);
+    let trace = error.stack && (0, exports.stripAscii)(error.stack);
+    if (trace && message && trace.startsWith(`Error: ${message}`)) {
+        trace = trace.substr(message.length + "Error: ".length);
+    }
+    return {
+        message: message,
+        trace: trace,
+    };
+};
+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/dist/labels.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import { Link, Label, Attachment } from "testit-js-commons";
+export interface MetadataMessage {
+    workItemIds?: string[];
+    displayName?: string;
+    externalId?: string;
+    title?: string;
+    description?: string;
+    labels?: Label[];
+    links?: Link[];
+    namespace?: string;
+    classname?: string;
+    addLinks?: Link[];
+    addAttachments?: Attachment[];
+    addMessage?: string;
+    params?: Parameters;
+}
+interface AttachmentOptions {
+    contentType: ContentType | string;
+    fileExtension?: string;
+}
+declare enum ContentType {
+    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"
+}
+type Parameters = Record<string, string>;
+export declare class testit {
+    static addAttachment(name: string, content: Buffer | string, options: ContentType | string | Pick<AttachmentOptions, "contentType">): Promise<void>;
+    private static addMetadataAttachment;
+    private static mapParams;
+    static workItemIds(value: string[]): Promise<void>;
+    static displayName(value: string): Promise<void>;
+    static externalId(value: string): Promise<void>;
+    static title(value: string): Promise<void>;
+    static description(value: string): Promise<void>;
+    static labels(value: string[]): Promise<void>;
+    static links(value: Link[]): Promise<void>;
+    static namespace(value: string): Promise<void>;
+    static classname(value: string): Promise<void>;
+    static addLinks(value: Link[]): Promise<void>;
+    static addMessage(value: string): Promise<void>;
+    static params(value: any): Promise<void>;
+}
+export {};

package/dist/labels.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testit = void 0;
+const test_1 = __importDefault(require("@playwright/test"));
+var ContentType;
+(function (ContentType) {
+    ContentType["TEXT"] = "text/plain";
+    ContentType["XML"] = "application/xml";
+    ContentType["HTML"] = "text/html";
+    ContentType["CSV"] = "text/csv";
+    ContentType["TSV"] = "text/tab-separated-values";
+    ContentType["CSS"] = "text/css";
+    ContentType["URI"] = "text/uri-list";
+    ContentType["SVG"] = "image/svg+xml";
+    ContentType["PNG"] = "image/png";
+    ContentType["JSON"] = "application/json";
+    ContentType["ZIP"] = "application/zip";
+    ContentType["WEBM"] = "video/webm";
+    ContentType["JPEG"] = "image/jpeg";
+    ContentType["MP4"] = "video/mp4";
+})(ContentType || (ContentType = {}));
+class testit {
+    static async addAttachment(name, content, options) {
+        const contentType = typeof options === "string" ? options : options.contentType;
+        await test_1.default.info().attach(name, {
+            body: content,
+            contentType,
+        });
+    }
+    static async addMetadataAttachment(metadata) {
+        await test_1.default.info().attach("tms-metadata.json", {
+            contentType: "application/vnd.tms.metadata+json",
+            body: Buffer.from(JSON.stringify(metadata), "utf8"),
+        });
+    }
+    static async mapParams(params) {
+        switch (typeof params) {
+            case 'string':
+            case 'bigint':
+            case 'number':
+            case 'boolean':
+                return { value: params.toString() };
+            case 'object':
+                if (params === null) {
+                    return {};
+                }
+                return Object.keys(params).reduce((acc, key) => {
+                    acc[key] = params[key].toString();
+                    return acc;
+                }, {});
+            default:
+                return {};
+        }
+    }
+    static async workItemIds(value) {
+        await this.addMetadataAttachment({
+            workItemIds: value,
+        });
+    }
+    static async displayName(value) {
+        await this.addMetadataAttachment({
+            displayName: value,
+        });
+    }
+    static async externalId(value) {
+        await this.addMetadataAttachment({
+            externalId: value,
+        });
+    }
+    static async title(value) {
+        await this.addMetadataAttachment({
+            title: value,
+        });
+    }
+    static async description(value) {
+        await this.addMetadataAttachment({
+            description: value,
+        });
+    }
+    static async labels(value) {
+        await this.addMetadataAttachment({
+            labels: value.map((label) => ({ name: label })),
+        });
+    }
+    static async links(value) {
+        await this.addMetadataAttachment({
+            links: value,
+        });
+    }
+    static async namespace(value) {
+        await this.addMetadataAttachment({
+            namespace: value,
+        });
+    }
+    static async classname(value) {
+        await this.addMetadataAttachment({
+            classname: value,
+        });
+    }
+    static async addLinks(value) {
+        await this.addMetadataAttachment({
+            addLinks: value,
+        });
+    }
+    static async addMessage(value) {
+        await this.addMetadataAttachment({
+            addMessage: value,
+        });
+    }
+    static async params(value) {
+        await this.addMetadataAttachment({
+            params: await this.mapParams(value),
+        });
+    }
+}
+exports.testit = testit;

package/dist/reporter.d.ts

@@ -0,0 +1,29 @@
+import { FullConfig } from "@playwright/test";
+import { Reporter, Suite, TestCase, TestResult } from "@playwright/test/reporter";
+import { IStrategy } from "testit-js-commons";
+export type ReporterOptions = {
+    detail?: boolean;
+    outputFolder?: string;
+    suiteTitle?: boolean;
+    environmentInfo?: Record<string, string>;
+};
+declare class TmsReporter implements Reporter {
+    config: FullConfig;
+    suite: Suite;
+    resultsDir: string;
+    options: ReporterOptions;
+    strategy: IStrategy;
+    private readonly additions;
+    private testCache;
+    private globalStartTime;
+    constructor(options: ReporterOptions);
+    onBegin(config: FullConfig, suite: Suite): void;
+    onTestBegin(test: TestCase): void;
+    onTestEnd(test: TestCase, result: TestResult): Promise<void>;
+    onEnd(): void;
+    addSkippedResults(): void;
+    printsToStdio(): boolean;
+    private getAutotestData;
+}
+export default TmsReporter;
+export * from "./labels";

package/dist/reporter.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const testit_js_commons_1 = require("testit-js-commons");
+const converter_1 = require("./converter");
+class TmsReporter {
+    constructor(options) {
+        this.testCache = new Array();
+        this.globalStartTime = new Date();
+        this.options = { suiteTitle: true, detail: true, ...options };
+        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);
+    }
+    onBegin(config, suite) {
+        this.config = config;
+        this.suite = suite;
+    }
+    onTestBegin(test) {
+        this.testCache.push(test);
+    }
+    async onTestEnd(test, result) {
+        const autotest = converter_1.Converter.convertTestCaseToAutotestPost(await this.getAutotestData(test, result));
+        await this.strategy.loadAutotest(autotest, converter_1.Converter.convertStatus(result.status, test.expectedStatus) == "Passed");
+        await this.strategy.loadTestRun([converter_1.Converter.convertAutotestPostToAutotestResult(await this.getAutotestData(test, result), test, result)]);
+    }
+    onEnd() {
+        this.addSkippedResults();
+    }
+    addSkippedResults() {
+        const unprocessedCases = this.suite
+            .allTests()
+            .filter((testCase) => !this.testCache.includes(testCase));
+        unprocessedCases.forEach((testCase) => {
+            this.onTestEnd(testCase, {
+                status: "skipped",
+                attachments: [],
+                duration: 0,
+                errors: [],
+                parallelIndex: 0,
+                workerIndex: 0,
+                retry: 0,
+                steps: [],
+                stderr: [],
+                stdout: [],
+                startTime: this.globalStartTime,
+            });
+        });
+    }
+    printsToStdio() {
+        return false;
+    }
+    async getAutotestData(test, result) {
+        const autotestData = {
+            externalId: testit_js_commons_1.Utils.getHash(test.title),
+            displayName: test.title,
+            addAttachments: []
+        };
+        for (const attachment of result.attachments) {
+            if (!attachment.body || !attachment.path) {
+                continue;
+            }
+            if (attachment.contentType === "application/vnd.tms.metadata+json") {
+                const metadata = JSON.parse(attachment.body.toString());
+                if (metadata.externalId) {
+                    autotestData.externalId = metadata.externalId;
+                }
+                if (metadata.displayName) {
+                    autotestData.displayName = metadata.displayName;
+                }
+                if (metadata.title) {
+                    autotestData.title = metadata.title;
+                }
+                if (metadata.description) {
+                    autotestData.description = metadata.description;
+                }
+                if (metadata.labels) {
+                    autotestData.labels = metadata.labels;
+                }
+                if (metadata.links) {
+                    autotestData.links = metadata.links;
+                }
+                if (metadata.namespace) {
+                    autotestData.namespace = metadata.namespace;
+                }
+                if (metadata.classname) {
+                    autotestData.classname = metadata.classname;
+                }
+                if (metadata.addLinks) {
+                    autotestData.addLinks = metadata.addLinks;
+                }
+                if (metadata.addMessage) {
+                    autotestData.classname = metadata.addMessage;
+                }
+                if (metadata.params) {
+                    autotestData.params = metadata.params;
+                }
+                continue;
+            }
+            await this.additions.addAttachments(attachment.body.toString(), attachment.name).then((ids) => {
+                autotestData.addAttachments?.push(...ids);
+            });
+        }
+        return autotestData;
+    }
+}
+exports.default = TmsReporter;
+__exportStar(require("./labels"), exports);

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "testit-adapter-playwright",
+  "version": "2.0.1",
+  "description": "Playwright adapter for Test IT",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Integration team",
+    "email": "integrations@testit.software"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/testit-tms/adapters-js.git"
+  },
+  "keywords": [],
+  "main": "./dist/reporter.js",
+  "types": "./dist/reporter.d.ts",
+  "scripts": {
+    "clean": "rimraf ./dist ./out",
+    "build": "tsc -p tsconfig.json"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.34.1",
+    "@types/eslint": "^8",
+    "@types/node": "^20.6.3",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0",
+    "eslint": "^8.49.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-jsdoc": "^46.6.0",
+    "eslint-plugin-no-null": "^1.0.2",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "properties": "^1.2.1",
+    "rimraf": "^5.0.1",
+    "typescript": "^5.2.2",
+    "@types/debug": "^4.1.7",
+    "@types/request": "^2.48.8",
+    "jest": "^29.5.0",
+    "prettier": "^3.0.1"
+  },
+  "dependencies": {
+    "testit-js-commons": "^2.0.1"
+  },
+  "files": [
+    "dist"
+  ]
+}