chore: tests

.wallaby.js

@@ -22,14 +22,11 @@ module.exports = () => {
         pattern: './packages/midnight-smoker/data/*.json',
         instrument: false,
       },
-      {
-        pattern: './packages/midnight-smoker/test/**/*.ts',
-        instrument: false,
-      },
       {
         pattern: './packages/midnight-smoker/test/**/fixture/**/*',
         instrument: false,
       },
+      './packages/midnight-smoker/test/**/*.ts',
       './packages/midnight-smoker/src/**/*.ts',
       './packages/midnight-smoker/package.json',
       // './packages/midnight-smoker/src/package.json',

packages/midnight-smoker/src/cli/command/run-script-cmd.ts

@@ -5,7 +5,7 @@
  */
 import {handleRejection} from '#cli/cli-util';
 import {Smoker} from '#smoker';
-import {castArray} from '#util/schema-util';
+import {castArray} from '#util/util';
 import Debug from 'debug';
 import type {ArgumentsCamelCase, Argv, InferredOptionTypes} from 'yargs';
 import {BaseCommand} from './base-cmd';

packages/midnight-smoker/src/error/base-error.ts

@@ -1,5 +1,5 @@
 import {isZodError} from '#util/error-util';
-import {castArray} from '#util/schema-util';
+import {castArray} from '#util/util';
 import {italic, white, whiteBright, yellow} from 'chalk';
 import Debug from 'debug';
 import {format, formatWithOptions} from 'node:util';
@@ -126,7 +126,7 @@ export abstract class AggregateSmokerError<Context extends object | void = void>
       isZodError(err) ? fromZodError(err) : err,
     );
     super(errs, message);
-    this.context = context;
+    this.context = context ?? undefined;
     this.errors = errs;
     this.code = getErrorCode(this);
   }

packages/midnight-smoker/src/error/cleanup-error.ts

@@ -0,0 +1,20 @@
+import {BaseSmokerError} from './base-error';
+
+/**
+ * Thrown when `Smoker.cleanup()` fails.
+ *
+ * @group Errors
+ */
+
+export class CleanupError extends BaseSmokerError<
+  {
+    dir: string;
+  },
+  NodeJS.ErrnoException
+> {
+  public readonly id = 'CleanupError';
+
+  constructor(message: string, dir: string, error: NodeJS.ErrnoException) {
+    super(message, {dir}, error);
+  }
+}

packages/midnight-smoker/src/error/codes.ts

