test(replay): Rename & streamline replay test modules

Author: mydea

packages/replay/src/coreHandlers/handleFetch.ts

@@ -1,5 +1,5 @@
-import type { ReplayPerformanceEntry } from '../createPerformanceEntry';
 import type { ReplayContainer } from '../types';
+import type { ReplayPerformanceEntry } from '../util/createPerformanceEntry';
 import { createPerformanceSpans } from '../util/createPerformanceSpans';
 import { shouldFilterRequest } from '../util/shouldFilterRequest';
 

packages/replay/src/coreHandlers/handleHistory.ts

@@ -1,5 +1,5 @@
-import { ReplayPerformanceEntry } from '../createPerformanceEntry';
 import type { ReplayContainer } from '../types';
+import { ReplayPerformanceEntry } from '../util/createPerformanceEntry';
 import { createPerformanceSpans } from '../util/createPerformanceSpans';
 
 interface HistoryHandlerData {

packages/replay/src/coreHandlers/handleXhr.ts

@@ -1,5 +1,5 @@
-import { ReplayPerformanceEntry } from '../createPerformanceEntry';
 import type { ReplayContainer } from '../types';
+import { ReplayPerformanceEntry } from '../util/createPerformanceEntry';
 import { createPerformanceSpans } from '../util/createPerformanceSpans';
 import { shouldFilterRequest } from '../util/shouldFilterRequest';
 

packages/replay/src/replay.ts

@@ -18,7 +18,6 @@ import { handleGlobalEventListener } from './coreHandlers/handleGlobalEvent';
 import { handleHistorySpanListener } from './coreHandlers/handleHistory';
 import { handleXhrSpanListener } from './coreHandlers/handleXhr';
 import { setupPerformanceObserver } from './coreHandlers/performanceObserver';
-import { createPerformanceEntries } from './createPerformanceEntry';
 import { createEventBuffer } from './eventBuffer';
 import { deleteSession } from './session/deleteSession';
 import { getSession } from './session/getSession';
@@ -42,6 +41,7 @@ import { addEvent } from './util/addEvent';
 import { addMemoryEntry } from './util/addMemoryEntry';
 import { createBreadcrumb } from './util/createBreadcrumb';
 import { createPayload } from './util/createPayload';
+import { createPerformanceEntries } from './util/createPerformanceEntry';
 import { createPerformanceSpans } from './util/createPerformanceSpans';
 import { createReplayEnvelope } from './util/createReplayEnvelope';
 import { debounce } from './util/debounce';

packages/replay/src/createPerformanceEntry.ts renamed to packages/replay/src/util/createPerformanceEntry.ts

@@ -1,8 +1,8 @@
 import { browserPerformanceTimeOrigin } from '@sentry/utils';
 import { record } from 'rrweb';
 
-import { WINDOW } from './constants';
-import type { AllPerformanceEntry, PerformanceNavigationTiming, PerformancePaintTiming } from './types';
+import { WINDOW } from '../constants';
+import type { AllPerformanceEntry, PerformanceNavigationTiming, PerformancePaintTiming } from '../types';
 
 export interface ReplayPerformanceEntry {
   /**

packages/replay/src/util/createPerformanceSpans.ts

@@ -1,8 +1,8 @@
 import { EventType } from 'rrweb';
 
-import { ReplayPerformanceEntry } from '../createPerformanceEntry';
 import type { ReplayContainer } from '../types';
 import { addEvent } from './addEvent';
+import { ReplayPerformanceEntry } from './createPerformanceEntry';
 
 /**
  * Create a "span" for each performance entry. The parent transaction is `this.replayEvent`.

packages/replay/test/integration/autoSaveSession.test.ts

@@ -0,0 +1,57 @@
+import { EventType } from 'rrweb';
+
+import type { RecordingEvent } from '../../src/types';
+import { addEvent } from '../../src/util/addEvent';
+import { resetSdkMock } from '../mocks/resetSdkMock';
+import { useFakeTimers } from '../utils/use-fake-timers';
+
+useFakeTimers();
+
+describe('Integration | autoSaveSession', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test.each([
+    ['with stickySession=true', true, 1],
+    ['with stickySession=false', false, 0],
+  ])('%s', async (_: string, stickySession: boolean, addSummand: number) => {
+    let saveSessionSpy;
+
+    jest.mock('../../src/session/saveSession', () => {
+      saveSessionSpy = jest.fn();
+
+      return {
+        saveSession: saveSessionSpy,
+      };
+    });
+
+    const { replay } = await resetSdkMock({
+      replayOptions: {
+        stickySession,
+      },
+    });
+
+    // Initially called up to three times: once for start, then once for replay.updateSessionActivity & once for segmentId increase
+    expect(saveSessionSpy).toHaveBeenCalledTimes(addSummand * 3);
+
+    replay.updateSessionActivity();
+
+    expect(saveSessionSpy).toHaveBeenCalledTimes(addSummand * 4);
+
+    // In order for runFlush to actually do something, we need to add an event
+    const event = {
+      type: EventType.Custom,
+      data: {
+        tag: 'test custom',
+      },
+      timestamp: new Date().valueOf(),
+    } as RecordingEvent;
+
+    addEvent(replay, event);
+
+    await replay.runFlush();
+
+    expect(saveSessionSpy).toHaveBeenCalledTimes(addSummand * 5);
+  });
+});

packages/replay/test/integration/coreHandlers/handleGlobalEvent.test.ts

@@ -16,7 +16,7 @@ import { useFakeTimers } from '../../utils/use-fake-timers';
 useFakeTimers();
 let replay: ReplayContainer;
 
-describe('handleGlobalEvent', () => {
+describe('Integration | coreHandlers | handleGlobalEvent', () => {
   beforeEach(async () => {
     ({ replay } = await resetSdkMock({
       replayOptions: {

packages/replay/test/integration/coreHandlers/handleScope.test.ts

@@ -3,29 +3,27 @@ import { getCurrentHub } from '@sentry/core';
 import * as HandleScope from '../../../src/coreHandlers/handleScope';
 import { mockSdk } from './../../index';
 
-let mockHandleScope: jest.MockedFunction<typeof HandleScope.handleScope>;
-
 jest.useFakeTimers();
 
-beforeAll(async function () {
-  await mockSdk();
-  jest.spyOn(HandleScope, 'handleScope');
-  mockHandleScope = HandleScope.handleScope as jest.MockedFunction<typeof HandleScope.handleScope>;
-
-  jest.runAllTimers();
-});
+describe('Integration | coreHandlers | handleScope', () => {
+  beforeAll(async function () {
+    await mockSdk();
+    jest.runAllTimers();
+  });
 
-it('returns a breadcrumb only if last breadcrumb has changed (integration)', function () {
-  getCurrentHub().getScope()?.addBreadcrumb({ message: 'testing' });
+  it('returns a breadcrumb only if last breadcrumb has changed', function () {
+    const mockHandleScope = jest.spyOn(HandleScope, 'handleScope');
+    getCurrentHub().getScope()?.addBreadcrumb({ message: 'testing' });
 
-  expect(mockHandleScope).toHaveBeenCalledTimes(1);
-  expect(mockHandleScope).toHaveReturnedWith(expect.objectContaining({ message: 'testing' }));
+    expect(mockHandleScope).toHaveBeenCalledTimes(1);
+    expect(mockHandleScope).toHaveReturnedWith(expect.objectContaining({ message: 'testing' }));
 
-  mockHandleScope.mockClear();
+    mockHandleScope.mockClear();
 
-  // This will trigger breadcrumb/scope listener, but handleScope should return
-  // null because breadcrumbs has not changed
-  getCurrentHub().getScope()?.setUser({ email: '[email protected]' });
-  expect(mockHandleScope).toHaveBeenCalledTimes(1);
-  expect(mockHandleScope).toHaveReturnedWith(null);
+    // This will trigger breadcrumb/scope listener, but handleScope should return
+    // null because breadcrumbs has not changed
+    getCurrentHub().getScope()?.setUser({ email: '[email protected]' });
+    expect(mockHandleScope).toHaveBeenCalledTimes(1);
+    expect(mockHandleScope).toHaveReturnedWith(null);
+  });
 });

packages/replay/test/integration/errorSampleRate.test.ts

@@ -16,7 +16,7 @@ async function advanceTimers(time: number) {
   await new Promise(process.nextTick);
 }
 
-describe('Replay (errorSampleRate)', () => {
+describe('Integration | errorSampleRate', () => {
   let replay: ReplayContainer;
   let mockRecord: RecordMock;
   let domHandler: DomHandler;

packages/replay/test/integration/eventProcessors.test.ts

@@ -0,0 +1,82 @@
+import { getCurrentHub } from '@sentry/core';
+import { Event, Hub, Scope } from '@sentry/types';
+
+import { BASE_TIMESTAMP } from '..';
+import { resetSdkMock } from '../mocks/resetSdkMock';
+import { useFakeTimers } from '../utils/use-fake-timers';
+
+useFakeTimers();
+
+describe('Integration | eventProcessors', () => {
+  let hub: Hub;
+  let scope: Scope;
+
+  beforeEach(() => {
+    hub = getCurrentHub();
+    scope = hub.pushScope();
+  });
+
+  afterEach(() => {
+    hub.popScope();
+    jest.resetAllMocks();
+  });
+
+  it('handles event processors properly', async () => {
+    const MUTATED_TIMESTAMP = BASE_TIMESTAMP + 3000;
+
+    const { mockRecord } = await resetSdkMock({
+      replayOptions: {
+        stickySession: false,
+      },
+    });
+
+    const client = hub.getClient()!;
+
+    jest.runAllTimers();
+    const mockTransportSend = jest.spyOn(client.getTransport()!, 'send');
+    mockTransportSend.mockReset();
+
+    const handler1 = jest.fn((event: Event): Event | null => {
+      event.timestamp = MUTATED_TIMESTAMP;
+
+      return event;
+    });
+
+    const handler2 = jest.fn((): Event | null => {
+      return null;
+    });
+
+    scope.addEventProcessor(handler1);
+
+    const TEST_EVENT = { data: {}, timestamp: BASE_TIMESTAMP, type: 3 };
+
+    mockRecord._emitter(TEST_EVENT);
+    jest.runAllTimers();
+    jest.advanceTimersByTime(1);
+    await new Promise(process.nextTick);
+
+    expect(mockTransportSend).toHaveBeenCalledTimes(1);
+
+    scope.addEventProcessor(handler2);
+
+    const TEST_EVENT2 = { data: {}, timestamp: BASE_TIMESTAMP, type: 3 };
+
+    mockRecord._emitter(TEST_EVENT2);
+    jest.runAllTimers();
+    jest.advanceTimersByTime(1);
+    await new Promise(process.nextTick);
+
+    expect(mockTransportSend).toHaveBeenCalledTimes(1);
+
+    expect(handler1).toHaveBeenCalledTimes(2);
+    expect(handler2).toHaveBeenCalledTimes(1);
+
+    // This receives an envelope, which is a deeply nested array
+    // We only care about the fact that the timestamp was mutated
+    expect(mockTransportSend).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.arrayContaining([expect.arrayContaining([expect.objectContaining({ timestamp: MUTATED_TIMESTAMP })])]),
+      ]),
+    );
+  });
+});