@futdevpro/nts-dynamo 1.15.151 → 1.15.154

package/src/_modules/scheduler/_models/scheduler-job.interface.ts

@@ -1,35 +1,35 @@
-/**
- * Egy regisztralhato utemzett job a DyNTS_Scheduler_Service-hez.
- *
- * A handler IDEMPOTENS es RESTART-BIZTOS kell legyen: ne a scheduler futasi
- * idejere, hanem sajat igazsagforras-timestampekre (pl. egy DB rekord
- * `autoAcceptAt` mezojere) tamaszkodjon. Igy egy esetleges duplikalt vagy
- * kihagyott futas sem okoz inkonzisztenciat.
- */
-export interface DyNTS_ScheduledJob {
-  /** Egyedi job-kulcs (pl. "sp-auto-accept"). */
-  key: string;
-  /** Futasok kozotti ido ms-ben (pozitiv). */
-  intervalMs: number;
-  /** Elso futas kesleltetese ms-ben. Ha nincs megadva → intervalMs. */
-  initialDelayMs?: number;
-  /** A futtatando feladat. Sync vagy async egyarant lehet. */
-  handler: () => Promise<void> | void;
-}
-
-/** Egy job-futas allapota. */
-export type DyNTS_ScheduledJobRunStatus = 'running' | 'success' | 'failed';
-
-/** Egy job-futas naplo-eleme (in-memory ring bufferben). */
-export interface DyNTS_ScheduledJobRun {
-  /** A futtatott job kulcsa. */
-  jobKey: string;
-  /** Indulas idopontja (ISO). */
-  startedAt: string;
-  /** Befejezes idopontja (ISO), ha mar lefutott. */
-  finishedAt?: string;
-  /** Allapot. */
-  status: DyNTS_ScheduledJobRunStatus;
-  /** Hibauzenet, ha a futas elbukott (sosem `[object Object]`). */
-  error?: string;
-}
+/**
+ * Egy regisztralhato utemzett job a DyNTS_Scheduler_Service-hez.
+ *
+ * A handler IDEMPOTENS es RESTART-BIZTOS kell legyen: ne a scheduler futasi
+ * idejere, hanem sajat igazsagforras-timestampekre (pl. egy DB rekord
+ * `autoAcceptAt` mezojere) tamaszkodjon. Igy egy esetleges duplikalt vagy
+ * kihagyott futas sem okoz inkonzisztenciat.
+ */
+export interface DyNTS_ScheduledJob {
+  /** Egyedi job-kulcs (pl. "sp-auto-accept"). */
+  key: string;
+  /** Futasok kozotti ido ms-ben (pozitiv). */
+  intervalMs: number;
+  /** Elso futas kesleltetese ms-ben. Ha nincs megadva → intervalMs. */
+  initialDelayMs?: number;
+  /** A futtatando feladat. Sync vagy async egyarant lehet. */
+  handler: () => Promise<void> | void;
+}
+
+/** Egy job-futas allapota. */
+export type DyNTS_ScheduledJobRunStatus = 'running' | 'success' | 'failed';
+
+/** Egy job-futas naplo-eleme (in-memory ring bufferben). */
+export interface DyNTS_ScheduledJobRun {
+  /** A futtatott job kulcsa. */
+  jobKey: string;
+  /** Indulas idopontja (ISO). */
+  startedAt: string;
+  /** Befejezes idopontja (ISO), ha mar lefutott. */
+  finishedAt?: string;
+  /** Allapot. */
+  status: DyNTS_ScheduledJobRunStatus;
+  /** Hibauzenet, ha a futas elbukott (sosem `[object Object]`). */
+  error?: string;
+}

package/src/_modules/scheduler/get-scheduler-routing-module.util.ts

