allure-js-commons

  • Version 2.0.0-beta.9
  • Published
  • 64.9 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) => any) => any;

                                              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 AllureConfig

                                                            class AllureConfig implements IAllureConfig {}

                                                              constructor

                                                              constructor(
                                                              resultsDir?: string,
                                                              testMapper?: (test: TestResult) => TestResult | null,
                                                              writer?: IAllureWriter
                                                              );

                                                                property resultsDir

                                                                readonly resultsDir: string;

                                                                  property testMapper

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

                                                                    property writer

                                                                    readonly writer?: IAllureWriter;

                                                                      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: IAllureConfig);

                                                                                            method startGroup

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

                                                                                              method writeAttachment

                                                                                              writeAttachment: (
                                                                                              content: Buffer | string,
                                                                                              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;

                                                                                                                    method addLabel

                                                                                                                    addLabel: (name: string, value: string) => void;
                                                                                                                      addLink: (url: string, name?: string, type?: 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[]) => any) => (...args: any[]) => any;

                                                                                                                                          class InMemoryAllureWriter

                                                                                                                                          class InMemoryAllureWriter implements IAllureWriter {}

                                                                                                                                            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 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 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 IAllureConfig

                                                                                                                                                                                                                          interface IAllureConfig {}

                                                                                                                                                                                                                            property resultsDir

                                                                                                                                                                                                                            readonly resultsDir: string;

                                                                                                                                                                                                                              property testMapper

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

                                                                                                                                                                                                                                property writer

                                                                                                                                                                                                                                readonly writer?: IAllureWriter;

                                                                                                                                                                                                                                  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 (2)

                                                                                                                                                                                                                                                                                                                                                                                                          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>