@jsenv/test 2.1.3 → 3.0.0

package/src/execution/logs_file_execution.js

@@ -1,495 +0,0 @@
-import wrapAnsi from "wrap-ansi";
-import {
-  ANSI,
-  UNICODE,
-  msAsEllapsedTime,
-  msAsDuration,
-  byteAsMemoryUsage,
-} from "@jsenv/log";
-
-import { EXECUTION_COLORS } from "./execution_colors.js";
-
-export const createExecutionLog = (
-  {
-    executionIndex,
-    fileRelativeUrl,
-    runtimeName,
-    runtimeVersion,
-    executionParams,
-    executionResult,
-    startMs,
-    endMs,
-    nowMs,
-    timeEllapsed,
-    memoryHeap,
-    counters,
-  },
-  {
-    logShortForCompletedExecutions,
-    logRuntime,
-    logEachDuration,
-    logTimeUsage,
-    logMemoryHeapUsage,
-  },
-) => {
-  const label = formatExecutionLabel(
-    {
-      executionIndex,
-      executionParams,
-      executionResult,
-      timeEllapsed,
-      memoryHeap,
-      counters,
-    },
-    {
-      logTimeUsage,
-      logMemoryHeapUsage,
-    },
-  );
-
-  const { status } = executionResult;
-  let log;
-  if (logShortForCompletedExecutions && status === "completed") {
-    log = label;
-  } else {
-    log = formatExecution(
-      {
-        fileRelativeUrl,
-        runtimeName,
-        runtimeVersion,
-        executionResult,
-        startMs,
-        endMs,
-        nowMs,
-      },
-      {
-        label,
-        logRuntime,
-        logEachDuration,
-      },
-    );
-  }
-
-  const { columns = 80 } = process.stdout;
-  log = wrapAnsi(log, columns, {
-    trim: false,
-    hard: true,
-    wordWrap: false,
-  });
-  if (endMs) {
-    if (logShortForCompletedExecutions) {
-      return `${log}\n`;
-    }
-    if (executionIndex === counters.total - 1) {
-      return `${log}\n`;
-    }
-    return `${log}\n\n`;
-  }
-  return log;
-};
-
-export const formatExecution = (
-  {
-    fileRelativeUrl,
-    runtimeName,
-    runtimeVersion,
-    executionResult,
-    startMs,
-    endMs,
-    nowMs,
-  },
-  { label, logRuntime = true, logEachDuration = true } = {},
-) => {
-  const { status } = executionResult;
-  const { consoleCalls = [], errors = [] } = executionResult;
-  const consoleOutput = formatConsoleCalls(consoleCalls);
-  const errorsOutput = formatErrors(errors);
-
-  const details = {
-    file: fileRelativeUrl,
-    ...(logRuntime ? { runtime: `${runtimeName}/${runtimeVersion}` } : {}),
-    ...(logEachDuration
-      ? {
-          duration:
-            status === "executing"
-              ? msAsEllapsedTime((nowMs || Date.now()) - startMs)
-              : msAsDuration(endMs - startMs),
-        }
-      : {}),
-  };
-  let message = ``;
-  message += label;
-  Object.keys(details).forEach((key) => {
-    message += `
-${key}: ${details[key]}`;
-  });
-  if (consoleOutput) {
-    message += `\n${consoleOutput}`;
-  }
-  if (errorsOutput) {
-    message += `\n${errorsOutput}`;
-  }
-  return message;
-};
-
-export const formatExecutionLabel = (
-  {
-    executionIndex,
-    executionParams,
-    executionResult,
-    timeEllapsed,
-    memoryHeap,
-    counters,
-  },
-  { logTimeUsage, logMemoryHeapUsage } = {},
-) => {
-  const { status } = executionResult;
-  const descriptionFormatter = descriptionFormatters[status];
-  const description = descriptionFormatter({
-    index: executionIndex,
-    total: counters.total,
-    executionParams,
-  });
-  const intermediateSummaryText = createIntermediateSummary({
-    executionIndex,
-    counters,
-    timeEllapsed,
-    memoryHeap,
-    logTimeUsage,
-    logMemoryHeapUsage,
-  });
-  return `${description}${intermediateSummaryText}`;
-};
-
-const formatErrors = (errors) => {
-  if (errors.length === 0) {
-    return "";
-  }
-  const formatError = (error) => {
-    if (error === null || error === undefined) {
-      return String(error);
-    }
-    if (error) {
-      return error.stack || error.message || error;
-    }
-    return error;
-  };
-
-  if (errors.length === 1) {
-    return `${ANSI.color(`-------- error --------`, ANSI.RED)}
-${formatError(errors[0])}
-${ANSI.color(`-------------------------`, ANSI.RED)}`;
-  }
-
-  let output = [];
-  errors.forEach((error) => {
-    output.push(
-      prefixFirstAndIndentRemainingLines({
-        prefix: `${UNICODE.CIRCLE_CROSS} `,
-        indentation: "   ",
-        text: formatError(error),
-      }),
-    );
-  });
-  return `${ANSI.color(`-------- errors (${errors.length}) --------`, ANSI.RED)}
-${output.join(`\n`)}
-${ANSI.color(`-------------------------`, ANSI.RED)}`;
-};
-
-export const formatSummaryLog = (
-  summary,
-) => `-------------- summary -----------------
-${formatSummary(summary)}
-----------------------------------------`;
-
-export const formatSummary = (summary) => `${createAllExecutionsSummary(
-  summary,
-)}
-total duration: ${msAsDuration(summary.duration)}`;
-
-const createAllExecutionsSummary = ({ counters }) => {
-  if (counters.total === 0) {
-    return `no execution`;
-  }
-  const executionLabel =
-    counters.total === 1 ? `1 execution` : `${counters.total} executions`;
-  return `${executionLabel}: ${createStatusSummary({
-    counters,
-  })}`;
-};
-
-const createIntermediateSummary = ({
-  executionIndex,
-  counters,
-  memoryHeap,
-  timeEllapsed,
-  logTimeUsage,
-  logMemoryHeapUsage,
-}) => {
-  const parts = [];
-  if (executionIndex > 0 || counters.done > 0) {
-    parts.push(
-      createStatusSummary({
-        counters: {
-          ...counters,
-          total: executionIndex + 1,
-        },
-      }),
-    );
-  }
-  if (logTimeUsage && timeEllapsed) {
-    parts.push(`duration: ${msAsEllapsedTime(timeEllapsed)}`);
-  }
-  if (logMemoryHeapUsage && memoryHeap) {
-    parts.push(`memory heap: ${byteAsMemoryUsage(memoryHeap)}`);
-  }
-  if (parts.length === 0) {
-    return "";
-  }
-  return ` (${parts.join(` / `)})`;
-};
-
-const createStatusSummary = ({ counters }) => {
-  if (counters.aborted === counters.total) {
-    return `all ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`;
-  }
-  if (counters.timedout === counters.total) {
-    return `all ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`;
-  }
-  if (counters.failed === counters.total) {
-    return `all ${ANSI.color(`failed`, EXECUTION_COLORS.failed)}`;
-  }
-  if (counters.completed === counters.total) {
-    return `all ${ANSI.color(`completed`, EXECUTION_COLORS.completed)}`;
-  }
-  if (counters.cancelled === counters.total) {
-    return `all ${ANSI.color(`cancelled`, EXECUTION_COLORS.cancelled)}`;
-  }
-  return createMixedDetails({
-    counters,
-  });
-};
-
-const createMixedDetails = ({ counters }) => {
-  const parts = [];
-  if (counters.timedout) {
-    parts.push(
-      `${counters.timedout} ${ANSI.color(
-        `timed out`,
-        EXECUTION_COLORS.timedout,
-      )}`,
-    );
-  }
-  if (counters.failed) {
-    parts.push(
-      `${counters.failed} ${ANSI.color(`failed`, EXECUTION_COLORS.failed)}`,
-    );
-  }
-  if (counters.completed) {
-    parts.push(
-      `${counters.completed} ${ANSI.color(
-        `completed`,
-        EXECUTION_COLORS.completed,
-      )}`,
-    );
-  }
-  if (counters.aborted) {
-    parts.push(
-      `${counters.aborted} ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`,
-    );
-  }
-  if (counters.cancelled) {
-    parts.push(
-      `${counters.cancelled} ${ANSI.color(
-        `cancelled`,
-        EXECUTION_COLORS.cancelled,
-      )}`,
-    );
-  }
-  return `${parts.join(", ")}`;
-};
-
-const descriptionFormatters = {
-  executing: ({ index, total }) => {
-    return ANSI.color(
-      `executing ${padNumber(index, total)} of ${total}`,
-      EXECUTION_COLORS.executing,
-    );
-  },
-  aborted: ({ index, total }) => {
-    return ANSI.color(
-      `${UNICODE.FAILURE_RAW} execution ${padNumber(
-        index,
-        total,
-      )} of ${total} aborted`,
-      EXECUTION_COLORS.aborted,
-    );
-  },
-  timedout: ({ index, total, executionParams }) => {
-    return ANSI.color(
-      `${UNICODE.FAILURE_RAW} execution ${padNumber(
-        index,
-        total,
-      )} of ${total} timeout after ${executionParams.allocatedMs}ms`,
-      EXECUTION_COLORS.timedout,
-    );
-  },
-  failed: ({ index, total }) => {
-    return ANSI.color(
-      `${UNICODE.FAILURE_RAW} execution ${padNumber(
-        index,
-        total,
-      )} of ${total} failed`,
-      EXECUTION_COLORS.failed,
-    );
-  },
-  completed: ({ index, total }) => {
-    return ANSI.color(
-      `${UNICODE.OK_RAW} execution ${padNumber(
-        index,
-        total,
-      )} of ${total} completed`,
-      EXECUTION_COLORS.completed,
-    );
-  },
-  cancelled: ({ index, total }) => {
-    return ANSI.color(
-      `${UNICODE.FAILURE_RAW} execution ${padNumber(
-        index,
-        total,
-      )} of ${total} cancelled`,
-      EXECUTION_COLORS.cancelled,
-    );
-  },
-};
-
-const padNumber = (index, total) => {
-  const number = index + 1;
-  const numberWidth = String(number).length;
-  const totalWith = String(total).length;
-  let missingWidth = totalWith - numberWidth;
-  let padded = "";
-  while (missingWidth--) {
-    padded += "0";
-  }
-  padded += number;
-  return padded;
-};
-
-const formatConsoleCalls = (consoleCalls) => {
-  if (consoleCalls.length === 0) {
-    return "";
-  }
-  const repartition = {
-    debug: 0,
-    info: 0,
-    warning: 0,
-    error: 0,
-    log: 0,
-  };
-  consoleCalls.forEach((consoleCall) => {
-    repartition[consoleCall.type]++;
-  });
-  const consoleOutput = formatConsoleOutput(consoleCalls);
-
-  return `${ANSI.color(
-    `-------- ${formatConsoleSummary(repartition)} --------`,
-    ANSI.GREY,
-  )}
-${consoleOutput}
-${ANSI.color(`-------------------------`, ANSI.GREY)}`;
-};
-
-export const formatConsoleOutput = (consoleCalls) => {
-  // inside Node.js you can do process.stdout.write()
-  // and in that case the consoleCall is not suffixed with "\n"
-  // we want to keep these calls together in the output
-  const regroupedCalls = [];
-  consoleCalls.forEach((consoleCall, index) => {
-    if (index === 0) {
-      regroupedCalls.push(consoleCall);
-      return;
-    }
-    const previousCall = consoleCalls[index - 1];
-    if (previousCall.type !== consoleCall.type) {
-      regroupedCalls.push(consoleCall);
-      return;
-    }
-    if (previousCall.text.endsWith("\n")) {
-      regroupedCalls.push(consoleCall);
-      return;
-    }
-    if (previousCall.text.endsWith("\r")) {
-      regroupedCalls.push(consoleCall);
-      return;
-    }
-    const previousRegroupedCallIndex = regroupedCalls.length - 1;
-    const previousRegroupedCall = regroupedCalls[previousRegroupedCallIndex];
-    previousRegroupedCall.text = `${previousRegroupedCall.text}${consoleCall.text}`;
-  });
-
-  let consoleOutput = ``;
-  regroupedCalls.forEach((regroupedCall, index) => {
-    const text = regroupedCall.text;
-    const textFormatted = prefixFirstAndIndentRemainingLines({
-      prefix: CONSOLE_ICONS[regroupedCall.type],
-      text,
-      trimLines: true,
-      trimLastLine: index === regroupedCalls.length - 1,
-    });
-    consoleOutput += textFormatted;
-  });
-  return consoleOutput;
-};
-
-const prefixFirstAndIndentRemainingLines = ({
-  prefix,
-  indentation = "  ",
-  text,
-  trimLines,
-  trimLastLine,
-}) => {
-  const lines = text.split(/\r?\n/);
-  const firstLine = lines.shift();
-  let result = `${prefix} ${firstLine}`;
-  let i = 0;
-  while (i < lines.length) {
-    const line = trimLines ? lines[i].trim() : lines[i];
-    i++;
-    result += line.length
-      ? `\n${indentation}${line}`
-      : trimLastLine && i === lines.length
-        ? ""
-        : `\n`;
-  }
-  return result;
-};
-
-const CONSOLE_ICONS = {
-  debug: UNICODE.DEBUG,
-  info: UNICODE.INFO,
-  warning: UNICODE.WARNING,
-  error: UNICODE.FAILURE,
-  log: " ",
-};
-
-const formatConsoleSummary = (repartition) => {
-  const { debug, info, warning, error } = repartition;
-  const parts = [];
-  if (error) {
-    parts.push(`${CONSOLE_ICONS.error} ${error}`);
-  }
-  if (warning) {
-    parts.push(`${CONSOLE_ICONS.warning} ${warning}`);
-  }
-  if (info) {
-    parts.push(`${CONSOLE_ICONS.info} ${info}`);
-  }
-  if (debug) {
-    parts.push(`${CONSOLE_ICONS.debug} ${debug}`);
-  }
-  if (parts.length === 0) {
-    return `console`;
-  }
-  return `console (${parts.join(" ")})`;
-};