testbeats 2.0.0

package/src/helpers/ci.js

@@ -0,0 +1,62 @@
+const ENV = process.env;
+
+function getCIInformation() {
+  if (ENV.GITHUB_ACTIONS) {
+    return getGitHubActionsInformation();
+  }
+  if (ENV.JENKINS_URL) {
+    return getJenkinsInformation();
+  }
+  if (ENV.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI) {
+    return getAzureDevOpsInformation();
+  }
+}
+
+function getGitHubActionsInformation() {
+  return {
+    ci: 'GITHUB_ACTIONS',
+    git: 'GITHUB',
+    repository_url: ENV.GITHUB_SERVER_URL + '/' + ENV.GITHUB_REPOSITORY,
+    repository_name: ENV.GITHUB_REPOSITORY,
+    repository_ref: ENV.GITHUB_REF,
+    repository_commit_sha: ENV.GITHUB_SHA,
+    build_url: ENV.GITHUB_SERVER_URL + '/' + ENV.GITHUB_REPOSITORY + '/actions/runs/' + ENV.GITHUB_RUN_ID,
+    build_number: ENV.GITHUB_RUN_NUMBER,
+    build_name: ENV.GITHUB_WORKFLOW,
+    user: ENV.GITHUB_ACTOR,
+  }
+}
+
+function getAzureDevOpsInformation() {
+  return {
+    ci: 'AZURE_DEVOPS_PIPELINES',
+    git: 'AZURE_DEVOPS_REPOS',
+    repository_url: ENV.BUILD_REPOSITORY_URI,
+    repository_name: ENV.BUILD_REPOSITORY_NAME,
+    repository_ref: ENV.BUILD_SOURCEBRANCH,
+    repository_commit_sha: ENV.BUILD_SOURCEVERSION,
+    build_url: ENV.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI + ENV.SYSTEM_TEAMPROJECT + '/_build/results?buildId=' + ENV.BUILD_BUILDID,
+    build_number: ENV.BUILD_BUILDNUMBER,
+    build_name: ENV.BUILD_DEFINITIONNAME,
+    user: ENV.BUILD_REQUESTEDFOR
+  }
+}
+
+function getJenkinsInformation() {
+  return {
+    ci: 'JENKINS',
+    git: '',
+    repository_url: ENV.GIT_URL || ENV.GITHUB_URL || ENV.BITBUCKET_URL,
+    repository_name: ENV.JOB_NAME,
+    repository_ref: ENV.BRANCH || ENV.BRANCH_NAME,
+    repository_commit_sha: ENV.GIT_COMMIT || ENV.GIT_COMMIT_SHA || ENV.GITHUB_SHA || ENV.BITBUCKET_COMMIT,
+    build_url: ENV.BUILD_URL,
+    build_number: ENV.BUILD_NUMBER,
+    build_name: ENV.JOB_NAME,
+    user: ENV.USER || ENV.USERNAME
+  }
+}
+
+module.exports = {
+  getCIInformation
+}

package/src/helpers/constants.js

@@ -0,0 +1,45 @@
+const STATUS = Object.freeze({
+  PASS: 'pass',
+  FAIL: 'fail',
+  PASS_OR_FAIL: 'passOrfail'
+});
+
+const HOOK = Object.freeze({
+  START: 'start',
+  AFTER_SUMMARY: 'after-summary',
+  END: 'end',
+});
+
+const TARGET = Object.freeze({
+  SLACK: 'slack',
+  TEAMS: 'teams',
+  CHAT: 'chat',
+  CUSTOM: 'custom',
+  DELAY: 'delay',
+  INFLUX: 'influx',
+});
+
+const EXTENSION = Object.freeze({
+  HYPERLINKS: 'hyperlinks',
+  MENTIONS: 'mentions',
+  REPORT_PORTAL_ANALYSIS: 'report-portal-analysis',
+  REPORT_PORTAL_HISTORY: 'report-portal-history',
+  QUICK_CHART_TEST_SUMMARY: 'quick-chart-test-summary',
+  PERCY_ANALYSIS: 'percy-analysis',
+  CUSTOM: 'custom',
+  METADATA: 'metadata',
+  CI_INFO: 'ci-info',
+});
+
+const URLS = Object.freeze({
+  PERCY: 'https://percy.io',
+  QUICK_CHART: 'https://quickchart.io'
+});
+
+module.exports = Object.freeze({
+  STATUS,
+  HOOK,
+  TARGET,
+  EXTENSION,
+  URLS
+});

package/src/helpers/extension.helper.js

