testbeats 2.2.5 → 2.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.2.5",
+  "version": "2.2.7",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",

package/src/commands/publish.command.js

@@ -173,21 +173,40 @@ class PublishCommand {
         }
       }
       if (target.inputs) {
-        const inputs = target.inputs;
-        if (target.name === 'slack' || target.name === 'teams' || target.name === 'chat') {
-          if (!inputs.url) {
-            throw new Error(`missing url in ${target.name} target inputs`);
-          }
-          if (typeof inputs.url !== 'string') {
-            throw new Error(`url in ${target.name} target inputs must be a string`);
-          }
-          if (!inputs.url.startsWith('http')) {
-            throw new Error(`url in ${target.name} target inputs must start with 'http' or 'https'`);
+        this.#validateURL(target);
+      }
+    }
+    logger.debug("Validating targets - Successful!")
+  }
+
+  #validateURL(target) {
+    const inputs = target.inputs;
+    if (target.name === 'slack' || target.name === 'teams' || target.name === 'chat') {
+      if (inputs.token) {
+        if (!Array.isArray(inputs.channels)) {
+          throw new Error(`channels in ${target.name} target inputs must be an array`);
+        }
+        if (!inputs.channels.length) {
+          throw new Error(`at least one channel must be defined in ${target.name} target inputs`);
+        }
+        for (const channel of inputs.channels) {
+          if (typeof channel !== 'string') {
+            throw new Error(`channel in ${target.name} target inputs must be a string`);
           }
         }
+        return;
+      }
+
+      if (!inputs.url) {
+        throw new Error(`missing url in ${target.name} target inputs`);
+      }
+      if (typeof inputs.url !== 'string') {
+        throw new Error(`url in ${target.name} target inputs must be a string`);
+      }
+      if (!inputs.url.startsWith('http')) {
+        throw new Error(`url in ${target.name} target inputs must start with 'http' or 'https'`);
       }
     }
-    logger.debug("Validating targets - Successful!")
   }
 
   #processResults() {

package/src/extensions/ai-failure-summary.extension.js

@@ -36,7 +36,7 @@ class AIFailureSummaryExtension extends BaseExtension {
      * @type {import('../beats/beats.types').IBeatExecutionMetric}
      */
     const execution_metrics = data.execution_metrics[0];
-    this.text = execution_metrics.failure_summary;
+    this.text = this.platform.code(execution_metrics.failure_summary);
   }
 }
 

package/src/extensions/base.extension.js

@@ -35,7 +35,7 @@ class BaseExtension {
     this.default_options = {};
 
     /**
-     * @type {import('../platforms').BasePlatform}
+     * @type {import('../platforms/base.platform').BasePlatform}
      */
     this.platform = getPlatform(this.target.name);
   }

package/src/helpers/constants.js

