testit-adapter-cucumber 1.0.0

package/.eslintignore

@@ -0,0 +1,2 @@
+dist/*
+demo/*

package/.eslintrc.json

@@ -0,0 +1,27 @@
+{
+  "env": {
+    "es2021": true,
+    "node": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:prettier/recommended",
+    "prettier"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 12,
+    "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint", "prettier"],
+  "rules": {
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      { "argsIgnorePattern": "^_" }
+    ],
+    "prettier/prettier": "warn",
+    "@typescript-eslint/explicit-function-return-type": "error"
+  }
+}

package/.prettierrc

@@ -0,0 +1,9 @@
+{
+  "endOfLine": "lf",
+  "printWidth": 80,
+  "semi": true,
+  "singleQuote": true,
+  "useTabs": false,
+  "trailingComma": "es5",
+  "tabWidth": 2
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "testit-adapter-cucumber",
+  "version": "1.0.0",
+  "description": "Adapter provides formatter for cucumber output and some additional methods to Cucumber world.",
+  "main": "dist/formatter.js",
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "tsc",
+    "start": "npm run build && cd demo && npm run test",
+    "lint": "eslint . --ext=.ts"
+  },
+  "keywords": [],
+  "author": "Andrey Kiselev",
+  "license": "Apache-2.0",
+  "peerDependencies": {
+    "axios": "^0.22.0",
+    "minimist": "^1.2.5"
+  },
+  "dependencies": {
+    "@cucumber/cucumber": "^7.3.1",
+    "@cucumber/messages": "^17.1.1",
+    "testit-api-client": "file:testit-api-client-1.0.0.tgz"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.15.8",
+    "@babel/preset-typescript": "^7.15.0",
+    "@types/node": "^16.10.3",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "eslint": "^7.32.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.1",
+    "eslint-plugin-prettier": "^4.0.0",
+    "prettier": "^2.4.1",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.3.0",
+    "typescript": "^4.4.3"
+  },
+  "bugs": {
+    "url": "https://github.com/testit-tms/adapters-js/issues"
+  },
+  "homepage": "https://github.com/testit-tms/adapters-js"
+}

package/readme.md

@@ -0,0 +1,78 @@
+# TestIt Cucumber Adapter
+
+Adapter provides formatter for cucumber output and some additional methods to Cucumber world.
+
+# Installation
+
+```
+npm i <TBD>
+```
+
+or
+
+```
+yarn add <TBD>
+```
+
+# Usage
+
+Create `formatter.js` file with
+
+```js
+const { TestItFormatter } = require('<TBD>');
+
+module.exports = class CustomFormatter extends TestItFormatter {
+  constructor(options) {
+    super(options, {
+      url: '<url>',
+      privateToken: '<token>',
+      projectId: '<id>',
+      configurationId: '<id>',
+      testRunId: '<optional id>',
+    });
+  }
+};
+```
+
+And fill object with your configuration. Formatter sends results to TestIt.
+
+> TestRunId is optional. If it's not provided than it create automatically.
+
+Formatter provides additional methods to World:
+
+- addMessage - adds message to autotest
+- addLinks - adds links to autotest
+- addAttachments - uploads specified to TestIt and links to test run
+
+```js
+When('Something happens', function () {
+  this.addMessage('💔');
+  this.addLinks([
+    {
+      url: 'http://github.com',
+    },
+    {
+      url: 'https://wikipedia.org',
+      title: 'Wikipedia',
+      description: 'The free encyclopedia',
+      type: 'Related',
+      hasInfo: true,
+    },
+  ]);
+  this.addAttachments(['path/to/file.txt']);
+});
+```
+
+# Tags
+
+Cucumber tags can be used to specify information about autotest.
+
+> Only those specified above the `Scenario` are taken into account
+
+- `@ExternalId` - Unique identifier of autotest (Required)
+- `@Title` - Title that is displayed on autotest page
+- `@DisplayName` - Name that is displayed in autotests table
+- `@Description` - Autotest description
+- `@Link` - can be specified either in JSON (`@Link={"url":"http://google.com","hasInfo":true,"description":"GoogleDescription","title":"Google","type":"Defect"}`) or in text (`@Link=http://google.com`)
+- `@Label` - Label that is going to be linked to autotest
+- `@WorkItemID` - Work item's ID to which autotest is going to be linked

package/src/formatter.ts

@@ -0,0 +1,285 @@
+import { Formatter, IFormatterOptions } from '@cucumber/cucumber';
+import {
+  Envelope,
+  GherkinDocument,
+  Pickle,
+  TestCase,
+  TestStepFinished,
+  TestRunFinished,
+  TestCaseStarted,
+  TestCaseFinished,
+  TestStepStarted,
+  Meta,
+  TestRunStarted,
+} from '@cucumber/messages';
+import {
+  Client,
+  ClientConfigWithFile,
+  IClient,
+  LinkPost,
+} from 'testit-api-client';
+import { IStorage } from './types/storage';
+import { Storage } from './storage';
+import { IFormatter } from './types/formatter';
+import { AutotestPostWithWorkItemId } from './mappers';
+import { AxiosError } from 'axios';
+
+export class TestItFormatter extends Formatter implements IFormatter {
+  client: IClient;
+  storage: IStorage = new Storage();
+  currentTestCaseId: string | undefined;
+
+  constructor(
+    options: IFormatterOptions,
+    config: Partial<ClientConfigWithFile>
+  ) {
+    super(options);
+    this.client = new Client(config);
+    options.eventBroadcaster.on('envelope', (envelope: Envelope) => {
+      if (envelope.meta) {
+        return this.onMeta(envelope.meta);
+      }
+      if (envelope.gherkinDocument) {
+        return this.onGherkinDocument(envelope.gherkinDocument);
+      }
+      if (envelope.pickle) {
+        return this.onPickle(envelope.pickle);
+      }
+      if (envelope.testCase) {
+        return this.onTestCase(envelope.testCase);
+      }
+      if (envelope.testRunStarted) {
+        return this.onTestRunStarted(envelope.testRunStarted);
+      }
+      if (envelope.testCaseStarted) {
+        return this.onTestCaseStarted(envelope.testCaseStarted);
+      }
+      if (envelope.testStepStarted) {
+        return this.testStepStarted(envelope.testStepStarted);
+      }
+      if (envelope.testStepFinished) {
+        return this.onTestStepFinished(envelope.testStepFinished);
+      }
+      if (envelope.testCaseFinished) {
+        return this.testCaseFinished(envelope.testCaseFinished);
+      }
+      if (envelope.testRunFinished) {
+        return this.onTestRunFinished(envelope.testRunFinished);
+      }
+    });
+    options.supportCodeLibrary.World.prototype.addMessage =
+      this.addMessage.bind(this);
+    options.supportCodeLibrary.World.prototype.addLinks =
+      this.addLinks.bind(this);
+    options.supportCodeLibrary.World.prototype.addAttachments =
+      this.addAttachments.bind(this);
+  }
+
+  private testRunId: Promise<string> | undefined;
+  private testRunStarted: Promise<void> | undefined;
+  private attachmentsQueue: Promise<void>[] = [];
+
+  onMeta(_meta: Meta): void {
+    const { projectId, testRunId } = this.client.getConfig();
+    if (testRunId === undefined) {
+      this.testRunId = this.client
+        .createTestRun({
+          projectId,
+        })
+        .then((testRun) => testRun.id);
+    } else {
+      this.testRunId = Promise.resolve(testRunId);
+    }
+  }
+
+  onGherkinDocument(document: GherkinDocument): void {
+    this.storage.saveGherkinDocument(document);
+  }
+
+  onPickle(pickle: Pickle): void {
+    this.storage.savePickle(pickle);
+  }
+
+  onTestRunStarted(_testRunStarted: TestRunStarted): void {
+    if (this.testRunId === undefined) {
+      throw new Error('TestRunId is not yet specified');
+    }
+    this.testRunStarted = this.testRunId.then((id) =>
+      this.client.startTestRun(id)
+    );
+  }
+
+  onTestCase(testCase: TestCase): void {
+    this.storage.saveTestCase(testCase);
+  }
+
+  onTestCaseStarted(testCaseStarted: TestCaseStarted): void {
+    this.currentTestCaseId = testCaseStarted.testCaseId;
+    this.storage.saveTestCaseStarted(testCaseStarted);
+  }
+
+  testStepStarted(testStepStarted: TestStepStarted): void {
+    this.storage.saveTestStepStarted(testStepStarted);
+  }
+
+  onTestStepFinished(testStepFinished: TestStepFinished): void {
+    this.storage.saveTestStepFinished(testStepFinished);
+  }
+
+  testCaseFinished(testCaseFinished: TestCaseFinished): void {
+    this.currentTestCaseId = undefined;
+    this.storage.saveTestCaseFinished(testCaseFinished);
+  }
+
+  onTestRunFinished(_testRunFinished: TestRunFinished): void {
+    if (this.testRunId === undefined) {
+      throw new Error('TestRunId is not yet specified');
+    }
+    if (this.testRunStarted === undefined) {
+      throw new Error('Test run is not started yet');
+    }
+
+    Promise.all([
+      this.testRunId,
+      this.testRunStarted,
+      Promise.all(this.attachmentsQueue),
+    ])
+      .then(async ([id]) => {
+        const { configurationId } = this.client.getConfig();
+        const autotests = this.storage.getAutotests(
+          this.client.getConfig().projectId
+        );
+        const results = this.storage.getTestRunResults(configurationId);
+        await Promise.all(
+          autotests.map((autotestPost) => {
+            const result = results.find(
+              (result) => result.autotestExternalId === autotestPost.externalId
+            );
+            if (result === undefined) {
+              throw new Error(
+                `Cannot find result for ${autotestPost.externalId} autotest`
+              );
+            }
+            if (result.outcome !== 'Passed') {
+              return this.loadAutotest(autotestPost);
+            }
+            return this.loadPassedAutotest(autotestPost);
+          })
+        );
+        return this.client.loadTestRunResults(id, results);
+      })
+      .catch((err) => {
+        console.error(err);
+        this.testRunId?.then((id) => this.client.completeTestRun(id));
+      });
+  }
+
+  async loadAutotest(autotestPost: AutotestPostWithWorkItemId): Promise<void> {
+    try {
+      await this.createNewAutotest(autotestPost);
+    } catch (err) {
+      const axiosError = err as AxiosError;
+
+      if (axiosError.response?.status === 409) {
+        const [autotest] = await this.client.getAutotest({
+          projectId: this.client.getConfig().projectId,
+          externalId: autotestPost.externalId,
+        });
+        await this.updateAutotest({
+          ...autotest,
+          links: autotestPost.links,
+        });
+      } else {
+        this.logError(axiosError);
+      }
+    }
+  }
+
+  async loadPassedAutotest(
+    autotestPost: AutotestPostWithWorkItemId
+  ): Promise<void> {
+    try {
+      await this.createNewAutotest(autotestPost);
+    } catch (err) {
+      const axiosError = err as AxiosError;
+      if (axiosError.response?.status === 409) {
+        await this.updateAutotest(autotestPost);
+      } else {
+        this.logError(axiosError);
+      }
+    }
+
+    if (autotestPost.workItemId !== undefined) {
+      this.linkWorkItem(autotestPost.externalId, autotestPost.workItemId);
+    }
+  }
+
+  async createNewAutotest(
+    autotestPost: AutotestPostWithWorkItemId
+  ): Promise<void> {
+    await this.client.createAutotest(autotestPost);
+  }
+
+  async updateAutotest(
+    autotestPost: AutotestPostWithWorkItemId
+  ): Promise<void> {
+    await this.client.updateAutotest(autotestPost).catch(this.logError);
+  }
+
+  async linkWorkItem(externalId: string, workItemId: string): Promise<void> {
+    const [autotest] = await this.client
+      .getAutotest({
+        projectId: this.client.getConfig().projectId,
+        externalId: externalId,
+      })
+      .catch(() => []);
+    if (autotest?.id !== undefined) {
+      await this.client.linkToWorkItem(autotest.id, {
+        id: workItemId,
+      });
+    }
+  }
+
+  addMessage(message: string): void {
+    if (this.currentTestCaseId === undefined) {
+      throw new Error('CurrentTestCaseId is not set');
+    }
+    this.storage.addMessage(this.currentTestCaseId, message);
+  }
+
+  addLinks(links: LinkPost[]): void {
+    if (this.currentTestCaseId === undefined) {
+      throw new Error('CurrentTestCaseId is not set');
+    }
+    this.storage.addLinks(this.currentTestCaseId, links);
+  }
+
+  addAttachments(attachments: string[]): void {
+    if (this.currentTestCaseId === undefined) {
+      throw new Error('CurrentTestCaseId is not set');
+    }
+    const currentTestCaseId = this.currentTestCaseId;
+    this.attachmentsQueue.push(
+      ...attachments.map(async (attachment) => {
+        const { id } = await this.client.loadAttachment(attachment);
+        if (id === undefined) {
+          // NOTE: Why?
+          console.warn('Attachment id is not returned');
+          return;
+        }
+        this.storage.addAttachment(currentTestCaseId, id);
+      })
+    );
+  }
+
+  private logError(err: AxiosError): void {
+    console.error(
+      err.response?.status,
+      err.config.method,
+      err.config.url,
+      err.response?.data
+    );
+  }
+
+  // TODO: add stopping run on error
+}

package/src/mappers.ts

@@ -0,0 +1,174 @@
+import {
+  Background,
+  DataTable,
+  Examples,
+  GherkinDocument,
+  Rule,
+  Scenario,
+  Step,
+  TestStepResultStatus,
+} from '@cucumber/messages';
+import { AutotestPost, AutotestStep, OutcomeType } from 'testit-api-client';
+import { parseTags } from './utils';
+
+export interface AutotestPostWithWorkItemId extends AutotestPost {
+  workItemId?: string;
+}
+
+export function mapStatus(status: TestStepResultStatus): OutcomeType {
+  switch (status) {
+    case TestStepResultStatus.PASSED:
+      return 'Passed';
+    case TestStepResultStatus.FAILED:
+      return 'Failed';
+    case TestStepResultStatus.PENDING:
+      return 'Pending';
+    case TestStepResultStatus.SKIPPED:
+      return 'Skipped';
+    case TestStepResultStatus.UNKNOWN:
+    case TestStepResultStatus.UNDEFINED:
+    case TestStepResultStatus.AMBIGUOUS:
+      return 'Blocked';
+    default:
+      throw new Error('Unknown status');
+  }
+}
+
+export function mapDate(date: number): string {
+  return new Date(date * 1000).toISOString();
+}
+
+export function mapDocument(
+  document: GherkinDocument,
+  projectId: string
+): AutotestPostWithWorkItemId[] {
+  if (document.feature === undefined) {
+    return [];
+  }
+
+  const setup = document.feature.children
+    .filter((child) => child.background !== undefined)
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    .map((child) => mapBackground(child.background!));
+  const scenarioAutotests = document.feature.children
+    .filter((child) => child.scenario !== undefined)
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    .map((child) => mapScenario(child.scenario!, projectId, setup));
+  const ruleAutotests = document.feature.children
+    .filter((child) => child.rule !== undefined)
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    .flatMap((child) => mapRule(child.rule!, projectId, setup));
+
+  return scenarioAutotests.concat(...ruleAutotests);
+}
+
+export function mapBackground(background: Background): AutotestStep {
+  return {
+    title: background.name,
+    description: background.description,
+    steps: background.steps.map(mapStep),
+  };
+}
+
+export function mapRule(
+  rule: Rule,
+  projectId: string,
+  setup: AutotestStep[]
+): AutotestPostWithWorkItemId[] {
+  const ruleSetup = setup.concat(
+    rule.children
+      .filter((child) => child.background !== undefined)
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      .map((child) => mapBackground(child.background!))
+  );
+  return (
+    rule.children
+      .filter((child) => child.scenario !== undefined)
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      .map((child) => mapScenario(child.scenario!, projectId, ruleSetup))
+  );
+}
+
+export function mapScenario(
+  scenario: Scenario,
+  projectId: string,
+  setup: AutotestStep[]
+): AutotestPostWithWorkItemId {
+  const tags = parseTags(scenario.tags);
+  if (tags.externalId === undefined) {
+    throw new Error(`External id is not provided in ${scenario.name}`);
+  }
+  const exampleSteps = scenario.examples.map(mapExamples);
+  return {
+    setup: exampleSteps.concat(setup),
+    externalId: tags.externalId,
+    links: tags.links,
+    name: tags.name ?? scenario.name,
+    title: tags.title,
+    description: tags.description ?? scenario.description,
+    projectId,
+    steps: scenario.steps.map(mapStep),
+    workItemId: tags.workItemId,
+    // Disable for now (BUG??)
+    // labels:
+    //   tags.labels.length > 0
+    //     ? tags.labels.map((label) => ({ name: label }))
+    //     : undefined,
+  };
+}
+
+export function mapExamples(examples: Examples): AutotestStep {
+  let table: string[][] | Record<string, string>[] = [];
+  const body = examples.tableBody.map((row) =>
+    row.cells.map((cell) => cell.value)
+  );
+  if (examples.tableHeader !== undefined) {
+    const header = examples.tableHeader?.cells.map((cell) => cell.value);
+    table = body.map((row) =>
+      header.reduce((acc, key, i) => {
+        acc[key] = row[i];
+        return acc;
+      }, {} as Record<string, string>)
+    );
+  } else {
+    table = body;
+  }
+  const description = [examples.description];
+
+  const tags = parseTags(examples.tags);
+
+  if (table.length > 0) {
+    description.push(JSON.stringify(table));
+  }
+
+  return {
+    title: tags.title ?? tags.name ?? examples.name,
+    description: tags.description ?? description.join('\n\n'),
+  };
+}
+
+export function mapStep(step: Step): AutotestStep {
+  return {
+    title: `${step.keyword} ${step.text}`,
+    description: step.docString?.content ?? mapDataTable(step.dataTable),
+  };
+}
+
+export function mapDataTable(
+  dataTable: DataTable | undefined
+): string | undefined {
+  if (dataTable === undefined) {
+    return undefined;
+  }
+  const keys = dataTable.rows[0].cells.map((cell) => cell.value);
+  const rows = dataTable.rows
+    .slice(1)
+    .map((row) => row.cells.map((cell) => cell.value));
+  const objects = rows.map((value) =>
+    keys.reduce((acc, key, i) => {
+      acc[key] = value[i];
+      return acc;
+    }, {} as Record<string, string>)
+  );
+  return JSON.stringify(objects);
+}

package/src/storage.ts

@@ -0,0 +1,212 @@
+import {
+  AttachmentPut,
+  AttachmentPutModelAutotestStepResults,
+  AutotestResultsForTestRun,
+  LinkPost,
+} from 'testit-api-client';
+import {
+  GherkinDocument,
+  Pickle,
+  PickleStep,
+  TestCase,
+  TestCaseFinished,
+  TestCaseStarted,
+  TestStepFinished,
+  TestStepStarted,
+} from '@cucumber/messages';
+import { IStorage } from './types/storage';
+import {
+  AutotestPostWithWorkItemId,
+  mapDate,
+  mapDocument,
+  mapStatus,
+} from './mappers';
+import { calculateResultOutcome, parseTags } from './utils';
+
+export class Storage implements IStorage {
+  private gherkinDocuments: GherkinDocument[] = [];
+  private pickles: Pickle[] = [];
+  private testCases: TestCase[] = [];
+  private testCasesStarted: TestCaseStarted[] = [];
+  private testCasesFinished: TestCaseFinished[] = [];
+  private testStepsStarted: TestStepStarted[] = [];
+  private testStepsFinished: TestStepFinished[] = [];
+  private messages: Record<string, string[]> = {};
+  private links: Record<string, LinkPost[]> = {};
+  private attachments: Record<string, string[]> = {};
+
+  saveGherkinDocument(document: GherkinDocument): void {
+    this.gherkinDocuments.push(document);
+  }
+  getAutotests(projectId: string): AutotestPostWithWorkItemId[] {
+    return this.gherkinDocuments.flatMap((document) =>
+      mapDocument(document, projectId)
+    );
+  }
+  savePickle(pickle: Pickle): void {
+    this.pickles.push(pickle);
+  }
+  saveTestCase(testCase: TestCase): void {
+    this.testCases.push(testCase);
+  }
+  saveTestCaseStarted(testCaseStarted: TestCaseStarted): void {
+    this.testCasesStarted.push(testCaseStarted);
+  }
+  saveTestCaseFinished(testCaseFinished: TestCaseFinished): void {
+    this.testCasesFinished.push(testCaseFinished);
+  }
+  saveTestStepStarted(testStepStarted: TestStepStarted): void {
+    this.testStepsStarted.push(testStepStarted);
+  }
+  saveTestStepFinished(testStepFinished: TestStepFinished): void {
+    this.testStepsFinished.push(testStepFinished);
+  }
+  getTestRunResults(configurationId: string): AutotestResultsForTestRun[] {
+    const results: AutotestResultsForTestRun[] = [];
+    for (const pickle of this.pickles) {
+      const tags = parseTags(pickle.tags);
+      if (tags.externalId === undefined) {
+        throw new Error('External id is not provided');
+      }
+      const testCase = this.testCases.find(
+        (testCase) => testCase.pickleId === pickle.id
+      );
+      if (testCase === undefined) {
+        throw new Error('TestCase not found');
+      }
+      const testCaseStarted = this.testCasesStarted.find(
+        (testCase) => testCase.id === testCase.id
+      );
+      if (testCaseStarted === undefined) {
+        throw new Error('TestCaseStarted not found');
+      }
+      const testCaseFinished = this.testCasesFinished.find(
+        (testCase) => testCase.testCaseStartedId === testCaseStarted.id
+      );
+      if (testCaseFinished === undefined) {
+        throw new Error('TestCaseFinished not found');
+      }
+      const steps = pickle.steps
+        .map((step) => this.getStepResult(step, testCase))
+        .filter((item, i, arr) => {
+          const prevOutcome = arr[i - 1]?.outcome;
+          if (
+            item.outcome === 'Skipped' &&
+            prevOutcome !== undefined &&
+            ['Failed', 'Skipped'].includes(prevOutcome)
+          ) {
+            return false;
+          }
+          return true;
+        });
+      const messages: string[] = [];
+      for (const step of pickle.steps) {
+        const message = this.getStepMessage(step, testCase);
+        if (message !== undefined) {
+          messages.push(message);
+        }
+      }
+      const links = this.links[testCase.id] ?? [];
+      links.push(...tags.links);
+      const result: AutotestResultsForTestRun = {
+        autotestExternalId: tags.externalId,
+        configurationId,
+        links,
+        stepResults: steps,
+        outcome: calculateResultOutcome(steps.map((step) => step.outcome)),
+        startedOn: mapDate(testCaseStarted.timestamp.seconds),
+        completeOn: mapDate(testCaseFinished.timestamp.seconds),
+        duration:
+          testCaseFinished.timestamp.seconds -
+          testCaseStarted.timestamp.seconds,
+        message: this.messages[testCase.id]?.join('\n\n') ?? undefined,
+        traces: messages.join('\n\n'),
+        attachments: this.getAttachments(testCase.id),
+      };
+      results.push(result);
+    }
+
+    return results;
+  }
+  getStepResult(
+    pickleStep: PickleStep,
+    testCase: TestCase
+  ): AttachmentPutModelAutotestStepResults {
+    const testStep = testCase.testSteps.find(
+      (step) => step.pickleStepId === pickleStep.id
+    );
+    if (testStep === undefined) {
+      throw new Error('TestCase step not found');
+    }
+    const testStepStarted = this.testStepsStarted.find(
+      (step) => step.testStepId === testStep.id
+    );
+    if (testStepStarted === undefined) {
+      throw new Error('TestStepStarted not found');
+    }
+    const testStepFinished = this.testStepsFinished.find(
+      (step) => step.testStepId === testStepStarted.testStepId
+    );
+    if (testStepFinished === undefined) {
+      throw new Error('TestStepFinished not found');
+    }
+    return {
+      title: pickleStep.text,
+      startedOn: mapDate(testStepStarted.timestamp.seconds),
+      duration: testStepFinished.testStepResult.duration.seconds,
+      completedOn: mapDate(testStepFinished.timestamp.seconds),
+      outcome: mapStatus(testStepFinished.testStepResult.status),
+    };
+  }
+  getStepMessage(
+    pickleStep: PickleStep,
+    testCase: TestCase
+  ): string | undefined {
+    const testStep = testCase.testSteps.find(
+      (step) => step.pickleStepId === pickleStep.id
+    );
+    if (testStep === undefined) {
+      throw new Error('TestCase step not found');
+    }
+    const testStepStarted = this.testStepsStarted.find(
+      (step) => step.testStepId === testStep.id
+    );
+    if (testStepStarted === undefined) {
+      throw new Error('TestStepStarted not found');
+    }
+    const testStepFinished = this.testStepsFinished.find(
+      (step) => step.testStepId === testStepStarted.testStepId
+    );
+    if (testStepFinished === undefined) {
+      throw new Error('TestStepFinished not found');
+    }
+    return testStepFinished.testStepResult.message;
+  }
+  getAttachments(testCaseId: string): AttachmentPut[] | undefined {
+    if (this.attachments[testCaseId] === undefined) {
+      return undefined;
+    }
+    return this.attachments[testCaseId].map((id) => ({ id }));
+  }
+  addMessage(testCaseId: string, message: string): void {
+    if (this.messages[testCaseId] === undefined) {
+      this.messages[testCaseId] = [message];
+    } else {
+      this.messages[testCaseId].push(message);
+    }
+  }
+  addLinks(testCaseId: string, links: LinkPost[]): void {
+    if (this.links[testCaseId] === undefined) {
+      this.links[testCaseId] = links;
+    } else {
+      this.links[testCaseId].push(...links);
+    }
+  }
+  addAttachment(testCaseId: string, attachmentId: string): void {
+    if (this.attachments[testCaseId] === undefined) {
+      this.attachments[testCaseId] = [attachmentId];
+    } else {
+      this.attachments[testCaseId].concat(attachmentId);
+    }
+  }
+}

package/src/types/formatter.ts

@@ -0,0 +1,29 @@
+import {
+  GherkinDocument,
+  Meta,
+  Pickle,
+  TestCase,
+  TestCaseFinished,
+  TestCaseStarted,
+  TestRunFinished,
+  TestRunStarted,
+  TestStepFinished,
+  TestStepStarted,
+} from '@cucumber/messages';
+import { IClient } from 'testit-api-client';
+import { IStorage } from './storage';
+
+export interface IFormatter {
+  client: IClient;
+  storage: IStorage;
+  onMeta(meta: Meta): void;
+  onGherkinDocument(document: GherkinDocument): void;
+  onPickle(pickle: Pickle): void;
+  onTestRunStarted(testRunStarted: TestRunStarted): void;
+  onTestCase(testCase: TestCase): void;
+  onTestCaseStarted(testCaseStarted: TestCaseStarted): void;
+  testStepStarted(testStepStarted: TestStepStarted): void;
+  onTestStepFinished(testStepFinished: TestStepFinished): void;
+  testCaseFinished(testCaseFinished: TestCaseFinished): void;
+  onTestRunFinished(_testRunFinished: TestRunFinished): void;
+}

package/src/types/storage.ts

@@ -0,0 +1,26 @@
+import {
+  GherkinDocument,
+  Pickle,
+  TestCase,
+  TestCaseFinished,
+  TestCaseStarted,
+  TestStepFinished,
+  TestStepStarted,
+} from '@cucumber/messages';
+import { AutotestResultsForTestRun, LinkPost } from 'testit-api-client';
+import { AutotestPostWithWorkItemId } from '../mappers';
+
+export interface IStorage {
+  saveGherkinDocument(document: GherkinDocument): void;
+  getAutotests(projectId: string): AutotestPostWithWorkItemId[];
+  savePickle(pickle: Pickle): void;
+  saveTestCase(testCase: TestCase): void;
+  saveTestCaseStarted(testCaseStarted: TestCaseStarted): void;
+  saveTestCaseFinished(testCaseFinished: TestCaseFinished): void;
+  saveTestStepStarted(testStepStarted: TestStepStarted): void;
+  saveTestStepFinished(testStepFinished: TestStepFinished): void;
+  getTestRunResults(configurationId: string): AutotestResultsForTestRun[];
+  addMessage(testCaseId: string, message: string): void;
+  addLinks(testCaseId: string, links: LinkPost[]): void;
+  addAttachment(testCaseId: string, attachmentId: string): void;
+}

package/src/types/tags.ts

@@ -0,0 +1,33 @@
+import { Link } from 'testit-api-client';
+
+export type ParsedTags = {
+  externalId?: string;
+  links: Omit<Link, 'id'>[];
+  title?: string;
+  workItemId?: string;
+  name?: string;
+  description?: string;
+  labels: string[];
+};
+
+export enum TagType {
+  ExternalId,
+  LinkUrl,
+  Link,
+  Title,
+  WorkItemId,
+  Name,
+  Description,
+  Label,
+  Unknown,
+}
+
+export const tags: Record<keyof ParsedTags, string> = {
+  externalId: 'ExternalId',
+  links: 'Link',
+  title: 'Title',
+  name: 'DisplayName',
+  workItemId: 'WorkItemId',
+  description: 'Description',
+  labels: 'Label',
+};

package/src/types/world.ts

@@ -0,0 +1,8 @@
+import { World } from '@cucumber/cucumber';
+import { LinkPost } from 'testit-api-client';
+
+export interface TestItWorld extends World {
+  addMessage(message: string): void;
+  addLinks(links: LinkPost[]): void;
+  addAttachments(attachments: string[]): void;
+}

package/src/utils.ts

@@ -0,0 +1,127 @@
+import { Tag } from '@cucumber/messages';
+import { Link, OutcomeType } from 'testit-api-client';
+import { ParsedTags, tags, TagType } from './types/tags';
+
+export function getTagType(tag: string): TagType {
+  if (new RegExp(`^@${tags.externalId}=.+$`).test(tag)) {
+    return TagType.ExternalId;
+  }
+  if (new RegExp(`^@${tags.links}=.+$`).test(tag)) {
+    // Check if it is JSON
+    if (tag.endsWith('}')) {
+      return TagType.Link;
+    }
+    return TagType.LinkUrl;
+  }
+  if (new RegExp(`^@${tags.title}=.+$`).test(tag)) {
+    return TagType.Title;
+  }
+  if (new RegExp(`^@${tags.workItemId}=.+$`).test(tag)) {
+    return TagType.WorkItemId;
+  }
+  if (new RegExp(`^@${tags.name}=.+$`).test(tag)) {
+    return TagType.Name;
+  }
+  if (new RegExp(`^@${tags.description}=.+$`).test(tag)) {
+    return TagType.Description;
+  }
+  if (new RegExp(`^@${tags.labels}=.+$`).test(tag)) {
+    return TagType.Label;
+  }
+  return TagType.Unknown;
+}
+
+export function getExternalId(tag: string): string {
+  return tag.replace(new RegExp(`^@${tags.externalId}=`), '');
+}
+
+export function getLinkUrl(tag: string): string {
+  return tag.replace(new RegExp(`^@${tags.links}=`), '');
+}
+
+export function getLink(tag: string): Omit<Link, 'id'> {
+  const linkData: Omit<Link, 'id'> = JSON.parse(getLinkUrl(tag));
+  return linkData;
+}
+
+export function getTitle(tag: string): string {
+  return tag.replace(new RegExp(`^@${tags.title}=`), '');
+}
+
+export function getWorkItemId(tag: string): string {
+  return tag.replace(new RegExp(`^@${tags.workItemId}=`), '');
+}
+
+export function getName(tag: string): string {
+  return tag.replace(new RegExp(`^@${tags.name}=`), '');
+}
+
+export function getDescription(tag: string): string {
+  return tag.replace(new RegExp(`^@${tags.description}=`), '');
+}
+
+export function getLabel(tag: string): string {
+  return tag.replace(new RegExp(`^@${tags.labels}=`), '');
+}
+
+export function parseTags(tags: readonly Pick<Tag, 'name'>[]): ParsedTags {
+  const parsedTags: ParsedTags = { links: [], labels: [] };
+  for (const tag of tags) {
+    switch (getTagType(tag.name)) {
+      case TagType.ExternalId:
+        parsedTags.externalId = getExternalId(tag.name);
+        continue;
+      case TagType.LinkUrl: {
+        parsedTags.links?.push({ url: getLinkUrl(tag.name) });
+        continue;
+      }
+      case TagType.Link: {
+        parsedTags.links?.push(getLink(tag.name));
+        continue;
+      }
+      case TagType.Title: {
+        parsedTags.title = getTitle(tag.name);
+        continue;
+      }
+      case TagType.WorkItemId: {
+        parsedTags.workItemId = getWorkItemId(tag.name);
+        continue;
+      }
+      case TagType.Name: {
+        parsedTags.name = getName(tag.name);
+        continue;
+      }
+      case TagType.Description: {
+        parsedTags.description = getDescription(tag.name);
+        continue;
+      }
+      case TagType.Label: {
+        parsedTags.labels?.push(getLabel(tag.name));
+        continue;
+      }
+      case TagType.Unknown:
+        continue;
+      default:
+        throw new Error('Unknown tag type');
+    }
+  }
+  return parsedTags;
+}
+
+export function calculateResultOutcome(
+  outcomes: (OutcomeType | undefined)[]
+): OutcomeType {
+  if (outcomes.some((outcome) => outcome === 'Failed')) {
+    return 'Failed';
+  }
+  if (outcomes.some((outcome) => outcome === 'Blocked')) {
+    return 'Blocked';
+  }
+  if (outcomes.some((outcome) => outcome === 'Skipped')) {
+    return 'Skipped';
+  }
+  if (outcomes.every((outcome) => outcome === 'Passed')) {
+    return 'Passed';
+  }
+  throw new Error('Cannot calculate result outcome');
+}

package/tsconfig.json

@@ -0,0 +1,101 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ES2017" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+    // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+
+    /* Modules */
+    "module": "commonjs" /* Specify what module code is generated. */,
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+    /* Emit */
+    "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    "sourceMap": true /* Create source map files for emitted JavaScript files. */,
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
+    // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src"]
+}