How to use

Process

in

process

_onTestFinished(test) {
  if (test.result === 'ok')
   process.stdout.write(`${GREEN_COLOR}.${RESET_COLOR}`);
  else if (test.result === 'skipped')
   process.stdout.write(`${YELLOW_COLOR}*${RESET_COLOR}`);
  else if (test.result === 'failed')
   process.stdout.write(`${RED_COLOR}F${RESET_COLOR}`);
  else if (test.result === 'timedout')
   process.stdout.write(`${RED_COLOR}T${RESET_COLOR}`);
 }

Router.events.on('routeChangeComplete', (url) => {
 if (window && process.env.GA_MEASUREMENT_ID) {
  window.gtag('config', process.env.GA_MEASUREMENT_ID, {
   page_path: url,
  });
 }

 NProgress.done();
});

describe('gae_flex_postgres_connect', () => {
 it('should be listening', async () => {
  const child = childProcess.exec(`node ${appPath}`);
  const isOpen = await waitPort({port: PORT});
  expect(isOpen).to.be.true;
  process.kill(child.pid, 'SIGTERM');
 });
});

_read() {
  if (this._ended)
   return;
  this._ended = true;
  process.nextTick(_ => {
   this.push(Buffer.from(this._str, 'utf8'));
   this.push(null);
  });
 }

/**
  * @param {string} fileURL
  * @return {string}
  */
 function fileURLToPath(fileURL) {
  if (process.platform === 'win32')
   return fileURL.substr('file:///'.length).replace(/\//g, '\\');
  return fileURL.substr('file://'.length);
 }

_onTerminated(message, error) {
  this._printTestResults();
  console.log(`${RED_COLOR}## TERMINATED ##${RESET_COLOR}`);
  console.log('Message:');
  console.log(`  ${RED_COLOR}${message}${RESET_COLOR}`);
  if (error && error.stack) {
   console.log('Stack:');
   console.log(error.stack.split('\n').map(line => '  ' + line).join('\n'));
  }
  process.exit(2);
 }

const displayNumberOfEventProcessedBySeconds = (time) => {
 const elapsed = process.hrtime(time)[1] / 1000000; // divide by a million to get nano to milli
 const perSecond = (1000 * NUMBER_OF_EVENTS_TO_THROW) / elapsed;
 const millionEventProcessedPerSecond = perSecond / 1000000;
 const millionEventProcessedPerSecondBeautiful = Math.round(millionEventProcessedPerSecond * 100) / 100;
 logger.info(
  `Processed 1 million events in ${elapsed} ms, so ${millionEventProcessedPerSecondBeautiful}M events/per second`,
 );
}

async version(req, res) {
  let version = {};

  version["Xmysql"] = this.app.get("version");
  version["mysql"] = await this.getMysqlHealth();
  version["node"] = process.versions.node;
  res.json(version);
 }

/**
 * Returns the size of the screen.
 *
 * @returns {number[]} The size of the screen as an array of [width, height].
 */
function getScreenSize() {
 return [process.stdout.columns, process.stdout.rows];
}

it('should got right level on prod env when set allowDebugAtProd to true', async () => {
  mm.env('prod');
  mm(process.env, 'EGG_LOG', '');
  mm(process.env, 'HOME', utils.getFilepath('apps/mock-production-app-do-not-force/config'));
  app = utils.app('apps/mock-production-app-do-not-force');
  await app.ready();

  assert(app.config.logger.allowDebugAtProd === true);

  assert(app.logger.get('file').options.level === Logger.DEBUG);
  assert(app.logger.get('console').options.level === Logger.INFO);
  assert(app.coreLogger.get('file').options.level === Logger.DEBUG);
  assert(app.coreLogger.get('console').options.level === Logger.INFO);
 });

before(() => {
  sandbox = sinon.createSandbox();
  process.env[config.PORT_KEY] = TEST_PORT;
  process.env[config.BLOCKED_THRESHOLD_KEY] = 1;
  process.env[config.REFRESH_INTERVAL_KEY] = 10;
 });

cluster.on("disconnect", function(worker) {
  if (production) {
    if (!stopping) {
      cluster.fork();
    }
  } else
    process.exit(1);
});

process.on('SIGINT', () => {
 watcher.close();
 flowServer.kill();
 console.log(CLEARLINE + yellow(invert('stopped watching')));
 process.exit();
});

function afterPageCreation(filename) {
 process.stdout.write('\n');
 process.stdout.write(`New Component ${filename} is created and ready!`);
 process.stdout.write('\n');
 process.stdout.write('\n');
 process.exit(0);
}

const displayNumberOfEventProcessedBySeconds = (time) => {
 const elapsed = process.hrtime(time)[1] / 1000000; // divide by a million to get nano to milli
 const perSecond = (1000 * NUMBER_OF_EVENTS_TO_THROW) / elapsed;
 const millionEventProcessedPerSecond = perSecond / 1000000;
 const millionEventProcessedPerSecondBeautiful = Math.round(millionEventProcessedPerSecond * 100) / 100;
 logger.info(
  `Processed 1 million events in ${elapsed} ms, so ${millionEventProcessedPerSecondBeautiful}M events/per second`,
 );
}