@@ -1,33 +1,33 @@
-import { DyNTS_RoutingModule_Settings } from '../../_models/interfaces/routing-module-settings.interface';
-import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
-import { DyNTS_Scheduler_Controller, DyNTS_SchedulerController_Config } from './scheduler.controller';
-
-/**
- * Letrehoz egy /scheduler routing module-t a job-utemzo futas-naplojanak lekeresehez.
- *
- * Hasznalat (auth NELKUL):
- *   DyNTS_getSchedulerRoutingModule()
- *
- * Hasznalat (auth-TAL):
- *   DyNTS_getSchedulerRoutingModule({ authPreProcess: authService.authenticate_sercretKey })
- *
- * FONTOS: a job-ok regisztralasa + inditasa kulon tortenik a szerver indulasakor:
- *   const scheduler = DyNTS_Scheduler_Service.getInstance();
- *   scheduler.registerJob({ ... });
- *   scheduler.start();
- */
-export function DyNTS_getSchedulerRoutingModule(
-  config?: DyNTS_SchedulerController_Config
-): DyNTS_RoutingModule {
-  // Konfiguracio atadasa a controller-nek (static, mert a singleton elott kell)
-  if (config) {
-    DyNTS_Scheduler_Controller.configure(config);
-  }
-
-  const set: DyNTS_RoutingModule_Settings = {
-    route: '/scheduler',
-    controllers: [DyNTS_Scheduler_Controller.getInstance()],
-  };
-
-  return new DyNTS_RoutingModule(set);
-}
+import { DyNTS_RoutingModule_Settings } from '../../_models/interfaces/routing-module-settings.interface';
+import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
+import { DyNTS_Scheduler_Controller, DyNTS_SchedulerController_Config } from './scheduler.controller';
+
+/**
+ * Letrehoz egy /scheduler routing module-t a job-utemzo futas-naplojanak lekeresehez.
+ *
+ * Hasznalat (auth NELKUL):
+ *   DyNTS_getSchedulerRoutingModule()
+ *
+ * Hasznalat (auth-TAL):
+ *   DyNTS_getSchedulerRoutingModule({ authPreProcess: authService.authenticate_sercretKey })
+ *
+ * FONTOS: a job-ok regisztralasa + inditasa kulon tortenik a szerver indulasakor:
+ *   const scheduler = DyNTS_Scheduler_Service.getInstance();
+ *   scheduler.registerJob({ ... });
+ *   scheduler.start();
+ */
+export function DyNTS_getSchedulerRoutingModule(
+  config?: DyNTS_SchedulerController_Config
+): DyNTS_RoutingModule {
+  // Konfiguracio atadasa a controller-nek (static, mert a singleton elott kell)
+  if (config) {
+    DyNTS_Scheduler_Controller.configure(config);
+  }
+
+  const set: DyNTS_RoutingModule_Settings = {
+    route: '/scheduler',
+    controllers: [DyNTS_Scheduler_Controller.getInstance()],
+  };
+
+  return new DyNTS_RoutingModule(set);
+}

package/src/_modules/scheduler/index.ts

@@ -1,8 +1,8 @@
-export { DyNTS_Scheduler_Service } from './scheduler.service';
-export { DyNTS_Scheduler_Controller, DyNTS_SchedulerController_Config } from './scheduler.controller';
-export { DyNTS_getSchedulerRoutingModule } from './get-scheduler-routing-module.util';
-export {
-  DyNTS_ScheduledJob,
-  DyNTS_ScheduledJobRun,
-  DyNTS_ScheduledJobRunStatus,
-} from './_models/scheduler-job.interface';
+export { DyNTS_Scheduler_Service } from './scheduler.service';
+export { DyNTS_Scheduler_Controller, DyNTS_SchedulerController_Config } from './scheduler.controller';
+export { DyNTS_getSchedulerRoutingModule } from './get-scheduler-routing-module.util';
+export {
+  DyNTS_ScheduledJob,
+  DyNTS_ScheduledJobRun,
+  DyNTS_ScheduledJobRunStatus,
+} from './_models/scheduler-job.interface';

package/src/_modules/scheduler/scheduler.controller.spec.ts

