apidog-reporter-allure/dist/handlers/handleDone.js

An adapter for apidog proving reports in allure format

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = handleDone;
var _allure = _interopRequireDefault(require("../allure"));
var _allureJsCommons = require("allure-js-commons");
var _handleHttp = require("./handleHttp");
var _handleScript = require("./handleScript");
var _utils = require("../utils");
var _testops = require("../allure/testops");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function handleExecution(item) {
  switch (item.metaInfo.type) {
    case 'http':
      {
        return (0, _handleHttp.handleHttpExecution)(item);
      }
    case 'script':
      {
        return (0, _handleScript.handleScriptExecution)(item);
      }
    default:
      {
        console.log('Unknown type');
        return true;
      }
  }
}
function parseIterations(iterationData) {
  if (!iterationData) {
    return undefined;
  }
  const iterations = iterationData.trim().split('\n').map(_utils.parseTestDataRow);
  return {
    headers: iterations[0].slice(1),
    dataRows: iterations.slice(1).map(item => {
      return {
        name: item[0],
        values: item.slice(1)
      };
    })
  };
}
async function handleSingleRun({
  name,
  env,
  executions,
  timings,
  variables,
  pathInfo,
  isLast,
  issueLinkLabel,
  issueLinkPattern,
  component
}, {
  options
}) {
  const sorted = executions.sort((sourceA, sourceB) => sourceA.cursor.requestIndex - sourceB.cursor.requestIndex);
  await async function () {
    try {
      const id = await (0, _testops.getId)(name);

      // Classify tags once so override logic and label application share the same data
      const tags = pathInfo?.tags ?? [];
      const issueRegex = new RegExp(`^(?:${issueLinkPattern})$`);
      const issueTags = tags.filter(t => issueRegex.test(t));
      const kvEntries = tags.map(t => t.match(/^([^=]+)=(.+)$/)).filter(m => m !== null).map(m => [m[1].charAt(0).toUpperCase() + m[1].slice(1), m[2]]);
      const regularTags = tags.filter(t => !issueRegex.test(t) && !/^[^=]+=.+$/.test(t));
      const overrides = new Map(kvEntries);
      _allure.default.startTest(name, timings.started);
      _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.FRAMEWORK, "apidog");
      if (pathInfo) {
        _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.PACKAGE, `${pathInfo.path.join('.')}.${pathInfo.id}`);
        const [epic, feature, story] = pathInfo.path.slice(-3);
        const resolvedEpic = overrides.get(_allureJsCommons.LabelName.EPIC) ?? epic;
        const resolvedFeature = overrides.get(_allureJsCommons.LabelName.FEATURE) ?? feature;
        const resolvedStory = overrides.get(_allureJsCommons.LabelName.STORY) ?? story ?? name;
        if (resolvedEpic) _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.EPIC, resolvedEpic);
        if (resolvedFeature) _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.FEATURE, resolvedFeature);
        _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.STORY, resolvedStory);
      }
      _allure.default.currentTest?.addLabel('Component', overrides.get('Component') ?? component);
      console.log(`Processing '${name}'`);
      _allure.default.currentTest?.addParameter('env', env);
      variables.forEach(({
        key,
        value
      }) => _allure.default.currentTest?.addParameter(key, value));
      const httpCalls = sorted.filter(e => e.metaInfo?.type === 'http' && e.metaInfo?.httpApiPath).map(e => `${(e.metaInfo.httpApiMethod || '').toUpperCase()} ${e.metaInfo.httpApiPath}`);
      if (httpCalls.length > 0 && _allure.default.currentTest) {
        _allure.default.currentTest.description = httpCalls.map(c => `- ${c}`).join('\n');
      }
      let hasPassed = true;
      sorted.forEach(item => hasPassed &&= handleExecution(item));
      // Apply tags regardless of TestOps availability
      const managedLabels = new Set([_allureJsCommons.LabelName.EPIC, _allureJsCommons.LabelName.FEATURE, _allureJsCommons.LabelName.STORY, 'Component']);
      issueTags.forEach(tag => _allure.default.currentTest?.addLabel(issueLinkLabel, tag));
      regularTags.forEach(tag => _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.TAG, tag.toLowerCase()));
      kvEntries.filter(([k]) => !managedLabels.has(k)).forEach(([k, v]) => _allure.default.currentTest?.addLabel(k, v));
      if (id !== undefined) {
        if (id > 0) {
          _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.ALLURE_ID, `${id}`);
        } else {
          console.log('Could not bind a test to allure testops');
        }
        if (_allure.default.currentTest) {
          _allure.default.currentTest.historyId = name;
          _allure.default.currentTest.status = hasPassed ? _allureJsCommons.Status.PASSED : _allureJsCommons.Status.FAILED;
          _allure.default.endTest(timings.completed);
        }
      }
      if (isLast) {
        _allure.default.endGroup();
      }
    } catch (e) {
      console.log('Could not handle test.');
      console.log(JSON.stringify(e));
    }
  }();
}
function handleMultiRun({
  env,
  executions,
  timings,
  iterations,
  name,
  pathInfo,
  issueLinkLabel,
  issueLinkPattern,
  component
}, summary) {
  const promises = iterations.dataRows.map((dataRow, index) => async function () {
    try {
      const testName = name.endsWith('.') ? `${name} ${dataRow.name}` : `${name}. ${dataRow.name}`;
      const testExecutions = executions.filter(({
        cursor
      }) => cursor.iteration === index);
      await handleSingleRun({
        name: testName,
        executions: testExecutions,
        timings: {
          started: testExecutions.find(({
            timings
          }) => timings)?.timings?.started || timings.started,
          completed: testExecutions.filter(({
            timings
          }) => timings)[-1]?.timings?.completed || timings.completed
        },
        env,
        pathInfo,
        issueLinkLabel,
        issueLinkPattern,
        component,
        variables: dataRow.values.map((value, index) => {
          return {
            key: iterations.headers[index],
            value
          };
        }),
        isLast: false
      }, summary);
    } catch (e) {
      console.log("Unexpected error:");
      console.log(JSON.stringify(e));
    }
  }());
  Promise.all(promises).catch(e => console.log(`Error: ${JSON.stringify(e)}`)).then(() => {
    _allure.default.endGroup();
  });
}
function createOnDone(app, pathInfo, issueLinkLabel = 'Related', issueLinkPattern = 'LB-\\d+', component = 'Control Plane') {
  const {
    name,
    environment,
    ciRunningOptions
  } = app.summary.collection;
  const iterations = parseIterations(ciRunningOptions.iterationData);
  return async function (_err, {
    executions,
    timings
  }) {
    try {
      _allure.default.startGroup();
      if (iterations) {
        handleMultiRun({
          iterations,
          name,
          env: environment.name,
          executions,
          timings,
          pathInfo,
          issueLinkLabel,
          issueLinkPattern,
          component
        }, app.summary);
      } else {
        await handleSingleRun({
          name,
          env: environment.name,
          executions,
          timings,
          pathInfo,
          issueLinkLabel,
          issueLinkPattern,
          component,
          variables: [],
          isLast: true
        }, app.summary);
      }
    } catch (e) {
      console.log('Error');
      console.log(JSON.stringify(e));
    }
  };
}
function handleDone({
  app,
  options
}, pathInfo) {
  const component = process.env.ALLURE_COMPONENT ?? options.component ?? 'Control Plane';
  app.on('done', (err, data) => {
    createOnDone(app, pathInfo, options.issueLinkLabel, options.issueLinkPattern, component)(err, data);
  });
}