@futdevpro/nts-dynamo 1.15.157 → 1.15.163

package/src/_modules/server/index.ts

@@ -1,40 +0,0 @@
-
-//
-// Server module
-//
-// This module contains solutions for basic server endpoints such as:
-//
-// - Errors; 
-//     saving and retrieving errors that are occuring on the server
-//
-// - Server Status; 
-//     retrieving the status of the server
-//
-// - Server Status Snapshot; 
-//     saving and retrieving the status of the server at a specific time
-//
-
-
-// ERRORS
-export * from './errors/errors.controller';
-export * from './errors/errors.control-service';
-export * from './errors/errors.data-service';
-
-// SERVER-STATUS
-export * from './server-status/db-readiness-probe-code.type-enum';
-export * from './server-status/db-readiness-probe-stage.type-enum';
-export * from './server-status/db-readiness-probe.interface';
-export * from './server-status/db-readiness-probe.control-service';
-export * from './server-status/server-status-snapshot.data-service';
-export * from './server-status/server-status-snapshot.control-service';
-export * from './server-status/server-status.control-service';
-export * from './server-status/server-status.controller';
-
-// SAFE-DIAGNOSTIC
-export * from './safe-diagnostic/safe-diagnostic-cause.type-enum';
-export * from './safe-diagnostic/safe-diagnostic-stage.type-enum';
-export * from './safe-diagnostic/safe-diagnostic.interface';
-export * from './safe-diagnostic/safe-diagnostic.control-service';
-
-
-

package/src/_modules/server/safe-diagnostic/safe-diagnostic-cause.type-enum.ts

@@ -1,8 +0,0 @@
-/** Stable, content-free classifications for framework-owned failures. */
-export enum DyNTS_SafeDiagnosticCause_Type {
-  dynamoError = 'dynamo-error',
-  nativeError = 'native-error',
-  object = 'object',
-  primitive = 'primitive',
-  unknown = 'unknown',
-}

package/src/_modules/server/safe-diagnostic/safe-diagnostic-stage.type-enum.ts

@@ -1,20 +0,0 @@
-/** Framework stages that may emit a content-free diagnostic. */
-export enum DyNTS_SafeDiagnosticStage_Type {
-  bootstrap = 'bootstrap',
-  collectionGrowthMonitor = 'collection-growth-monitor',
-  databaseConnect = 'database-connect',
-  databaseRuntime = 'database-runtime',
-  eventLoopDiagnostic = 'event-loop-diagnostic',
-  endpoint = 'endpoint',
-  expressFallback = 'express-fallback',
-  globalErrorHandler = 'global-error-handler',
-  httpServer = 'http-server',
-  httpsServer = 'https-server',
-  memoryGuard = 'memory-guard',
-  mongoReconnectGuard = 'mongo-reconnect-guard',
-  postProcess = 'post-process',
-  readiness = 'readiness',
-  retention = 'retention',
-  routing = 'routing',
-  unhandledRejection = 'unhandled-rejection',
-}

package/src/_modules/server/safe-diagnostic/safe-diagnostic.control-service.spec.ts