@@ -0,0 +1,107 @@
+/**
+ * Add Slack Extension function.
+ *
+ * @param {object} param0 - the payload object
+ * @param {object} param0.payload - the payload object
+ * @param {import("..").Extension} param0.extension - the extension to add
+ * @param {string} param0.text - the text to include
+ * @return {void} 
+ */
+function addSlackExtension({ payload, extension, text }) {
+  if (extension.inputs.separator) {
+    payload.blocks.push({
+      "type": "divider"
+    });
+  }
+  let updated_text = text;
+  if (extension.inputs.title) {
+    const title = extension.inputs.title_link ? `<${extension.inputs.title_link}|${extension.inputs.title}>` : extension.inputs.title;
+    updated_text = `*${title}*\n\n${text}`;
+  }
+  if (extension.inputs.block_type === 'context') {
+    payload.blocks.push({
+      "type": "context",
+      "elements": [
+        {
+          "type": "mrkdwn",
+          "text": updated_text
+        }
+      ]
+    });
+  } else {
+    payload.blocks.push({
+      "type": "section",
+      "text": {
+        "type": "mrkdwn",
+        "text": updated_text
+      }
+    });
+  }
+}
+
+/**
+ * Add Teams Extension function.
+ *
+ * @param {object} param0 - the payload object
+ * @param {object} param0.payload - the payload object
+ * @param {import("..").Extension} param0.extension - the extension to add
+ * @param {string} param0.text - the text to include
+ * @return {void} 
+ */
+function addTeamsExtension({ payload, extension, text }) {
+  if (extension.inputs.title) {
+    const title = extension.inputs.title_link ? `[${extension.inputs.title}](${extension.inputs.title_link})` : extension.inputs.title
+    payload.body.push({
+      "type": "TextBlock",
+      "text": title,
+      "isSubtle": true,
+      "weight": "bolder",
+      "separator": extension.inputs.separator,
+      "wrap": true
+    });
+    payload.body.push({
+      "type": "TextBlock",
+      "text": text,
+      "wrap": true
+    });
+  } else {
+    payload.body.push({
+      "type": "TextBlock",
+      "text": text,
+      "wrap": true,
+      "separator": extension.inputs.separator
+    });
+  }
+}
+
+/**
+ * Add Chat Extension function.
+ *
+ * @param {object} param0 - the payload object
+ * @param {object} param0.payload - the payload object
+ * @param {import("..").Extension} param0.extension - the extension to add
+ * @param {string} param0.text - the text to include
+ * @return {void} 
+ */
+function addChatExtension({ payload, extension, text }) {
+  let updated_text = text;
+  if (extension.inputs.title) {
+    const title = extension.inputs.title_link ? `<a href="${extension.inputs.title_link}">${extension.inputs.title}</a>` : extension.inputs.title;
+    updated_text = `<b>${title}</b><br><br>${text}`;
+  }
+  payload.sections.push({
+    "widgets": [
+      {
+        "textParagraph": {
+          "text": updated_text
+        }
+      }
+    ]
+  });
+}
+
+module.exports = {
+  addSlackExtension,
+  addTeamsExtension,
+  addChatExtension
+}

package/src/helpers/helper.js

