testbeats 2.0.0

package/src/extensions/mentions.js

@@ -0,0 +1,112 @@
+const { getOnCallPerson } = require('rosters');
+const { addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
+const { HOOK, STATUS } = require('../helpers/constants');
+
+function run({ target, extension, payload, root_payload }) {
+  if (target.name === 'teams') {
+    extension.inputs = Object.assign({}, default_inputs_teams, extension.inputs);
+    attachForTeam({ extension, payload });
+  } else if (target.name === 'slack') {
+    extension.inputs = Object.assign({}, default_inputs_slack, extension.inputs);
+    attachForSlack({ extension, payload });
+  } else if (target.name === 'chat') {
+    extension.inputs = Object.assign({}, default_inputs_chat, extension.inputs);
+    attachForChat({ extension, root_payload });
+  }
+}
+
+function attachForTeam({ extension, payload }) {
+  const users = getUsers(extension);
+  if (users.length > 0) {
+    setPayloadWithMSTeamsEntities(payload);
+    const users_ats = users.map(user => `<at>${user.name}</at>`);
+    addTeamsExtension({ payload, extension, text: users_ats.join(' ｜ ')});
+    for (const user of users) {
+      payload.msteams.entities.push({
+        "type": "mention",
+        "text": `<at>${user.name}</at>`,
+        "mentioned": {
+          "id": user.teams_upn,
+          "name": user.name
+        }
+      });
+    }
+  }
+}
+
+function formatSlackMentions({slack_uid, slack_gid}) {
+  if (slack_gid && slack_uid) {
+    throw new Error(`Error in slack extension configuration. Either slack user or group Id is allowed`);
+  }
+  if (slack_uid) {
+    return `<@${slack_uid}>`
+  }
+  const tagPrefix = ["here", "everyone", "channel"].includes(slack_gid.toLowerCase()) ? "" : "subteam^";
+  return `<!${tagPrefix}${slack_gid}>`
+}
+
+function attachForSlack({ extension, payload }) {
+  const users = getUsers(extension);
+  const user_ids = users.map(formatSlackMentions);
+  if (users.length > 0) {
+    addSlackExtension({ payload, extension, text: user_ids.join(' ｜ ') });
+  }
+}
+
+function attachForChat({ extension, root_payload }) {
+  const users = getUsers(extension);
+  const user_ids = users.map(user => `<users/${user.chat_uid}>`);
+  if (users.length > 0) {
+    root_payload.text = user_ids.join(' ｜ ');
+  }
+}
+
+function getUsers(extension) {
+  const users = [];
+  if (extension.inputs.users) {
+    users.push(...extension.inputs.users);
+  }
+  if (extension.inputs.schedule) {
+    const user = getOnCallPerson(extension.inputs.schedule);
+    if (user) {
+      users.push(user);
+    } else {
+      // TODO: warn message for no on-call person
+    }
+  }
+  return users;
+}
+
+function setPayloadWithMSTeamsEntities(payload) {
+  if (!payload.msteams) {
+    payload.msteams = {};
+  }
+  if (!payload.msteams.entities) {
+    payload.msteams.entities = [];
+  }
+}
+
+const default_options = {
+  hook: HOOK.END,
+  condition: STATUS.FAIL
+}
+
+const default_inputs_teams = {
+  title: '',
+  separator: true
+}
+
+const default_inputs_slack = {
+  title: '',
+  separator: false
+}
+
+const default_inputs_chat = {
+  title: '',
+  separator: true
+}
+
+module.exports = {
+  run,
+  default_options
+}

package/src/extensions/metadata.js

@@ -0,0 +1,89 @@
+const { HOOK, STATUS } = require('../helpers/constants');
+const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
+const { getTeamsMetaDataText, getSlackMetaDataText, getChatMetaDataText } = require('../helpers/metadata.helper');
+
+/**
+ * @param {object} param0
+ * @param {import('..').Target} param0.target
+ * @param {import('..').MetadataExtension} param0.extension
+ */
+async function run({ target, extension, result, payload, root_payload }) {
+  if (target.name === 'teams') {
+    extension.inputs = Object.assign({}, default_inputs_teams, extension.inputs);
+    await attachForTeams({ target, extension, payload, result });
+  } else if (target.name === 'slack') {
+    extension.inputs = Object.assign({}, default_inputs_slack, extension.inputs);
+    await attachForSlack({ target, extension, payload, result });
+  } else if (target.name === 'chat') {
+    extension.inputs = Object.assign({}, default_inputs_chat, extension.inputs);
+    await attachForChat({ target, extension, payload, result });
+  }
+}
+
+/**
+ * @param {object} param0
+ * @param {import('..').MetadataExtension} param0.extension
+ */
+async function attachForTeams({ target, extension, payload, result }) {
+  const text = await getTeamsMetaDataText({
+    elements: extension.inputs.data,
+    target,
+    extension,
+    result,
+    default_condition: default_options.condition
+  });
+  if (text) {
+    addTeamsExtension({ payload, extension, text });
+  }
+}
+
+async function attachForSlack({ target, extension, payload, result }) {
+  const text = await getSlackMetaDataText({
+    elements: extension.inputs.data,
+    target,
+    extension,
+    result,
+    default_condition: default_options.condition
+  });
+  if (text) {
+    addSlackExtension({ payload, extension, text });
+  }
+}
+
+async function attachForChat({ target, extension, payload, result }) {
+  const text = await getChatMetaDataText({
+    elements: extension.inputs.data,
+    target,
+    extension,
+    result,
+    default_condition: default_options.condition
+  });
+  if (text) {
+    addChatExtension({ payload, extension, text });
+  }
+}
+
+const default_options = {
+  hook: HOOK.END,
+  condition: STATUS.PASS_OR_FAIL
+}
+
+const default_inputs_teams = {
+  title: '',
+  separator: true
+}
+
+const default_inputs_slack = {
+  title: '',
+  separator: false
+}
+
+const default_inputs_chat = {
+  title: '',
+  separator: true
+}
+
+module.exports = {
+  run,
+  default_options
+}

package/src/extensions/percy-analysis.js

@@ -0,0 +1,203 @@
+const retry = require('async-retry');
+const { getProjectByName, getLastBuild, getBuild, getRemovedSnapshots } = require('../helpers/percy');
+const { HOOK, STATUS, URLS } = require('../helpers/constants');
+const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
+
+/**
+ * 
+ * @param {object} param0 
+ * @param {import('../index').PercyAnalysisExtension} param0.extension 
+ */
+async function run({ extension, payload, target }) {
+  extension.inputs = Object.assign({}, default_inputs, extension.inputs);
+  await initialize(extension);
+  if (target.name === 'teams') {
+    extension.inputs = Object.assign({}, default_inputs_teams, extension.inputs);
+    attachForTeams({ payload, extension });
+  } else if (target.name === 'slack') {
+    extension.inputs = Object.assign({}, default_inputs_slack, extension.inputs);
+    attachForSlack({ payload, extension });
+  } else if (target.name === 'chat') {
+    extension.inputs = Object.assign({}, default_inputs_chat, extension.inputs);
+    attachForChat({ payload, extension });
+  }
+}
+
+/**
+ * @param {import('../index').PercyAnalysisExtension} extension 
+ */
+async function initialize(extension) {
+  const { inputs } = extension;
+  if (!inputs.build_id) {
+    await setBuildByLastRun(extension);
+  } else {
+    await setBuild(extension);
+  }
+  await setRemovedSnapshots(extension);
+  if (!inputs.title_link && inputs.title_link_to_build) {
+    inputs.title_link = `https://percy.io/${inputs.organization_uid}/${inputs.project_name}/builds/${inputs.build_id}`;
+  }
+}
+
+/**
+ * @param {import('../index').PercyAnalysisExtension} extension 
+ */
+async function setBuildByLastRun(extension) {
+  const { inputs, outputs } = extension;
+  if (!inputs.project_id) {
+    await setProjectId(extension)
+  }
+  const response = await getLastFinishedBuild(extension);
+  inputs.build_id = response.data[0].id;
+  outputs.build = response.data[0];
+  if (!outputs.project) {
+    outputs.project = response.included.find(_item => _item.type === 'projects');
+  }
+  if (!inputs.project_name) {
+    inputs.project_name = outputs.project.attributes.name;
+  }
+  if (!inputs.organization_uid) {
+    inputs.organization_uid = getOrganizationUID(outputs.project.attributes['full-slug']);
+  }
+}
+
+/**
+ * @param {import('../index').PercyAnalysisExtension} extension 
+ */
+function getLastFinishedBuild(extension) {
+  const { inputs } = extension;
+  const minTimeout = 5000;
+
+  return retry(async () => {
+      let response;
+      try {
+          response = await getLastBuild(inputs);
+      } catch (error) {
+          throw new Error(`Error occurred while fetching the last build: ${error}`);
+      }
+      if (!response.data || !response.data[0] || !response.data[0].attributes) {
+          throw new Error(`Invalid response data: ${JSON.stringify(response)}`);
+      }
+      const state = response.data[0].attributes.state;
+      if (state !== "finished" && state !== "failed") {
+          throw new Error(`build is still '${state}'`);
+      }
+      return response;
+  }, { retries: inputs.retries, minTimeout });
+}
+
+/**
+ * @param {import('../index').PercyAnalysisExtension} extension 
+ */
+async function setProjectId(extension) {
+  const { inputs, outputs } = extension;
+  if (!inputs.project_name) {
+    throw "mandatory inputs 'build_id' or 'project_id' or 'project_name' are not provided for percy-analysis extension"
+  }
+  const response = await getProjectByName(inputs);
+  inputs.project_id = response.data.id;
+  outputs.project = response.data;
+}
+
+/**
+ * @param {import('../index').PercyAnalysisExtension} extension 
+ */
+async function setBuild(extension) {
+  const { inputs, outputs } = extension;
+  const response = await getBuild(inputs);
+  outputs.build = response.data;
+  outputs.project = response.included.find(_item => _item.type === 'projects');
+  if (!inputs.project_id) {
+    inputs.project_id = outputs.project.id;
+  }
+  if (!inputs.project_name) {
+    inputs.project_name = outputs.project.attributes.name;
+  }
+  if (!inputs.organization_uid) {
+    inputs.organization_uid = getOrganizationUID(outputs.project.attributes['full-slug']);
+  }
+}
+
+function getOrganizationUID(slug) {
+  return slug.split('/')[0];
+}
+
+/**
+ * @param {import('../index').PercyAnalysisExtension} extension 
+ */
+async function setRemovedSnapshots(extension) {
+  const response = await getRemovedSnapshots(extension.inputs);
+  extension.outputs.removed_snapshots = response.data;
+}
+
+function attachForTeams({ payload, extension }) {
+  const text = getAnalysisSummary(extension.outputs).join(' ｜ ');
+  addTeamsExtension({ payload, extension, text });
+}
+
+function attachForSlack({ payload, extension }) {
+  const text = getAnalysisSummary(extension.outputs, '*', '*').join(' ｜ ');
+  addSlackExtension({ payload, extension, text });
+}
+
+function attachForChat({ payload, extension }) {
+  const text = getAnalysisSummary(extension.outputs, '<b>', '</b>').join(' ｜ ');
+  addChatExtension({ payload, extension, text });
+}
+
+function getAnalysisSummary(outputs, bold_start = '**', bold_end = '**') {
+  const { build, removed_snapshots } = outputs;
+  const results = [];
+  const total = build.attributes['total-snapshots'];
+  const un_reviewed = build.attributes['total-snapshots-unreviewed'];
+  const approved = total - un_reviewed;
+  if (approved) {
+    results.push(`${bold_start}✔ AP - ${approved}${bold_end}`);
+  } else {
+    results.push(`✔ AP - ${approved || 0}`);
+  }
+  if (un_reviewed) {
+    results.push(`${bold_start}🔎 UR - ${un_reviewed}${bold_end}`);
+  } else {
+    results.push(`🔎 UR - ${un_reviewed || 0}`);
+  }
+  if (removed_snapshots && removed_snapshots.length) {
+    results.push(`${bold_start}🗑 RM - ${removed_snapshots.length}${bold_end}`);
+  } else {
+    results.push(`🗑 RM - 0`);
+  }
+  return results;
+}
+
+const default_options = {
+  hook: HOOK.END,
+  condition: STATUS.PASS_OR_FAIL
+}
+
+const default_inputs = {
+  title: 'Percy Analysis',
+  url: URLS.PERCY,
+  title_link_to_build: true,
+  retries: 10,
+  build_id: '',
+  project_id: '',
+  project_name: '',
+  organization_uid: ''
+}
+
+const default_inputs_teams = {
+  separator: true
+}
+
+const default_inputs_slack = {
+  separator: false
+}
+
+const default_inputs_chat = {
+  separator: true
+}
+
+module.exports = {
+  run,
+  default_options
+}

package/src/extensions/quick-chart-test-summary.js

@@ -0,0 +1,82 @@
+const { getPercentage } = require('../helpers/helper');
+const { HOOK, STATUS, URLS } = require('../helpers/constants');
+
+function getUrl(extension, result) {
+  const percentage = getPercentage(result.passed, result.total);
+  const chart = {
+    type: 'radialGauge',
+    data: {
+      datasets: [{
+        data: [percentage],
+        backgroundColor: 'green',
+      }]
+    },
+    options: {
+      trackColor: '#FF0000',
+      roundedCorners: false,
+      centerPercentage: 80,
+      centerArea: {
+        fontSize: 74,
+        text: `${percentage}%`,
+      },
+    }
+  }
+  return `${extension.inputs.url}/chart?c=${encodeURIComponent(JSON.stringify(chart))}`;
+}
+
+function attachForTeams({ extension, result, payload }) {
+  const main_column = {
+    "type": "Column",
+    "items": [payload.body[0], payload.body[1]],
+    "width": "stretch"
+  }
+  const image_column = {
+    "type": "Column",
+    "items": [
+      {
+        "type": "Image",
+        "url": getUrl(extension, result),
+        "altText": "overall-results-summary",
+        "size": "large"
+      }
+    ],
+    "width": "auto"
+  }
+  const column_set = {
+    "type": "ColumnSet",
+    "columns": [
+      main_column,
+      image_column
+    ]
+  }
+  payload.body = [column_set];
+}
+
+function attachForSlack({ extension, result, payload }) {
+  payload.blocks[0]["accessory"] = {
+    "type": "image",
+    "alt_text": "overall-results-summary",
+    "image_url": getUrl(extension, result)
+  }
+}
+
+function run(params) {
+  const { extension, target } = params;  
+  params.extension.inputs = extension.inputs || {};
+  params.extension.inputs["url"] = (extension.inputs.url && extension.inputs.url.trim()) || URLS.QUICK_CHART;
+  if (target.name === 'teams') {
+    attachForTeams(params);
+  } else if (target.name === 'slack') {
+    attachForSlack(params);
+  }
+}
+
+const default_options = {
+  hook: HOOK.AFTER_SUMMARY,
+  condition: STATUS.PASS_OR_FAIL
+}
+
+module.exports = {
+  run,
+  default_options
+}

package/src/extensions/report-portal-analysis.js

@@ -0,0 +1,95 @@
+const { getLaunchDetails, getLastLaunchByName } = require('../helpers/report-portal');
+const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
+const { HOOK, STATUS } = require('../helpers/constants');
+
+function getReportPortalDefectsSummary(defects, bold_start = '**', bold_end = '**') {
+  const results = [];
+  if (defects.product_bug) {
+    results.push(`${bold_start}🔴 PB - ${defects.product_bug.total}${bold_end}`);
+  } else {
+    results.push(`🔴 PB - 0`);
+  }
+  if (defects.automation_bug) {
+    results.push(`${bold_start}🟡 AB - ${defects.automation_bug.total}${bold_end}`);
+  } else {
+    results.push(`🟡 AB - 0`);
+  }
+  if (defects.system_issue) {
+    results.push(`${bold_start}🔵 SI - ${defects.system_issue.total}${bold_end}`);
+  } else {
+    results.push(`🔵 SI - 0`);
+  }
+  if (defects.no_defect) {
+    results.push(`${bold_start}◯ ND - ${defects.no_defect.total}${bold_end}`);
+  } else {
+    results.push(`◯ ND - 0`);
+  }
+  if (defects.to_investigate) {
+    results.push(`${bold_start}🟠 TI - ${defects.to_investigate.total}${bold_end}`);
+  } else {
+    results.push(`🟠 TI - 0`);
+  }
+  return results;
+}
+
+async function _getLaunchDetails(options) {
+  if (!options.launch_id && options.launch_name) {
+    return getLastLaunchByName(options);
+  }
+  return getLaunchDetails(options);
+}
+
+async function initialize(extension) {
+  extension.inputs = Object.assign({}, default_inputs, extension.inputs);
+  extension.outputs.launch = await _getLaunchDetails(extension.inputs);
+  if (!extension.inputs.title_link && extension.inputs.title_link_to_launch) {
+    extension.inputs.title_link = `${extension.inputs.url}/ui/#${extension.inputs.project}/launches/all/${extension.outputs.launch.uuid}`;
+  }
+}
+
+async function run({ extension, payload, target }) {
+  await initialize(extension);
+  const { statistics } = extension.outputs.launch;
+  if (statistics && statistics.defects) {
+    if (target.name === 'teams') {
+      extension.inputs = Object.assign({}, default_inputs_teams, extension.inputs);
+      const analyses = getReportPortalDefectsSummary(statistics.defects);
+      addTeamsExtension({ payload, extension, text: analyses.join(' ｜ ') });
+    } else if (target.name === 'slack') {
+      extension.inputs = Object.assign({}, default_inputs_slack, extension.inputs);
+      const analyses = getReportPortalDefectsSummary(statistics.defects, '*', '*');
+      addSlackExtension({ payload, extension, text: analyses.join(' ｜ ') });
+    } else if (target.name === 'chat') {
+      extension.inputs = Object.assign({}, default_inputs_chat, extension.inputs);
+      const analyses = getReportPortalDefectsSummary(statistics.defects, '<b>', '</b>');
+      addChatExtension({ payload, extension, text: analyses.join(' ｜ ') });
+    }
+  }
+}
+
+const default_options = {
+  hook: HOOK.END,
+  condition: STATUS.FAIL
+}
+
+const default_inputs = {
+  title: 'Report Portal Analysis',
+  title_link_to_launch: true,
+}
+
+const default_inputs_teams = {
+  separator: true
+}
+
+const default_inputs_slack = {
+  separator: false
+}
+
+const default_inputs_chat = {
+  separator: true
+}
+
+module.exports = {
+  run,
+  default_options
+}

package/src/extensions/report-portal-history.js

@@ -0,0 +1,105 @@
+const { getSuiteHistory, getLastLaunchByName, getLaunchDetails } = require('../helpers/report-portal');
+const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
+const { HOOK, STATUS } = require('../helpers/constants');
+
+async function getLaunchHistory(extension) {
+  const { inputs, outputs } = extension;
+  if (!inputs.launch_id && inputs.launch_name) {
+    const launch = await getLastLaunchByName(inputs);
+    outputs.launch = launch;
+    inputs.launch_id = launch.id;
+  }
+  if (typeof inputs.launch_id === 'string') {
+    const launch = await getLaunchDetails(inputs);
+    outputs.launch = launch;
+    inputs.launch_id = launch.id;
+  }
+  const response = await getSuiteHistory(inputs);
+  if (response.content.length > 0) {
+    outputs.history = response.content[0].resources;
+    return response.content[0].resources;
+  }
+  return [];
+}
+
+function getSymbols({ target, extension, launches }) {
+  const symbols = [];
+  for (let i = 0; i < launches.length; i++) {
+    const launch = launches[i];
+    const launch_url = `${extension.inputs.url}/ui/#${extension.inputs.project}/launches/all/${launch[extension.inputs.link_history_via]}`;
+    let current_symbol = '⚠️';
+    if (launch.status === 'PASSED') {
+      current_symbol = '✅'; 
+    } else if (launch.status === 'FAILED') {
+      current_symbol = '❌'; 
+    }
+    if (target.name === 'teams') {
+      symbols.push(`[${current_symbol}](${launch_url})`);
+    } else if (target.name === 'slack') {
+      symbols.push(`<${launch_url}|${current_symbol}>`);
+    } else if (target.name === 'chat') {
+      symbols.push(`<a href="${launch_url}">${current_symbol}</a>`);
+    } else {
+      symbols.push(current_symbol);
+    }
+  }
+  return symbols;
+}
+
+function setTitle(extension, symbols) {
+  if (extension.inputs.title === 'Last Runs') {
+    extension.inputs.title = `Last ${symbols.length} Runs`
+  }
+}
+
+async function run({ extension, target, payload }) {
+  try {
+    extension.inputs = Object.assign({}, default_inputs, extension.inputs);
+    const launches = await getLaunchHistory(extension);
+    const symbols = getSymbols({ target, extension, launches });
+    if (symbols.length > 0) {
+      setTitle(extension, symbols);
+      if (target.name === 'teams') {
+        extension.inputs = Object.assign({}, default_inputs_teams, extension.inputs);
+        addTeamsExtension({ payload, extension, text: symbols.join(' ') });
+      } else if (target.name === 'slack') {
+        extension.inputs = Object.assign({}, default_inputs_slack, extension.inputs);
+        addSlackExtension({ payload, extension, text: symbols.join(' ') });
+      } else if (target.name === 'chat') {
+        extension.inputs = Object.assign({}, default_inputs_chat, extension.inputs);
+        addChatExtension({ payload, extension, text: symbols.join(' ') });
+      }
+    }
+  } catch (error) {
+    console.log('Failed to get report portal history');
+    console.log(error);
+  }
+}
+
+const default_inputs = {
+  history_depth: 5,
+  title: 'Last Runs',
+  link_history_via: 'uuid'
+}
+
+const default_inputs_teams = {
+  separator: true
+}
+
+const default_inputs_chat = {
+  separator: true
+}
+
+const default_inputs_slack = {
+  separator: false
+}
+
+const default_options = {
+  hook: HOOK.END,
+  condition: STATUS.FAIL
+}
+
+module.exports = {
+  run,
+  default_options
+}