wdio-test-ledger-service 9.0.0

package/.github/workflows/release.yml

@@ -0,0 +1,47 @@
+name: Publish to NPM
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_type:
+        description: 'Release type'
+        required: true
+        type: 'choice'
+        default: 'patch'
+        options:
+          - 'patch'
+          - 'minor'
+          - 'major'
+env:
+  NPM_ACCESS_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: 'master'
+          fetch-depth: 0
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '20'
+
+      - name: NPM Setup
+        run: |
+          npm set registry "https://registry.npmjs.org/"
+          npm set //registry.npmjs.org/:_authToken $NPM_ACCESS_TOKEN
+          npm whoami
+
+      - name: Git Setup
+        run: |
+          git config --global user.email "wpbrock@gmail.com"
+          git config --global user.name "Test Reporter Service Release Bot"
+
+      - name: Install Dependencies
+        run: npm ci
+
+      - run: npm run release -- ${{ github.event.inputs.release_type }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_ACCESS_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}

package/README.md

@@ -0,0 +1,49 @@
+# WebdriverIO Test Reporter Service
+
+WDIO service that takes results from [wdio-test-reporter](https://github.com/WillBrock/wdio-test-reporter) and uploads them to [testreporter.io](https://testreporter.io)
+
+testreporter.io stores and tracks all test runs with extensive details about each test. This gives you a historical overivew of how your tests are running.
+
+Setup is very simple. All you need to do is add the service and reporter to the `services` and `reporters` arrays in your wdio.conf.js file.
+
+## Install the service
+
+```
+npm install wdio-test-reporter-service
+```
+
+## Add the service to the services array in wdio.conf.js
+
+```
+services: [['test-reporter', {
+	reporterOutputDir : `./testreporter`,          // This must match the outputDir from the wdio-test-reporter
+	apiUrl            : `app-api.testreporter.io`, // Defaults to app-api.testreporter.io if none is set
+	username          : `jenkins@foobar.com`,      // app.testreporter.io username
+	apiToken          : `12345`,                   // Found in the app.testreporter.io under your proifle section
+	projectId         : 123,                       // Only needed if using more than one project
+	appVersion        : `2.8.10`,                  // The code version can also be set here
+	enableFlaky       : 1,                         // Will mark tests as flaky if it detects them based on previous runs
+}]],
+```
+
+You will create a custom `username` and `apiToken` in the UI under Settings -> Profile -> API Keys
+
+## Add the wdio-test-reporter to the reporters array in wdio.conf.js
+
+```
+npm install wdio-test-reporter
+```
+
+```
+reporters : [[`test`, {
+	outputDir : `./testreporter`
+}]]
+```
+
+## Environment variables
+
+Environment variables can be set when running tests that the server will use to add to the results
+
+* `RUN_TITLE`    - Title of the test run. This might be something like a Jira issue key. Defaults to a timestamp if not specified
+* `RUN_UUID`     - UUID which can be used to directly link to the test run results. e.g. https://app.testreporter.io/runs/c26b23d8-eb9f-4ff4-a884-5cb9f3d3aba5<uuid>
+* `APP_VERSION`  - Set the version of app this test run ran against

package/RELEASE.md

@@ -0,0 +1 @@
+https://www.npmjs.com/package/np

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "wdio-test-ledger-service",
+  "version": "9.0.0",
+  "description": "WebdriverIO server to send reporter data to testledger.dev",
+  "type": "module",
+  "main": "src/index.js",
+  "engines": {
+    "node": "20.x"
+  },
+  "scripts": {
+    "release": "release-it --github.release"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WillBrock/wdio-test-ledger-service.git"
+  },
+  "keywords": [
+    "WebdriverIO",
+    "tests",
+    "test",
+    "e2e",
+    "wdio",
+    "testing",
+    "reporter",
+    "service"
+  ],
+  "author": "Will Brock",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/WillBrock/wdio-test-ledger-service/issues"
+  },
+  "homepage": "https://github.com/WillBrock/wdio-test-ledger-service#readme",
+  "dependencies": {
+    "btoa": "^1.2.1",
+    "fs-extra": "^11.2.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "release-it": "^17.0.1"
+  }
+}

package/src/index.js