@@ -1,42 +1,42 @@
-import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_Scheduler_Controller } from './scheduler.controller';
-
-describe('| DyNTS_Scheduler_Controller', (): void => {
-  let controller: DyNTS_Scheduler_Controller;
-
-  beforeEach((): void => {
-    controller = DyNTS_Scheduler_Controller.getInstance();
-  });
-
-  it('| is a singleton instance', (): void => {
-    const a: DyNTS_Scheduler_Controller = DyNTS_Scheduler_Controller.getInstance();
-    const b: DyNTS_Scheduler_Controller = DyNTS_Scheduler_Controller.getInstance();
-    expect(a).toBe(b);
-    expect(a).toBeInstanceOf(DyNTS_Scheduler_Controller);
-  });
-
-  it('| sets up the /runs endpoint', (): void => {
-    controller.setupEndpoints();
-
-    expect(controller.endpoints).toBeDefined();
-    expect(controller.endpoints.length).toBeGreaterThan(0);
-
-    const runsEndpoint = controller.endpoints.find((ep) => ep.name === 'getSchedulerRuns');
-    expect(runsEndpoint).toBeDefined();
-    expect(runsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-  });
-
-  it('| applies an auth preProcess when configured', (): void => {
-    DyNTS_Scheduler_Controller.configure({
-      authPreProcess: async (): Promise<void> => {},
-    });
-    controller.setupEndpoints();
-
-    const runsEndpoint = controller.endpoints.find((ep) => ep.name === 'getSchedulerRuns');
-    expect((runsEndpoint as any)?.preProcesses?.length).toBeGreaterThan(0);
-
-    // visszaallitas, hogy ne szivarogjon at masik teszthez
-    DyNTS_Scheduler_Controller.configure({});
-  });
-});
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_Scheduler_Controller } from './scheduler.controller';
+
+describe('| DyNTS_Scheduler_Controller', (): void => {
+  let controller: DyNTS_Scheduler_Controller;
+
+  beforeEach((): void => {
+    controller = DyNTS_Scheduler_Controller.getInstance();
+  });
+
+  it('| is a singleton instance', (): void => {
+    const a: DyNTS_Scheduler_Controller = DyNTS_Scheduler_Controller.getInstance();
+    const b: DyNTS_Scheduler_Controller = DyNTS_Scheduler_Controller.getInstance();
+    expect(a).toBe(b);
+    expect(a).toBeInstanceOf(DyNTS_Scheduler_Controller);
+  });
+
+  it('| sets up the /runs endpoint', (): void => {
+    controller.setupEndpoints();
+
+    expect(controller.endpoints).toBeDefined();
+    expect(controller.endpoints.length).toBeGreaterThan(0);
+
+    const runsEndpoint = controller.endpoints.find((ep) => ep.name === 'getSchedulerRuns');
+    expect(runsEndpoint).toBeDefined();
+    expect(runsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+  });
+
+  it('| applies an auth preProcess when configured', (): void => {
+    DyNTS_Scheduler_Controller.configure({
+      authPreProcess: async (): Promise<void> => {},
+    });
+    controller.setupEndpoints();
+
+    const runsEndpoint = controller.endpoints.find((ep) => ep.name === 'getSchedulerRuns');
+    expect((runsEndpoint as any)?.preProcesses?.length).toBeGreaterThan(0);
+
+    // visszaallitas, hogy ne szivarogjon at masik teszthez
+    DyNTS_Scheduler_Controller.configure({});
+  });
+});

package/src/_modules/scheduler/scheduler.controller.ts

@@ -1,69 +1,69 @@
-import { Request, Response } from 'express';
-
-import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_Controller } from '../../_services/route/controller.service';
-import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
-import { DyNTS_Scheduler_Service } from './scheduler.service';
-
-/**
- * A scheduler controller konfiguracioja.
- * Az authPreProcess opcionalis — ha megadod, a /runs endpoint vedett lesz.
- */
-export interface DyNTS_SchedulerController_Config {
-  /** Opcionalis auth preprocess. Ha nincs megadva → nyilt hozzaferes. */
-  authPreProcess?: (req: Request, res: Response) => Promise<void>;
-}
-
-/**
- * NTS Scheduler Controller — read-only futas-naplo endpoint a job-utemzohoz.
- *
- * Hasznalat:
- *   DyNTS_getSchedulerRoutingModule()  — auth nelkul
- *   DyNTS_getSchedulerRoutingModule({ authPreProcess: myAuth })  — auth-tal
- */
-export class DyNTS_Scheduler_Controller extends DyNTS_Controller {
-
-  private static config: DyNTS_SchedulerController_Config = {};
-
-  static configure(config: DyNTS_SchedulerController_Config): void {
-    DyNTS_Scheduler_Controller.config = config;
-  }
-
-  static getInstance(): DyNTS_Scheduler_Controller {
-    return DyNTS_Scheduler_Controller.getSingletonInstance();
-  }
-
-  private readonly schedulerService: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
-
-  setupEndpoints(): void {
-    const preProcesses: ((req: Request, res: Response) => Promise<void>)[] = [];
-    if (DyNTS_Scheduler_Controller.config.authPreProcess) {
-      preProcesses.push(DyNTS_Scheduler_Controller.config.authPreProcess);
-    }
-
-    this.endpoints = [
-      // GET /runs?limit=100 — utolso N futas, legujabb elol
-      new DyNTS_Endpoint_Params({
-        name: 'getSchedulerRuns',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/runs',
-        preProcesses: preProcesses,
-        logRequest: false,
-        tasks: [
-          async (req: Request, res: Response): Promise<void> => {
-            const limit: number = Math.min(parseInt(req.query.limit as string) || 100, 500);
-            const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = this.schedulerService.getRuns(limit);
-
-            res.send({
-              jobs: this.schedulerService.getJobKeys(),
-              started: this.schedulerService.isStarted(),
-              returned: runs.length,
-              runs: runs,
-            });
-          },
-        ],
-      }),
-    ];
-  }
-}
+import { Request, Response } from 'express';
+
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_Controller } from '../../_services/route/controller.service';
+import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_Scheduler_Service } from './scheduler.service';
+
+/**
+ * A scheduler controller konfiguracioja.
+ * Az authPreProcess opcionalis — ha megadod, a /runs endpoint vedett lesz.
+ */
+export interface DyNTS_SchedulerController_Config {
+  /** Opcionalis auth preprocess. Ha nincs megadva → nyilt hozzaferes. */
+  authPreProcess?: (req: Request, res: Response) => Promise<void>;
+}
+
+/**
+ * NTS Scheduler Controller — read-only futas-naplo endpoint a job-utemzohoz.
+ *
+ * Hasznalat:
+ *   DyNTS_getSchedulerRoutingModule()  — auth nelkul
+ *   DyNTS_getSchedulerRoutingModule({ authPreProcess: myAuth })  — auth-tal
+ */
+export class DyNTS_Scheduler_Controller extends DyNTS_Controller {
+
+  private static config: DyNTS_SchedulerController_Config = {};
+
+  static configure(config: DyNTS_SchedulerController_Config): void {
+    DyNTS_Scheduler_Controller.config = config;
+  }
+
+  static getInstance(): DyNTS_Scheduler_Controller {
+    return DyNTS_Scheduler_Controller.getSingletonInstance();
+  }
+
+  private readonly schedulerService: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
+
+  setupEndpoints(): void {
+    const preProcesses: ((req: Request, res: Response) => Promise<void>)[] = [];
+    if (DyNTS_Scheduler_Controller.config.authPreProcess) {
+      preProcesses.push(DyNTS_Scheduler_Controller.config.authPreProcess);
+    }
+
+    this.endpoints = [
+      // GET /runs?limit=100 — utolso N futas, legujabb elol
+      new DyNTS_Endpoint_Params({
+        name: 'getSchedulerRuns',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/runs',
+        preProcesses: preProcesses,
+        logRequest: false,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            const limit: number = Math.min(parseInt(req.query.limit as string) || 100, 500);
+            const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = this.schedulerService.getRuns(limit);
+
+            res.send({
+              jobs: this.schedulerService.getJobKeys(),
+              started: this.schedulerService.isStarted(),
+              returned: runs.length,
+              runs: runs,
+            });
+          },
+        ],
+      }),
+    ];
+  }
+}

