wdio-rerun-service 1.7.7 → 1.7.8

package/.github/workflows/release.yml

@@ -0,0 +1,68 @@
+name: Manual NPM Publish
+
+on:
+  workflow_dispatch:
+    inputs:
+      releaseType:
+        description: "Release type - major, minor or patch"
+        required: true
+        type: choice
+        default: "patch"
+        options:
+          - patch
+          - minor
+          - major
+      distTag:
+        description: 'NPM tag (e.g. use "next --preRelease=alpha --github.preRelease" to release a test version)'
+        required: true
+        default: 'latest'
+      preRelease:
+        description: If latest release was a pre-release (e.g. X.X.X-alpha.0) and you want to push another one, pick "yes"
+        required: true
+        type: choice
+        default: "no"
+        options:
+          - "yes"
+          - "no"
+
+env:
+  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: v7
+          fetch-depth: 0
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+      - name: NPM Setup
+        run: |
+          npm set registry "https://registry.npmjs.org/"
+          npm set //registry.npmjs.org/:_authToken $NPM_TOKEN
+          npm whoami
+      - name: Git Setup
+        run: |
+          git config --global user.email "bot@webdriver.io"
+          git config --global user.name "WebdriverIO Release Bot"
+      - name: Install Dependencies
+        run: npm ci --ignore-scripts
+      - name: Build Project
+        run: npm run build --if-present
+        env:
+          NODE_ENV: production
+      - name: Release
+        run: npx release-it ${{github.event.inputs.releaseType}} --github.release --ci --npm.skipChecks --no-git.requireCleanWorkingDir --npm.tag=${{github.event.inputs.distTag}}
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        if: ${{ github.event.inputs.preRelease == 'no' }}
+      - name: Pre-Release
+        run: npx release-it ${{github.event.inputs.releaseType}} --github.release --ci --npm.skipChecks --no-git.requireCleanWorkingDir --preRelease=alpha --github.preRelease --npm.tag=next
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        if: ${{ github.event.inputs.preRelease == 'yes' }}

package/.github/workflows/{node.js.yml → test.yml}

@@ -1,52 +1,56 @@
 # This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
 # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
 
-name: wdio-rerun-service CI
+name: Test
 
 on:
   push:
     branches:
-      - master
       - main
       - v7
       - lts
   pull_request:
     branches:
-      - master
       - main
       - v7
       - lts
