testit-adapter-jest 1.1.1 → 1.1.2

package/dist/config.d.ts

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

package/dist/config.js

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

package/dist/debug.d.ts

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

package/dist/debug.js

@@ -0,0 +1,8 @@
+"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/globalSetup.d.ts

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

package/dist/globalSetup.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testClient_1 = require("./testClient");
+const utils_1 = require("./utils");
+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;
+};

package/dist/globalTeardown.d.ts

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

package/dist/globalTeardown.js

@@ -0,0 +1,16 @@
+"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;
+    }
+    try {
+        await globalThis.testClient.completeTestRun();
+    }
+    catch (err) {
+        console.error('Failed to complete test run', (0, utils_1.formatError)(err));
+    }
+};

package/dist/mappers.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,46 @@
+"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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,128 @@
+"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;

package/dist/testitEnvironment.d.ts

@@ -0,0 +1,56 @@
+/// <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';
+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 attachmentsQueue;
+    private automaticCreationTestCases;
+    constructor(config: JestEnvironmentConfig, context: EnvironmentContext);
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+    getVmContext(): import("vm").Context | null;
+    exportConditions(): string[];
+    handleTestEvent(event: Event, state: State): Promise<void>;
+    startHookCapture(hook: Extract<Event, {
+        name: 'hook_start';
+    }>['hook']): void;
+    finishHookCapture(hook: Extract<Event, {
+        name: 'hook_start';
+    }>['hook']): void;
+    startTestCapture(test: Extract<Event, {
+        name: 'test_fn_start';
+    }>['test']): void;
+    finishTestCapture(test: Extract<Event, {
+        name: 'test_fn_success';
+    }>['test']): void;
+    saveResult(test: Extract<Event, {
+        name: 'test_done';
+    }>['test']): void;
+    loadResults(): Promise<void>;
+    resetTest(): void;
+    resetStep(): void;
+    setExternalId(id: string): void;
+    setDisplayName(name: string): void;
+    setTitle(title: string): void;
+    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;
+    setLabels(labels: string[]): void;
+    setWorkItems(workItems: string[]): void;
+    setParams(params: any): void;
+    startStep(name: string, description?: string): void;
+    generateExternalId(testName: string): string;
+}

package/dist/testitEnvironment.js