@@ -18,6 +18,7 @@ const TARGET = Object.freeze({
   CUSTOM: 'custom',
   DELAY: 'delay',
   INFLUX: 'influx',
+  HTTP: 'http',
 });
 
 const EXTENSION = Object.freeze({

package/src/index.d.ts

@@ -10,7 +10,7 @@ export interface ITarget {
   name: TargetName;
   enable?: string | boolean;
   condition?: Condition;
-  inputs?: SlackInputs | TeamsInputs | ChatInputs | GitHubInputs | CustomTargetInputs | InfluxDBTargetInputs;
+  inputs?: SlackInputs | TeamsInputs | ChatInputs | GitHubInputs | ICustomTargetInputs | InfluxDBTargetInputs;
   extensions?: IExtension[];
 }
 
@@ -234,6 +234,8 @@ export interface TargetInputs {
 
 export interface SlackInputs extends TargetInputs {
   message_format?: 'blocks' | 'attachments';
+  token?: string;
+  channels?: string[];
 }
 
 export interface TeamsInputs extends TargetInputs {
@@ -275,11 +277,19 @@ export interface CustomTargetFunctionContext {
 
 export type CustomTargetFunction = (ctx: CustomTargetFunctionContext) => void | Promise<void>;
 
-export interface CustomTargetInputs {
+export interface ICustomTargetInputs {
   load: string | CustomTargetFunction;
 }
 
+export interface IDelayTargetInputs {
+  seconds: number;
+}
 
+export interface IHttpTargetInputs {
+  url: string;
+  method: string;
+  headers: object;
+}
 
 export interface CustomResultOptions {
   type: string;
@@ -337,5 +347,9 @@ export type IExtensionDefaultOptions = {
   condition: Condition
 }
 
+export type ITargetDefaultOptions = {
+  condition: Condition
+}
+
 export function publish(options: PublishOptions): Promise<any>
 export function defineConfig(config: PublishConfig): PublishConfig

package/src/platforms/base.platform.js

@@ -31,6 +31,16 @@ class BasePlatform {
     return this.merge(items.map(item => `- ${item}`));
   }
 
+  /**
+   * @param {string} text
+   * @returns {string}
+   */
+  code(text) {
+    return text;
+  }
+
+
+
   /**
    *
    * @param {import('..').ITarget} target

package/src/platforms/index.js

@@ -3,6 +3,7 @@ const { SlackPlatform } = require('./slack.platform');
 const { TeamsPlatform } = require('./teams.platform');
 const { ChatPlatform } = require('./chat.platform');
 const { GitHubPlatform } = require('./github.platform');
+const { BasePlatform } = require('./base.platform');
 
 /**
  *
@@ -19,7 +20,7 @@ function getPlatform(name) {
     case TARGET.GITHUB:
       return new GitHubPlatform();
     default:
-      throw new Error('Invalid Platform');
+      return new BasePlatform();
   }
 }
 

package/src/platforms/slack.platform.js

@@ -19,6 +19,13 @@ class SlackPlatform extends BasePlatform {
     }
     return this.merge(items.map(item => `• ${item}`));
   }
+
+  code(text) {
+    if (text) {
+      return `\`\`\`${text}\`\`\``;
+    }
+    return text;
+  }
 }
 
-module.exports = { SlackPlatform }
+module.exports = { SlackPlatform }

package/src/targets/base.target.js

@@ -0,0 +1,45 @@
+const { getPlatform } = require('../platforms');
+const { STATUS } = require('../helpers/constants');
+
+class BaseTarget {
+
+  constructor({ target }) {
+
+    /**
+     * @type {import('../index').ITarget}
+     */
+    this.target = target;
+
+    /**
+     * @type {string}
+     */
+    this.name = target.name;
+
+    /**
+     * @type {string | boolean}
+     */
+    this.enable = target.enable;
+
+    /**
+     * @type {import('../index').Condition}
+     */
+    this.condition = target.condition || STATUS.PASS_OR_FAIL;
+
+    /**
+     * @type {import('../index').IExtension[]}
+     */
+    this.extensions = target.extensions || [];
+
+    /**
+     * @type {import('../platforms/base.platform').BasePlatform}
+     */
+    this.platform = getPlatform(this.name);
+  }
+
+  async run({ result }) {
+    // throw new Error('Not implemented');
+  }
+
+}
+
+  module.exports = { BaseTarget};

package/src/targets/custom.target.js

@@ -0,0 +1,31 @@
+const { BaseTarget } = require('./base.target');
+const path = require('path');
+
+const DEFAULT_INPUTS = {};
+
+class CustomTarget extends BaseTarget {
+
+  constructor({ target }) {
+    super({ target });
+
+    /**
+     * @type {import('../index').ICustomTargetInputs}
+     */
+    this.inputs = Object.assign({}, DEFAULT_INPUTS, target.inputs);
+  }
+
+  async run({ result }) {
+    if (typeof this.inputs.load === 'string') {
+      const cwd = process.cwd();
+      const target_runner = require(path.join(cwd, this.inputs.load));
+      await target_runner.run({ target: this.target, result });
+    } else if (typeof this.inputs.load === 'function') {
+      await this.inputs.load({ target: this.target, result });
+    } else {
+      throw `Invalid 'load' input in custom target - ${this.inputs.load}`;
+    }
+  }
+
+}
+
+module.exports = { CustomTarget };

package/src/targets/delay.target.js

@@ -0,0 +1,24 @@
+const { BaseTarget } = require('./base.target');
+
+const DEFAULT_INPUTS = {
+  seconds: 5
+};
+
+class DelayTarget extends BaseTarget {
+
+  constructor({ target }) {
+    super({ target });
+
+    /**
+     * @type {import('../index').IDelayTargetInputs}
+     */
+    this.inputs = Object.assign({}, DEFAULT_INPUTS, target.inputs);
+  }
+
+  async run() {
+    await new Promise(resolve => setTimeout(resolve, this.inputs.seconds * 1000));
+  }
+
+}
+
+module.exports = { DelayTarget };

package/src/targets/http.target.js

@@ -0,0 +1,36 @@
+const { BaseTarget } = require('./base.target');
+const request = require('phin-retry');
+
+const DEFAULT_INPUTS = {
+  url: '',
+  method: 'POST',
+  headers: {}
+};
+
+class HttpTarget extends BaseTarget {
+
+  constructor({ target }) {
+    super({ target });
+
+    /**
+     * @type {import('../index').IHttpTargetInputs}
+     */
+    this.inputs = Object.assign({}, DEFAULT_INPUTS, target.inputs);
+  }
+
+  async run({ result }) {
+    const { url, method, headers } = this.inputs;
+    await request.__fetch({
+      url,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers
+      },
+      body: { result }
+    });
+  }
+
+}
+
+module.exports = { HttpTarget };

package/src/targets/index.js

@@ -2,8 +2,9 @@ const teams = require('./teams');
 const slack = require('./slack');
 const chat = require('./chat');
 const github = require('./github');
-const custom = require('./custom');
-const delay = require('./delay');
+const { CustomTarget } = require('./custom.target');
+const { DelayTarget } = require('./delay.target');
+const { HttpTarget } = require('./http.target');
 const influx = require('./influx');
 const { TARGET } = require('../helpers/constants');
 const { checkCondition } = require('../helpers/helper');
@@ -19,11 +20,13 @@ function getTargetRunner(target) {
     case TARGET.GITHUB:
       return github;
     case TARGET.CUSTOM:
-      return custom;
+      return new CustomTarget({ target });
     case TARGET.DELAY:
-      return delay;
+      return new DelayTarget({ target });
     case TARGET.INFLUX:
       return influx;
+    case TARGET.HTTP:
+      return new HttpTarget({ target });
     default:
       return require(target.name);
   }
@@ -31,8 +34,9 @@ function getTargetRunner(target) {
 
 async function run(target, result) {
   const target_runner = getTargetRunner(target);
-  const target_options = Object.assign({}, target_runner.default_options, target);
-  if (await checkCondition({ condition: target_options.condition, result, target })) {
+  // const target_options = Object.assign({}, target_runner.default_options, target);
+  const condition = target.condition ||  target_runner.default_options?.condition || target_runner.condition;
+  if (await checkCondition({ condition, result, target })) {
     await target_runner.run({result, target});
   }
 }

package/src/targets/slack.js

@@ -9,6 +9,8 @@ const { getValidMetrics, getMetricValuesText } = require('../helpers/performance
 const TestResult = require('test-results-parser/src/models/TestResult');
 const { getPlatform } = require('../platforms');
 
+const SLACK_BASE_URL = 'https://slack.com';
+
 const STATUSES = {
   GOOD: ':white_check_mark:',
   WARNING: ':warning:',
@@ -31,10 +33,7 @@ async function run({ result, target }) {
   }
   const message = getRootPayload({ result, target, payload });
   logger.info(`🔔 Publishing results to Slack...`);
-  return request.post({
-    url: target.inputs.url,
-    body: message
-  });
+  return publish({ inputs: target.inputs, message });
 }
 
 async function setFunctionalPayload({ result, target, payload }) {
@@ -325,6 +324,28 @@ async function handleErrors({ target, errors }) {
   });
 }
 
+async function publish({ inputs, message}) {
+  const { url, token, channels } = inputs;
+  if (token) {
+    for (let i = 0; i < channels.length; i++) {
+      message.channel = channels[i];
+      return request.post({
+        url: url ? url : `${SLACK_BASE_URL}/api/chat.postMessage`,
+        headers: {
+          'Authorization': `Bearer ${token}`
+        },
+        body: message
+      });
+    }
+
+  } else {
+    return request.post({
+      url,
+      body: message
+    });
+  }
+}
+
 module.exports = {
   run,
   handleErrors,

package/src/targets/custom.js

@@ -1,28 +0,0 @@
-const path = require('path');
-const { STATUS } = require('../helpers/constants');
-
-/**
- *
- * @param {object} param0
- * @param {import('../index').ITarget} param0.target
- */
-async function run({result, target}) {
-  if (typeof target.inputs.load === 'string') {
-    const cwd = process.cwd();
-    const target_runner = require(path.join(cwd, target.inputs.load));
-    await target_runner.run({ target, result });
-  } else if (typeof target.inputs.load === 'function') {
-    await target.inputs.load({ target, result });
-  } else {
-    throw `Invalid 'load' input in custom target - ${target.inputs.load}`;
-  }
-}
-
-const default_options = {
-  condition: STATUS.PASS_OR_FAIL
-}
-
-module.exports = {
-  run,
-  default_options
-}

package/src/targets/delay.js

@@ -1,19 +0,0 @@
-const { STATUS } = require("../helpers/constants");
-
-async function run({ target }) {
-  target.inputs = Object.assign({}, default_inputs, target.inputs);
-  await new Promise(resolve => setTimeout(resolve, target.inputs.seconds * 1000));
-}
-
-const default_options = {
-  condition: STATUS.PASS_OR_FAIL
-}
-
-const default_inputs = {
-  seconds: 5
-}
-
-module.exports = {
-  run,
-  default_options
-}