@@ -0,0 +1,102 @@
+const pretty_ms = require('pretty-ms');
+
+const DATA_REF_PATTERN = /(\{[^\}]+\})/g;
+const ALLOWED_CONDITIONS = new Set(['pass', 'fail', 'passorfail']);
+const GENERIC_CONDITIONS = new Set(['always', 'never']);
+
+function getPercentage(x, y) {
+  if (y > 0) {
+    return Math.floor((x / y) * 100);
+  }
+  return 0;
+}
+
+function processText(raw) {
+  const dataRefMatches = raw.match(DATA_REF_PATTERN);
+  if (dataRefMatches) {
+    const values = [];
+    for (let i = 0; i < dataRefMatches.length; i++) {
+      const dataRefMatch = dataRefMatches[i];
+      const content = dataRefMatch.slice(1, -1);
+      if (process.env[content]) {
+        values.push(process.env[content]);
+      } else {
+        values.push(content);
+      }
+    }
+    for (let i = 0; i < dataRefMatches.length; i++) {
+      raw = raw.replace(dataRefMatches[i], values[i]);
+    }
+  }
+  return raw;
+}
+
+/** 
+ * @returns {import('../index').PublishConfig }
+ */
+function processData(data) {
+  if (typeof data === 'string') {
+    return processText(data);
+  }
+  if (typeof data === 'object') {
+    for (const prop in data) {
+      data[prop] = processData(data[prop]);
+    }
+  }
+  return data;
+}
+
+function truncate(text, length) {
+  if (text && text.length > length) {
+    return text.slice(0, length) + "...";
+  } else {
+    return text;
+  }
+}
+
+function getPrettyDuration(ms, format) {
+  return pretty_ms(parseInt(ms), { [format]: true, secondsDecimalDigits: 0 })
+}
+
+function getTitleText({ result, target }) {
+  const title = target.inputs.title ? target.inputs.title : result.name;
+  if (target.inputs.title_suffix) {
+    return `${title} ${target.inputs.title_suffix}`;
+  }
+  return `${title}`;
+}
+
+function getResultText({ result }) {
+  const percentage = getPercentage(result.passed, result.total);
+  return `${result.passed} / ${result.total} Passed (${percentage}%)`;
+}
+
+/**
+ * 
+ * @param {object} param0
+ * @param {string | Function} param0.condition 
+ */
+async function checkCondition({ condition, result, target, extension }) {
+  if (typeof condition === 'function') {
+    return await condition({ target, result, extension });
+  } else {
+    const lower_condition = condition.toLowerCase();
+    if (ALLOWED_CONDITIONS.has(lower_condition)) {
+      return lower_condition.includes(result.status.toLowerCase());
+    } else if (GENERIC_CONDITIONS.has(lower_condition)) {
+      return lower_condition === 'always';
+    } else {
+      return eval(condition);
+    }
+  }
+}
+
+module.exports = {
+  getPercentage,
+  processData,
+  truncate,
+  getPrettyDuration,
+  getTitleText,
+  getResultText,
+  checkCondition,
+}

package/src/helpers/metadata.helper.js

@@ -0,0 +1,115 @@
+const { checkCondition } = require('./helper')
+
+/**
+ * Asynchronously generates metadata text for slack.
+ *
+ * @param {object} param0 - the payload object
+ * @param {Object} param0.elements - The elements to generate metadata text from
+ * @param {import('..').Target} param0.target - The result object
+ * @param {import('..').Extension} param0.extension - The result object
+ * @param {Object} param0.result - The result object
+ * @param {string} param0.default_condition - The default condition object
+ * @return {string} The generated metadata text
+ */
+async function getSlackMetaDataText({ elements, target, extension, result, default_condition }) {
+  const items = [];
+  for (const element of elements) {
+    if (await is_valid({ element, result, default_condition })) {
+      if (element.type === 'hyperlink') {
+        const url = await get_url({ url: element.value, target, result, extension });
+        if (element.label) {
+          items.push(`*${element.label}:* <${url}|${element.key}>`);
+        } else {
+          items.push(`<${url}|${element.key}>`);
+        }
+      } else if (element.key) {
+        items.push(`*${element.key}:* ${element.value}`);
+      } else {
+        items.push(element.value);
+      }
+    }
+  }
+  return items.join(' ｜ ');
+}
+
+/**
+ * Asynchronously generates metadata text for teams.
+ *
+ * @param {object} param0 - the payload object
+ * @param {Object} param0.elements - The elements to generate metadata text from
+ * @param {import('..').Target} param0.target - The result object
+ * @param {import('..').Extension} param0.extension - The result object
+ * @param {Object} param0.result - The result object
+ * @param {string} param0.default_condition - The default condition object
+ * @return {string} The generated metadata text
+ */
+async function getTeamsMetaDataText({ elements, target, extension, result, default_condition }) {
+  const items = [];
+  for (const element of elements) {
+    if (await is_valid({ element, result, default_condition })) {
+      if (element.type === 'hyperlink') {
+        const url = await get_url({ url: element.value, target, result, extension });
+        if (element.label) {
+          items.push(`**${element.label}:** [${element.key}](${url})`);
+        } else {
+          items.push(`[${element.key}](${url})`);
+        }
+      } else if (element.key) {
+        items.push(`**${element.key}:** ${element.value}`);
+      } else {
+        items.push(element.value);
+      }
+    }
+  }
+  return items.join(' ｜ ');
+}
+
+/**
+ * Asynchronously generates metadata text for chat.
+ *
+ * @param {object} param0 - the payload object
+ * @param {Object} param0.elements - The elements to generate metadata text from
+ * @param {import('..').Target} param0.target - The result object
+ * @param {import('..').Extension} param0.extension - The result object
+ * @param {Object} param0.result - The result object
+ * @param {string} param0.default_condition - The default condition object
+ * @return {string} The generated metadata text
+ */
+async function getChatMetaDataText({ elements, target, extension, result, default_condition }) {
+  const items = [];
+  for (const element of elements) {
+    if (await is_valid({ element, result, default_condition })) {
+      if (element.type === 'hyperlink') {
+        const url = await get_url({ url: element.value, target, result, extension });
+        if (element.label) {
+          items.push(`<b>${element.label}:</b> <a href="${url}">${element.key}</a>`);
+        } else {
+          items.push(`<a href="${url}">${element.key}</a>`);
+        }
+      } else if (element.key) {
+        items.push(`<b>${element.key}:</b> ${element.value}`);
+      } else {
+        items.push(element.value);
+      }
+    }
+  }
+  return items.join(' ｜ ');
+}
+
+function is_valid({ element, result, default_condition }) {
+  const condition = element.condition || default_condition;
+  return checkCondition({ condition, result });
+}
+
+function get_url({ url, target, extension, result}) {
+  if (typeof url === 'function') {
+    return url({target, extension, result});
+  }
+  return url;
+}
+
+module.exports = {
+  getSlackMetaDataText,
+  getTeamsMetaDataText,
+  getChatMetaDataText
+}