package/src/_modules/scheduler/scheduler.service.spec.ts

@@ -1,141 +1,141 @@
-import { DyNTS_Scheduler_Service } from './scheduler.service';
-
-describe('| DyNTS_Scheduler_Service', (): void => {
-  let svc: DyNTS_Scheduler_Service;
-
-  beforeEach((): void => {
-    svc = DyNTS_Scheduler_Service.getInstance();
-    svc._resetForTesting();
-  });
-
-  afterEach((): void => {
-    svc._resetForTesting();
-  });
-
-  describe('| singleton', (): void => {
-    it('| returns the same instance', (): void => {
-      const a: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
-      const b: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
-      expect(a).toBe(b);
-      expect(a).toBeInstanceOf(DyNTS_Scheduler_Service);
-    });
-  });
-
-  describe('| registerJob', (): void => {
-    it('| registers a job by key', (): void => {
-      svc.registerJob({ key: 'a', intervalMs: 1000, handler: (): void => {} });
-      expect(svc.getJobKeys()).toEqual(['a']);
-    });
-
-    it('| throws on duplicate key', (): void => {
-      svc.registerJob({ key: 'dup', intervalMs: 1000, handler: (): void => {} });
-      expect((): void => svc.registerJob({ key: 'dup', intervalMs: 1000, handler: (): void => {} })).toThrow();
-    });
-
-    it('| throws on missing key', (): void => {
-      expect((): void => svc.registerJob({ key: '', intervalMs: 1000, handler: (): void => {} })).toThrow();
-    });
-
-    it('| throws on non-positive intervalMs', (): void => {
-      expect((): void => svc.registerJob({ key: 'x', intervalMs: 0, handler: (): void => {} })).toThrow();
-    });
-  });
-
-  describe('| unregisterJob', (): void => {
-    it('| removes a registered job', (): void => {
-      svc.registerJob({ key: 'a', intervalMs: 1000, handler: (): void => {} });
-      svc.unregisterJob('a');
-      expect(svc.getJobKeys()).toEqual([]);
-    });
-
-    it('| is a no-op for unknown key', (): void => {
-      expect((): void => svc.unregisterJob('nope')).not.toThrow();
-    });
-  });
-
-  describe('| start / stop', (): void => {
-    it('| start marks the scheduler started', (): void => {
-      expect(svc.isStarted()).toBe(false);
-      svc.start();
-      expect(svc.isStarted()).toBe(true);
-    });
-
-    it('| stop marks the scheduler stopped', (): void => {
-      svc.start();
-      svc.stop();
-      expect(svc.isStarted()).toBe(false);
-    });
-
-    it('| start is idempotent', (): void => {
-      svc.start();
-      svc.start();
-      expect(svc.isStarted()).toBe(true);
-    });
-  });
-
-  describe('| runNow', (): void => {
-    it('| executes the handler and records a success run', async (): Promise<void> => {
-      let calls: number = 0;
-      svc.registerJob({ key: 'ok', intervalMs: 1000, handler: (): void => { calls++; } });
-
-      await svc.runNow('ok');
-
-      expect(calls).toBe(1);
-      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
-      expect(runs.length).toBe(1);
-      expect(runs[0].jobKey).toBe('ok');
-      expect(runs[0].status).toBe('success');
-      expect(runs[0].finishedAt).toBeDefined();
-    });
-
-    it('| records a failed run with a rich error message', async (): Promise<void> => {
-      svc.registerJob({ key: 'bad', intervalMs: 1000, handler: (): void => { throw new Error('boom'); } });
-
-      await svc.runNow('bad');
-
-      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
-      expect(runs[0].status).toBe('failed');
-      expect(runs[0].error).toContain('boom');
-    });
-
-    it('| throws for an unknown job key', async (): Promise<void> => {
-      let thrown: unknown = null;
-      try { await svc.runNow('nope'); } catch (error: unknown) { thrown = error; }
-      expect(thrown).not.toBeNull();
-    });
-
-    it('| skip-if-running prevents overlapping executions', async (): Promise<void> => {
-      let active: number = 0;
-      let maxActive: number = 0;
-      svc.registerJob({
-        key: 'lock',
-        intervalMs: 1000,
-        handler: async (): Promise<void> => {
-          active++;
-          maxActive = Math.max(maxActive, active);
-          await new Promise<void>((resolve: () => void): void => { setTimeout(resolve, 20); });
-          active--;
-        },
-      });
-
-      await Promise.all([svc.runNow('lock'), svc.runNow('lock')]);
-
-      expect(maxActive).toBe(1);
-    });
-  });
-
-  describe('| getRuns', (): void => {
-    it('| returns the most recent run first', async (): Promise<void> => {
-      svc.registerJob({ key: 'first', intervalMs: 1000, handler: (): void => {} });
-      svc.registerJob({ key: 'second', intervalMs: 1000, handler: (): void => {} });
-
-      await svc.runNow('first');
-      await svc.runNow('second');
-
-      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
-      expect(runs.length).toBe(2);
-      expect(runs[0].jobKey).toBe('second');
-      expect(runs[1].jobKey).toBe('first');
-    });
-  });
-});
+import { DyNTS_Scheduler_Service } from './scheduler.service';
+
+describe('| DyNTS_Scheduler_Service', (): void => {
+  let svc: DyNTS_Scheduler_Service;
+
+  beforeEach((): void => {
+    svc = DyNTS_Scheduler_Service.getInstance();
+    svc._resetForTesting();
+  });
+
+  afterEach((): void => {
+    svc._resetForTesting();
+  });
+
+  describe('| singleton', (): void => {
+    it('| returns the same instance', (): void => {
+      const a: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
+      const b: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
+      expect(a).toBe(b);
+      expect(a).toBeInstanceOf(DyNTS_Scheduler_Service);
+    });
+  });
+
+  describe('| registerJob', (): void => {
+    it('| registers a job by key', (): void => {
+      svc.registerJob({ key: 'a', intervalMs: 1000, handler: (): void => {} });
+      expect(svc.getJobKeys()).toEqual(['a']);
+    });
+
+    it('| throws on duplicate key', (): void => {
+      svc.registerJob({ key: 'dup', intervalMs: 1000, handler: (): void => {} });
+      expect((): void => svc.registerJob({ key: 'dup', intervalMs: 1000, handler: (): void => {} })).toThrow();
+    });
+
+    it('| throws on missing key', (): void => {
+      expect((): void => svc.registerJob({ key: '', intervalMs: 1000, handler: (): void => {} })).toThrow();
+    });
+
+    it('| throws on non-positive intervalMs', (): void => {
+      expect((): void => svc.registerJob({ key: 'x', intervalMs: 0, handler: (): void => {} })).toThrow();
+    });
+  });
+
+  describe('| unregisterJob', (): void => {
+    it('| removes a registered job', (): void => {
+      svc.registerJob({ key: 'a', intervalMs: 1000, handler: (): void => {} });
+      svc.unregisterJob('a');
+      expect(svc.getJobKeys()).toEqual([]);
+    });
+
+    it('| is a no-op for unknown key', (): void => {
+      expect((): void => svc.unregisterJob('nope')).not.toThrow();
+    });
+  });
+
+  describe('| start / stop', (): void => {
+    it('| start marks the scheduler started', (): void => {
+      expect(svc.isStarted()).toBe(false);
+      svc.start();
+      expect(svc.isStarted()).toBe(true);
+    });
+
+    it('| stop marks the scheduler stopped', (): void => {
+      svc.start();
+      svc.stop();
+      expect(svc.isStarted()).toBe(false);
+    });
+
+    it('| start is idempotent', (): void => {
+      svc.start();
+      svc.start();
+      expect(svc.isStarted()).toBe(true);
+    });
+  });
+
+  describe('| runNow', (): void => {
+    it('| executes the handler and records a success run', async (): Promise<void> => {
+      let calls: number = 0;
+      svc.registerJob({ key: 'ok', intervalMs: 1000, handler: (): void => { calls++; } });
+
+      await svc.runNow('ok');
+
+      expect(calls).toBe(1);
+      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
+      expect(runs.length).toBe(1);
+      expect(runs[0].jobKey).toBe('ok');
+      expect(runs[0].status).toBe('success');
+      expect(runs[0].finishedAt).toBeDefined();
+    });
+
+    it('| records a failed run with a rich error message', async (): Promise<void> => {
+      svc.registerJob({ key: 'bad', intervalMs: 1000, handler: (): void => { throw new Error('boom'); } });
+
+      await svc.runNow('bad');
+
+      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
+      expect(runs[0].status).toBe('failed');
+      expect(runs[0].error).toContain('boom');
+    });
+
+    it('| throws for an unknown job key', async (): Promise<void> => {
+      let thrown: unknown = null;
+      try { await svc.runNow('nope'); } catch (error: unknown) { thrown = error; }
+      expect(thrown).not.toBeNull();
+    });
+
+    it('| skip-if-running prevents overlapping executions', async (): Promise<void> => {
+      let active: number = 0;
+      let maxActive: number = 0;
+      svc.registerJob({
+        key: 'lock',
+        intervalMs: 1000,
+        handler: async (): Promise<void> => {
+          active++;
+          maxActive = Math.max(maxActive, active);
+          await new Promise<void>((resolve: () => void): void => { setTimeout(resolve, 20); });
+          active--;
+        },
+      });
+
+      await Promise.all([svc.runNow('lock'), svc.runNow('lock')]);
+
+      expect(maxActive).toBe(1);
+    });
+  });
+
+  describe('| getRuns', (): void => {
+    it('| returns the most recent run first', async (): Promise<void> => {
+      svc.registerJob({ key: 'first', intervalMs: 1000, handler: (): void => {} });
+      svc.registerJob({ key: 'second', intervalMs: 1000, handler: (): void => {} });
+
+      await svc.runNow('first');
+      await svc.runNow('second');
+
+      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
+      expect(runs.length).toBe(2);
+      expect(runs[0].jobKey).toBe('second');
+      expect(runs[1].jobKey).toBe('first');
+    });
+  });
+});