@futdevpro/nts-dynamo 1.15.72 → 1.15.74

package/src/_services/core/memory-guard.service.spec.ts

@@ -1,165 +1,245 @@
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-import { DyNTS_GlobalService } from './global.service';
-import { DyNTS_MemoryGuard } from './memory-guard.service';
-
-/**
- * FR-193 — a bedrock heap-watchdog spec-je. A `poll()`-t KÖZVETLENÜL hívjuk (nem
- * az intervallumra várunk), mockolt heap-plafonnal + `process.memoryUsage`-dzsel,
- * így determinisztikusan teszteljük a hiszterézis-állapotgépet + a tartós rögzítést.
- */
-
-const MB: number = 1024 * 1024;
-
-/**
- * A privát `getHeapLimitBytes` + `process.memoryUsage` mockolása adott heap-%-hoz.
- * Visszaadja a memoryUsage-spy-t, hogy a hívó később átállíthassa (recovery-teszt).
- * `process as any`: a `MemoryUsageFn` típus egy `.rss()` submetódust is hordoz, amit
- * egy egyszerű return-value mock nem elégít ki — a cast kikerüli ezt a teszt-zajt.
- */
-const mockHeap = (guard: DyNTS_MemoryGuard, limitMb: number, usedMb: number): jasmine.Spy => {
-  spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(limitMb * MB);
-  return spyOn(process as any, 'memoryUsage').and.returnValue({
-    heapUsed:      usedMb * MB,
-    heapTotal:     usedMb * MB,
-    rss:           (usedMb + 100) * MB,
-    external:      10 * MB,
-    arrayBuffers:  0,
-  } as NodeJS.MemoryUsage);
-};
-
-/** Egy poll-ciklus kézi kiváltása. */
-const poll = (guard: DyNTS_MemoryGuard): void => { (guard as any).poll(); };
-
-describe('| DyNTS_MemoryGuard (FR-193)', (): void => {
-
-  let guard: DyNTS_MemoryGuard;
-  let sinkSpy: jasmine.Spy;
-  let originalSink: typeof DyNTS_GlobalService.globalErrorHandler;
-  let originalSettings: typeof DyNTS_global_settings.memoryGuard;
-
-  beforeEach((): void => {
-    guard = DyNTS_MemoryGuard.getInstance();
-    guard._teardownForTesting();
-
-    originalSettings = DyNTS_global_settings.memoryGuard;
-    DyNTS_global_settings.memoryGuard = {
-      enabled: true,
-      pollIntervalMs: 999999,   // ne tüzeljen az intervallum a teszt alatt
-      heapWarningThreshold: 85,
-      heapCriticalThreshold: 95,
-      recoveryMargin: 10,
-      maxHistoryCount: 100,
-    };
-
-    originalSink = DyNTS_GlobalService.globalErrorHandler;
-    sinkSpy = jasmine.createSpy('globalErrorHandler');
-    (DyNTS_GlobalService as any).globalErrorHandler = sinkSpy;
-  });
-
-  afterEach((): void => {
-    guard._teardownForTesting();
-    (DyNTS_GlobalService as any).globalErrorHandler = originalSink;
-    DyNTS_global_settings.memoryGuard = originalSettings;
-  });
-
-  it('| install() idempotens — második hívás no-op', (): void => {
-    guard.install();
-    expect(guard.isInstalled()).toBe(true);
-    guard.install();  // nem dob, nem indít új timert
-    expect(guard.isInstalled()).toBe(true);
-  });
-
-  it('| install() SOHA nem dob, akkor sem ha a settings hiányos', (): void => {
-    DyNTS_global_settings.memoryGuard = undefined as any;
-    expect((): void => guard.install()).not.toThrow();
-    expect(guard.isInstalled()).toBe(true);
-  });
-
-  it('| warning küszöb alatt NINCS esemény', (): void => {
-    guard.install();
-    mockHeap(guard, 1000, 800);  // 80% < 85
-    poll(guard);
-    expect(guard.getHistory().length).toBe(0);
-    expect(sinkSpy).not.toHaveBeenCalled();
-  });
-
-  it('| warning küszöb átlépése → 1 warning esemény + tartós error-sink (level warning)', (): void => {
-    guard.install();
-    mockHeap(guard, 1000, 880);  // 88% ∈ [85, 95)
-    poll(guard);
-
-    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
-    expect(hist.length).toBe(1);
-    expect(hist[0].level).toBe('warning');
-    expect(hist[0].heapPct).toBe(88);
-    expect(sinkSpy).toHaveBeenCalledTimes(1);
-    expect(guard.getStatus().state).toBe('warning');
-  });
-
-  it('| warning-sávban maradva NINCS re-emit (hiszterézis)', (): void => {
-    guard.install();
-    mockHeap(guard, 1000, 880);  // 88% → warning
-    poll(guard);
-    poll(guard);  // még mindig 88% (ugyanaz a mock) → nincs új esemény
-    expect(guard.getHistory().length).toBe(1);
-  });
-
-  it('| critical küszöb átlépése → critical esemény + onCritical hook', (): void => {
-    const onCritical: jasmine.Spy = jasmine.createSpy('onCritical');
-    guard.install({ onCritical: onCritical });
-    mockHeap(guard, 1000, 970);  // 97% ≥ 95
-    poll(guard);
-
-    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
-    expect(hist[hist.length - 1].level).toBe('critical');
-    expect(onCritical).toHaveBeenCalledTimes(1);
-    expect(guard.getStatus().state).toBe('critical');
-  });
-
-  it('| helyreállás: a warning-margó alá esve → recovered esemény (sink NÉLKÜL)', (): void => {
-    guard.install();
-
-    const muSpy: jasmine.Spy = mockHeap(guard, 1000, 880);  // 88% → warning
-    poll(guard);
-    sinkSpy.calls.reset();
-    muSpy.and.returnValue({
-      heapUsed: 700 * MB, heapTotal: 700 * MB, rss: 800 * MB, external: 10 * MB, arrayBuffers: 0,
-    } as NodeJS.MemoryUsage);                 // 70% ≤ 85 - 10
-    poll(guard);
-
-    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
-    expect(hist[hist.length - 1].level).toBe('recovered');
-    expect(guard.getStatus().state).toBe('normal');
-    expect(sinkSpy).not.toHaveBeenCalled();   // recovered NEM ír az error-sinkbe
-  });
-
-  it('| history ring-buffer a maxHistoryCount-ra van kapva', (): void => {
-    DyNTS_global_settings.memoryGuard!.maxHistoryCount = 3;
-    guard.install();
-    spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(1000 * MB);
-    const high: NodeJS.MemoryUsage =
-      { heapUsed: 880 * MB, heapTotal: 880 * MB, rss: 980 * MB, external: 0, arrayBuffers: 0 } as NodeJS.MemoryUsage;
-    const low: NodeJS.MemoryUsage =
-      { heapUsed: 700 * MB, heapTotal: 700 * MB, rss: 800 * MB, external: 0, arrayBuffers: 0 } as NodeJS.MemoryUsage;
-    let tick: number = 0;
-    // warning ↔ recovered oszcilláció: páros tick=high (warning), páratlan=low (recovered)
-    spyOn(process as any, 'memoryUsage').and.callFake((): NodeJS.MemoryUsage => (tick++ % 2 === 0 ? high : low));
-    for (let k: number = 0; k < 8; k++) { poll(guard); }  // 8 állapot-váltás, csak 3 marad
-    expect(guard.getHistory().length).toBe(3);
-  });
-
-  it('| poll() SOHA nem dob (heap limit 0 → no-op)', (): void => {
-    guard.install();
-    spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(0);
-    expect((): void => poll(guard)).not.toThrow();
-    expect(guard.getHistory().length).toBe(0);
-  });
-
-  it('| getStatus a csúcsokat is követi', (): void => {
-    guard.install();
-    mockHeap(guard, 1000, 920);  // 92%
-    poll(guard);
-    expect(guard.getStatus().peakHeapPct).toBe(92);
-    expect(guard.getStatus().peakRssMb).toBeGreaterThan(0);
-  });
-});
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_GlobalService } from './global.service';
+import { DyNTS_MemoryGuard } from './memory-guard.service';
+
+/**
+ * FR-193 — a bedrock heap-watchdog spec-je. A `poll()`-t KÖZVETLENÜL hívjuk (nem
+ * az intervallumra várunk), mockolt heap-plafonnal + `process.memoryUsage`-dzsel,
+ * így determinisztikusan teszteljük a hiszterézis-állapotgépet + a tartós rögzítést.
+ */
+
+const MB: number = 1024 * 1024;
+
+/**
+ * A privát `getHeapLimitBytes` + `process.memoryUsage` mockolása adott heap-%-hoz.
+ * Visszaadja a memoryUsage-spy-t, hogy a hívó később átállíthassa (recovery-teszt).
+ * `process as any`: a `MemoryUsageFn` típus egy `.rss()` submetódust is hordoz, amit
+ * egy egyszerű return-value mock nem elégít ki — a cast kikerüli ezt a teszt-zajt.
+ */
+const mockHeap = (guard: DyNTS_MemoryGuard, limitMb: number, usedMb: number): jasmine.Spy => {
+  spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(limitMb * MB);
+  return spyOn(process as any, 'memoryUsage').and.returnValue({
+    heapUsed:      usedMb * MB,
+    heapTotal:     usedMb * MB,
+    rss:           (usedMb + 100) * MB,
+    external:      10 * MB,
+    arrayBuffers:  0,
+  } as NodeJS.MemoryUsage);
+};
+
+/** Egy poll-ciklus kézi kiváltása. */
+const poll = (guard: DyNTS_MemoryGuard): void => { (guard as any).poll(); };
+
+describe('| DyNTS_MemoryGuard (FR-193)', (): void => {
+
+  let guard: DyNTS_MemoryGuard;
+  let sinkSpy: jasmine.Spy;
+  let originalSink: typeof DyNTS_GlobalService.globalErrorHandler;
+  let originalSettings: typeof DyNTS_global_settings.memoryGuard;
+
+  beforeEach((): void => {
+    guard = DyNTS_MemoryGuard.getInstance();
+    guard._teardownForTesting();
+
+    originalSettings = DyNTS_global_settings.memoryGuard;
+    DyNTS_global_settings.memoryGuard = {
+      enabled: true,
+      pollIntervalMs: 999999,   // ne tüzeljen az intervallum a teszt alatt
+      heapWarningThreshold: 85,
+      heapCriticalThreshold: 95,
+      recoveryMargin: 10,
+      maxHistoryCount: 100,
+      gcWarningFraction: 0.40,
+      gcCriticalFraction: 0.60,
+      // A tesztek NE regisztráljanak process-szintű crash-handlert / ne lépjenek ki (a jasmine-harness védelme).
+      installCrashHandlers: false,
+      exitOnSustainedCritical: false,
+    };
+
+    originalSink = DyNTS_GlobalService.globalErrorHandler;
+    sinkSpy = jasmine.createSpy('globalErrorHandler');
+    (DyNTS_GlobalService as any).globalErrorHandler = sinkSpy;
+  });
+
+  afterEach((): void => {
+    guard._teardownForTesting();
+    (DyNTS_GlobalService as any).globalErrorHandler = originalSink;
+    DyNTS_global_settings.memoryGuard = originalSettings;
+  });
+
+  it('| install() idempotens — második hívás no-op', (): void => {
+    guard.install();
+    expect(guard.isInstalled()).toBe(true);
+    guard.install();  // nem dob, nem indít új timert
+    expect(guard.isInstalled()).toBe(true);
+  });
+
+  it('| install() SOHA nem dob, akkor sem ha a settings hiányos', (): void => {
+    DyNTS_global_settings.memoryGuard = undefined as any;
+    expect((): void => guard.install()).not.toThrow();
+    expect(guard.isInstalled()).toBe(true);
+  });
+
+  it('| warning küszöb alatt NINCS esemény', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 800);  // 80% < 85
+    poll(guard);
+    expect(guard.getHistory().length).toBe(0);
+    expect(sinkSpy).not.toHaveBeenCalled();
+  });
+
+  it('| warning küszöb átlépése → 1 warning esemény + tartós error-sink (level warning)', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 880);  // 88% ∈ [85, 95)
+    poll(guard);
+
+    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
+    expect(hist.length).toBe(1);
+    expect(hist[0].level).toBe('warning');
+    expect(hist[0].heapPct).toBe(88);
+    expect(sinkSpy).toHaveBeenCalledTimes(1);
+    expect(guard.getStatus().state).toBe('warning');
+  });
+
+  it('| warning-sávban maradva NINCS re-emit (hiszterézis)', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 880);  // 88% → warning
+    poll(guard);
+    poll(guard);  // még mindig 88% (ugyanaz a mock) → nincs új esemény
+    expect(guard.getHistory().length).toBe(1);
+  });
+
+  it('| critical küszöb átlépése → critical esemény + onCritical hook', (): void => {
+    const onCritical: jasmine.Spy = jasmine.createSpy('onCritical');
+    guard.install({ onCritical: onCritical });
+    mockHeap(guard, 1000, 970);  // 97% ≥ 95
+    poll(guard);
+
+    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
+    expect(hist[hist.length - 1].level).toBe('critical');
+    expect(onCritical).toHaveBeenCalledTimes(1);
+    expect(guard.getStatus().state).toBe('critical');
+  });
+
+  it('| helyreállás: a warning-margó alá esve → recovered esemény (sink NÉLKÜL)', (): void => {
+    guard.install();
+
+    const muSpy: jasmine.Spy = mockHeap(guard, 1000, 880);  // 88% → warning
+    poll(guard);
+    sinkSpy.calls.reset();
+    muSpy.and.returnValue({
+      heapUsed: 700 * MB, heapTotal: 700 * MB, rss: 800 * MB, external: 10 * MB, arrayBuffers: 0,
+    } as NodeJS.MemoryUsage);                 // 70% ≤ 85 - 10
+    poll(guard);
+
+    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
+    expect(hist[hist.length - 1].level).toBe('recovered');
+    expect(guard.getStatus().state).toBe('normal');
+    expect(sinkSpy).not.toHaveBeenCalled();   // recovered NEM ír az error-sinkbe
+  });
+
+  it('| history ring-buffer a maxHistoryCount-ra van kapva', (): void => {
+    DyNTS_global_settings.memoryGuard!.maxHistoryCount = 3;
+    guard.install();
+    spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(1000 * MB);
+    const high: NodeJS.MemoryUsage =
+      { heapUsed: 880 * MB, heapTotal: 880 * MB, rss: 980 * MB, external: 0, arrayBuffers: 0 } as NodeJS.MemoryUsage;
+    const low: NodeJS.MemoryUsage =
+      { heapUsed: 700 * MB, heapTotal: 700 * MB, rss: 800 * MB, external: 0, arrayBuffers: 0 } as NodeJS.MemoryUsage;
+    let tick: number = 0;
+    // warning ↔ recovered oszcilláció: páros tick=high (warning), páratlan=low (recovered)
+    spyOn(process as any, 'memoryUsage').and.callFake((): NodeJS.MemoryUsage => (tick++ % 2 === 0 ? high : low));
+    for (let k: number = 0; k < 8; k++) { poll(guard); }  // 8 állapot-váltás, csak 3 marad
+    expect(guard.getHistory().length).toBe(3);
+  });
+
+  it('| poll() SOHA nem dob (heap limit 0 → no-op)', (): void => {
+    guard.install();
+    spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(0);
+    expect((): void => poll(guard)).not.toThrow();
+    expect(guard.getHistory().length).toBe(0);
+  });
+
+  it('| getStatus a csúcsokat is követi', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 920);  // 92%
+    poll(guard);
+    expect(guard.getStatus().peakHeapPct).toBe(92);
+    expect(guard.getStatus().peakRssMb).toBeGreaterThan(0);
+  });
+
+  // --- GC-thrash precursor (a %-küszöb ALATT is OOM-jel) ---
+
+  it('| GC-thrash kritikus, bár a heap-% csak 70% (a %-küszöb ALATT) — trigger=gc', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 700);  // 70% < warn 85
+    spyOn(guard as any, 'recentGcFraction').and.returnValue(0.65);  // GC 65% ≥ crit 60%
+    poll(guard);
+    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
+    expect(hist[hist.length - 1].level).toBe('critical');
+    expect(hist[hist.length - 1].trigger).toBe('gc');
+    expect(sinkSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('| közepes GC (40–60%) alacsony heap-nél → warning (trigger=gc)', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 700);  // 70%
+    spyOn(guard as any, 'recentGcFraction').and.returnValue(0.45);
+    poll(guard);
+    expect(guard.getHistory()[0].level).toBe('warning');
+    expect(guard.getHistory()[0].trigger).toBe('gc');
+  });
+
+  // --- pressure() / shouldShedLoad() — a fogyasztói load-shed gate ---
+
+  it('| pressure() a heap-% + GC közül a rosszabb szintet adja; shouldShedLoad critical-nál true', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 970);  // 97% ≥ crit
+    spyOn(guard as any, 'recentGcFraction').and.returnValue(0.0);
+    const p = guard.pressure();
+    expect(p.level).toBe('critical');
+    expect(p.heapPct).toBe(97);
+    expect(guard.shouldShedLoad()).toBe(true);
+  });
+
+  it('| shouldShedLoad false, ha ok-szint (alacsony heap + alacsony GC)', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 500);  // 50%
+    spyOn(guard as any, 'recentGcFraction').and.returnValue(0.10);
+    expect(guard.pressure().level).toBe('ok');
+    expect(guard.shouldShedLoad()).toBe(false);
+  });
+
+  // --- graceful-exit: tartós critical → exit (a wrapper újraindít) ---
+
+  it('| exitOnSustainedCritical: N egymás utáni critical poll → gracefulExit (process.exit)', (): void => {
+    DyNTS_global_settings.memoryGuard!.exitOnSustainedCritical = true;
+    DyNTS_global_settings.memoryGuard!.sustainedCriticalPolls = 3;
+    DyNTS_global_settings.memoryGuard!.bootGraceMs = 0;   // nincs grace → azonnal élesedik
+    const exitSpy: jasmine.Spy = spyOn(guard as any, 'gracefulExit').and.stub();
+    guard.install();
+    mockHeap(guard, 1000, 970);  // 97% critical
+    spyOn(guard as any, 'recentGcFraction').and.returnValue(0.0);
+    poll(guard); poll(guard);
+    expect(exitSpy).not.toHaveBeenCalled();   // 2 critical < 3
+    poll(guard);
+    expect(exitSpy).toHaveBeenCalledTimes(1);  // a 3. critical → exit
+  });
+
+  it('| BOOT-GRACE: a grace alatt a sustained-critical NEM lép ki; a grace után IGEN', (): void => {
+    DyNTS_global_settings.memoryGuard!.exitOnSustainedCritical = true;
+    DyNTS_global_settings.memoryGuard!.sustainedCriticalPolls = 3;
+    DyNTS_global_settings.memoryGuard!.bootGraceMs = 60000;   // 60s grace
+    const exitSpy: jasmine.Spy = spyOn(guard as any, 'gracefulExit').and.stub();
+    guard.install();
+    mockHeap(guard, 1000, 970);  // 97% critical
+    spyOn(guard as any, 'recentGcFraction').and.returnValue(0.0);
+    // A grace ALATT (installedAt épp most): hiába N+ critical poll, NINCS exit.
+    poll(guard); poll(guard); poll(guard); poll(guard);
+    expect(exitSpy).not.toHaveBeenCalled();
+    // A grace UTÁN (installedAt 61s-cel ezelőttre állítva): a következő critical poll már kilép.
+    (guard as any).installedAt = Date.now() - 61000;
+    poll(guard);
+    expect(exitSpy).toHaveBeenCalledTimes(1);
+  });
+});