package/src/helpers/percy.js

@@ -0,0 +1,60 @@
+const request = require('phin-retry');
+
+/**
+ * @param {import('../index').PercyAnalysisInputs} inputs 
+ */
+async function getProjectByName(inputs) {
+  return request.get({
+    url: `${inputs.url}/api/v1/projects`,
+    headers: {
+      'Authorization': `Token ${inputs.token}`
+    },
+    form: {
+      'project_slug': inputs.project_name
+    }
+  });
+}
+
+/**
+ * @param {import('../index').PercyAnalysisInputs} inputs 
+ */
+async function getLastBuild(inputs) {
+  return request.get({
+    url: `${inputs.url}/api/v1/builds?project_id=${inputs.project_id}&page[limit]=1`,
+    headers: {
+      'Authorization': `Token ${inputs.token}`
+    }
+  });
+}
+
+/**
+ * @param {import('../index').PercyAnalysisInputs} inputs 
+ */
+ async function getBuild(inputs) {
+  return request.get({
+    url: `${inputs.url}/api/v1/builds/${inputs.build_id}`,
+    headers: {
+      'Authorization': `Token ${inputs.token}`
+    }
+  });
+}
+
+/**
+ * @param {import('../index').PercyAnalysisInputs} inputs 
+ */
+ async function getRemovedSnapshots(inputs) {
+  return request.get({
+    url: `${inputs.url}/api/v1/builds/${inputs.build_id}/removed-snapshots`,
+    headers: {
+      'Authorization': `Token ${inputs.token}`
+    }
+  });
+}
+
+
+module.exports = {
+  getProjectByName,
+  getLastBuild,
+  getBuild,
+  getRemovedSnapshots
+}

package/src/helpers/performance.js