+
+permissions:
+  contents: read # to fetch code (actions/checkout)
+
 jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [12.x, 13.x, 14.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+        node-version: [16.x, 18.x]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v3
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm ci
-    - run: npm install -g eslint
+    - run: npm i -g npm@latest
+    - run: npm ci --ignore-scripts
     - run: npm run build --if-present
-    - run: npm run test
-    
+    - run: npm test
+      env:
+        CI: true
+
   build-windows:
     runs-on: windows-latest
     strategy:
       matrix:
-        node-version: [12.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+        node-version: [16.x]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v3
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm ci
-    - run: npm install -g eslint
+    - run: npm i -g npm@latest
+    - run: npm ci --ignore-scripts
     - run: npm run build --if-present
-    - run: npm run test
+    - run: npm test
+      env:
+        CI: true

package/.github/workflows/update.yml

@@ -0,0 +1,30 @@
+# this workflow merges requests from Dependabot if tests are passing
+name: Merge me!
+
+on:
+  workflow_run:
+    workflows:
+      - Test
+    types:
+      - completed
+
+jobs:
+  merge-me:
+    name: Merge me!
+    runs-on: ubuntu-latest
+    steps:
+      - name: Merge me!
+        if: ${{ github.event.workflow_run.conclusion == 'success' }}
+        uses: ridedott/merge-me-action@v2
+        with:
+          # Depending on branch prodtection rules, a manually populated
+          # `GITHUB_TOKEN_WORKAROUND` secret with permissions to push to
+          # a protected branch must be used.
+          #
+          # When using a custom token, it is recommended to leave the following
+          # comment for other developers to be aware of the reasoning behind it:
+          #
+          # This must be used as GitHub Actions token does not support pushing
+          # to protected branches.
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PRESET: DEPENDABOT_MINOR

package/CHANGELOG.md

@@ -11,6 +11,17 @@
 
 _Note: Gaps between patch versions are faulty, broken or test releases._
 
+## v1.7.8 (2023-01-18)
+#### :bug: Bug Fix
+* Service release; no new features/fixes
+
+## v1.7.7 (2023-01-18)
+#### :bug: Bug Fix
+* [[#53]](https://github.com/webdriverio-community/wdio-rerun-service/pull/53) Generate failure line number at Example data line rather than the Scenario Outline line ([@wenzhhu](https://github.com/wenzhhu))
+
+#### Committers: 1
+- [@wenzhhu](https://github.com/wenzhhu)
+
 ---
 ## v1.7.6 (2022-09-13)
 #### :bug: Bug Fix

package/README.md

@@ -32,7 +32,7 @@ The easiest way is to add `wdio-rerun-service` to `devDependencies` in your `pac
 ```json
 {
     "devDependencies": {
-        "wdio-rerun-service": "^1.7.6"
+        "wdio-rerun-service": "^1.7.8"
     }
 }
 ```

package/build/index.js

@@ -1,7 +1,5 @@
 "use strict";
 
-require("source-map-support/register");
-
 const fs = require('fs');
 
 const path = require('path');
@@ -17,14 +15,16 @@ class RerunService {
     ignoredTags,
     rerunDataDir,
     rerunScriptPath,
-    commandPrefix
+    commandPrefix,
+    customParameters
   } = {}) {
     this.nonPassingItems = [];
     this.serviceWorkerId;
-    this.ignoredTags = ignoredTags ? ignoredTags : [];
-    this.rerunDataDir = rerunDataDir ? rerunDataDir : "./results/rerun";
-    this.rerunScriptPath = rerunScriptPath ? rerunScriptPath : "./rerun.sh";
-    this.commandPrefix = commandPrefix ? commandPrefix : "";
+    this.ignoredTags = ignoredTags || [];
+    this.rerunDataDir = rerunDataDir || "./results/rerun";
+    this.rerunScriptPath = rerunScriptPath || "./rerun.sh";
+    this.commandPrefix = commandPrefix || "";
+    this.customParameters = customParameters || "";
     this.specFile = "";
   }
 
@@ -53,20 +53,35 @@ class RerunService {
     }
   }
 
-  afterScenario(world) {
-    const status = world.result.status;
-    const scenarioLineNumber = world.gherkinDocument.feature.children.filter(child => {
+  afterScenario(world, result, context) {
+    const CUCUMBER_STATUS_MAP = ['UNKNOWN', 'PASSED', 'SKIPPED', 'PENDING', 'UNDEFINED', 'AMBIGUOUS', 'FAILED'];
+    const status = typeof world.result.status === 'number' ? CUCUMBER_STATUS_MAP[world.result.status || 0] : world.result.status;
+    const scenario = world.gherkinDocument.feature.children.filter(child => {
       if (child.scenario) {
         return child.scenario && world.pickle.astNodeIds.includes(child.scenario.id.toString());
       }
-    })[0].scenario.location.line;
+    })[0].scenario;
+    let scenarioLineNumber = scenario.location.line;
+
+    if (scenario.examples && scenario.examples.length > 0) {
+      let exampleLineNumber = 0;
+      scenario.examples.find(example => example.tableBody.find(row => {
+        if (row.id === world.pickle.astNodeIds[1]) {
+          exampleLineNumber = row.location.line;
+          return true;
+        } else {
+          return false;
+        }
+      }));
+      scenarioLineNumber = exampleLineNumber;
+    }
 
     if (browser.config.framework === 'cucumber' && status !== 'PASSED' && status !== 'SKIPPED') {
       const scenarioLocation = `${world.pickle.uri}:${scenarioLineNumber}`;
       const tagsList = world.pickle.tags.map(tag => tag.name);
       const service = this;
 
-      if (this.ignoredTags && tagsList.some(ignoredTag => service.ignoredTags.includes(ignoredTag))) {} else {
+      if (this.ignoredTags && !tagsList.some(ignoredTag => service.ignoredTags.includes(ignoredTag))) {
         this.nonPassingItems.push({
           location: scenarioLocation,
           failure: world.result.message
@@ -88,12 +103,7 @@ class RerunService {
       const rerunFiles = fs.readdirSync(directoryPath);
 
       if (rerunFiles.length > 0) {
-        let rerunCommand = `DISABLE_RERUN=true node_modules/.bin/wdio ${argv._[0]} `;
-
-        if (this.commandPrefix) {
-          rerunCommand = `${this.commandPrefix} ${rerunCommand}`;
-        }
-
+        let rerunCommand = `${this.commandPrefix} DISABLE_RERUN=true node_modules/.bin/wdio ${argv._[0]} ${this.customParameters} `;
         let failureLocations = [];
         rerunFiles.forEach(file => {
           const json = JSON.parse(fs.readFileSync(`${this.rerunDataDir}/${file}`));
@@ -113,5 +123,4 @@ class RerunService {
 }
 
 ;
-module.exports = RerunService;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["fs","require","path","v5","uuidv5","argv","process","slice","RerunService","constructor","ignoredTags","rerunDataDir","rerunScriptPath","commandPrefix","nonPassingItems","serviceWorkerId","specFile","before","capabilities","specs","mkdirSync","recursive","Date","now","afterTest","test","context","error","result","duration","passed","retries","browser","config","framework","message","push","location","failure","afterScenario","world","status","scenarioLineNumber","gherkinDocument","feature","children","filter","child","scenario","pickle","astNodeIds","includes","id","toString","line","scenarioLocation","uri","tagsList","tags","map","tag","name","service","some","ignoredTag","after","length","writeFileSync","JSON","stringify","onComplete","exitCode","results","directoryPath","join","cwd","existsSync","rerunFiles","readdirSync","rerunCommand","_","failureLocations","forEach","file","json","parse","readFileSync","replace","failureLocationsUnique","Set","failureLocation","module","exports"],"mappings":"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","sourcesContent":["const fs = require('fs');\nconst path = require('path');\nconst { v5: uuidv5 } = require('uuid');\n\nconst argv = require('minimist')(process.argv.slice(2));\n\nclass RerunService {\n\n    constructor({ ignoredTags, rerunDataDir, rerunScriptPath, commandPrefix } = {}) {\n        this.nonPassingItems = [];\n        this.serviceWorkerId;\n        this.ignoredTags = ignoredTags ? ignoredTags : [];\n        this.rerunDataDir = rerunDataDir ? rerunDataDir : \"./results/rerun\";\n        this.rerunScriptPath = rerunScriptPath ? rerunScriptPath : \"./rerun.sh\";\n        this.commandPrefix = commandPrefix ? commandPrefix : \"\";\n        this.specFile = \"\";\n    }\n\n    before(capabilities, specs) {\n        this.specFile = specs[0];\n        // console.log(`Re-run service is activated. Data directory: ${this.rerunDataDir}`);\n        fs.mkdirSync(this.rerunDataDir, { recursive: true });\n        // INFO: `namespace` below copied from: https://github.com/kelektiv/node-uuid/blob/master//lib/v35.js#L54:16\n        this.serviceWorkerId = uuidv5(`${Date.now()}`, '6ba7b810-9dad-11d1-80b4-00c04fd430c8');\n    }\n\n    afterTest(test, context, { error, result, duration, passed, retries }) {\n        if (browser.config.framework !== 'cucumber' && !passed) {\n            // console.log(`Re-run service is inspecting non-passing test.`);\n            // console.log(`Test location: ${this.specFile}`);\n            if (error && error.message) {\n                this.nonPassingItems.push({ location: this.specFile, failure: error.message });\n            } else {\n                // console.log(\"The non-passing test did not contain any error message, it could not be added for re-run.\")\n            }\n        }\n    }\n\n    // Executed after a Cucumber scenario ends.\n    afterScenario(world) {\n        const status = world.result.status;\n        const scenarioLineNumber = world.gherkinDocument.feature.children.filter((child) => {\n            if(child.scenario){\n                return child.scenario && world.pickle.astNodeIds.includes(child.scenario.id.toString());\n            }\n        })[0].scenario.location.line;\n\n        if (browser.config.framework === 'cucumber' && (status !== 'PASSED' && status !== 'SKIPPED')) {\n            // console.log(`Re-run service is inspecting non-passing scenario.`);\n            const scenarioLocation = `${world.pickle.uri}:${scenarioLineNumber}`;\n            // console.log(`Scenario location: ${scenarioLocation}`);\n            const tagsList = world.pickle.tags.map(tag => tag.name);\n            // console.log(`Scenario tags: ${tagsList}`);\n            const service = this;\n            if (this.ignoredTags && tagsList.some(ignoredTag => service.ignoredTags.includes(ignoredTag))) {\n                // console.log(`Re-run service will ignore the current scenario since it includes one of the ignored tags: ${this.ignoredTags}`);\n            } else {\n                this.nonPassingItems.push({ location: scenarioLocation, failure: world.result.message });\n            }\n        }\n    }\n\n    after(result, capabilities, specs) {\n        if (this.nonPassingItems.length > 0) {\n            fs.writeFileSync(`${this.rerunDataDir}/rerun-${this.serviceWorkerId}.json`, JSON.stringify(this.nonPassingItems));\n        } else {\n            // console.log('Re-run service did not detect any non-passing scenarios or tests.');\n        }\n    }\n\n    onComplete(exitCode, config, capabilities, results) {\n        const directoryPath = path.join(process.cwd(), `${this.rerunDataDir}`);\n        if (fs.existsSync(directoryPath)) {\n            const rerunFiles = fs.readdirSync(directoryPath);\n            if (rerunFiles.length > 0) {\n                let rerunCommand = `DISABLE_RERUN=true node_modules/.bin/wdio ${argv._[0]} `;\n                if (this.commandPrefix) {\n                    rerunCommand = `${this.commandPrefix} ${rerunCommand}`;\n                }\n                let failureLocations = [];\n                rerunFiles.forEach(file => {\n                    const json = JSON.parse(fs.readFileSync(`${this.rerunDataDir}/${file}`));\n                    json.forEach(failure => {\n                        failureLocations.push(failure.location.replace(/\\\\/g, \"/\"));\n                    });\n                });\n                const failureLocationsUnique = [...new Set(failureLocations)];\n                failureLocationsUnique.forEach(failureLocation => {\n                    rerunCommand += ` --spec=${failureLocation}`;\n                });\n                fs.writeFileSync(this.rerunScriptPath, rerunCommand);\n                // console.log(`Re-run script has been generated @ ${this.rerunScriptPath}`);\n            }\n        }\n    }\n};\n\nmodule.exports = RerunService;\n"]}
+module.exports = RerunService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdio-rerun-service",
-  "version": "1.7.7",
+  "version": "1.7.8",
   "description": "A WebdriverIO service to track and prepare for re-running failing or flaky Jasmine/Mocha tests or Cucumber Scenarios.",
   "author": "Mike Salvia <msalvia@jwplayer.com>",
   "homepage": "https://github.com/webdriverio-community/wdio-rerun-service",