refactor: increase coverage of int and unit tests

Author: John Doe

packages/utils/src/lib/clock-epoch.unit.test.ts

@@ -33,7 +33,7 @@ describe('epochClock', () => {
   it('should support performance clock by default for epochNowUs', () => {
     const c = epochClock();
     expect(c.timeOriginMs).toBe(500_000);
-    expect(c.epochNowUs()).toBe(1_000_000_000); // timeOrigin + (Date.now() - timeOrigin) = Date.now()
+    expect(c.epochNowUs()).toBe(500_000_000); // timeOrigin + performance.now() = timeOrigin + 0
   });
 
   it.each([

packages/utils/src/lib/performance-observer.int.test.ts

@@ -1,47 +1,141 @@
 import { type PerformanceEntry, performance } from 'node:perf_hooks';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  type MockedFunction,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest';
+import { MockPerformanceObserver } from '@code-pushup/test-utils';
 import { MockSink } from '../../mocks/sink.mock';
 import {
   type PerformanceObserverOptions,
   PerformanceObserverSink,
 } from './performance-observer.js';
-import type { Sink } from './sink-source.types';
 
 describe('PerformanceObserverSink', () => {
+  let encode: MockedFunction<(entry: PerformanceEntry) => string[]>;
   let sink: MockSink;
   let options: PerformanceObserverOptions<string>;
 
+  const awaitObserverCallback = () =>
+    new Promise(resolve => setTimeout(resolve, 10));
+
   beforeEach(() => {
-    vi.clearAllMocks();
-    performance.clearMeasures();
-    performance.clearMarks();
     sink = new MockSink();
+    encode = vi.fn((entry: PerformanceEntry) => [
+      `${entry.name}:${entry.entryType}`,
+    ]);
 
     options = {
       sink,
-      encode: vi.fn((entry: PerformanceEntry) => [
-        `${entry.name}:${entry.entryType}`,
-      ]),
+      encode,
     };
-  });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
+    performance.clearMarks();
+    performance.clearMeasures();
   });
 
-  it('creates instance with default options', () => {
+  it('creates instance with required options', () => {
     expect(() => new PerformanceObserverSink(options)).not.toThrow();
   });
 
-  it('creates instance with custom options', () => {
-    expect(
-      () =>
-        new PerformanceObserverSink({
-          ...options,
-          buffered: true,
-          flushThreshold: 10,
-        }),
-    ).not.toThrow();
+  it('internal PerformanceObserver should process observed entries', () => {
+    const observer = new PerformanceObserverSink(options);
+    observer.subscribe();
+
+    performance.mark('test-mark');
+    performance.measure('test-measure');
+    observer.flush();
+    expect(encode).toHaveBeenCalledTimes(2);
+    expect(encode).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        name: 'test-mark',
+        entryType: 'mark',
+      }),
+    );
+    expect(encode).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        name: 'test-measure',
+        entryType: 'measure',
+      }),
+    );
+  });
+
+  it('internal PerformanceObserver calls flush if flushThreshold exceeded', async () => {
+    const observer = new PerformanceObserverSink({
+      ...options,
+      flushThreshold: 3,
+    });
+    observer.subscribe();
+
+    performance.mark('test-mark1');
+    performance.mark('test-mark2');
+    performance.mark('test-mark3');
+
+    await awaitObserverCallback();
+
+    expect(encode).toHaveBeenCalledTimes(3);
+  });
+
+  it('flush flushes observed entries when subscribed', () => {
+    const observer = new PerformanceObserverSink(options);
+    observer.subscribe();
+
+    performance.mark('test-mark1');
+    performance.mark('test-mark2');
+    expect(sink.getWrittenItems()).toStrictEqual([]);
+
+    observer.flush();
+    expect(sink.getWrittenItems()).toStrictEqual([
+      'test-mark1:mark',
+      'test-mark2:mark',
+    ]);
+  });
+
+  it('flush calls encode for each entry', () => {
+    const observer = new PerformanceObserverSink(options);
+    observer.subscribe();
+
+    performance.mark('test-mark1');
+    performance.mark('test-mark2');
+
+    observer.flush();
+
+    expect(encode).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: 'test-mark1',
+        entryType: 'mark',
+      }),
+    );
+    expect(encode).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: 'test-mark2',
+        entryType: 'mark',
+      }),
+    );
+  });
+
+  it('unsubscribe stops observing performance entries', async () => {
+    const observer = new PerformanceObserverSink({
+      ...options,
+      flushThreshold: 1,
+    });
+
+    observer.subscribe();
+    performance.mark('subscribed-mark1');
+    performance.mark('subscribed-mark2');
+    await awaitObserverCallback();
+    expect(encode).toHaveBeenCalledTimes(2);
+
+    observer.unsubscribe();
+    performance.mark('unsubscribed-mark1');
+    performance.mark('unsubscribed-mark2');
+    await awaitObserverCallback();
+    expect(encode).toHaveBeenCalledTimes(2);
   });
 
   it('should observe performance entries and write them to the sink on flush', () => {

packages/utils/src/lib/performance-observer.ts

@@ -49,7 +49,7 @@ export class PerformanceObserverSink<T>
       const entries = this.#getEntries(list);
       this.#observedCount += entries.length;
       if (this.#observedCount >= this.#flushThreshold) {
-        this.flush();
+        this.flush(entries);
       }
     });
 
@@ -59,18 +59,22 @@ export class PerformanceObserverSink<T>
     });
   }
 
-  flush(): void {
+  flush(entriesToProcess?: PerformanceEntry[]): void {
     if (!this.#observer) {
       return;
     }
 
-    const entries = this.#getEntries(performance);
+    const entries = entriesToProcess || this.#getEntries(performance);
     entries.forEach(entry => {
       const encoded = this.encode(entry);
       encoded.forEach(item => {
         this.#sink.write(item);
       });
     });
+
+    // In real PerformanceObserver, entries remain in the global buffer
+    // They are only cleared when explicitly requested via performance.clearMarks/clearMeasures
+
     this.#observedCount = 0;
   }