@@ -1,124 +0,0 @@
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
-import { DyNTS_SafeDiagnosticStage_Type } from './safe-diagnostic-stage.type-enum';
-import {
-  DyNTS_SafeDiagnosticInput_Interface,
-  DyNTS_SafeDiagnostic_Interface
-} from './safe-diagnostic.interface';
-import { DyNTS_SafeDiagnostic_ControlService } from './safe-diagnostic.control-service';
-
-describe('| DyNTS_SafeDiagnostic_ControlService', (): void => {
-  const canary: string = 'mongodb://user:secret@private-host.example/raw-driver-message';
-
-  it('| returns the exact immutable content-free allowlist', (): void => {
-    const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
-      code: 'DYNTS|APP|DB_CONNECT_FAILED',
-      stage: DyNTS_SafeDiagnosticStage_Type.databaseConnect,
-      error: new Error(canary),
-      status: 503,
-    });
-
-    expect(Object.keys(result).sort()).toEqual([
-      'causeType',
-      'code',
-      'contractVersion',
-      'fingerprint',
-      'stage',
-      'status',
-    ]);
-    expect(result).toEqual({
-      contractVersion: 'dynts-safe-diagnostic/1',
-      code: 'DYNTS|APP|DB_CONNECT_FAILED',
-      stage: DyNTS_SafeDiagnosticStage_Type.databaseConnect,
-      causeType: DyNTS_SafeDiagnosticCause_Type.nativeError,
-      fingerprint: jasmine.stringMatching(/^[a-f0-9]{64}$/),
-      status: 503,
-    });
-    expect(Object.isFrozen(result)).toBeTrue();
-    expect(JSON.stringify(result)).not.toContain(canary);
-    expect(JSON.stringify(result)).not.toContain('secret');
-  });
-
-  it('| creates a deterministic correlation without reflecting its raw subject', (): void => {
-    const input: DyNTS_SafeDiagnosticInput_Interface = {
-      code: 'DYNTS|APP|BOOT_FAILED',
-      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-      error: new Error(canary),
-    };
-    const first: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project(input);
-    const second: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project(input);
-
-    expect(first.fingerprint).toBe(second.fingerprint);
-    expect(first.fingerprint).not.toContain(canary);
-  });
-
-  it('| classifies Dynamo, object, primitive and absent failures without returning content', (): void => {
-    const failures: unknown[] = [
-      new DyFM_Error({ errorCode: 'TEST', message: canary }),
-      { privateValue: canary },
-      canary,
-      undefined,
-    ];
-    const expected: DyNTS_SafeDiagnosticCause_Type[] = [
-      DyNTS_SafeDiagnosticCause_Type.dynamoError,
-      DyNTS_SafeDiagnosticCause_Type.object,
-      DyNTS_SafeDiagnosticCause_Type.primitive,
-      DyNTS_SafeDiagnosticCause_Type.unknown,
-    ];
-
-    failures.forEach((error: unknown, index: number): void => {
-      const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
-        code: 'DYNTS|APP|FAILURE',
-        stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-        error: error,
-      });
-
-      expect(result.causeType).toBe(expected[index]);
-      expect(JSON.stringify(result)).not.toContain(canary);
-    });
-  });
-
-  it('| fails closed for invalid code, status and hostile getters', (): void => {
-    const hostile: Error = new Error('placeholder');
-
-    Object.defineProperty(hostile, 'message', {
-      get: (): never => {
-        throw new Error(canary);
-      },
-    });
-    Object.defineProperty(hostile, 'stack', {
-      get: (): never => {
-        throw new Error(canary);
-      },
-    });
-
-    const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
-      code: canary,
-      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-      error: hostile,
-      status: 999,
-    });
-
-    expect(result.code).toBe('DYNTS_SAFE_DIAGNOSTIC_INVALID_CODE');
-    expect(result.status).toBe(500);
-    expect(result.fingerprint).toMatch(/^[a-f0-9]{64}$/);
-    expect(JSON.stringify(result)).not.toContain(canary);
-  });
-
-  it('| reports and creates framework errors from the safe result only', (): void => {
-    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
-    const diagnostic: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.report({
-      code: 'DYNTS|APP|FAILURE',
-      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-      error: new Error(canary),
-    });
-    const error: DyFM_Error = DyNTS_SafeDiagnostic_ControlService.toError(diagnostic);
-    const serialized: string = JSON.stringify(error);
-
-    expect(logSpy).toHaveBeenCalledOnceWith('[DyNTS safe diagnostic]', diagnostic);
-    expect(serialized).not.toContain(canary);
-    expect(serialized).not.toContain('secret');
-    expect(serialized).toContain(diagnostic.fingerprint);
-  });
-});

package/src/_modules/server/safe-diagnostic/safe-diagnostic.control-service.ts

