testit-adapter-jest 1.1.7 → 2.0.1

package/README.md

@@ -10,13 +10,6 @@ npm install testit-adapter-jest
 
 ## Usage
 
-### API client
-
-To use adapter you need to install `testit-api-client`:
-```
-npm install testit-api-client
-```
-
 ### Configuration
 
 | Description                                                                                                                                                                                                                                                                                                                                                                            | Property                   | Environment variable              | CLI argument                  |
@@ -85,20 +78,21 @@ You can also specify options via cli arguments `jest --testEnvironment testit-ad
 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.link` - 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)
+- `testit.workItemIds` - a method that links autotests with manual tests. Receives the array of manual tests' IDs
+- `testit.displayName` - internal autotest name (used in Test IT)
+- `testit.externalId` - unique internal autotest ID (used in Test IT)
+- `testit.title` - autotest name specified in the autotest card. If not specified, the name from the displayName method is used
+- `testit.description` - autotest description specified in the autotest card
+- `testit.labels` - tags listed in the autotest card
+- `testit.link` - links listed 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
+- `testit.step` - add step of autotest
 
 ### Examples
 

package/dist/globalSetup.d.ts

@@ -1,3 +1,3 @@
-import { Config } from '@jest/reporters';
+import { Config } from "@jest/reporters";
 declare const _default: (globalConfig: Config.GlobalConfig, projectConfig: Config.ProjectConfig) => Promise<void>;
 export default _default;

package/dist/globalSetup.js

@@ -1,35 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const testClient_1 = require("./testClient");
-const utils_1 = require("./utils");
+const testit_js_commons_1 = require("testit-js-commons");
 exports.default = async (globalConfig, projectConfig) => {
-    const adapterMode = projectConfig.testEnvironmentOptions?.adapterMode ?? 0;
-    const automaticCreationTestCases = projectConfig.testEnvironmentOptions?.automaticCreationTestCases ?? false;
-    let testRunId;
-    try {
-        switch (adapterMode) {
-            case 0:
-            case 1: {
-                testRunId = projectConfig.testEnvironmentOptions?.testRunId;
-                if (!testRunId) {
-                    throw new Error('testRunId is required when mode is 1');
-                }
-                globalThis.testClient = new testClient_1.TestClient(projectConfig.testEnvironmentOptions);
-                break;
-            }
-            case 2: {
-                globalThis.testClient = new testClient_1.TestClient(projectConfig.testEnvironmentOptions);
-                testRunId = await globalThis.testClient.createTestRun();
-                break;
-            }
-            default:
-                throw new Error(`Unknown adapter mode ${adapterMode}`);
-        }
-    }
-    catch (err) {
-        console.error('Failed to setup', (0, utils_1.formatError)(err));
-        process.exit(1);
-    }
-    projectConfig.globals['testRunId'] = testRunId;
-    projectConfig.globals['automaticCreationTestCases'] = automaticCreationTestCases;
+    const config = new testit_js_commons_1.ConfigComposer().compose(projectConfig.testEnvironmentOptions);
+    const client = new testit_js_commons_1.Client(config);
+    const strategy = testit_js_commons_1.StrategyFactory.create(client, config);
+    await strategy.setup();
+    const testRunId = await strategy.testRunId;
+    globalThis.client = client;
+    projectConfig.globals["testRunId"] = testRunId;
 };

package/dist/globalTeardown.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("./utils");
 exports.default = async (globalConfig, projectConfig) => {
     const testRunId = projectConfig.globals['testRunId'];
     if (!testRunId) {
-        console.error('Looks like globalSetup was not called');
-        return;
+        return console.error('Looks like globalSetup was not called');
     }
     try {
-        await globalThis.testClient.completeTestRun();
+        await globalThis.client.testRuns.completeTestRun(testRunId);
     }
     catch (err) {
-        console.error('Failed to complete test run', (0, utils_1.formatError)(err));
+        console.error('Failed to complete test run');
     }
 };

package/dist/testitEnvironment.d.ts

@@ -1,41 +1,41 @@
 /// <reference types="node" />