@@ -0,0 +1,206 @@
+import fs   from 'fs-extra';
+import path from 'path';
+import btoa from 'btoa';
+import { SevereServiceError } from 'webdriverio';
+
+const api_url = `https://app-api.testreporter.io`;
+
+class TestReporterLauncher {
+	constructor(options) {
+		this.options = options;
+
+		if(!this.options.reporterOutputDir) {
+			throw new SevereServiceError(`No reporterOutputDir specified`)
+		}
+
+		if(!this.options.username) {
+			throw new SevereServiceError(`No username specified`)
+		}
+
+		if(!this.options.apiToken) {
+			throw new SevereServiceError(`No apiToken specified`)
+		}
+	}
+
+	onPrepare() {
+		fs.emptyDirSync(this.options.reporterOutputDir);
+
+		fs.writeFileSync(`${this.options.reporterOutputDir}/trio-onPrepare.txt`, `onPrepare called`, { encoding : `utf-8` });
+
+		this.start = new Date();
+	}
+
+	async onComplete(exit_code, config) {
+		const data = this.buildData(config);
+
+		try {
+			const tmp = await this.post(data);
+			fs.writeFileSync(`${this.options.reporterOutputDir}/trio-onComplete-post.txt`, `onComplete-post`, { encoding : `utf-8` });
+		}
+		catch(e) {
+			fs.writeFileSync(`${this.options.reporterOutputDir}/trio-post-error.txt`, e.message, { encoding : `utf-8` });
+		}
+	}
+
+	buildData(config) {
+		const directory  = path.resolve(this.options.reporterOutputDir);
+		const files      = fs.readdirSync(directory);
+		const suite_data = {};
+		const all_errors = {};
+		const all_hooks  = {};
+
+
+		fs.writeFileSync(`${this.options.reporterOutputDir}/trio-skip-passed.txt`, `Value of SKIP_PASSED_UPLOADS: ${process.env.SKIP_PASSED_UPLOADS}`, { encoding : `utf-8` });
+		fs.writeFileSync(`${this.options.reporterOutputDir}/trio-buildData.txt`, `Starting buildData`, { encoding : `utf-8` });
+
+		const data = {
+			project_id    : this.options.projectId,
+			uuid          : process.env.RUN_UUID,
+			// This is a way to group runs together, for example if you're using sharding
+			group_uuid    : process.env.GROUP_UUID,
+			main_run      : Number(process.env.MAIN_RUN),
+			title         : process.env.RUN_TITLE || this.start,
+			// Site the tests were ran on
+			site          : process.env.SITE,
+			build_url     : process.env.BUILD_URL,
+			run_date      : this.start.toISOString(),
+			duration      : new Date().getTime() - this.start.getTime(),
+			version       : process.env.APP_VERSION || process.env.CODE_VERSION || this.options.appVersion || `0.0.1`,
+			suites_ran    : config.suite ? config.suite.join(`, `)               : (config.multiRun || config.repeat ? `RepeatRun` : ``),
+			issue_user    : process.env.ISSUE_USER ?? null,
+			issue_summary : process.env.ISSUE_SUMMARY ?? null,
+			enable_flaky  : Number(process.env.ENABLE_FLAKY) || this.options.enableFlaky || 0,
+			passed        : 1,
+			failed        : 0,
+			suites        : [],
+		};
+
+		for(const file of files) {
+			if(!file.match(/test-reporter.log/)) {
+				continue;
+			}
+
+			let tmp = false;
+			try {
+				const filepath = `${directory}/${file}`;
+				tmp            = fs.readFileSync(filepath, { encoding : `utf8` });
+			}
+			catch(e) {
+				fs.writeFileSync(`${this.options.reporterOutputDir}/trio-readfile-error.txt`, e.message, { encoding : `utf-8` });
+			}
+
+			const identifier = file.match(/wdio-(\d+-\d+)-/)[1];
+
+			if(!tmp) {
+				continue;
+			}
+
+			const content   = JSON.parse(tmp);
+			const suite_key = btoa(`${identifier}:${content.spec_file}:${content.capabilities}:${content.title}`);
+
+			if(content.passed && Number(process.env.SKIP_PASSED_UPLOADS) === 1) {
+				continue;
+			}
+
+			suite_data[suite_key] = {
+				title        : content.title,
+				spec_file    : content.spec_file,
+				filepath     : content.filepath,
+				capabilities : content.capabilities,
+				duration     : content.duration,
+				retries      : content.retries || 0,
+				passed       : content.passed,
+				failed       : content.failed,
+				skipped      : content.skipped,
+				start        : content.start,
+				tests        : [],
+			};
+
+			for(const test of content.tests) {
+				const hook     = test.type === `hook`;
+				const test_key = btoa(`${identifier}:${content.spec_file}:${content.capabilities}:${content.title}:${test.title}`);
+
+				if(!all_errors[test_key]) {
+					all_errors[test_key] = [];
+				}
+
+				// This will make sure we have stored errors from the same test if it has retried
+				all_errors[test_key] = [...all_errors[test_key], ...test.errors];
+
+				const test_data = {
+					title    : test.title,
+					duration : test.duration,
+					passed   : test.passed,
+					retries  : test.retries,
+					failed   : test.failed,
+					skipped  : test.skipped,
+					errors   : all_errors[test_key],
+				};
+
+				suite_data[suite_key].tests.push(test_data);
+
+				if(hook && !all_hooks[suite_key]) {
+					all_hooks[suite_key] = [];
+				}
+
+				if(hook) {
+					all_hooks[suite_key].push(test_data)
+				}
+			}
+
+			if(all_hooks[suite_key]) {
+				suite_data[suite_key].tests = [...suite_data[suite_key].tests, ...all_hooks[suite_key]];
+			}
+		}
+
+		const suites = Object.values(suite_data);
+		for(const suite of suites) {
+			if(!suite.failed) {
+				continue;
+			}
+
+			data.failed = 1;
+			data.passed = 0;
+
+			break;
+		}
+
+		fs.writeFileSync(`${this.options.reporterOutputDir}/trio-end-buildData.txt`, `Ending buildData`, { encoding : `utf-8` });
+
+		data.suites = suites;
+
+		return data;
+	}
+
+	post(data) {
+		return fetch(this.getApiRoute(), {
+			method  : `POST`,
+			headers : {
+				'Content-Type'  : `application/json`,
+				'Authorization' : `Basic ${this.getAuthToken()}`,
+			},
+			body : JSON.stringify(data),
+		});
+	}
+
+	getApiUrl() {
+		return `https://${this.options.apiUrl?.replace(`https://`, ``) || api_url}`;
+	}
+
+	getApiRoute() {
+		return [
+			this.getApiUrl(),
+			`/runs`,
+		].join(``);
+	}
+
+	getAuthToken() {
+		return btoa([
+			this.options.username,
+			this.options.apiToken,
+		].join(`:`));
+	}
+}
+
+export default class TestReporterService {};
+export const launcher = TestReporterLauncher;