@@ -1,99 +0,0 @@
-import { createHash } from 'crypto';
-
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
-import {
-  DyNTS_SafeDiagnosticInput_Interface,
-  DyNTS_SafeDiagnostic_Interface
-} from './safe-diagnostic.interface';
-
-/** Projects arbitrary failures to a versioned, content-free public diagnostic. */
-export class DyNTS_SafeDiagnostic_ControlService {
-  private static readonly contractVersion: 'dynts-safe-diagnostic/1' = 'dynts-safe-diagnostic/1';
-  private static readonly defaultCode: string = 'DYNTS_SAFE_DIAGNOSTIC_INVALID_CODE';
-  private static readonly defaultStatus: number = 500;
-
-  /** Returns an immutable exact allowlist and never reflects raw failure content. */
-  static project(input: DyNTS_SafeDiagnosticInput_Interface): DyNTS_SafeDiagnostic_Interface {
-    const code: string = this.getCode(input.code);
-    const causeType: DyNTS_SafeDiagnosticCause_Type = this.getCauseType(input.error);
-    const status: number = this.getStatus(input.status);
-    const fingerprint: string = this.getFingerprint([
-      this.contractVersion,
-      code,
-      input.stage,
-      causeType,
-      status.toString(),
-    ]);
-
-    return Object.freeze({
-      contractVersion: this.contractVersion,
-      code: code,
-      stage: input.stage,
-      causeType: causeType,
-      fingerprint: fingerprint,
-      status: status,
-    });
-  }
-
-  /** Logs only the projected allowlist and returns the same immutable diagnostic. */
-  static report(input: DyNTS_SafeDiagnosticInput_Interface): DyNTS_SafeDiagnostic_Interface {
-    const diagnostic: DyNTS_SafeDiagnostic_Interface = this.project(input);
-
-    DyFM_Log.error('[DyNTS safe diagnostic]', diagnostic);
-
-    return diagnostic;
-  }
-
-  /** Creates a framework error that carries only the safe diagnostic allowlist. */
-  static toError(diagnostic: DyNTS_SafeDiagnostic_Interface): DyFM_Error {
-    return new DyFM_Error({
-      errorCode: diagnostic.code,
-      message: `Framework failure at ${diagnostic.stage}. Correlation: ${diagnostic.fingerprint}.`,
-      userMessage: 'A server operation failed. Contact the responsible team with the correlation fingerprint.',
-      additionalContent: { diagnostic: diagnostic },
-      status: diagnostic.status,
-    });
-  }
-
-  private static getCode(code: string): string {
-    return /^[A-Z][A-Z0-9_|-]{2,127}$/.test(code) ? code : this.defaultCode;
-  }
-
-  private static getCauseType(error: unknown): DyNTS_SafeDiagnosticCause_Type {
-    try {
-      if (error instanceof DyFM_Error) {
-        return DyNTS_SafeDiagnosticCause_Type.dynamoError;
-      }
-
-      if (error instanceof Error) {
-        return DyNTS_SafeDiagnosticCause_Type.nativeError;
-      }
-
-      if (error !== null && typeof error === 'object') {
-        return DyNTS_SafeDiagnosticCause_Type.object;
-      }
-
-      if (error !== undefined) {
-        return DyNTS_SafeDiagnosticCause_Type.primitive;
-      }
-    } catch {
-      return DyNTS_SafeDiagnosticCause_Type.unknown;
-    }
-
-    return DyNTS_SafeDiagnosticCause_Type.unknown;
-  }
-
-  private static getStatus(status?: number): number {
-    if (typeof status !== 'number' || !Number.isInteger(status) || status < 100 || status > 599) {
-      return this.defaultStatus;
-    }
-
-    return status;
-  }
-
-  private static getFingerprint(subject: string[]): string {
-    return createHash('sha256').update(subject.join('\u0000'), 'utf8').digest('hex');
-  }
-}

package/src/_modules/server/safe-diagnostic/safe-diagnostic.interface.ts

@@ -1,20 +0,0 @@
-import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
-import { DyNTS_SafeDiagnosticStage_Type } from './safe-diagnostic-stage.type-enum';
-
-/** Caller-owned input whose raw failure content is never returned or logged. */
-export interface DyNTS_SafeDiagnosticInput_Interface {
-  code: string;
-  stage: DyNTS_SafeDiagnosticStage_Type;
-  error?: unknown;
-  status?: number;
-}
-
-/** Exact public allowlist emitted by the safe diagnostic boundary. */
-export interface DyNTS_SafeDiagnostic_Interface {
-  contractVersion: 'dynts-safe-diagnostic/1';
-  code: string;
-  stage: DyNTS_SafeDiagnosticStage_Type;
-  causeType: DyNTS_SafeDiagnosticCause_Type;
-  fingerprint: string;
-  status: number;
-}