@@ -0,0 +1,141 @@
+const Metric = require("performance-results-parser/src/models/Metric");
+const { checkCondition } = require("./helper");
+const pretty_ms = require('pretty-ms');
+
+/**
+ * @param {object} param0 
+ * @param {Metric[]} param0.metrics 
+ * @param {object} param0.result
+ * @param {object} param0.target  
+ */
+async function getValidMetrics({ metrics, result, target }) {
+  if (target.inputs.metrics && target.inputs.metrics.length > 0) {
+    const valid_metrics = [];
+    for (let i = 0; i < metrics.length; i++) {
+      const metric = metrics[i];
+      for (let j = 0; j < target.inputs.metrics.length; j++) {
+        const metric_config = target.inputs.metrics[j];
+        if (metric.name === metric_config.name) {
+          const include = await checkCondition({ condition: metric_config.condition || 'always', result, target });
+          if (include) valid_metrics.push(metric);
+        }
+      }
+    }
+    return valid_metrics;
+  }
+  return metrics;
+}
+
+/**
+ * @param {Metric} metric 
+ * @param {string[]} fields 
+ */
+function getCounterMetricFieldValue(metric, fields) {
+  let value = '';
+  if (fields.includes('sum')) {
+    const sum_failure = metric.failures.find(_failure => _failure.field === 'sum');
+    if (sum_failure) {
+      const emoji = getEmoji(sum_failure.difference);
+      value = `${emoji} ${metric['sum']} (${getDifferenceSymbol(sum_failure.difference)}${sum_failure.difference}) `
+    } else {
+      value = `${metric['sum']} `;
+    }
+  }
+  if (fields.includes('rate')) {
+    let metric_unit = metric.unit.startsWith('/') ? metric.unit : ` ${metric.unit}`;
+    const rate_failure = metric.failures.find(_failure => _failure.field === 'rate');
+    if (rate_failure) {
+      const emoji = getEmoji(rate_failure.difference);
+      value += `${emoji} ${metric['rate']}${metric_unit} (${getDifferenceSymbol(rate_failure.difference)}${rate_failure.difference})`
+    } else {
+      value += `${metric['rate']}${metric_unit}`;
+    }
+  }
+  return value;
+}
+
+/**
+ * @param {Metric} metric 
+ */
+function getTrendMetricFieldValue(metric, field) {
+  const failure = metric.failures.find(_failure => _failure.field === field);
+  if (failure) {
+    const emoji = getEmoji(failure.difference);
+    return `${emoji} ${field}=${pretty_ms(metric[field])} (${getDifferenceSymbol(failure.difference)}${pretty_ms(failure.difference)})`
+  }
+  return `${field}=${pretty_ms(metric[field])}`;
+}
+
+/**
+ * @param {Metric} metric 
+ */
+function getRateMetricFieldValue(metric) {
+  const failure = metric.failures.find(_failure => _failure.field === 'rate');
+  if (failure) {
+    const emoji = getEmoji(failure.difference);
+    return `${emoji} ${metric['rate']} ${metric.unit} (${getDifferenceSymbol(failure.difference)}${failure.difference})`;
+  }
+  return `${metric['rate']} ${metric.unit}`;
+}
+
+function getEmoji(value) {
+  return value > 0 ? '🔺' : '🔻';
+}
+
+function getDifferenceSymbol(value) {
+  return value > 0 ? `+` : '';
+}
+
+/**
+ * 
+ * @param {object} param0 
+ * @param {Metric} param0.metric 
+ */
+function getDisplayFields({ metric, target }) {
+  let fields = [];
+  if (target.inputs.metrics) {
+    const metric_config = target.inputs.metrics.find(_metric => _metric.name === metric.name);
+    if (metric_config) {
+      fields = metric_config.fields;
+    }
+  }
+  if (fields && fields.length > 0) {
+    return fields;
+  } else {
+    switch (metric.type) {
+      case 'COUNTER':
+        return ['sum', 'rate'];
+      case 'RATE':
+        return ['rate'];
+      case 'TREND':
+        return ['avg', 'min', 'med', 'max', 'p90', 'p95', 'p99'];
+      default:
+        return ['sum', 'min', 'max'];
+    }
+  }
+}
+
+/**
+ * @param {object} param0 
+ * @param {Metric} param0.metric 
+ */
+function getMetricValuesText({ metric, target }) {
+  const fields = getDisplayFields({ metric, target });
+  const values = [];
+  if (metric.type === 'COUNTER') {
+    values.push(getCounterMetricFieldValue(metric, fields));
+  } else if (metric.type === 'TREND') {
+    for (let i = 0; i < fields.length; i++) {
+      const field_metric = fields[i];
+      values.push(getTrendMetricFieldValue(metric, field_metric));
+    }
+  } else if (metric.type === 'RATE') {
+    values.push(getRateMetricFieldValue(metric));
+  }
+  return values.join(' ｜ ');
+}
+
+module.exports = {
+  getValidMetrics,
+  getMetricValuesText
+}

package/src/helpers/report-portal.js

@@ -0,0 +1,47 @@
+const request = require('phin-retry');
+
+async function getLaunchDetails(options) {
+  return request.get({
+    url: `${options.url}/api/v1/${options.project}/launch/${options.launch_id}`,
+    headers: {
+      'Authorization': `Bearer ${options.api_key}`
+    }
+  });
+}
+
+async function getLaunchesByName(options) {
+  return request.get({
+    url: `${options.url}/api/v1/${options.project}/launch?filter.eq.name=${options.launch_name}&page.size=1&page.sort=startTime%2Cdesc`,
+    headers: {
+      'Authorization': `Bearer ${options.api_key}`
+    }
+  });
+}
+
+async function getLastLaunchByName(options) {
+  const response = await getLaunchesByName(options);
+  if (response.content && response.content.length > 0) {
+    return response.content[0];
+  }
+  return null;
+}
+
+async function getSuiteHistory(options) {
+  return request.get({
+    url: `${options.url}/api/v1/${options.project}/item/history`,
+    qs: {
+      historyDepth: options.history_depth,
+      'filter.eq.launchId': options.launch_id,
+      'filter.!ex.parentId': 'true'
+    },
+    headers: {
+      'Authorization': `Bearer ${options.api_key}`
+    }
+  });
+}
+
+module.exports = {
+  getLaunchDetails,
+  getLastLaunchByName,
+  getSuiteHistory
+}