@@ -0,0 +1,358 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 utils_1 = require("./utils");
+const log = debug_1.debug.extend('environment');
+const emptyTitle = '__EMPTY__';
+const emptyAutotestData = () => ({
+    name: emptyTitle,
+    steps: [],
+    afterEach: [],
+    beforeEach: [],
+    attachments: [],
+    links: [],
+    runtimeLinks: [],
+    labels: [],
+    workItems: [],
+});
+const emptyStepData = () => ({
+    title: emptyTitle,
+    attachments: [],
+});
+class TestItEnvironment extends jest_environment_node_1.default {
+    constructor(config, context) {
+        super(config, context);
+        this.autotestData = emptyAutotestData();
+        this.currentStepData = emptyStepData();
+        this.beforeAllSteps = [];
+        this.afterAllSteps = [];
+        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');
+        }
+        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);
+    }
+    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),
+            labels: this.setLabels.bind(this),
+            workItemIds: this.setWorkItems.bind(this),
+            params: this.setParams.bind(this),
+            step: this.startStep.bind(this),
+            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),
+        };
+    }
+    async teardown() {
+        await super.teardown();
+        (0, utils_1.removeTempDir)();
+    }
+    getVmContext() {
+        return super.getVmContext();
+    }
+    exportConditions() {
+        return super.exportConditions();
+    }
+    async handleTestEvent(event, state) {
+        switch (event.name) {
+            case 'hook_start': {
+                this.startHookCapture(event.hook);
+                break;
+            }
+            case 'hook_success':
+            case 'hook_failure': {
+                this.finishHookCapture(event.hook);
+                break;
+            }
+            case 'test_fn_start': {
+                this.startTestCapture(event.test);
+                break;
+            }
+            case 'test_fn_success':
+            case 'test_fn_failure': {
+                this.finishTestCapture(event.test);
+                break;
+            }
+            case 'test_done': {
+                this.saveResult(event.test);
+                break;
+            }
+            case 'test_skip': {
+                this.resetTest();
+                break;
+            }
+            case 'run_finish': {
+                await this.loadResults();
+                break;
+            }
+        }
+    }
+    startHookCapture(hook) {
+        log('Starting hook capture %s', hook.type);
+        this.currentType = hook.type;
+        // Use the hook type as the step name
+        this.currentStepData.title = hook.type;
+    }
+    finishHookCapture(hook) {
+        log('Finishing hook capture %s', hook.type);
+        switch (hook.type) {
+            case 'beforeAll': {
+                this.beforeAllSteps.push(this.currentStepData);
+                break;
+            }
+            case 'afterAll': {
+                this.afterAllSteps.push(this.currentStepData);
+                break;
+            }
+            case 'beforeEach': {
+                this.autotestData.beforeEach.push(this.currentStepData);
+                break;
+            }
+            case 'afterEach': {
+                this.autotestData.afterEach.push(this.currentStepData);
+                break;
+            }
+        }
+        this.resetStep();
+    }
+    startTestCapture(test) {
+        log('Starting test capture %s', test.name);
+        this.currentType = 'test';
+        this.setDisplayName(test.name);
+    }
+    finishTestCapture(test) {
+        log('Finishing test capture %s', test.name);
+        if (this.currentStepData.title !== emptyTitle) {
+            this.autotestData.steps.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;
+        const result = {
+            isFailed: test.errors.length > 0,
+            startedAt: 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,
+        };
+        this.autotests.push(this.autotestData);
+        this.autotestResults.push(result);
+        this.resetTest();
+    }
+    async loadResults() {
+        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);
+            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),
+                title: autotest.title,
+                name: autotest.name,
+                description: autotest.description,
+                namespace: (0, utils_1.getDir)(this.testPath),
+                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,
+            };
+            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);
+            }
+            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,
+            });
+        }
+        log('Loading results');
+        await this.testClient.loadAutotestResults(results);
+    }
+    resetTest() {
+        this.autotestData = emptyAutotestData();
+        this.currentType = undefined;
+    }
+    resetStep() {
+        this.currentStepData = emptyStepData();
+    }
+    setExternalId(id) {
+        log('Setting external id to %s', id);
+        this.autotestData.externalId = id;
+    }
+    setDisplayName(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);
+            this.autotestData.title = title;
+        }
+        else {
+            log('Setting step title to %s', title);
+            this.currentStepData.title = title;
+        }
+    }
+    setDescription(description) {
+        if (this.currentType === 'test') {
+            log('Setting autotest description to %s', description);
+            this.autotestData.description = description;
+        }
+        else {
+            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);
+        });
+        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);
+        this.autotestData.links = links;
+    }
+    setLabels(labels) {
+        log('Setting labels to %s', this.autotestData.name);
+        this.autotestData.labels = labels;
+    }
+    setWorkItems(workItems) {
+        log('Setting work items to %s', this.autotestData.name);
+        this.autotestData.workItems = workItems;
+    }
+    setParams(params) {
+        log('Setting params to %s', this.autotestData.name);
+        this.autotestData.params = params;
+    }
+    startStep(name, description) {
+        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);
+            this.resetStep();
+        }
+        this.currentType = 'step';
+        this.currentStepData.title = name;
+        this.currentStepData.description = description;
+    }
+    generateExternalId(testName) {
+        return (0, utils_1.getHash)(JSON.stringify({
+            path: this.testPath,
+            name: testName,
+        }));
+    }
+}
+exports.default = TestItEnvironment;

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+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;
+};

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+export declare function isDefined<T>(value: T | undefined | null): value is T;
+export declare function nullToUndefined<T>(value: T | undefined | null): T | undefined;
+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;

package/dist/utils.js

@@ -0,0 +1,85 @@
+"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;
+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 });
+    }
+}
+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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testit-adapter-jest",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "",
   "main": "dist/testitEnvironment.js",
   "scripts": {
@@ -12,7 +12,7 @@
   "license": "ISC",
   "dependencies": {
     "debug": "^4.3.4",
-    "testit-api-client": "^1.0.6"
+    "testit-api-client": "^1.0.8"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",