-import type { EnvironmentContext, JestEnvironmentConfig } from '@jest/environment';
-import { Event, State } from 'jest-circus';
-import NodeEnvironment from 'jest-environment-node';
-import { LinkPost } from 'testit-api-client';
+import type { EnvironmentContext, JestEnvironmentConfig } from "@jest/environment";
+import { Event } from "jest-circus";
+import NodeEnvironment from "jest-environment-node";
+import { Link } from "testit-js-commons";
 export default class TestItEnvironment extends NodeEnvironment {
     private autotestData;
     private currentStepData;
-    private testClient;
     private beforeAllSteps;
     private afterAllSteps;
     private currentType;
     private autotestResults;
     private autotests;
-    private testPath;
+    private readonly testPath;
     private attachmentsQueue;
-    private automaticCreationTestCases;
-    constructor(config: JestEnvironmentConfig, context: EnvironmentContext);
+    private readonly client;
+    private readonly additions;
+    constructor(jestConfig: JestEnvironmentConfig, jestContext: EnvironmentContext);
     setup(): Promise<void>;
     teardown(): Promise<void>;
     getVmContext(): import("vm").Context | null;
     exportConditions(): string[];
-    handleTestEvent(event: Event, state: State): Promise<void>;
+    handleTestEvent(event: Event): Promise<void>;
     startHookCapture(hook: Extract<Event, {
-        name: 'hook_start';
-    }>['hook']): void;
+        name: "hook_start";
+    }>["hook"]): void;
     finishHookCapture(hook: Extract<Event, {
-        name: 'hook_start';
-    }>['hook']): void;
+        name: "hook_start";
+    }>["hook"]): void;
     startTestCapture(test: Extract<Event, {
-        name: 'test_fn_start';
-    }>['test']): void;
+        name: "test_fn_start";
+    }>["test"]): void;
     finishTestCapture(test: Extract<Event, {
-        name: 'test_fn_success';
-    }>['test']): void;
+        name: "test_fn_success";
+    }>["test"]): void;
     saveResult(test: Extract<Event, {
-        name: 'test_done';
-    }>['test']): void;
+        name: "test_done";
+    }>["test"]): Promise<void>;
     loadResults(): Promise<void>;
     resetTest(): void;
     resetStep(): void;
