@zebrunner/javascript-agent-mocha/lib/worker.js

Zebrunner Agent for Mocha

const Mocha = require('mocha');
const ZebrunnerReporter = require('./zebrunner-reporter');
const { WORKER_EVENTS, REPORTING_EVENTS } = require('./events');

const {
  EVENT_RUN_BEGIN,
  EVENT_RUN_END,
  EVENT_TEST_BEGIN,
  EVENT_TEST_END,
  EVENT_TEST_FAIL,
  EVENT_TEST_PENDING,
} = Mocha.Runner.constants;

let reporter;
let isProcessingEvent = false;
const eventQueue = [];

async function processEvent() {
  if (!isProcessingEvent && eventQueue.length > 0) {
    isProcessingEvent = true;

    const message = eventQueue[0];

    switch (message.event) {
      case WORKER_EVENTS.INIT:
        reporter = new ZebrunnerReporter(message.config);

        break;
      case EVENT_RUN_BEGIN:
        await reporter.onLaunchStart();

        break;
      case EVENT_RUN_END:
        await reporter.onLaunchFinish();
        setTimeout(() => {
          console.log('Zebrunner Reporting completed');
          process.exit(0);
        }, 15000); // wait for 15 seconds to complete all promises

        break;
      case EVENT_TEST_BEGIN:
        await reporter.onTestStart(message.test);

        break;
      case EVENT_TEST_END:
        await reporter.onTestFinish(message.test);

        break;
      case EVENT_TEST_FAIL:
        await reporter.onTestFail(message.test);

        break;
      case EVENT_TEST_PENDING:
        await reporter.onTestPending(message.test);

        break;
      case REPORTING_EVENTS.ATTACH_TEST_RUN_LABELS:
        await reporter.attachTestRunLabels(message.labels);

        break;
      case REPORTING_EVENTS.ATTACH_TEST_RUN_ARTIFACT_REFERENCES:
        await reporter.attachTestRunArtifactReferences(message.references);

        break;
      case REPORTING_EVENTS.UPLOAD_TEST_RUN_ARTIFACT:
        await reporter.uploadTestRunArtifact(message.file);

        break;
      case REPORTING_EVENTS.ATTACH_TEST_LABELS:
        await reporter.attachTestLabels(message.test, message.labels);

        break;
      case REPORTING_EVENTS.ATTACH_TEST_ARTIFACT_REFERENCES:
        await reporter.attachTestArtifactReferences(message.test, message.references);

        break;
      case REPORTING_EVENTS.UPLOAD_TEST_ARTIFACT:
        await reporter.uploadTestArtifact(message.test, message.file);

        break;
      case REPORTING_EVENTS.SET_TEST_MAINTAINER:
        await reporter.setTestMaintainer(message.test, message.maintainer);

        break;
      case REPORTING_EVENTS.REVERT_TEST_REGISTRATION:
        await reporter.revertTestRegistration(message.test);

        break;
      case REPORTING_EVENTS.ADD_TEST_CASES:
        await reporter.addTestCase(message.test, message.testCase);

        break;
      case REPORTING_EVENTS.SEND_TEST_LOGS:
        await reporter.sendLogs(message.test, message.logs);

        break;
      default:
        break;
    }

    eventQueue.shift();
    isProcessingEvent = false;

    processEvent();
  }
}

process.on('message', async (message) => {
  console.log(`Zebrunner: processEvent ${message.event} with timestamp ${message.timestamp}`);
  // console.log(message);
  eventQueue.push(message);

  processEvent();
});