testbeats 2.0.0

package/src/index.d.ts

@@ -0,0 +1,243 @@
+import { PerformanceParseOptions } from 'performance-results-parser';
+import PerformanceTestResult from 'performance-results-parser/src/models/PerformanceTestResult';
+import { Schedule, User } from 'rosters';
+import { ParseOptions } from 'test-results-parser';
+import TestResult from 'test-results-parser/src/models/TestResult';
+
+export type ExtensionName = 'report-portal-analysis' | 'hyperlinks' | 'mentions' | 'report-portal-history' | 'quick-chart-test-summary' | 'metadata' | 'ci-info' | 'custom';
+export type Hook = 'start' | 'end' | 'after-summary';
+export type TargetName = 'slack' | 'teams' | 'chat' | 'custom' | 'delay';
+export type PublishReportType = 'test-summary' | 'test-summary-slim' | 'failure-details';
+
+export interface ConditionFunctionContext {
+  target: Target;
+  extension?: Extension,
+  result: TestResult;
+}
+export type ConditionFunction = (ctx: ConditionFunctionContext) => boolean | Promise<boolean>;
+export type Condition = 'pass' | 'fail' | 'passOrFail' | 'always' | 'never' | ConditionFunction;
+
+/**
+ * Extensions
+ */
+
+export interface ExtensionInputs {
+  title?: string;
+  title_link?: string;
+  separator?: boolean;
+}
+
+export interface ReportPortalAnalysisInputs extends ExtensionInputs {
+  url: string;
+  api_key: string;
+  project: string;
+  launch_id?: string;
+  launch_name?: string;
+}
+
+export interface ReportPortalHistoryInputs extends ExtensionInputs {
+  url: string;
+  api_key: string;
+  project: string;
+  launch_id?: string;
+  launch_name?: string;
+  history_depth?: number;
+  link_history_via?: string;
+}
+
+export interface QuickChartTestSummaryInputs {
+  url: string;
+}
+
+export interface MentionInputs extends ExtensionInputs {
+  users?: User[];
+  schedule?: Schedule;
+}
+
+export interface CIInfoInputs extends ExtensionInputs {
+  show_repository?: boolean;
+  show_repository_branch?: boolean;
+  show_build?: boolean;
+  data?: Metadata[];
+}
+
+export interface Extension {
+  name: ExtensionName;
+  condition?: Condition;
+  hook?: Hook;
+  inputs?: ReportPortalAnalysisInputs | ReportPortalHistoryInputs | HyperlinkInputs | MentionInputs | QuickChartTestSummaryInputs | PercyAnalysisInputs | CustomExtensionInputs | MetadataInputs | CIInfoInputs;
+}
+
+export interface PercyAnalysisInputs extends ExtensionInputs {
+  url?: string;
+  token?: string;
+  retries?: number;
+  build_id?: string;
+  project_id?: string;
+  project_name?: string;
+  organization_uid?: string;
+  title_link_to_build?: boolean;
+}
+
+export interface PercyAnalysisOutputs {
+  build?: object;
+  project?: object;
+}
+
+export interface PercyAnalysisExtension extends Extension {
+  inputs?: PercyAnalysisInputs;
+  outputs?: PercyAnalysisOutputs;
+}
+
+export interface CustomExtensionFunctionContext {
+  target: Target;
+  extension: Extension,
+  result: TestResult;
+  payload: any;
+  root_payload: any;
+}
+
+export type CustomExtensionFunction = (ctx: CustomExtensionFunctionContext) => void | Promise<void>;
+
+export interface CustomExtensionInputs extends ExtensionInputs {
+  load: string | CustomExtensionFunction;
+}
+
+export interface CustomExtension extends Extension {
+  inputs?: CustomExtensionInputs;
+  outputs?: any;
+}
+
+export interface LinkUrlFunctionContext {
+  target: Target;
+  extension: HyperlinksExtension,
+  result: TestResult;
+}
+
+export type LinkUrlFunction = (ctx: LinkUrlFunctionContext) => string | Promise<string>;
+
+export interface Link {
+  text: string;
+  url: string | LinkUrlFunction;
+  condition?: Condition;
+}
+
+export interface HyperlinkInputs extends ExtensionInputs {
+  links: Link[];
+}
+
+export interface HyperlinksExtension extends Extension {
+  inputs?: HyperlinkInputs;
+}
+
+export interface Metadata {
+  label?: string;
+  key?: string;
+  value: string;
+  type?: string;
+  condition?: Condition;
+}
+
+export interface MetadataInputs extends ExtensionInputs {
+  data?: Metadata[];
+}
+
+export interface MetadataExtension extends Extension {
+  inputs?: MetadataInputs;
+}
+
+/**
+ * Targets
+ */
+
+export interface MetricConfig {
+  name: string;
+  condition: Condition;
+  fields: string[];
+}
+
+export interface TargetInputs {
+  url: string;
+  title?: string;
+  title_suffix?: string;
+  title_link?: string;
+  duration?: string;
+  publish?: PublishReportType;
+  only_failures?: boolean;
+  max_suites?: number;
+  metrics?: MetricConfig[];
+}
+
+export interface SlackInputs extends TargetInputs { }
+
+export interface TeamsInputs extends TargetInputs {
+  width?: string;
+}
+
+export interface ChatInputs extends TargetInputs { }
+
+export interface InfluxDBTargetInputs {
+  url: string;
+  version?: string;
+  db: string;
+  username?: string;
+  password?: string;
+  org?: string;
+  bucket?: string;
+  precision?: string;
+  token?: string;
+  measurement_perf_run?: string;
+  measurement_perf_transaction?: string;
+  measurement_test_run?: string;
+  measurement_test_suite?: string;
+  measurement_test_case?: string;
+  tags?: object;
+  fields?: object;
+}
+
+export interface CustomTargetFunctionContext {
+  target: Target;
+  result: TestResult;
+}
+
+export type CustomTargetFunction = (ctx: CustomTargetFunctionContext) => void | Promise<void>;
+
+export interface CustomTargetInputs {
+  load: string | CustomTargetFunction;
+}
+
+export interface Target {
+  name: TargetName;
+  condition: Condition;
+  inputs: SlackInputs | TeamsInputs | ChatInputs | CustomTargetInputs | InfluxDBTargetInputs;
+  extensions?: Extension[];
+}
+
+export interface CustomResultOptions {
+  type: string;
+  result: TestResult | PerformanceTestResult;
+}
+
+export interface PublishReport {
+  api_key?: string;
+  project?: string;
+  run?: string;
+  targets?: Target[];
+  results?: ParseOptions[] | PerformanceParseOptions[] | CustomResultOptions[];
+}
+
+export interface PublishConfig {
+  api_key?: string;
+  project?: string;
+  run?: string;
+  targets?: Target[];
+  results?: ParseOptions[] | PerformanceParseOptions[] | CustomResultOptions[];
+  reports?: PublishReport[];
+}
+
+export interface PublishOptions {
+  config: string | PublishConfig;
+}
+
+export function publish(options: PublishOptions): Promise<any>
+export function defineConfig(config: PublishConfig): PublishConfig