package/src/_modules/server/server-status/db-readiness-probe-code.type-enum.ts

@@ -1,13 +0,0 @@
-/** Stable, content-free result codes emitted by the database-readiness probe. */
-export enum DyNTS_DbReadinessProbeCode_Type {
-  ready = 'dynts-db-readiness-ready',
-  connectionUnavailable = 'dynts-db-readiness-connection-unavailable',
-  disconnected = 'dynts-db-readiness-disconnected',
-  connecting = 'dynts-db-readiness-connecting',
-  disconnecting = 'dynts-db-readiness-disconnecting',
-  stateUnknown = 'dynts-db-readiness-state-unknown',
-  databaseUnavailable = 'dynts-db-readiness-database-unavailable',
-  pingFailed = 'dynts-db-readiness-ping-failed',
-  cancelled = 'dynts-db-readiness-cancelled',
-  probeFailed = 'dynts-db-readiness-probe-failed',
-}

package/src/_modules/server/server-status/db-readiness-probe-stage.type-enum.ts

@@ -1,7 +0,0 @@
-/** Bounded stages of the foreground database-readiness probe. */
-export enum DyNTS_DbReadinessProbeStage_Type {
-  input = 'input',
-  state = 'state',
-  ping = 'ping',
-  complete = 'complete',
-}

package/src/_modules/server/server-status/db-readiness-probe.control-service.spec.ts