@@ -45,9 +45,7 @@ export default class TestItEnvironment extends NodeEnvironment {
     setDescription(description: string): void;
     addAttachments(attachment: string, name?: string): void;
     addAttachments(attachments: string[]): void;
-    addLinks(links: LinkPost[]): void;
-    addMessage(message: string): void;
-    setAutotestLinks(links: LinkPost[]): void;
+    setLinks(links: Link[]): void;
     setLabels(labels: string[]): void;
     setWorkItems(workItems: string[]): void;
     setParams(params: any): void;

package/dist/testitEnvironment.js

@@ -4,30 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const jest_environment_node_1 = __importDefault(require("jest-environment-node"));
-const debug_1 = require("./debug");
-const mappers_1 = require("./mappers");
-const testClient_1 = require("./testClient");
+const testit_js_commons_1 = require("testit-js-commons");
+const debug_1 = require("debug");
 const utils_1 = require("./utils");
-const log = debug_1.debug.extend('environment');
-const emptyTitle = '__EMPTY__';
+const log = (0, debug_1.debug)("tms").extend("environment");
 const emptyAutotestData = () => ({
-    name: emptyTitle,
+    externalId: "",
+    name: "",
     steps: [],
     afterEach: [],
+    testSteps: [],
     beforeEach: [],
     attachments: [],
     links: [],
-    runtimeLinks: [],
     labels: [],
-    workItems: [],
 });
 const emptyStepData = () => ({
-    title: emptyTitle,
+    title: "",
     attachments: [],
 });
 class TestItEnvironment extends jest_environment_node_1.default {
-    constructor(config, context) {
-        super(config, context);
+    constructor(jestConfig, jestContext) {
+        super(jestConfig, jestContext);
         this.autotestData = emptyAutotestData();
         this.currentStepData = emptyStepData();
         this.beforeAllSteps = [];
@@ -35,28 +33,21 @@ class TestItEnvironment extends jest_environment_node_1.default {
         this.autotestResults = [];
         this.autotests = [];
         this.attachmentsQueue = [];
-        const testRunId = config.projectConfig.globals['testRunId'];
-        const automaticCreationTestCases = config.projectConfig.globals['automaticCreationTestCases'];
-        if (!testRunId || typeof testRunId !== 'string') {
-            throw new Error('Looks like globalSetup was not called');
+        const config = new testit_js_commons_1.ConfigComposer().compose(jestConfig.projectConfig.testEnvironmentOptions);
+        const testRunId = jestConfig.projectConfig.globals["testRunId"];
+        if (!testRunId || typeof testRunId !== "string") {
+            throw new Error("Looks like globalSetup was not called");
         }
-        if (!automaticCreationTestCases || typeof automaticCreationTestCases !== 'boolean') {
-            throw new Error('Looks like globalSetup was not called');
-        }
-        this.automaticCreationTestCases = automaticCreationTestCases;
-        this.testClient = new testClient_1.TestClient({
-            ...config.projectConfig.testEnvironmentOptions,
-            testRunId,
-        });
-        this.testPath = (0, utils_1.excludePath)(context.testPath, config.globalConfig.rootDir);
+        this.client = new testit_js_commons_1.Client({ ...config, testRunId });
+        this.additions = new testit_js_commons_1.Additions(this.client);
+        this.testPath = (0, utils_1.excludePath)(jestContext.testPath, jestConfig.globalConfig.rootDir);
     }
     async setup() {
         await super.setup();
-        (0, utils_1.createTempDir)();
         this.global.testit = {
             externalId: this.setExternalId.bind(this),
             displayName: this.setDisplayName.bind(this),
-            links: this.setAutotestLinks.bind(this),
+            links: this.setLinks.bind(this),
             labels: this.setLabels.bind(this),
             workItemIds: this.setWorkItems.bind(this),
             params: this.setParams.bind(this),
@@ -64,15 +55,14 @@ class TestItEnvironment extends jest_environment_node_1.default {
             title: this.setTitle.bind(this),
             description: this.setDescription.bind(this),
             addAttachments: this.addAttachments.bind(this),
-            addLinks: this.addLinks.bind(this),
-            addMessage: this.addMessage.bind(this),
-            nameSpace: this.setNameSpace.bind(this),
-            className: this.setClassName.bind(this),
+            addLinks: this.additions.addLinks.bind(this.additions),
+            addMessage: this.additions.addMessage.bind(this.additions),
+            namespace: this.setNameSpace.bind(this),
+            classname: this.setClassName.bind(this),
         };
     }
     async teardown() {
         await super.teardown();
-        (0, utils_1.removeTempDir)();
     }
     getVmContext() {
         return super.getVmContext();
@@ -80,62 +70,66 @@ class TestItEnvironment extends jest_environment_node_1.default {
     exportConditions() {
         return super.exportConditions();
     }
-    async handleTestEvent(event, state) {
+    async handleTestEvent(event) {
         switch (event.name) {
-            case 'hook_start': {
+            case "hook_start": {
                 this.startHookCapture(event.hook);
                 break;
             }
-            case 'hook_success':
-            case 'hook_failure': {
+            case "hook_success":
+            case "hook_failure": {
                 this.finishHookCapture(event.hook);
                 break;
             }
-            case 'test_fn_start': {
+            case "test_fn_start": {
                 this.startTestCapture(event.test);
                 break;
             }
-            case 'test_fn_success':
-            case 'test_fn_failure': {
+            case "test_fn_success":
+            case "test_fn_failure": {
                 this.finishTestCapture(event.test);
                 break;
             }
-            case 'test_done': {
-                this.saveResult(event.test);
+            case "test_done": {
+                await this.saveResult(event.test);
                 break;
             }
-            case 'test_skip': {
+            case "test_skip": {
                 this.resetTest();
                 break;
             }
-            case 'run_finish': {
+            case "run_finish": {
                 await this.loadResults();
                 break;
             }
         }
     }
     startHookCapture(hook) {
-        log('Starting hook capture %s', hook.type);
+        log("Starting hook capture %s", hook.type);
         this.currentType = hook.type;
         // Use the hook type as the step name
         this.currentStepData.title = hook.type;
+        this.currentStepData.startedOn = new Date();
     }
     finishHookCapture(hook) {
-        log('Finishing hook capture %s', hook.type);
+        log("Finishing hook capture %s", hook.type);
+        this.currentStepData.completedOn = new Date();
+        this.currentStepData.duration =
+            this.currentStepData.completedOn.getTime() - this.currentStepData.startedOn.getTime();
         switch (hook.type) {
-            case 'beforeAll': {
+            case "beforeAll": {
                 this.beforeAllSteps.push(this.currentStepData);
                 break;
             }
-            case 'afterAll': {
+            case "afterAll": {
                 this.afterAllSteps.push(this.currentStepData);
                 break;
             }
-            case 'beforeEach': {
+            case "beforeEach": {
                 this.autotestData.beforeEach.push(this.currentStepData);
                 break;
             }
-            case 'afterEach': {
+            case "afterEach": {
                 this.autotestData.afterEach.push(this.currentStepData);
                 break;
             }
@@ -143,223 +137,174 @@ class TestItEnvironment extends jest_environment_node_1.default {
         this.resetStep();
     }
     startTestCapture(test) {
-        log('Starting test capture %s', test.name);
-        this.currentType = 'test';
+        log("Starting test capture %s", test.name);
+        this.currentType = "test";
         this.setDisplayName(test.name);
+        this.setExternalId(this.generateExternalId(test.name));
     }
     finishTestCapture(test) {
-        log('Finishing test capture %s', test.name);
-        if (this.currentStepData.title !== emptyTitle) {
-            this.autotestData.steps.push(this.currentStepData);
+        log("Finishing test capture %s", test.name);
+        if (this.currentStepData.title !== "") {
+            this.autotestData.testSteps.push(this.currentStepData);
             this.resetStep();
         }
         this.currentType = undefined;
     }
-    saveResult(test) {
-        log('Saving result for %s', test.name);
-        const errorMessage = test.errors.length > 0
-            ? test.errors.map((err) => err[0]?.message).join('\n')
-            : undefined;
-        const errorTraces = test.errors.length > 0
-            ? test.errors.map((err) => err[0]?.stack).join('\n')
-            : undefined;
+    async saveResult(test) {
+        log("Saving result for %s", test.name);
+        await Promise.all(this.attachmentsQueue);
+        const errorMessage = test.errors.length > 0 ? test.errors.map((err) => err[0]?.message).join("\n") : undefined;
+        const errorTraces = test.errors.length > 0 ? test.errors.map((err) => err[0]?.stack).join("\n") : undefined;
         const result = {
-            isFailed: test.errors.length > 0,
-            startedAt: test.startedAt ?? undefined,
+            autoTestExternalId: this.autotestData.externalId,
+            outcome: test.errors.length > 0 ? "Failed" : "Passed",
+            startedOn: test.startedAt ? new Date(test.startedAt) : undefined,
             duration: test.duration ?? undefined,
-            finishedAt: test.startedAt && (0, utils_1.isDefined)(test.duration)
-                ? test.startedAt + test.duration
-                : undefined,
-            message: errorMessage,
-            trace: errorTraces,
+            traces: errorTraces,
+            attachments: this.additions.attachments,
+            message: this.additions.messages.join("\n").concat(errorMessage ?? ""),
+            links: this.additions.links,
         };
         this.autotests.push(this.autotestData);
         this.autotestResults.push(result);
         this.resetTest();
     }
     async loadResults() {
-        log('Waiting for attachments to be uploaded');
+        log("Waiting for attachments to be uploaded");
         await Promise.all(this.attachmentsQueue);
         const results = [];
         for (let i = 0; i < this.autotests.length; i++) {
             const autotest = this.autotests[i];
             const result = this.autotestResults[i];
-            log('Mapping autotest %s', autotest.name);
+            log("Mapping autotest %s", autotest.name);
             const setupSteps = this.beforeAllSteps.concat(autotest.beforeEach);
             const teardownSteps = autotest.afterEach.concat(this.afterAllSteps);
             const autotestPost = {
-                projectId: this.testClient.projectId,
-                externalId: autotest.externalId ?? this.generateExternalId(autotest.name),
+                externalId: autotest.externalId,
                 title: autotest.title,
                 name: autotest.name,
                 description: autotest.description,
-                namespace: autotest.namespace ?? (0, utils_1.getDir)(this.testPath),
-                classname: autotest.classname ?? (0, utils_1.getFileName)(this.testPath),
-                setup: setupSteps.map(mappers_1.mapStep),
-                steps: autotest.steps.map(mappers_1.mapStep),
-                teardown: teardownSteps.map(mappers_1.mapStep),
                 links: autotest.links,
-                labels: autotest.labels.map((label) => ({ name: label })),
-                shouldCreateWorkItem: this.automaticCreationTestCases,
+                labels: autotest.labels,
+                namespace: autotest.namespace ?? testit_js_commons_1.Utils.getDir(this.testPath),
+                classname: autotest.classname ?? testit_js_commons_1.Utils.getFileName(this.testPath),
+                setup: setupSteps,
+                steps: autotest.testSteps,
+                teardown: teardownSteps,
+                shouldCreateWorkItem: this.client.getConfig().automaticCreationTestCases,
             };
-            if (!result.isFailed) {
-                await this.testClient.loadPassedAutotest(autotestPost);
-            }
-            else {
-                await this.testClient.loadAutotest(autotestPost);
-            }
-            if (autotest.workItems.length > 0) {
-                const id = await this.testClient.getAutotestId(autotestPost.externalId);
-                try {
-                    await Promise.all(autotest.workItems.map((workItem) => {
-                        return this.testClient.linkWorkItem(id, workItem);
-                    }));
-                }
-                catch (err) {
-                    console.error('Failed to link work items', (0, utils_1.formatError)(err));
-                }
-            }
-            const messages = [];
-            if (autotest.message) {
-                messages.push(autotest.message);
-            }
-            if (result.message) {
-                messages.push(result.message);
+            await this.client.autoTests.loadAutotest(autotestPost, result.outcome === "Passed");
+            if (Array.isArray(autotest.workItemIds) && autotest.workItemIds.length > 0) {
+                await this.client.autoTests
+                    .linkToWorkItems(autotest.externalId, autotest.workItemIds)
+                    .catch((err) => console.error("Failed to link work items.", err));
             }
             results.push({
-                autotestExternalId: autotestPost.externalId,
-                configurationId: this.testClient.configurationId,
-                outcome: result.isFailed ? 'Failed' : 'Passed',
-                startedOn: result.startedAt ? (0, mappers_1.mapDate)(result.startedAt) : undefined,
-                duration: result.duration ? result.duration : undefined,
-                completedOn: result.finishedAt ? (0, mappers_1.mapDate)(result.finishedAt) : undefined,
-                attachments: (0, mappers_1.mapAttachments)(autotest.attachments),
-                message: messages.length > 0 ? messages.join('\n') : undefined,
-                traces: result.trace,
-                stepResults: autotest.steps.map(mappers_1.mapStepResult),
-                setupResults: setupSteps.map(mappers_1.mapStepResult),
-                teardownResults: teardownSteps.map(mappers_1.mapStepResult),
-                links: autotest.runtimeLinks,
-                parameters: autotest.params !== undefined
-                    ? (0, mappers_1.mapParams)(autotest.params)
-                    : undefined,
+                autoTestExternalId: autotestPost.externalId,
+                outcome: result.outcome,
+                startedOn: result.startedOn,
+                duration: result.duration,
+                attachments: result.attachments,
+                message: result.message,
+                links: result.links,
+                stepResults: autotest.testSteps,
+                traces: result.traces,
+                setupResults: setupSteps,
+                teardownResults: teardownSteps,
+                parameters: autotest.parameters !== undefined ? (0, utils_1.mapParams)(autotest.parameters) : undefined,
             });
         }
-        log('Loading results');
-        await this.testClient.loadAutotestResults(results);
+        log("Loading results");
+        const testRunId = this.client.getConfig().testRunId;
+        await this.client.testRuns.loadAutotests(testRunId, results);
     }
     resetTest() {
         this.autotestData = emptyAutotestData();
+        this.additions.clear();
         this.currentType = undefined;
     }
     resetStep() {
         this.currentStepData = emptyStepData();
     }
     setExternalId(id) {
-        log('Setting external id to %s', id);
+        log("Setting external id to %s", id);
         this.autotestData.externalId = id;
     }
     setDisplayName(name) {
-        log('Setting display name to %s', name);
+        log("Setting display name to %s", name);
         this.autotestData.name = name;
     }
     setTitle(title) {
-        if (this.currentType === 'test') {
-            log('Setting autotest title to %s', title);
+        if (this.currentType === "test") {
+            log("Setting autotest title to %s", title);
             this.autotestData.title = title;
         }
         else {
-            log('Setting step title to %s', title);
+            log("Setting step title to %s", title);
             this.currentStepData.title = title;
         }
     }
     setDescription(description) {
-        if (this.currentType === 'test') {
-            log('Setting autotest description to %s', description);
+        if (this.currentType === "test") {
+            log("Setting autotest description to %s", description);
             this.autotestData.description = description;
         }
         else {
-            log('Setting step description to %s', description);
+            log("Setting step description to %s", description);
             this.currentStepData.description = description;
         }
     }
     addAttachments(attachments, name) {
         const autotest = this.autotestData;
         const step = this.currentStepData;
-        let target;
-        if (this.currentType === 'test') {
-            log('Adding attachments to %s', autotest.name);
-            target = autotest.attachments;
-        }
-        else {
-            log('Adding attachments to %s', step.title);
-            target = step.attachments;
-        }
-        let files;
-        if (Array.isArray(attachments)) {
-            files = attachments;
-        }
-        else {
-            if (!name) {
-                name = (0, utils_1.generateFileName)();
-            }
-            const path = (0, utils_1.createTempFile)(name, attachments);
-            files = [path];
-        }
-        const promise = this.testClient.uploadAttachments(files).then((ids) => {
-            target.push(...ids);
+        const currentType = this.currentType;
+        // @ts-ignore
+        const promise = this.additions.addAttachments(attachments, name).then((ids) => {
+            currentType === "test" ? autotest.attachments.push(...ids) : step.attachments?.push(...ids);
         });
         this.attachmentsQueue.push(promise);
         return promise;
     }
-    addLinks(links) {
-        log('Adding links to %s', this.autotestData.name);
-        this.autotestData.runtimeLinks.push(...links);
-    }
-    addMessage(message) {
-        log('Adding message to %s', this.autotestData.name);
-        this.autotestData.message = message;
-    }
-    setAutotestLinks(links) {
-        log('Setting autotest links to %s', this.autotestData.name);
+    setLinks(links) {
+        log("Setting autotest links to %s", this.autotestData.name);
         this.autotestData.links = links;
     }
     setLabels(labels) {
-        log('Setting labels to %s', this.autotestData.name);
-        this.autotestData.labels = labels;
+        log("Setting labels to %s", this.autotestData.name);
+        this.autotestData.labels = labels.map((label) => ({ name: label }));
     }
     setWorkItems(workItems) {
-        log('Setting work items to %s', this.autotestData.name);
-        this.autotestData.workItems = workItems;
+        log("Setting work items to %s", this.autotestData.name);
+        this.autotestData.workItemIds = workItems;
     }
     setParams(params) {
-        log('Setting params to %s', this.autotestData.name);
-        this.autotestData.params = params;
+        log("Setting params to %s", this.autotestData.name);
+        this.autotestData.parameters = params;
     }
     setNameSpace(nameSpace) {
-        log('Setting nameSpace to %s', nameSpace);
+        log("Setting nameSpace to %s", nameSpace);
         this.autotestData.namespace = nameSpace;
     }
     setClassName(className) {
-        log('Setting className to %s', className);
+        log("Setting className to %s", className);
         this.autotestData.classname = className;
     }
     startStep(name, description) {
-        log('Starting step %s', name);
-        if (this.currentType !== 'test' && this.currentType !== 'step') {
-            log('Step can only be started in test');
+        log("Starting step %s", name);
+        if (this.currentType !== "test" && this.currentType !== "step") {
+            log("Step can only be started in test");
             return;
         }
-        if (this.currentType === 'step') {
-            this.autotestData.steps.push(this.currentStepData);
+        if (this.currentType === "step") {
+            this.autotestData.testSteps.push(this.currentStepData);
             this.resetStep();
         }
-        this.currentType = 'step';
+        this.currentType = "step";
         this.currentStepData.title = name;
         this.currentStepData.description = description;
     }
     generateExternalId(testName) {
-        return (0, utils_1.getHash)(JSON.stringify({
+        return testit_js_commons_1.Utils.getHash(JSON.stringify({
             path: this.testPath,
             name: testName,
         }));

package/dist/types.d.ts

@@ -1,32 +1,9 @@
-import { LinkPost } from 'testit-api-client';
-export type StepData = {
-    title: string;
-    description?: string;
-    attachments: string[];
-};
-export type AutotestData = {
-    name: string;
-    title?: string;
-    description?: string;
-    externalId?: string;
-    namespace?: string;
-    classname?: string;
-    attachments: string[];
-    beforeEach: StepData[];
-    steps: StepData[];
-    afterEach: StepData[];
-    links: LinkPost[];
-    runtimeLinks: LinkPost[];
-    message?: string;
-    labels: string[];
-    workItems: string[];
-    params?: any;
-};
-export type AutotestResult = {
-    startedAt?: number;
-    duration?: number;
-    finishedAt?: number;
-    isFailed: boolean;
-    message?: string;
-    trace?: string;
-};
+import { AutotestPost, Attachment, Step } from "testit-js-commons";
+export interface AutotestData extends AutotestPost {
+    parameters?: any;
+    attachments: Array<Attachment>;
+    beforeEach: Step[];
+    afterEach: Step[];
+    testSteps: Step[];
+}
+export type Parameters = Record<string, string>;

package/dist/utils.d.ts

@@ -1,13 +1,3 @@
-export declare function isDefined<T>(value: T | undefined | null): value is T;
-export declare function nullToUndefined<T>(value: T | undefined | null): T | undefined;
+import { Parameters } from "./types";
 export declare function excludePath(source: string, toRemove: string): string;
-export declare function normalizePath(path: string): string;
-export declare function getHash(input: string): string;
-export declare function getDir(file: string): string;
-export declare function getFileName(file: string): string;
-export declare function createTempDir(): void;
-export declare function createTempFile(name: string, content: string): string;
-export declare function removeTempDir(): void;
-export declare function generateExternalId(path: string, testName: string): string;
-export declare function generateFileName(): string;
-export declare function formatError(error: any): any;
+export declare function mapParams(params: any): Parameters;

package/dist/utils.js

@@ -1,85 +1,27 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatError = exports.generateFileName = exports.generateExternalId = exports.removeTempDir = exports.createTempFile = exports.createTempDir = exports.getFileName = exports.getDir = exports.getHash = exports.normalizePath = exports.excludePath = exports.nullToUndefined = exports.isDefined = void 0;
-const crypto_1 = require("crypto");
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const axios_1 = __importDefault(require("axios"));
-const debug_1 = require("./debug");
-const log = debug_1.debug.extend('utils');
-function isDefined(value) {
-    return value !== undefined && value !== null;
-}
-exports.isDefined = isDefined;
-function nullToUndefined(value) {
-    return value ?? undefined;
-}
-exports.nullToUndefined = nullToUndefined;
+exports.mapParams = exports.excludePath = void 0;
 function excludePath(source, toRemove) {
     return source.replace(toRemove, '');
 }
 exports.excludePath = excludePath;
-function normalizePath(path) {
-    return (0, path_1.normalize)(path);
-}
-exports.normalizePath = normalizePath;
-function getHash(input) {
-    return (0, crypto_1.createHash)('md5').update(input).digest('hex');
-}
-exports.getHash = getHash;
-function getDir(file) {
-    return (0, path_1.dirname)(file);
-}
-exports.getDir = getDir;
-function getFileName(file) {
-    return (0, path_1.parse)(file).base;
-}
-exports.getFileName = getFileName;
-const dirPrefix = 'testit-';
-let tempDir;
-function createTempDir() {
-    log('Creating temp dir');
-    tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), dirPrefix));
-    log('Created temp dir %s', tempDir);
-}
-exports.createTempDir = createTempDir;
-function createTempFile(name, content) {
-    if (!tempDir) {
-        throw new Error('Temp dir is not created');
-    }
-    log('Creating temp file %s in %s', name, tempDir);
-    const path = (0, path_1.join)(tempDir, name);
-    (0, fs_1.writeFileSync)(path, content);
-    return path;
-}
-exports.createTempFile = createTempFile;
-function removeTempDir() {
-    if (tempDir) {
-        log('Removing temp dir %s', tempDir);
-        (0, fs_1.rmSync)(tempDir, { recursive: true });
+function 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 {};
     }
 }
-exports.removeTempDir = removeTempDir;
-function generateExternalId(path, testName) {
-    return getHash(JSON.stringify({
-        path: path,
-        name: testName,
-    }));
-}
-exports.generateExternalId = generateExternalId;
-function generateFileName() {
-    return `${(0, crypto_1.randomUUID)()}-attachment.txt`;
-}
-exports.generateFileName = generateFileName;
-function formatError(error) {
-    return axios_1.default.isAxiosError(error)
-        ? error.response?.data ?? error.response?.statusText ?? error.message
-        : error instanceof Error
-            ? error.message
-            : error;
-}
-exports.formatError = formatError;
+exports.mapParams = mapParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testit-adapter-jest",
-  "version": "1.1.7",
+  "version": "2.0.1",
   "description": "Jest adapter for Test IT",
   "main": "dist/testitEnvironment.js",
   "scripts": {
@@ -15,13 +15,15 @@
   "license": "ISC",
   "dependencies": {
     "debug": "^4.3.4",
-    "testit-api-client": "^1.0.8"
+    "testit-js-commons": "^2.0.1"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
     "@types/jest": "^27.4.1",
     "@types/node": "^18.11.9",
+    "@types/request": "^2.48.8",
     "jest": "^29.5.0",
+    "prettier": "^3.0.1",
     "typescript": "^4.8.4"
   },
   "bugs": {
@@ -33,6 +35,7 @@
     "url": "git+https://github.com/testit-tms/adapters-js.git"
   },
   "files": [
-    "dist"
+    "dist",
+    "types.d.ts"
   ]
 }

package/types.d.ts

@@ -0,0 +1,23 @@
+import { Link } from "testit-js-commons";
+
+declare global {
+  const testit: {
+    externalId(id: string): void;
+    displayName(name: string): void;
+    links(links: Link[]): void;
+    labels(labels: string[]): void;
+    workItemIds(workItemsIds: string[]): void;
+    params(params: any): void;
+    step(name: string, description?: string): void;
+    title(title: string): void;
+    description(description: string): void;
+    addAttachments(attachment: string, name?: string): void;
+    addAttachments(attachments: string[]): void;
+    addAttachments(attachments: string[] | string, name?: string): void;
+    addLinks(link: Link): void;
+    addLinks(links: Link[]): void;
+    addMessage(message: string): void;
+    namespace(namespace: string): void;
+    classname(classname: string): void;
+  };
+}

package/dist/config.d.ts

@@ -1 +0,0 @@
-export type AdapterMode = 0 | 1 | 2;

package/dist/config.js

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

package/dist/debug.d.ts

@@ -1,2 +0,0 @@
-import d from 'debug';
-export declare const debug: d.Debugger;

package/dist/debug.js

@@ -1,8 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debug = void 0;
-const debug_1 = __importDefault(require("debug"));
-exports.debug = (0, debug_1.default)('testit');

package/dist/mappers.d.ts

@@ -1,7 +0,0 @@
-import { AttachmentPut, AttachmentPutModelAutotestStepResults, AutotestStep, Parameters } from 'testit-api-client';
-import { StepData } from './types';
-export declare function mapDate(date: number): string;
-export declare function mapStep(step: StepData): AutotestStep;
-export declare function mapParams(params: any): Parameters;
-export declare function mapStepResult(step: StepData): AttachmentPutModelAutotestStepResults;
-export declare function mapAttachments(attachments: string[]): AttachmentPut[];

package/dist/mappers.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapAttachments = exports.mapStepResult = exports.mapParams = exports.mapStep = exports.mapDate = void 0;
-function mapDate(date) {
-    return new Date(date).toISOString();
-}
-exports.mapDate = mapDate;
-function mapStep(step) {
-    return {
-        title: step.title,
-        description: step.description,
-    };
-}
-exports.mapStep = mapStep;
-function 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 {};
-    }
-}
-exports.mapParams = mapParams;
-function mapStepResult(step) {
-    return {
-        title: step.title,
-        description: step.description,
-        attachments: mapAttachments(step.attachments),
-    };
-}
-exports.mapStepResult = mapStepResult;
-function mapAttachments(attachments) {
-    return attachments.map((id) => ({ id }));
-}
-exports.mapAttachments = mapAttachments;

package/dist/testClient.d.ts

@@ -1,18 +0,0 @@
-import { AutotestPost, AutotestResultsForTestRun, ClientConfig } from 'testit-api-client';
-export declare class TestClient {
-    constructor(clientConfig?: Partial<ClientConfig>);
-    private client;
-    private _testRunId;
-    get testRunId(): string;
-    get projectId(): string;
-    get configurationId(): string;
-    createTestRun(): Promise<string>;
-    startTestRun(): Promise<void>;
-    completeTestRun(): Promise<void>;
-    loadAutotest(autotestPost: AutotestPost): Promise<string>;
-    loadPassedAutotest(autotest: AutotestPost): Promise<void>;
-    getAutotestId(externalId: string): Promise<string>;
-    linkWorkItem(externalId: string, workItemId: string): Promise<void>;
-    loadAutotestResults(results: AutotestResultsForTestRun[]): Promise<void>;
-    uploadAttachments(attachments: string[]): Promise<string[]>;
-}

package/dist/testClient.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestClient = void 0;
-const testit_api_client_1 = require("testit-api-client");
-const debug_1 = require("./debug");
-const utils_1 = require("./utils");
-const log = debug_1.debug.extend('client');
-class TestClient {
-    constructor(clientConfig = {}) {
-        this.client = new testit_api_client_1.Client(clientConfig);
-        this._testRunId = clientConfig.testRunId;
-    }
-    get testRunId() {
-        if (this._testRunId === undefined) {
-            throw new Error('Test run id is not set');
-        }
-        return this._testRunId;
-    }
-    get projectId() {
-        return this.client.getConfig().projectId;
-    }
-    get configurationId() {
-        return this.client.getConfig().configurationId;
-    }
-    async createTestRun() {
-        const { projectId, testRunId } = this.client.getConfig();
-        if (testRunId === undefined) {
-            log('Test run id is not provided, creating test run for project %s', projectId);
-            this._testRunId = await this.client
-                .createTestRun({ projectId })
-                .then((testRun) => testRun.id);
-        }
-        else {
-            log('Using provided test run id %s', testRunId);
-            this._testRunId = testRunId;
-        }
-        log('Starting test run %s', this.testRunId);
-        return this.testRunId;
-    }
-    async startTestRun() {
-        log('Starting test run %s', this.testRunId);
-        await this.client.startTestRun(this.testRunId);
-    }
-    async completeTestRun() {
-        log('Completing test run %s', this.testRunId);
-        const testRun = await this.client.getTestRun(this.testRunId);
-        if (testRun.stateName === 'InProgress') {
-            await this.client.completeTestRun(this.testRunId);
-        }
-    }
-    async loadAutotest(autotestPost) {
-        try {
-            log('Creating autotest %o', autotestPost);
-            const { id } = await this.client.createAutotest(autotestPost);
-            return id;
-        }
-        catch (err) {
-            const axiosError = err;
-            if (axiosError.response?.status === 409) {
-                log('Autotest %s already exists, updating with %o', autotestPost.externalId, autotestPost);
-                const [autotest] = await this.client.getAutotest({
-                    projectId: this.client.getConfig().projectId,
-                    externalId: autotestPost.externalId,
-                });
-                await this.client.updateAutotest({
-                    ...autotest,
-                    links: autotest.links,
-                });
-                return autotest.id;
-            }
-            else {
-                console.error((0, utils_1.formatError)(err));
-                throw err;
-            }
-        }
-    }
-    async loadPassedAutotest(autotest) {
-        try {
-            log('Creating autotest %o', autotest);
-            await this.client.createAutotest(autotest);
-        }
-        catch (err) {
-            const axiosError = err;
-            if (axiosError.response?.status === 409) {
-                log('Autotest %s already exists, updating with %o', autotest.externalId, autotest);
-                await this.client.updateAutotest(autotest);
-            }
-            else {
-                console.error((0, utils_1.formatError)(err));
-                throw err;
-            }
-        }
-    }
-    async getAutotestId(externalId) {
-        const [autotest] = await this.client.getAutotest({
-            projectId: this.client.getConfig().projectId,
-            externalId,
-        });
-        return autotest.id;
-    }
-    async linkWorkItem(externalId, workItemId) {
-        log('Linking work item %s to autotest %s', workItemId, externalId);
-        return this.client.linkToWorkItem(externalId, { id: workItemId });
-    }
-    async loadAutotestResults(results) {
-        log('Loading autotest results %o', results);
-        await this.client.loadTestRunResults(this.testRunId, results);
-    }
-    async uploadAttachments(attachments) {
-        const attachmentIds = [];
-        for (const attachment of attachments) {
-            try {
-                log('Uploading attachment %s', attachment);
-                const { id } = await this.client.loadAttachment(attachment);
-                if (!id) {
-                    log('Attachment id is not returned');
-                    continue;
-                }
-                attachmentIds.push(id);
-            }
-            catch (err) {
-                console.error(`Failed to load attachment`, (0, utils_1.formatError)(err));
-            }
-        }
-        return attachmentIds;
-    }
-}
-exports.TestClient = TestClient;