@@ -11,14 +11,16 @@
 export const ErrorCodes = {
   CleanupError: 'ESMOKER_CLEANUP',
   ComponentCollisionError: 'ESMOKER_COMPONENTIDCOLLISION',
-  DirCreationError: 'ESMOKER_DIRCREATION',
+  TempDirError: 'ESMOKER_DIRCREATION',
   DisallowedPluginError: 'ESMOKER_DISALLOWEDPLUGIN',
   DuplicatePluginError: 'ESMOKER_DUPLICATEPLUGIN',
   ExecError: 'ESMOKER_EXEC',
   InstallError: 'ESMOKER_INSTALL',
   InvalidArgError: 'ESMOKER_INVALIDARG',
   InvalidComponentError: 'ESMOKER_INVALIDCOMPONENT',
   InvalidPluginError: 'ESMOKER_INVALIDPLUGIN',
+  LifecycleError: 'ESMOKER_LIFECYCLE',
+  MachineError: 'ESMOKER_MACHINE',
   MissingPackageJsonError: 'ESMOKER_MISSINGPACKAGEJSON',
   NotImplementedError: 'ESMOKER_NOTIMPLEMENTED',
   PackageManagerError: 'ESMOKER_PACKAGEMANAGER',
@@ -30,10 +32,11 @@ export const ErrorCodes = {
   PluginInitError: 'ESMOKER_PLUGININIT',
   PluginResolutionError: 'ESMOKER_PLUGINRESOLUTION',
   ReporterError: 'ESMOKER_REPORTER',
+  ReporterListenerError: 'ESMOKER_REPORTERLISTENER',
   RuleError: 'ESMOKER_RULEERROR',
   RunScriptError: 'ESMOKER_RUNSCRIPT',
   ScriptFailedError: 'ESMOKER_SCRIPTFAILED',
-  SmokeFailedError: 'ESMOKER_SMOKEFAILED',
+  SmokeError: 'ESMOKER_SMOKE',
   SmokerReferenceError: 'ESMOKER_REFERENCE',
   UnknownDistTagError: 'ESMOKER_UNKNOWNDISTTAG',
   UnknownScriptError: 'ESMOKER_UNKNOWNSCRIPT',

packages/midnight-smoker/src/error/create-dir-error.ts

@@ -1,16 +1,22 @@
+import {type StaticPkgManagerSpec} from '#schema/static-pkg-manager-spec';
+import {isString} from 'lodash';
 import {BaseSmokerError} from './base-error';
 
 /**
  * @group Errors
  */
 
-export class DirCreationError extends BaseSmokerError<
-  {prefix: string},
+export class TempDirError extends BaseSmokerError<
+  {spec: string},
   NodeJS.ErrnoException
 > {
-  public readonly id = 'DirCreationError';
+  public readonly id = 'TempDirError';
 
-  constructor(message: string, prefix: string, error: NodeJS.ErrnoException) {
-    super(message, {prefix}, error);
+  constructor(
+    message: string,
+    spec: string | StaticPkgManagerSpec,
+    error: NodeJS.ErrnoException,
+  ) {
+    super(message, {spec: isString(spec) ? spec : spec.spec}, error);
   }
 }

packages/midnight-smoker/src/error/index.ts

@@ -12,6 +12,8 @@ export * from './base-error';
 
 export * from './codes';
 
+export * from './cleanup-error';
+
 export * from './component-collision-error';
 
 export * from './create-dir-error';
@@ -56,7 +58,7 @@ export * from './script-bailed';
 
 export * from './script-failed-error';
 
-export * from './smoker-error';
+export * from './smoke-error';
 
 export * from './smoker-reference-error';
 

packages/midnight-smoker/src/error/install-error.ts

@@ -1,7 +1,11 @@
-import type {ExecError} from '#error/exec-error';
-import {type PkgManagerSpec} from '#pkg-manager/pkg-manager-spec';
+import {ExecError} from '#error/exec-error';
+import {isExecResult, type ExecResult} from '#schema/exec-result';
+import {type StaticPkgManagerSpec} from '#schema/static-pkg-manager-spec';
+import {isExecaError, isSmokerError} from '#util/error-util';
 import {red} from 'chalk';
+import {isString} from 'lodash';
 import {BaseSmokerError} from './base-error';
+import {fromUnknownError} from './from-unknown-error';
 
 /**
  * @group Errors
@@ -11,32 +15,43 @@ export class InstallError extends BaseSmokerError<
     pkgManager: string;
     pkgSpec: string;
     cwd: string;
-    exitCode?: number;
-    output?: string;
-    error?: object;
+    result?: ExecResult;
   },
-  ExecError | undefined
+  ExecError | Error | undefined
 > {
   public readonly id = 'InstallError';
 
   constructor(
     message: string,
-    pkgManager: string | PkgManagerSpec,
+    pkgManager: string | StaticPkgManagerSpec,
     pkgSpec: string,
     cwd: string,
-    {
-      error,
-      exitCode,
-      output,
-    }: {error?: object; exitCode?: number; output?: string} = {},
-    execError?: ExecError,
+    rawResult: unknown,
   ) {
+    const pmSpec = isString(pkgManager) ? pkgManager : pkgManager.spec;
+    let error: ExecError | Error | undefined;
+    let result: ExecResult | undefined;
+
+    if (isExecaError(rawResult)) {
+      error = isSmokerError(ExecError, rawResult)
+        ? rawResult
+        : new ExecError(rawResult);
+    } else if (!isExecResult(rawResult)) {
+      error = fromUnknownError(rawResult);
+    } else {
+      result = rawResult;
+    }
     super(
-      `Package manager ${pkgManager} failed to install "${pkgSpec}" in dir ${cwd}: ${red(
+      `Package manager ${pmSpec} failed to install "${pkgSpec}" in dir ${cwd}: ${red(
         message,
       )}`,
-      {pkgManager: `${pkgManager}`, pkgSpec, cwd, exitCode, output, error},
-      execError,
+      {
+        pkgManager: pmSpec,
+        pkgSpec,
+        cwd,
+        result,
+      },
+      error,
     );
   }
 }

packages/midnight-smoker/src/error/lifecycle-error.ts

@@ -0,0 +1,37 @@
+import {type StaticPluginMetadata} from '#schema/static-plugin-metadata';
+import {BaseSmokerError} from './base-error';
+
+export type LifecycleStage = 'setup' | 'teardown';
+
+export type LifecycleComponentKind = 'reporter' | 'pkg-manager';
+
+export class LifecycleError extends BaseSmokerError<
+  {
+    name: string;
+    stage: LifecycleStage;
+    plugin: StaticPluginMetadata;
+    kind: LifecycleComponentKind;
+  },
+  Error
+> {
+  public readonly id = 'LifecycleError';
+
+  constructor(
+    error: Error,
+    stage: LifecycleStage,
+    kind: LifecycleComponentKind,
+    name: string,
+    plugin: StaticPluginMetadata,
+  ) {
+    super(
+      `Error during lifecycle hook "${stage}"`,
+      {
+        name,
+        kind,
+        stage,
+        plugin,
+      },
+      error,
+    );
+  }
+}

packages/midnight-smoker/src/error/machine-error.ts

@@ -0,0 +1,43 @@
+import {castArray} from 'lodash';
+import {AggregateSmokerError} from './base-error';
+
+/**
+ * Generic aggregate error for machines
+ *
+ * @group Errors
+ */
+export class MachineError extends AggregateSmokerError<{
+  machineId: string;
+}> {
+  public readonly id = 'MachineError';
+
+  public override readonly context: {
+    machineId: string;
+  };
+
+  static originators = new WeakMap<Error, string>();
+
+  constructor(message: string, errors: Error[] | Error, machineId: string) {
+    errors = castArray(errors);
+    for (const error of errors) {
+      MachineError.originators.set(error, machineId);
+    }
+    super(message, errors, {machineId});
+    this.context = {machineId};
+  }
+
+  /**
+   * Clone this instance with additional errors and options.
+   *
+   * @param error Zero or more errors to append to the aggregate
+   * @param options Results of linting and running scripts, if any
+   * @returns New instance of `SmokeError` with the given errors and options
+   */
+  clone(error: Error | Error[] = []): MachineError {
+    return new MachineError(
+      this.message,
+      [...this.errors, ...castArray(error)],
+      this.context.machineId,
+    );
+  }
+}

packages/midnight-smoker/src/error/pack-error.ts

@@ -1,43 +1,40 @@
-import {type PkgManagerSpec} from '#pkg-manager/pkg-manager-spec';
+import {type StaticPkgManagerSpec} from '#schema/static-pkg-manager-spec';
 import {type WorkspaceInfo} from '#schema/workspaces';
 import {red} from 'chalk';
+import {isString} from 'lodash';
 import {BaseSmokerError} from './base-error';
+import {fromUnknownError} from './from-unknown-error';
 
 /**
  * @group Errors
  */
-export class PackError extends BaseSmokerError<{
-  spec: string;
-  dest: string;
-  cwd?: string;
-  exitCode?: number;
-  output?: string;
-  error?: object;
-  workspace: WorkspaceInfo;
-}> {
+export class PackError extends BaseSmokerError<
+  {
+    spec: string;
+    dest: string;
+    workspace: WorkspaceInfo;
+  },
+  Error | undefined
+> {
   public readonly id = 'PackError';
 
   constructor(
     message: string,
-    pkgManager: string | PkgManagerSpec,
+    pkgManager: string | StaticPkgManagerSpec,
     workspace: WorkspaceInfo,
     dest: string,
-    {
-      cwd,
-      error,
-      exitCode,
-      output,
-    }: {cwd?: string; error?: object; exitCode?: number; output?: string} = {},
+    error?: unknown,
   ) {
-    super(`Package manager ${pkgManager} failed to pack: ${red(message)}`, {
-      error,
-      spec: `${pkgManager}`,
-      cwd,
-      dest,
-      exitCode,
-      output,
-      workspace,
-    });
+    const pmSpec = isString(pkgManager) ? pkgManager : pkgManager.spec;
+    super(
+      `Package manager ${pmSpec} failed to pack: ${red(message)}`,
+      {
+        spec: pmSpec,
+        dest,
+        workspace,
+      },
+      fromUnknownError(error),
+    );
   }
 }
 
@@ -56,11 +53,12 @@ export class PackParseError extends BaseSmokerError<
 
   constructor(
     message: string,
-    pkgManager: string | PkgManagerSpec,
+    pkgManager: string | StaticPkgManagerSpec,
     workspace: WorkspaceInfo,
     error: SyntaxError,
     output: string,
   ) {
-    super(message, {pkgManager: `${pkgManager}`, output, workspace}, error);
+    const pmSpec = isString(pkgManager) ? pkgManager : pkgManager.spec;
+    super(message, {pkgManager: pmSpec, output, workspace}, error);
   }
 }