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
}, {
  options
}) {
  const sorted = executions.sort((sourceA, sourceB) => sourceA.cursor.requestIndex - sourceB.cursor.requestIndex);
  await async function () {
    try {
      const id = await (0, _testops.getId)(name);
      _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}`);
      }
      if (options.reporterOptions.name) {
        console.log(`Processing ${options.reporterOptions.name}: '${name}'`);
        _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.SUITE, options.reporterOptions.name);
        _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.EPIC, "Design time");
        _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.FEATURE, options.reporterOptions.name);
      } else {
        console.log(`Processing '${name}'`);
      }
      _allure.default.currentTest?.addParameter('env', env);
      variables.forEach(({
        key,
        value
      }) => _allure.default.currentTest?.addParameter(key, value));
      let hasPassed = true;
      sorted.forEach(item => hasPassed &&= handleExecution(item));
      if (id !== undefined) {
        if (id > 0) {
          console.log('tags');
          console.log(pathInfo?.tags);
          pathInfo?.tags.forEach(tag => _allure.default.currentTest?.addLabel(_allureJsCommons.LabelName.TAG, tag));
          _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
}, 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,
        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) {
  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
        }, app.summary);
      } else {
        await handleSingleRun({
          name,
          env: environment.name,
          executions,
          timings,
          pathInfo,
          variables: [],
          isLast: true
        }, app.summary);
      }
    } catch (e) {
      console.log('Error');
      console.log(JSON.stringify(e));
    }
  };
}
function handleDone({
  app
}, pathInfo) {
  app.on('done', (err, doneData) => {
    createOnDone(app, pathInfo)(err, doneData);
  });
}