@@ -1,235 +0,0 @@
-import * as mongoose from 'mongoose';
-
-import { DyNTS_DbReadinessProbeCode_Type } from './db-readiness-probe-code.type-enum';
-import { DyNTS_DbReadinessProbe_ControlService } from './db-readiness-probe.control-service';
-import {
-  DyNTS_DbReadinessProbeRequest_Interface,
-  DyNTS_DbReadinessProbeResult_Interface
-} from './db-readiness-probe.interface';
-import { DyNTS_DbReadinessProbeStage_Type } from './db-readiness-probe-stage.type-enum';
-
-interface TestConnectionSet {
-  readyState?: number;
-  databaseAvailable?: boolean;
-  ping?: () => Promise<Record<string, number>>;
-  readyStateGetter?: () => number;
-  databaseGetter?: () => mongoose.Connection['db'];
-}
-
-interface CyclicFailure {
-  marker: string;
-  self?: CyclicFailure;
-}
-
-describe('| DyNTS_DbReadinessProbe_ControlService', (): void => {
-  const canary: string = 'mongodb://user:secret@private-host.example/internal-driver-message';
-
-  /** Creates a local Mongoose connection handle with deterministic probe capabilities. */
-  function createConnection(set: TestConnectionSet = {}): mongoose.Connection {
-    const connection: mongoose.Connection = mongoose.createConnection();
-    const registryIndex: number = mongoose.connections.indexOf(connection);
-
-    if (registryIndex >= 0) {
-      mongoose.connections.splice(registryIndex, 1);
-    }
-
-    Object.defineProperty(connection, 'readyState', {
-      configurable: true,
-      get: set.readyStateGetter ?? ((): number => set.readyState ?? 1),
-    });
-    Object.defineProperty(connection, 'db', {
-      configurable: true,
-      get: set.databaseGetter ?? ((): unknown => {
-        if (set.databaseAvailable === false) {
-          return undefined;
-        }
-
-        return {
-          admin: (): { ping: () => Promise<Record<string, number>> } => ({
-            ping: set.ping ?? (async (): Promise<Record<string, number>> => ({ ok: 1 })),
-          }),
-        };
-      }),
-    });
-
-    return connection;
-  }
-
-  /** Runs the content-free probe against a deterministic test connection. */
-  async function probe(connection: mongoose.Connection): Promise<DyNTS_DbReadinessProbeResult_Interface> {
-    return DyNTS_DbReadinessProbe_ControlService.probe({ connection: connection });
-  }
-
-  it('| returns the exact allowlisted ready result after a successful ping', async (): Promise<void> => {
-    const result: DyNTS_DbReadinessProbeResult_Interface = await probe(createConnection());
-
-    expect(result).toEqual({
-      contractVersion: 'dynts-db-readiness/1',
-      ready: true,
-      readyState: 1,
-      pingOk: true,
-      stage: DyNTS_DbReadinessProbeStage_Type.complete,
-      code: DyNTS_DbReadinessProbeCode_Type.ready,
-    });
-    expect(Object.keys(result)).toEqual([
-      'contractVersion',
-      'ready',
-      'readyState',
-      'pingOk',
-      'stage',
-      'code',
-    ]);
-  });
-
-  [
-    { readyState: 0, code: DyNTS_DbReadinessProbeCode_Type.disconnected },
-    { readyState: 2, code: DyNTS_DbReadinessProbeCode_Type.connecting },
-    { readyState: 3, code: DyNTS_DbReadinessProbeCode_Type.disconnecting },
-  ].forEach((set: { readyState: number; code: DyNTS_DbReadinessProbeCode_Type }): void => {
-    it(`| reports state ${set.readyState} without pinging`, async (): Promise<void> => {
-      const ping: jasmine.Spy = jasmine.createSpy('ping');
-      const result: DyNTS_DbReadinessProbeResult_Interface = await probe(createConnection({
-        readyState: set.readyState,
-        ping: ping,
-      }));
-
-      expect(result.ready).toBeFalse();
-      expect(result.readyState).toBe(set.readyState);
-      expect(result.pingOk).toBeFalse();
-      expect(result.stage).toBe(DyNTS_DbReadinessProbeStage_Type.state);
-      expect(result.code).toBe(set.code);
-      expect(ping).not.toHaveBeenCalled();
-    });
-  });
-
-  it('| normalizes an out-of-range state without exposing its value', async (): Promise<void> => {
-    const result: DyNTS_DbReadinessProbeResult_Interface = await probe(createConnection({ readyState: 99 }));
-
-    expect(result.readyState).toBe(-1);
-    expect(result.code).toBe(DyNTS_DbReadinessProbeCode_Type.stateUnknown);
-  });
-
-  it('| fails closed when the runtime connection input is unavailable', async (): Promise<void> => {
-    const request: DyNTS_DbReadinessProbeRequest_Interface = Object.create(null);
-
-    Object.defineProperty(request, 'connection', { configurable: true, get: (): undefined => undefined });
-
-    const result: DyNTS_DbReadinessProbeResult_Interface =
-      await DyNTS_DbReadinessProbe_ControlService.probe(request);
-
-    expect(result.code).toBe(DyNTS_DbReadinessProbeCode_Type.connectionUnavailable);
-    expect(result.ready).toBeFalse();
-  });
-
-  it('| fails closed when the connected handle has no database', async (): Promise<void> => {
-    const result: DyNTS_DbReadinessProbeResult_Interface = await probe(createConnection({
-      databaseAvailable: false,
-    }));
-
-    expect(result.readyState).toBe(1);
-    expect(result.stage).toBe(DyNTS_DbReadinessProbeStage_Type.ping);
-    expect(result.code).toBe(DyNTS_DbReadinessProbeCode_Type.databaseUnavailable);
-  });
-
-  it('| converts a ping rejection to a stable result without leaking its content', async (): Promise<void> => {
-    const stdoutSpy: jasmine.Spy = spyOn(process.stdout, 'write');
-    const stderrSpy: jasmine.Spy = spyOn(process.stderr, 'write');
-    const result: DyNTS_DbReadinessProbeResult_Interface = await probe(createConnection({
-      ping: async (): Promise<Record<string, number>> => Promise.reject(new Error(canary)),
-    }));
-    const serialized: string = JSON.stringify(result);
-
-    expect(result.code).toBe(DyNTS_DbReadinessProbeCode_Type.pingFailed);
-    expect(result.readyState).toBe(1);
-    expect(result.ready).toBeFalse();
-    expect(result.pingOk).toBeFalse();
-    expect(serialized).not.toContain(canary);
-    expect(serialized).not.toContain('secret');
-    expect(serialized).not.toContain('private-host');
-    expect(stdoutSpy).not.toHaveBeenCalled();
-    expect(stderrSpy).not.toHaveBeenCalled();
-  });
-
-  it('| honors caller-owned cancellation before the probe', async (): Promise<void> => {
-    const controller: AbortController = new AbortController();
-
-    controller.abort();
-
-    const result: DyNTS_DbReadinessProbeResult_Interface =
-      await DyNTS_DbReadinessProbe_ControlService.probe({
-        connection: createConnection(),
-        abortSignal: controller.signal,
-      });
-
-    expect(result.stage).toBe(DyNTS_DbReadinessProbeStage_Type.input);
-    expect(result.code).toBe(DyNTS_DbReadinessProbeCode_Type.cancelled);
-  });
-
-  it('| honors caller-owned cancellation after the ping settles', async (): Promise<void> => {
-    const controller: AbortController = new AbortController();
-    const connection: mongoose.Connection = createConnection({
-      ping: async (): Promise<Record<string, number>> => {
-        controller.abort();
-
-        return { ok: 1 };
-      },
-    });
-
-    const result: DyNTS_DbReadinessProbeResult_Interface =
-      await DyNTS_DbReadinessProbe_ControlService.probe({ connection: connection, abortSignal: controller.signal });
-
-    expect(result.stage).toBe(DyNTS_DbReadinessProbeStage_Type.ping);
-    expect(result.code).toBe(DyNTS_DbReadinessProbeCode_Type.cancelled);
-    expect(result.pingOk).toBeFalse();
-  });
-
-  it('| contains a hostile ready-state getter without reflecting its value', async (): Promise<void> => {
-    const failure: CyclicFailure = { marker: canary };
-
-    failure.self = failure;
-    const result: DyNTS_DbReadinessProbeResult_Interface = await probe(createConnection({
-      readyStateGetter: (): number => {
-        throw failure;
-      },
-    }));
-
-    expect(result.code).toBe(DyNTS_DbReadinessProbeCode_Type.probeFailed);
-    expect(JSON.stringify(result)).not.toContain(canary);
-  });
-
-  it('| contains a hostile database getter without reflecting its value', async (): Promise<void> => {
-    const failure: CyclicFailure = { marker: canary };
-
-    failure.self = failure;
-    const result: DyNTS_DbReadinessProbeResult_Interface = await probe(createConnection({
-      databaseGetter: (): mongoose.Connection['db'] => {
-        throw failure;
-      },
-    }));
-
-    expect(result.code).toBe(DyNTS_DbReadinessProbeCode_Type.pingFailed);
-    expect(JSON.stringify(result)).not.toContain(canary);
-  });
-
-  it('| starts no timer or signal listener and writes no output', async (): Promise<void> => {
-    const timeoutSpy: jasmine.Spy = spyOn(globalThis, 'setTimeout');
-    const intervalSpy: jasmine.Spy = spyOn(globalThis, 'setInterval');
-    const listenerSpy: jasmine.Spy = spyOn(AbortSignal.prototype, 'addEventListener');
-    const stdoutSpy: jasmine.Spy = spyOn(process.stdout, 'write');
-    const stderrSpy: jasmine.Spy = spyOn(process.stderr, 'write');
-    const controller: AbortController = new AbortController();
-
-    const result: DyNTS_DbReadinessProbeResult_Interface =
-      await DyNTS_DbReadinessProbe_ControlService.probe({
-        connection: createConnection(),
-        abortSignal: controller.signal,
-      });
-
-    expect(result.ready).toBeTrue();
-    expect(timeoutSpy).not.toHaveBeenCalled();
-    expect(intervalSpy).not.toHaveBeenCalled();
-    expect(listenerSpy).not.toHaveBeenCalled();
-    expect(stdoutSpy).not.toHaveBeenCalled();
-    expect(stderrSpy).not.toHaveBeenCalled();
-  });
-});