allure-js-commons

  • Version 2.0.0-beta.12
  • Published
  • 67.1 kB
  • 3 dependencies
  • Apache-2.0 license

Install

npm i allure-js-commons
yarn add allure-js-commons
pnpm add allure-js-commons

Overview

Allure JS Commons

Index

Functions

Classes

Interfaces

Enums

Type Aliases

Functions

function isPromise

isPromise: (obj: any) => boolean;

    Classes

    class Allure

    abstract class Allure {}

      constructor

      protected constructor(runtime: AllureRuntime);

        property currentExecutable

        readonly currentExecutable: ExecutableItemWrapper;

          property currentTest

          readonly currentTest: AllureTest;

            property runtime

            protected runtime: AllureRuntime;

              method attachment

              abstract attachment: (
              name: string,
              content: Buffer | string,
              options: ContentType | string | AttachmentOptions
              ) => void;

                method createAttachment

                createAttachment: (
                name: string,
                content: Buffer | string | Function,
                type: ContentType
                ) => (...args: any[]) => void;

                  method createStep

                  createStep: (name: string, stepFunction: Function) => (...args: any[]) => any;

                    method description

                    description: (markdown: string) => void;

                      method descriptionHtml

                      descriptionHtml: (html: string) => void;

                        method epic

                        epic: (epic: string) => void;

                          method feature

                          feature: (feature: string) => void;

                            method issue

                            issue: (name: string, url: string) => void;

                              method label

                              label: (name: string, value: string) => void;
                                link: (url: string, name?: string, type?: string) => void;

                                  method logStep

                                  abstract logStep: (name: string, status?: Status) => void;

                                    method owner

                                    owner: (owner: string) => void;

                                      method parameter

                                      parameter: (name: string, value: string) => void;

                                        method parentSuite

                                        parentSuite: (name: string) => void;

                                          method severity

                                          severity: (severity: string) => void;

                                            method step

                                            abstract step: <T>(name: string, body: (step: StepInterface) => T) => T;

                                              method story

                                              story: (story: string) => void;

                                                method subSuite

                                                subSuite: (name: string) => void;

                                                  method suite

                                                  suite: (name: string) => void;

                                                    method tag

                                                    tag: (tag: string) => void;

                                                      method tms

                                                      tms: (name: string, url: string) => void;

                                                        method writeCategoriesDefinitions

                                                        writeCategoriesDefinitions: (categories: Category[]) => void;

                                                          method writeEnvironmentInfo

                                                          writeEnvironmentInfo: (info: Record<string, string>) => void;

                                                            class AllureGroup

                                                            class AllureGroup {}

                                                              constructor

                                                              constructor(runtime: AllureRuntime);

                                                                property name

                                                                name: string;

                                                                  property uuid

                                                                  readonly uuid: string;

                                                                    method addAfter

                                                                    addAfter: () => ExecutableItemWrapper;

                                                                      method addBefore

                                                                      addBefore: () => ExecutableItemWrapper;

                                                                        method endGroup

                                                                        endGroup: () => void;

                                                                          method startGroup

                                                                          startGroup: (name?: string) => AllureGroup;

                                                                            method startTest

                                                                            startTest: (name?: string, start?: number) => AllureTest;

                                                                              class AllureRuntime

                                                                              class AllureRuntime {}

                                                                                constructor

                                                                                constructor(config: AllureConfig);

                                                                                  method startGroup

                                                                                  startGroup: (name?: string) => AllureGroup;

                                                                                    method writeAttachment

                                                                                    writeAttachment: (
                                                                                    content: Buffer | string,
                                                                                    options: ContentType | string | AttachmentOptions
                                                                                    ) => string;

                                                                                      method writeAttachmentFromPath

                                                                                      writeAttachmentFromPath: (
                                                                                      filePath: any,
                                                                                      options: ContentType | string | AttachmentOptions
                                                                                      ) => string;

                                                                                        method writeCategoriesDefinitions

                                                                                        writeCategoriesDefinitions: (categories: Category[]) => void;

                                                                                          method writeEnvironmentInfo

                                                                                          writeEnvironmentInfo: (info?: Record<string, string>) => void;

                                                                                            method writeGroup

                                                                                            writeGroup: (result: TestResultContainer) => void;

                                                                                              method writeResult

                                                                                              writeResult: (result: TestResult) => void;

                                                                                                class AllureStep

                                                                                                class AllureStep extends ExecutableItemWrapper {}

                                                                                                  constructor

                                                                                                  constructor(stepResult: ExecutableItem, start?: number);

                                                                                                    method endStep

                                                                                                    endStep: (stop?: number) => void;

                                                                                                      class AllureTest

                                                                                                      class AllureTest extends ExecutableItemWrapper {}

                                                                                                        constructor

                                                                                                        constructor(runtime: AllureRuntime, start?: number);

                                                                                                          property uuid

                                                                                                          readonly uuid: string;
                                                                                                            addIssueLink: (url: string, name: string) => void;

                                                                                                              method addLabel

                                                                                                              addLabel: (name: string, value: string) => void;
                                                                                                                addLink: (url: string, name?: string, type?: string) => void;
                                                                                                                  addTmsLink: (url: string, name: string) => void;

                                                                                                                    method endTest

                                                                                                                    endTest: (stop?: number) => void;

                                                                                                                      class ExecutableItemWrapper

                                                                                                                      class ExecutableItemWrapper {}

                                                                                                                        constructor

                                                                                                                        constructor(info: TestResult | ExecutableItem);

                                                                                                                          property status

                                                                                                                          status: Status;

                                                                                                                            property wrappedItem

                                                                                                                            readonly wrappedItem: TestResult | ExecutableItem;

                                                                                                                              method addAttachment

                                                                                                                              addAttachment: (
                                                                                                                              name: string,
                                                                                                                              options: ContentType | string | AttachmentOptions,
                                                                                                                              fileName: string
                                                                                                                              ) => void;

                                                                                                                                method addParameter

                                                                                                                                addParameter: (name: string, value: string) => void;

                                                                                                                                  method startStep

                                                                                                                                  startStep: (name: string, start?: number) => AllureStep;

                                                                                                                                    method wrap

                                                                                                                                    wrap: <T>(fun: (...args: any[]) => T) => (...args: any[]) => T;

                                                                                                                                      class InMemoryAllureWriter

                                                                                                                                      class InMemoryAllureWriter implements AllureWriter {}

                                                                                                                                        property attachments

                                                                                                                                        attachments: Record<string, any>;

                                                                                                                                          property categories

                                                                                                                                          categories?: Category[];

                                                                                                                                            property envInfo

                                                                                                                                            envInfo?: Record<string, string>;

                                                                                                                                              property groups

                                                                                                                                              groups: TestResultContainer[];

                                                                                                                                                property tests

                                                                                                                                                tests: TestResult[];

                                                                                                                                                  method getGroupByName

                                                                                                                                                  getGroupByName: (name: string) => TestResultContainer;

                                                                                                                                                    method getMaybeGroupByName

                                                                                                                                                    getMaybeGroupByName: (name: string) => TestResultContainer | undefined;

                                                                                                                                                      method getMaybeTestByName

                                                                                                                                                      getMaybeTestByName: (name: string) => TestResult | undefined;

                                                                                                                                                        method getTestByName

                                                                                                                                                        getTestByName: (name: string) => TestResult;

                                                                                                                                                          method reset

                                                                                                                                                          reset: () => void;

                                                                                                                                                            method writeAttachment

                                                                                                                                                            writeAttachment: (name: string, content: Buffer | string) => void;

                                                                                                                                                              method writeAttachmentFromPath

                                                                                                                                                              writeAttachmentFromPath: (targetFileName: string, sourceFilePath: any) => void;

                                                                                                                                                                method writeCategoriesDefinitions

                                                                                                                                                                writeCategoriesDefinitions: (categories: Category[]) => void;

                                                                                                                                                                  method writeEnvironmentInfo

                                                                                                                                                                  writeEnvironmentInfo: (envInfo?: Record<string, string | undefined>) => void;

                                                                                                                                                                    method writeGroup

                                                                                                                                                                    writeGroup: (result: TestResultContainer) => void;

                                                                                                                                                                      method writeResult

                                                                                                                                                                      writeResult: (result: TestResult) => void;

                                                                                                                                                                        Interfaces

                                                                                                                                                                        interface AllureConfig

                                                                                                                                                                        interface AllureConfig {}

                                                                                                                                                                          property resultsDir

                                                                                                                                                                          readonly resultsDir: string;

                                                                                                                                                                            property testMapper

                                                                                                                                                                            readonly testMapper?: (test: TestResult) => TestResult | null;

                                                                                                                                                                              property writer

                                                                                                                                                                              readonly writer?: AllureWriter;

                                                                                                                                                                                interface AllureResults

                                                                                                                                                                                interface AllureResults {}

                                                                                                                                                                                  property attachments

                                                                                                                                                                                  attachments: Record<string, Buffer | string>;

                                                                                                                                                                                    property groups

                                                                                                                                                                                    groups: TestResultContainer[];

                                                                                                                                                                                      property tests

                                                                                                                                                                                      tests: TestResult[];

                                                                                                                                                                                        interface Attachment

                                                                                                                                                                                        interface Attachment {}

                                                                                                                                                                                          property name

                                                                                                                                                                                          name: string;

                                                                                                                                                                                            property source

                                                                                                                                                                                            source: string;

                                                                                                                                                                                              property type

                                                                                                                                                                                              type: string;

                                                                                                                                                                                                interface AttachmentOptions

                                                                                                                                                                                                interface AttachmentOptions {}

                                                                                                                                                                                                  property contentType

                                                                                                                                                                                                  contentType: ContentType | string;

                                                                                                                                                                                                    property fileExtension

                                                                                                                                                                                                    fileExtension?: string;

                                                                                                                                                                                                      interface Category

                                                                                                                                                                                                      interface Category {}

                                                                                                                                                                                                        property description

                                                                                                                                                                                                        description?: string;

                                                                                                                                                                                                          property descriptionHtml

                                                                                                                                                                                                          descriptionHtml?: string;

                                                                                                                                                                                                            property flaky

                                                                                                                                                                                                            flaky?: boolean;

                                                                                                                                                                                                              property matchedStatuses

                                                                                                                                                                                                              matchedStatuses?: Status[];

                                                                                                                                                                                                                property messageRegex

                                                                                                                                                                                                                messageRegex?: string | RegExp;

                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                  name?: string;

                                                                                                                                                                                                                    property traceRegex

                                                                                                                                                                                                                    traceRegex?: string | RegExp;

                                                                                                                                                                                                                      interface ExecutorInfo

                                                                                                                                                                                                                      interface ExecutorInfo {}

                                                                                                                                                                                                                        property buildName

                                                                                                                                                                                                                        buildName?: string;

                                                                                                                                                                                                                          property buildOrder

                                                                                                                                                                                                                          buildOrder?: number;

                                                                                                                                                                                                                            property buildUrl

                                                                                                                                                                                                                            buildUrl?: string;

                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                              name?: string;

                                                                                                                                                                                                                                property reportName

                                                                                                                                                                                                                                reportName?: string;

                                                                                                                                                                                                                                  property reportUrl

                                                                                                                                                                                                                                  reportUrl?: string;

                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                    type?: string;

                                                                                                                                                                                                                                      property url

                                                                                                                                                                                                                                      url?: string;

                                                                                                                                                                                                                                        interface Label

                                                                                                                                                                                                                                        interface Label {}

                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                          name: LabelName | string;

                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                            value: string;
                                                                                                                                                                                                                                              interface Link {}

                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                name?: string;

                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                  type?: LinkType | string;

                                                                                                                                                                                                                                                    property url

                                                                                                                                                                                                                                                    url: string;

                                                                                                                                                                                                                                                      interface Parameter

                                                                                                                                                                                                                                                      interface Parameter {}

                                                                                                                                                                                                                                                        property excluded

                                                                                                                                                                                                                                                        excluded?: boolean;

                                                                                                                                                                                                                                                          property hidden

                                                                                                                                                                                                                                                          hidden?: boolean;

                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                              value: string;

                                                                                                                                                                                                                                                                interface StatusDetails

                                                                                                                                                                                                                                                                interface StatusDetails {}

                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                  message?: string;

                                                                                                                                                                                                                                                                    property trace

                                                                                                                                                                                                                                                                    trace?: string;

                                                                                                                                                                                                                                                                      interface StepInterface

                                                                                                                                                                                                                                                                      interface StepInterface {}

                                                                                                                                                                                                                                                                        method name

                                                                                                                                                                                                                                                                        name: (name: string) => void;

                                                                                                                                                                                                                                                                          method parameter

                                                                                                                                                                                                                                                                          parameter: (name: string, value: string) => void;

                                                                                                                                                                                                                                                                            interface TestResult

                                                                                                                                                                                                                                                                            interface TestResult extends ExecutableItem {}

                                                                                                                                                                                                                                                                              property fullName

                                                                                                                                                                                                                                                                              fullName?: string;

                                                                                                                                                                                                                                                                                property historyId

                                                                                                                                                                                                                                                                                historyId: string;

                                                                                                                                                                                                                                                                                  property labels

                                                                                                                                                                                                                                                                                  labels: Label[];
                                                                                                                                                                                                                                                                                    links: Link[];

                                                                                                                                                                                                                                                                                      property testCaseId

                                                                                                                                                                                                                                                                                      testCaseId?: string;

                                                                                                                                                                                                                                                                                        property uuid

                                                                                                                                                                                                                                                                                        uuid: string;

                                                                                                                                                                                                                                                                                          interface TestResultContainer

                                                                                                                                                                                                                                                                                          interface TestResultContainer {}

                                                                                                                                                                                                                                                                                            property afters

                                                                                                                                                                                                                                                                                            afters: FixtureResult[];

                                                                                                                                                                                                                                                                                              property befores

                                                                                                                                                                                                                                                                                              befores: FixtureResult[];

                                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                                children: string[];

                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                  name?: string;

                                                                                                                                                                                                                                                                                                    property uuid

                                                                                                                                                                                                                                                                                                    uuid: string;

                                                                                                                                                                                                                                                                                                      Enums

                                                                                                                                                                                                                                                                                                      enum ContentType

                                                                                                                                                                                                                                                                                                      enum ContentType {
                                                                                                                                                                                                                                                                                                      TEXT = 'text/plain',
                                                                                                                                                                                                                                                                                                      XML = 'application/xml',
                                                                                                                                                                                                                                                                                                      CSV = 'text/csv',
                                                                                                                                                                                                                                                                                                      TSV = 'text/tab-separated-values',
                                                                                                                                                                                                                                                                                                      CSS = 'text/css',
                                                                                                                                                                                                                                                                                                      URI = 'text/uri-list',
                                                                                                                                                                                                                                                                                                      SVG = 'image/svg+xml',
                                                                                                                                                                                                                                                                                                      PNG = 'image/png',
                                                                                                                                                                                                                                                                                                      JSON = 'application/json',
                                                                                                                                                                                                                                                                                                      WEBM = 'video/webm',
                                                                                                                                                                                                                                                                                                      JPEG = 'image/jpeg',
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        member CSS

                                                                                                                                                                                                                                                                                                        CSS = 'text/css'

                                                                                                                                                                                                                                                                                                          member CSV

                                                                                                                                                                                                                                                                                                          CSV = 'text/csv'

                                                                                                                                                                                                                                                                                                            member JPEG

                                                                                                                                                                                                                                                                                                            JPEG = 'image/jpeg'

                                                                                                                                                                                                                                                                                                              member JSON

                                                                                                                                                                                                                                                                                                              JSON = 'application/json'

                                                                                                                                                                                                                                                                                                                member PNG

                                                                                                                                                                                                                                                                                                                PNG = 'image/png'

                                                                                                                                                                                                                                                                                                                  member SVG

                                                                                                                                                                                                                                                                                                                  SVG = 'image/svg+xml'

                                                                                                                                                                                                                                                                                                                    member TEXT

                                                                                                                                                                                                                                                                                                                    TEXT = 'text/plain'

                                                                                                                                                                                                                                                                                                                      member TSV

                                                                                                                                                                                                                                                                                                                      TSV = 'text/tab-separated-values'

                                                                                                                                                                                                                                                                                                                        member URI

                                                                                                                                                                                                                                                                                                                        URI = 'text/uri-list'

                                                                                                                                                                                                                                                                                                                          member WEBM

                                                                                                                                                                                                                                                                                                                          WEBM = 'video/webm'

                                                                                                                                                                                                                                                                                                                            member XML

                                                                                                                                                                                                                                                                                                                            XML = 'application/xml'

                                                                                                                                                                                                                                                                                                                              enum LabelName

                                                                                                                                                                                                                                                                                                                              enum LabelName {
                                                                                                                                                                                                                                                                                                                              AS_ID = 'AS_ID',
                                                                                                                                                                                                                                                                                                                              SUITE = 'suite',
                                                                                                                                                                                                                                                                                                                              PARENT_SUITE = 'parentSuite',
                                                                                                                                                                                                                                                                                                                              SUB_SUITE = 'subSuite',
                                                                                                                                                                                                                                                                                                                              EPIC = 'epic',
                                                                                                                                                                                                                                                                                                                              FEATURE = 'feature',
                                                                                                                                                                                                                                                                                                                              STORY = 'story',
                                                                                                                                                                                                                                                                                                                              SEVERITY = 'severity',
                                                                                                                                                                                                                                                                                                                              TAG = 'tag',
                                                                                                                                                                                                                                                                                                                              OWNER = 'owner',
                                                                                                                                                                                                                                                                                                                              LEAD = 'lead',
                                                                                                                                                                                                                                                                                                                              HOST = 'host',
                                                                                                                                                                                                                                                                                                                              THREAD = 'thread',
                                                                                                                                                                                                                                                                                                                              TEST_METHOD = 'testMethod',
                                                                                                                                                                                                                                                                                                                              TEST_CLASS = 'testClass',
                                                                                                                                                                                                                                                                                                                              PACKAGE = 'package',
                                                                                                                                                                                                                                                                                                                              FRAMEWORK = 'framework',
                                                                                                                                                                                                                                                                                                                              LANGUAGE = 'language',
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                member AS_ID

                                                                                                                                                                                                                                                                                                                                AS_ID = 'AS_ID'

                                                                                                                                                                                                                                                                                                                                  member EPIC

                                                                                                                                                                                                                                                                                                                                  EPIC = 'epic'

                                                                                                                                                                                                                                                                                                                                    member FEATURE

                                                                                                                                                                                                                                                                                                                                    FEATURE = 'feature'

                                                                                                                                                                                                                                                                                                                                      member FRAMEWORK

                                                                                                                                                                                                                                                                                                                                      FRAMEWORK = 'framework'

                                                                                                                                                                                                                                                                                                                                        member HOST

                                                                                                                                                                                                                                                                                                                                        HOST = 'host'

                                                                                                                                                                                                                                                                                                                                          member LANGUAGE

                                                                                                                                                                                                                                                                                                                                          LANGUAGE = 'language'

                                                                                                                                                                                                                                                                                                                                            member LEAD

                                                                                                                                                                                                                                                                                                                                            LEAD = 'lead'

                                                                                                                                                                                                                                                                                                                                              member OWNER

                                                                                                                                                                                                                                                                                                                                              OWNER = 'owner'

                                                                                                                                                                                                                                                                                                                                                member PACKAGE

                                                                                                                                                                                                                                                                                                                                                PACKAGE = 'package'

                                                                                                                                                                                                                                                                                                                                                  member PARENT_SUITE

                                                                                                                                                                                                                                                                                                                                                  PARENT_SUITE = 'parentSuite'

                                                                                                                                                                                                                                                                                                                                                    member SEVERITY

                                                                                                                                                                                                                                                                                                                                                    SEVERITY = 'severity'

                                                                                                                                                                                                                                                                                                                                                      member STORY

                                                                                                                                                                                                                                                                                                                                                      STORY = 'story'

                                                                                                                                                                                                                                                                                                                                                        member SUB_SUITE

                                                                                                                                                                                                                                                                                                                                                        SUB_SUITE = 'subSuite'

                                                                                                                                                                                                                                                                                                                                                          member SUITE

                                                                                                                                                                                                                                                                                                                                                          SUITE = 'suite'

                                                                                                                                                                                                                                                                                                                                                            member TAG

                                                                                                                                                                                                                                                                                                                                                            TAG = 'tag'

                                                                                                                                                                                                                                                                                                                                                              member TEST_CLASS

                                                                                                                                                                                                                                                                                                                                                              TEST_CLASS = 'testClass'

                                                                                                                                                                                                                                                                                                                                                                member TEST_METHOD

                                                                                                                                                                                                                                                                                                                                                                TEST_METHOD = 'testMethod'

                                                                                                                                                                                                                                                                                                                                                                  member THREAD

                                                                                                                                                                                                                                                                                                                                                                  THREAD = 'thread'

                                                                                                                                                                                                                                                                                                                                                                    enum LinkType

                                                                                                                                                                                                                                                                                                                                                                    enum LinkType {
                                                                                                                                                                                                                                                                                                                                                                    ISSUE = 'issue',
                                                                                                                                                                                                                                                                                                                                                                    TMS = 'tms',
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      member ISSUE

                                                                                                                                                                                                                                                                                                                                                                      ISSUE = 'issue'

                                                                                                                                                                                                                                                                                                                                                                        member TMS

                                                                                                                                                                                                                                                                                                                                                                        TMS = 'tms'

                                                                                                                                                                                                                                                                                                                                                                          enum Severity

                                                                                                                                                                                                                                                                                                                                                                          enum Severity {
                                                                                                                                                                                                                                                                                                                                                                          BLOCKER = 'blocker',
                                                                                                                                                                                                                                                                                                                                                                          CRITICAL = 'critical',
                                                                                                                                                                                                                                                                                                                                                                          NORMAL = 'normal',
                                                                                                                                                                                                                                                                                                                                                                          MINOR = 'minor',
                                                                                                                                                                                                                                                                                                                                                                          TRIVIAL = 'trivial',
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            member BLOCKER

                                                                                                                                                                                                                                                                                                                                                                            BLOCKER = 'blocker'

                                                                                                                                                                                                                                                                                                                                                                              member CRITICAL

                                                                                                                                                                                                                                                                                                                                                                              CRITICAL = 'critical'

                                                                                                                                                                                                                                                                                                                                                                                member MINOR

                                                                                                                                                                                                                                                                                                                                                                                MINOR = 'minor'

                                                                                                                                                                                                                                                                                                                                                                                  member NORMAL

                                                                                                                                                                                                                                                                                                                                                                                  NORMAL = 'normal'

                                                                                                                                                                                                                                                                                                                                                                                    member TRIVIAL

                                                                                                                                                                                                                                                                                                                                                                                    TRIVIAL = 'trivial'

                                                                                                                                                                                                                                                                                                                                                                                      enum Stage

                                                                                                                                                                                                                                                                                                                                                                                      enum Stage {
                                                                                                                                                                                                                                                                                                                                                                                      SCHEDULED = 'scheduled',
                                                                                                                                                                                                                                                                                                                                                                                      RUNNING = 'running',
                                                                                                                                                                                                                                                                                                                                                                                      FINISHED = 'finished',
                                                                                                                                                                                                                                                                                                                                                                                      PENDING = 'pending',
                                                                                                                                                                                                                                                                                                                                                                                      INTERRUPTED = 'interrupted',
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        member FINISHED

                                                                                                                                                                                                                                                                                                                                                                                        FINISHED = 'finished'

                                                                                                                                                                                                                                                                                                                                                                                          member INTERRUPTED

                                                                                                                                                                                                                                                                                                                                                                                          INTERRUPTED = 'interrupted'

                                                                                                                                                                                                                                                                                                                                                                                            member PENDING

                                                                                                                                                                                                                                                                                                                                                                                            PENDING = 'pending'

                                                                                                                                                                                                                                                                                                                                                                                              member RUNNING

                                                                                                                                                                                                                                                                                                                                                                                              RUNNING = 'running'

                                                                                                                                                                                                                                                                                                                                                                                                member SCHEDULED

                                                                                                                                                                                                                                                                                                                                                                                                SCHEDULED = 'scheduled'

                                                                                                                                                                                                                                                                                                                                                                                                  enum Status

                                                                                                                                                                                                                                                                                                                                                                                                  enum Status {
                                                                                                                                                                                                                                                                                                                                                                                                  FAILED = 'failed',
                                                                                                                                                                                                                                                                                                                                                                                                  BROKEN = 'broken',
                                                                                                                                                                                                                                                                                                                                                                                                  PASSED = 'passed',
                                                                                                                                                                                                                                                                                                                                                                                                  SKIPPED = 'skipped',
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    member BROKEN

                                                                                                                                                                                                                                                                                                                                                                                                    BROKEN = 'broken'

                                                                                                                                                                                                                                                                                                                                                                                                      member FAILED

                                                                                                                                                                                                                                                                                                                                                                                                      FAILED = 'failed'

                                                                                                                                                                                                                                                                                                                                                                                                        member PASSED

                                                                                                                                                                                                                                                                                                                                                                                                        PASSED = 'passed'

                                                                                                                                                                                                                                                                                                                                                                                                          member SKIPPED

                                                                                                                                                                                                                                                                                                                                                                                                          SKIPPED = 'skipped'

                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                            type FixtureResult

                                                                                                                                                                                                                                                                                                                                                                                                            type FixtureResult = ExecutableItem;

                                                                                                                                                                                                                                                                                                                                                                                                              type StepResult

                                                                                                                                                                                                                                                                                                                                                                                                              type StepResult = ExecutableItem;

                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (10)

                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (6)

                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/allure-js-commons.

                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/allure-js-commons)
                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/allure-js-commons"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>