@futdevpro/nts-dynamo 1.15.151 → 1.15.154

package/src/_modules/server/index.ts

@@ -1,30 +1,40 @@
-
-//
-// 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 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/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/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

@@ -0,0 +1,8 @@
+/** 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

@@ -0,0 +1,19 @@
+/** 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',
+  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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,13 @@
+/** 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

@@ -0,0 +1,7 @@
+/** 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

@@ -0,0 +1,235 @@
+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();
+  });
+});