refactor: wip tests

Author: BioPhoton

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

@@ -41,7 +41,26 @@ describe('PerformanceObserverSink', () => {
     expect(() => new PerformanceObserverSink(options)).not.toThrow();
   });
 
-  it('internal PerformanceObserver should process observed entries', async () => {
+  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('observes and encodes performance entries', async () => {
     const observer = new PerformanceObserverSink(options);
     observer.subscribe();
 
@@ -64,23 +83,26 @@ describe('PerformanceObserverSink', () => {
     );
   });
 
-  it('internal PerformanceObserver calls flush if flushThreshold exceeded', async () => {
+  it('handles multiple items per performance entry', async () => {
+    const multiEncodeFn = vi.fn(e => [
+      `${e.entryType}-item1`,
+      `${e.entryType}item2`,
+    ]);
     const observer = new PerformanceObserverSink({
       ...options,
-      flushThreshold: 3,
+      encodePerfEntry: multiEncodeFn,
     });
-    observer.subscribe();
 
-    performance.mark('test-mark1');
-    performance.mark('test-mark2');
-    performance.mark('test-mark3');
+    observer.subscribe();
 
+    performance.mark('test-mark');
     await awaitObserverCallback();
+    observer.flush();
 
-    expect(encode).toHaveBeenCalledTimes(3);
+    expect(sink.getWrittenItems()).toHaveLength(2);
   });
 
-  it('flush flushes observed entries when subscribed', async () => {
+  it('successfully writes queued items to sink', async () => {
     const observer = new PerformanceObserverSink(options);
     observer.subscribe();
 
@@ -96,86 +118,89 @@ describe('PerformanceObserverSink', () => {
     ]);
   });
 
-  it('flush calls encode for each entry', async () => {
+  it('observes performance entries when subscribed', async () => {
     const observer = new PerformanceObserverSink(options);
+
+    observer.subscribe();
+    performance.mark('test-mark-1');
+    performance.mark('test-mark-2');
+    await awaitObserverCallback();
+    observer.flush();
+    expect(sink.getWrittenItems()).toHaveLength(2);
+  });
+
+  it('triggers proactive flush when threshold 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();
-    observer.flush();
 
-    expect(encode).toHaveBeenCalledWith(
-      expect.objectContaining({
-        name: 'test-mark1',
-        entryType: 'mark',
-      }),
-    );
-    expect(encode).toHaveBeenCalledWith(
-      expect.objectContaining({
-        name: 'test-mark2',
-        entryType: 'mark',
-      }),
-    );
+    expect(encode).toHaveBeenCalledTimes(3);
   });
 
-  it('unsubscribe stops observing performance entries', async () => {
+  it('keeps items in queue when sink write fails', async () => {
+    const failingSink = new MockSink();
+    failingSink.open();
+    failingSink.write.mockImplementation(() => {
+      throw new Error('Sink write failed');
+    });
+
     const observer = new PerformanceObserverSink({
-      ...options,
+      sink: failingSink,
+      encodePerfEntry: encode,
       flushThreshold: 1,
+      maxQueueSize: 10,
     });
 
     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');
+    performance.mark('test-mark');
     await awaitObserverCallback();
-    expect(encode).toHaveBeenCalledTimes(2);
+
+    const stats = observer.getStats();
+    expect(stats.dropped).toBe(0);
+    expect(stats.queued).toBe(1);
   });
 
-  it('should observe performance entries and write them to the sink on flush', async () => {
-    const observer = new PerformanceObserverSink(options);
+  it('keeps items in queue when sink is closed during flush', async () => {
+    const closedSink = new MockSink();
+    closedSink.open();
+    closedSink.close();
+
+    const observer = new PerformanceObserverSink({
+      sink: closedSink,
+      encodePerfEntry: encode,
+    });
 
     observer.subscribe();
+
     performance.mark('test-mark');
     await awaitObserverCallback();
-    observer.flush();
-    expect(sink.getWrittenItems()).toHaveLength(1);
-  });
 
-  it('should observe performance entries when subscribed', async () => {
-    const observer = new PerformanceObserverSink(options);
-
-    observer.subscribe();
-    performance.mark('test-mark-1');
-    performance.mark('test-mark-2');
-    await awaitObserverCallback();
-    observer.flush();
-    expect(sink.getWrittenItems()).toHaveLength(2);
+    const stats = observer.getStats();
+    expect(stats.queued).toBe(1);
+    expect(stats.dropped).toBe(0);
   });
 
-  it('handles multiple encoded items per performance entry', async () => {
-    const multiEncodeFn = vi.fn(e => [
-      `${e.entryType}-item1`,
-      `${e.entryType}item2`,
-    ]);
+  it('handles flush errors gracefully without losing items', async () => {
     const observer = new PerformanceObserverSink({
-      ...options,
-      encodePerfEntry: multiEncodeFn,
+      sink,
+      encodePerfEntry: encode,
     });
 
     observer.subscribe();
 
     performance.mark('test-mark');
     await awaitObserverCallback();
-    observer.flush();
 
-    expect(sink.getWrittenItems()).toHaveLength(2);
+    const stats = observer.getStats();
+    expect(stats.queued).toBeGreaterThanOrEqual(0);
   });
 });