package/src/index.js

@@ -0,0 +1,14 @@
+const cmd_publish = require('./commands/publish');
+
+function publish(options) {
+  return cmd_publish.run(options);
+}
+
+function defineConfig(config) {
+  return config
+}
+
+module.exports = {
+  publish,
+  defineConfig
+}

package/src/targets/chat.js

@@ -0,0 +1,242 @@
+const request = require('phin-retry');
+const { getTitleText, getResultText, truncate, getPrettyDuration } = require('../helpers/helper');
+const extension_manager = require('../extensions');
+const { HOOK, STATUS } = require('../helpers/constants');
+const PerformanceTestResult = require('performance-results-parser/src/models/PerformanceTestResult');
+const { getValidMetrics, getMetricValuesText } = require('../helpers/performance');
+
+async function run({ result, target }) {
+  setTargetInputs(target);
+  const root_payload = getRootPayload();
+  const payload = root_payload.cards[0];
+  if (result instanceof PerformanceTestResult) {
+    await setPerformancePayload({ result, target, payload, root_payload });
+  } else {
+    await setFunctionalPayload({ result, target, payload, root_payload });
+  }
+  return request.post({
+    url: target.inputs.url,
+    body: root_payload
+  });
+}
+
+async function setFunctionalPayload({ result, target, payload, root_payload }) {
+  await extension_manager.run({ result, target, payload, root_payload, hook: HOOK.START });
+  setMainBlock({ result, target, payload });
+  await extension_manager.run({ result, target, payload, root_payload, hook: HOOK.AFTER_SUMMARY });
+  setSuiteBlock({ result, target, payload });
+  await extension_manager.run({ result, target, payload, root_payload, hook: HOOK.END });
+}
+
+function setTargetInputs(target) {
+  target.inputs = Object.assign({}, default_inputs, target.inputs);
+  if (target.inputs.publish === 'test-summary-slim') {
+    target.inputs.include_suites = false;
+  }
+  if (target.inputs.publish === 'failure-details') {
+    target.inputs.include_failure_details = true;
+  }
+}
+
+function getRootPayload() {
+  return {
+    "cards": [
+      {
+        "sections": []
+      }
+    ]
+  };
+}
+
+function setMainBlock({ result, target, payload }) {
+  const title_text_with_emoji = getTitleTextWithEmoji({ result, target });
+  const result_text = getResultText({ result });
+  const duration_text = getPrettyDuration(result.duration, target.inputs.duration);
+
+  const text = `<b>${title_text_with_emoji}</b><br><br><b>Results</b>: ${result_text}<br><b>Duration</b>: ${duration_text}`;
+  payload.sections.push({
+    "widgets": [
+      {
+        "textParagraph": {
+          text
+        }
+      }
+    ]
+  });
+}
+
+function setSuiteBlock({ result, target, payload }) {
+  let suite_attachments_length = 0;
+  if (target.inputs.include_suites) {
+    let texts = [];
+    for (let i = 0; i < result.suites.length && suite_attachments_length < target.inputs.max_suites; i++) {
+      const suite = result.suites[i];
+      if (target.inputs.only_failures && suite.status !== 'FAIL') {
+        continue;
+      }
+      // if suites length eq to 1 then main block will include suite summary
+      if (result.suites.length > 1) {
+        texts.push(getSuiteSummary({ target, suite }));
+        suite_attachments_length += 1;
+      }
+      if (target.inputs.include_failure_details) {
+        texts.push(getFailureDetails(suite));
+      }
+    }
+    if (texts.length > 0) {
+      payload.sections.push({
+        "widgets": [
+          {
+            "textParagraph": {
+              "text": texts.join("<br><br>")
+            }
+          }
+        ]
+      });
+    }
+  }
+}
+
+function getSuiteSummary({ target, suite }) {
+  const emoji = suite.status === 'PASS' ? '✅' : '❌';
+  const suite_title = `${emoji} ${suite.name}`;
+  const result_text = getResultText({ result: suite });
+  const duration_text = getPrettyDuration(suite.duration, target.inputs.duration);
+  return `<b>${suite_title}</b><br><br><b>Results</b>: ${result_text}<br><b>Duration</b>: ${duration_text}`;
+}
+
+function getFailureDetails(suite) {
+  let text = '';
+  const cases = suite.cases;
+  for (let i = 0; i < cases.length; i++) {
+    const test_case = cases[i];
+    if (test_case.status === 'FAIL') {
+      text += `<b>Test</b>: ${test_case.name}<br><b>Error</b>: ${truncate(test_case.failure, 150)}<br><br>`;
+    }
+  }
+  return text;
+}
+
+function getTitleTextWithEmoji({ result, target }) {
+  const emoji = result.status === 'PASS' ? '✅' : '❌';
+  const title_text = getTitleText({ result, target });
+
+  let title_text_with_emoji = '';
+  if (target.inputs.include_suites === false) {
+    title_text_with_emoji = `${emoji} ${title_text}`;
+  } else if (result.suites && result.suites.length > 1 || result.transactions && result.transactions.length > 1) {
+    title_text_with_emoji = title_text;
+  } else {
+    title_text_with_emoji = `${emoji} ${title_text}`;
+  }
+  if (target.inputs.title_link) {
+    title_text_with_emoji = `<a href="${target.inputs.title_link}">${title_text_with_emoji}</a>`;
+  }
+  return title_text_with_emoji;
+}
+
+async function setPerformancePayload({ result, target, payload, root_payload }) {
+  await extension_manager.run({ result, target, payload, root_payload, hook: HOOK.START });
+  await setPerformanceMainBlock({ result, target, payload });
+  await extension_manager.run({ result, target, payload, root_payload, hook: HOOK.AFTER_SUMMARY });
+  await setTransactionBlock({ result, target, payload });
+  await extension_manager.run({ result, target, payload, root_payload, hook: HOOK.END });
+}
+
+/**
+ * 
+ * @param {object} param0
+ * @param {PerformanceTestResult} param0.result 
+ */
+async function setPerformanceMainBlock({ result, target, payload }) {
+  const title_text_with_emoji = getTitleTextWithEmoji({ result, target });
+  const result_text = getResultText({ result });
+  let text = `<b>${title_text_with_emoji}</b><br><br><b>Results</b>: ${result_text}<br>`;
+  const valid_metrics = await getValidMetrics({ metrics: result.metrics, target, result });
+  for (let i = 0; i < valid_metrics.length; i++) {
+    const metric = valid_metrics[i];
+    text += `<br><b>${metric.name}</b>: ${getMetricValuesText({ metric, target, result })}`;
+  }
+  payload.sections.push({
+    "widgets": [
+      {
+        "textParagraph": {
+          text
+        }
+      }
+    ]
+  });
+}
+
+/**
+ * 
+ * @param {object} param0
+ * @param {PerformanceTestResult} param0.result 
+ */
+async function setTransactionBlock({ result, target, payload }) {
+  if (target.inputs.include_suites) {
+    let texts = [];
+    for (let i = 0; i < result.transactions.length; i++) {
+      const transaction = result.transactions[i];
+      if (target.inputs.only_failures && transaction.status !== 'FAIL') {
+        continue;
+      }
+      // if transactions length eq to 1 then main block will include suite summary
+      if (result.transactions.length > 1) {
+        texts.push(await getTransactionSummary({ target, transaction,  }));
+      }
+    }
+    if (texts.length > 0) {
+      payload.sections.push({
+        "widgets": [
+          {
+            "textParagraph": {
+              "text": texts.join("<br><br>")
+            }
+          }
+        ]
+      });
+    }
+  }
+}
+
+async function getTransactionSummary({ target, transaction }) {
+  const emoji = transaction.status === 'PASS' ? '✅' : '❌';
+  const suite_title = `${emoji} ${transaction.name}`;
+  let text = `<b>${suite_title}</b><br>`;
+  const valid_metrics = await getValidMetrics({ metrics: transaction.metrics, target, result: transaction });
+  for (let i = 0; i < valid_metrics.length; i++) {
+    const metric = valid_metrics[i];
+    text += `<br><b>${metric.name}</b>: ${getMetricValuesText({ metric, target })}`;
+  }
+  return text;
+}
+
+
+const default_options = {
+  condition: STATUS.PASS_OR_FAIL
+};
+
+const default_inputs = {
+  publish: 'test-summary',
+  include_suites: true,
+  max_suites: 10,
+  only_failures: false,
+  include_failure_details: false,
+  duration: '',
+  metrics: [
+    {
+      "name": "Samples",
+    },
+    {
+      "name": "Duration",
+      "condition": "always",
+      "fields": ["avg", "p95"]
+    }
+  ]
+};
+
+module.exports = {
+  run,
+  default_options
+}

package/src/targets/custom.js

@@ -0,0 +1,28 @@
+const path = require('path');
+const { STATUS } = require('../helpers/constants');
+
+/**
+ * 
+ * @param {object} param0 
+ * @param {import('../index').Target} 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

@@ -0,0 +1,19 @@
+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
+}

package/src/targets/index.js

@@ -0,0 +1,39 @@
+const teams = require('./teams');
+const slack = require('./slack');
+const chat = require('./chat');
+const custom = require('./custom');
+const delay = require('./delay');
+const influx = require('./influx');
+const { TARGET } = require('../helpers/constants');
+const { checkCondition } = require('../helpers/helper');
+
+function getTargetRunner(target) {
+  switch (target.name) {
+    case TARGET.TEAMS:
+      return teams;
+    case TARGET.SLACK:
+      return slack;
+    case TARGET.CHAT:
+      return chat;
+    case TARGET.CUSTOM:
+      return custom;
+    case TARGET.DELAY:
+      return delay;
+    case TARGET.INFLUX:
+      return influx;
+    default:
+      return require(target.name);
+  }
+}
+
+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 })) {
+    await target_runner.run({result, target});
+  }
+}
+
+module.exports = {
+  run
+}