Merge pull request #32 from taskworld/dtinth/allure-report-ansi

Author: dtinth

.circleci/config.yml

@@ -29,10 +29,10 @@ jobs:
           command: ALLURE_SUITE_NAME=prescript-examples yarn run test-examples
       - run:
           name: allure
+          when: always
           command: |
             mkdir -p /tmp/allure-report
-            sudo npm install -g allure-commandline
-            allure generate allure-results -o "/tmp/allure-report"
+            yarn allure generate allure-results -o "/tmp/allure-report"
       - store_artifacts:
           path: /tmp/allure-report
           prefix: allure-report

examples/regression/tests/Issue27.js

@@ -1,37 +1,56 @@
-const { action, pending } = require('../../..')
+const { action } = require('../../..')
 const assert = require('assert')
+const expect = require('expect')
 const fs = require('fs')
 const glob = require('glob')
 const { execFileSync } = require('child_process')
 
-// To fix in later PR
-pending()
-
-action('Run test (it should fail)', async () => {
-  let failed = false
+action('Clean the results directory', async () => {
   execFileSync('rm', ['-rf', 'tmp/issue27-allure-results'])
-  try {
-    execFileSync(
-      './bin/prescript',
-      [require.resolve('../fixtures/Issue27-AnsiColorTestFixture.js')],
-      {
-        env: {
-          ...process.env,
-          ALLURE_RESULTS_DIR: 'tmp/issue27-allure-results',
-          ALLURE_SUITE_NAME: 'prescript-regression-issue27',
-          FORCE_COLOR: '1'
+})
+
+for (let i = 1; i <= 3; i++) {
+  action('Run test (it should fail)', async () => {
+    let failed = false
+    try {
+      execFileSync(
+        './bin/prescript',
+        [require.resolve('../fixtures/Issue27-AnsiColorTestFixture.js')],
+        {
+          env: {
+            ...process.env,
+            ALLURE_RESULTS_DIR: 'tmp/issue27-allure-results',
+            ALLURE_SUITE_NAME: 'prescript-regression-issue27',
+            FORCE_COLOR: '1'
+          }
         }
-      }
-    )
-  } catch (error) {
-    failed = true
-  }
-  assert(failed, 'Expected prescript command to fail')
+      )
+    } catch (error) {
+      failed = true
+    }
+    assert(failed, 'Expected prescript command to fail')
+  })
+}
+
+action('Verify that there are JSON allure results generated', async () => {
+  const files = glob.sync('*.json', { cwd: 'tmp/issue27-allure-results' })
+  assert(files.length > 0, 'Expected to find JSON files')
 })
 
-action('Verify that there is an XML allure result generated', async () => {
-  const files = glob.sync('*.xml', { cwd: 'tmp/issue27-allure-results' })
-  assert(files.length > 0, 'Expected to file XML files')
+action('Verify the test results JSON have consistent historyId', async () => {
+  const files = glob.sync('*-result.json', {
+    cwd: 'tmp/issue27-allure-results'
+  })
+  const historyIds = Array.from(
+    new Set(
+      files.map(
+        f =>
+          JSON.parse(fs.readFileSync(`tmp/issue27-allure-results/${f}`, 'utf8'))
+            .historyId
+      )
+    )
+  )
+  expect(historyIds).toHaveLength(1)
 })
 
 action('Generate an allure-report', async () => {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "prescript",
-  "version": "0.5555555.0-1",
+  "version": "0.5555555.0-55",
   "description": "Object-oriented acceptance test tool",
   "main": "./lib/singletonApi.js",
   "typings": "./lib/singletonApi.d.ts",
@@ -13,7 +13,7 @@
   ],
   "dependencies": {
     "@types/cosmiconfig": "^5.0.3",
-    "allure-js-commons": "^1.2.1",
+    "allure-js-commons": "^2.0.0-beta.7",
     "chalk": "^2.4.1",
     "co": "^4.6.0",
     "cosmiconfig": "^5.0.7",
@@ -30,8 +30,8 @@
     "@types/jest": "^22.2.3",
     "@types/ms": "^0.7.30",
     "@types/node": "^10.0.0",
-    "allure-commandline": "^2.13.0",
     "@typescript-eslint/parser": "^2.2.0",
+    "allure-commandline": "^2.13.0",
     "eslint": "^6.3.0",
     "eslint-config-prettier": "^6.2.0",
     "eslint-plugin-prettier": "^3.1.0",

src/cli.ts

@@ -357,11 +357,12 @@ async function runNext(
       })
     },
     attach: (name, buffer, mimeType) => {
-      const allure = singletonAllureInstance.currentInstance
       const buf = Buffer.from(buffer)
-      if (allure) {
-        allure.addAttachment(name, buf, mimeType)
-      }
+      singletonAllureInstance.currentReportingInterface.addAttachment(
+        name,
+        buf,
+        mimeType
+      )
       context.log(
         'Attachment added: "%s" (%s, %s bytes)',
         name,
@@ -425,24 +426,21 @@ async function runNext(
         chalk.dim('* ') + chalk.cyan(indentString(item.text, 2).substr(2))
       console.log(indentString(logText, indent))
     }
-    const allure = singletonAllureInstance.currentInstance
-    if (allure) {
-      if (log.length > 0) {
-        const logText = log
-          .map(item => {
-            const prefix = `[${new Date(item.timestamp).toJSON()}] `
-            return (
-              prefix +
-              indentString(item.text, prefix.length).substr(prefix.length)
-            )
-          })
-          .join('\n')
-        allure.addAttachment(
-          'Action log',
-          Buffer.from(logText, 'utf8'),
-          'text/plain'
-        )
-      }
+    if (log.length > 0) {
+      const logText = log
+        .map(item => {
+          const prefix = `[${new Date(item.timestamp).toJSON()}] `
+          return (
+            prefix +
+            indentString(item.text, prefix.length).substr(prefix.length)
+          )
+        })
+        .join('\n')
+      singletonAllureInstance.currentReportingInterface.addAttachment(
+        'Action log',
+        Buffer.from(logText, 'utf8'),
+        'text/plain'
+      )
     }
   }
 }

src/createReporter.ts

@@ -1,5 +1,18 @@
 import path from 'path'
+import { createHash } from 'crypto'
 import singletonAllureInstance from './singletonAllureInstance'
+import {
+  AllureRuntime,
+  IAllureConfig,
+  ExecutableItemWrapper,
+  AllureTest,
+  AllureStep,
+  Stage,
+  Status,
+  LabelName
+} from 'allure-js-commons'
+import { hostname } from 'os'
+import { AllureWriter } from 'allure-js-commons/dist/src/writers'
 
 export default function createReporter(testModulePath, rootStepName) {
   if (
@@ -9,6 +22,7 @@ export default function createReporter(testModulePath, rootStepName) {
   ) {
     return { onFinish(errors: Error[]) {}, iterationListener: {} }
   }
+
   const suiteName = process.env.ALLURE_SUITE_NAME || 'prescript'
   const getDefaultCaseName = () => {
     const testPath = path.relative(process.cwd(), testModulePath)
@@ -17,35 +31,121 @@ export default function createReporter(testModulePath, rootStepName) {
     return `${testPath}${testName ? ` - ${testName}` : ''}`
   }
   const caseName = process.env.ALLURE_CASE_NAME || getDefaultCaseName()
-  const Allure = require('allure-js-commons')
-  const allure = new Allure()
-  if (process.env.ALLURE_RESULTS_DIR) {
-    allure.options.targetDir = process.env.ALLURE_RESULTS_DIR
-  }
-  allure.startSuite(suiteName)
-  allure.startCase(caseName)
-  singletonAllureInstance.currentInstance = allure
+  const historyId = createHash('md5')
+    .update([suiteName, caseName].join(' / '))
+    .digest('hex')
+
+  const allureConfig: IAllureConfig = {
+    resultsDir: process.env.ALLURE_RESULTS_DIR || 'allure-results'
+  }
+  const writer = new AllureWriter(allureConfig)
+  const runtime = new AllureRuntime({ ...allureConfig, writer })
+  const group = runtime.startGroup(suiteName)
+  const test = group.startTest(caseName)
+  const prescriptVersion = require('../package').version
+  test.historyId = historyId
+  test.addLabel(LabelName.THREAD, `${process.pid}`)
+  test.addLabel(LabelName.HOST, `${hostname()}`)
+  test.addLabel(LabelName.FRAMEWORK, `prescript@${prescriptVersion}`)
+  let stack: IStepStack = new TestStepStack(test)
+  singletonAllureInstance.currentReportingInterface = {
+    addAttachment: (name, buf, mimeType) => {
+      const sha = createHash('sha256')
+        .update(buf)
+        .digest('hex')
+      const fileName = sha + path.extname(name)
+      writer.writeAttachment(fileName, buf)
+      stack.getExecutableItem().addAttachment(name, mimeType as any, fileName)
+    }
+  }
   return {
     iterationListener: {
       onEnter(node) {
-        if (node.number) allure.startStep(String(node.name), Date.now())
+        if (!node.number) {
+          return
+        }
+        stack = stack.push(String(node.name))
       },
       onExit(node, error) {
-        if (node.number) allure.endStep(error ? 'failed' : 'passed', Date.now())
+        if (!node.number) {
+          return
+        }
+        stack = stack.pop(error)
       }
     },
     onFinish(errors: Error[]) {
-      if (errors.length) {
-        const error = errors[0]
-        if ((error as any).__prescriptPending) {
-          allure.endCase('pending')
-        } else {
-          allure.endCase('failed', error)
-        }
-      } else {
-        allure.endCase('passed')
-      }
-      allure.endSuite()
+      stack = stack.pop(errors[0])
+      group.endGroup()
     }
   }
 }
+
+type Outcome = Error | undefined
+
+interface IStepStack {
+  push: (stepName: string) => IStepStack
+  pop: (outcome: Outcome) => IStepStack
+  getExecutableItem: () => ExecutableItemWrapper
+}
+
+const saveOutcome = (
+  executableItem: ExecutableItemWrapper,
+  outcome: Outcome
+) => {
+  if (!outcome) {
+    executableItem.status = Status.PASSED
+    executableItem.stage = Stage.FINISHED
+    return
+  }
+  if ((outcome as any).__prescriptPending) {
+    executableItem.stage = Stage.FINISHED
+    executableItem.status = Status.SKIPPED
+    return
+  }
+  executableItem.stage = Stage.FINISHED
+  executableItem.status = Status.FAILED
+  executableItem.detailsMessage = outcome.message || ''
+  executableItem.detailsTrace = outcome.stack || ''
+}
+
+class NullStepStack implements IStepStack {
+  push(): never {
+    throw new Error('This should not happen: Allure stack is corrupted.')
+  }
+  pop(): never {
+    throw new Error('This should not happen: Allure stack is corrupted.')
+  }
+  getExecutableItem(): never {
+    throw new Error('This should not happen: Allure stack is corrupted.')
+  }
+}
+
+class TestStepStack implements IStepStack {
+  constructor(private test: AllureTest) {}
+  push(stepName: string) {
+    return new StepStepStack(this, this.test.startStep(stepName))
+  }
+  pop(outcome: Outcome) {
+    saveOutcome(this.test, outcome)
+    this.test.endTest()
+    return new NullStepStack()
+  }
+  getExecutableItem() {
+    return this.test
+  }
+}
+
+class StepStepStack implements IStepStack {
+  constructor(private parent: IStepStack, private step: AllureStep) {}
+  push(stepName: string) {
+    return new StepStepStack(this, this.step.startStep(stepName))
+  }
+  pop(outcome: Outcome) {
+    saveOutcome(this.step, outcome)
+    this.step.endStep()
+    return this.parent
+  }
+  getExecutableItem() {
+    return this.step
+  }
+}

src/singletonAllureInstance.ts

@@ -1,3 +1,11 @@
+class NullReportingInterface implements IReportingInterface {
+  addAttachment = () => null
+}
+
+export interface IReportingInterface {
+  addAttachment: (name: string, buf: Buffer, mimeType: string) => void
+}
+
 export default {
-  currentInstance: null as any
+  currentReportingInterface: new NullReportingInterface() as IReportingInterface
 }