test(node): Fix node session aggregate tests (#11334)

Ports these tests to the new test runner - everything still seems to be
working as expected 🎉

Author: mydea

dev-packages/node-integration-tests/suites/sessions/crashed-session-aggregate/test.ts

@@ -1,47 +1,34 @@
-import path from 'path';
-import nock from 'nock';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
 
-import { TestEnv } from '../../../utils';
-
-// TODO: Convert this test to the new test runner
-// eslint-disable-next-line jest/no-disabled-tests
-test.skip('should aggregate successful and crashed sessions', async () => {
-  const env = await TestEnv.init(__dirname, `${path.resolve(__dirname, '..')}/server.ts`);
-
-  const envelope = (
-    await Promise.race([
-      env.getMultipleEnvelopeRequest({ url: `${env.url}/success`, endServer: false, envelopeType: 'sessions' }),
-      env.getMultipleEnvelopeRequest({ url: `${env.url}/error_unhandled`, endServer: false, envelopeType: 'sessions' }),
-      env.getMultipleEnvelopeRequest({
-        url: `${env.url}/success_next`,
-        endServer: false,
-        envelopeType: 'sessions',
-      }),
-    ])
-  )[0];
-
-  nock.cleanAll();
-  env.server.close();
-
-  expect(envelope[0]).toMatchObject({
-    sent_at: expect.any(String),
-    sdk: {
-      name: 'sentry.javascript.node',
-      version: expect.any(String),
-    },
-  });
+afterEach(() => {
+  cleanupChildProcesses();
+});
 
-  expect(envelope[1]).toMatchObject({
-    type: 'sessions',
+test('should aggregate successful and crashed sessions', async () => {
+  let _done: undefined | (() => void);
+  const promise = new Promise<void>(resolve => {
+    _done = resolve;
   });
 
-  expect(envelope[2]).toMatchObject({
-    aggregates: [
-      {
-        started: expect.any(String),
-        exited: 2,
-        crashed: 1,
+  const runner = createRunner(__dirname, 'server.ts')
+    .ignore('transaction', 'event', 'session')
+    .expectError()
+    .expect({
+      sessions: {
+        aggregates: [
+          {
+            started: expect.any(String),
+            exited: 2,
+            crashed: 1,
+          },
+        ],
       },
-    ],
-  });
+    })
+    .start(_done);
+
+  runner.makeRequest('get', '/success');
+  runner.makeRequest('get', '/error_unhandled');
+  runner.makeRequest('get', '/success_next');
+
+  await promise;
 });

dev-packages/node-integration-tests/suites/sessions/errored-session-aggregate/test.ts

@@ -1,40 +1,35 @@
-import path from 'path';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
 
-import { TestEnv } from '../../../utils';
-
-// TODO: Convert this test to the new test runner
-// eslint-disable-next-line jest/no-disabled-tests
-test.skip('should aggregate successful, crashed and erroneous sessions', async () => {
-  const env = await TestEnv.init(__dirname, `${path.resolve(__dirname, '..')}/server.ts`);
-
-  const aggregateSessionEnvelope = await Promise.race([
-    env.getEnvelopeRequest({ url: `${env.url}/success`, endServer: false, envelopeType: 'sessions' }),
-    env.getEnvelopeRequest({ url: `${env.url}/error_handled`, endServer: false, envelopeType: 'sessions' }),
-    env.getEnvelopeRequest({ url: `${env.url}/error_unhandled`, endServer: false, envelopeType: 'sessions' }),
-  ]);
-
-  await new Promise(resolve => env.server.close(resolve));
-
-  expect(aggregateSessionEnvelope[0]).toMatchObject({
-    sent_at: expect.any(String),
-    sdk: {
-      name: 'sentry.javascript.node',
-      version: expect.any(String),
-    },
-  });
+afterEach(() => {
+  cleanupChildProcesses();
+});
 
-  expect(aggregateSessionEnvelope[1]).toMatchObject({
-    type: 'sessions',
+test('should aggregate successful, crashed and erroneous sessions', async () => {
+  let _done: undefined | (() => void);
+  const promise = new Promise<void>(resolve => {
+    _done = resolve;
   });
 
-  expect(aggregateSessionEnvelope[2]).toMatchObject({
-    aggregates: [
-      {
-        started: expect.any(String),
-        exited: 1,
-        crashed: 1,
-        errored: 1,
+  const runner = createRunner(__dirname, 'server.ts')
+    .ignore('transaction', 'event', 'session')
+    .expectError()
+    .expect({
+      sessions: {
+        aggregates: [
+          {
+            started: expect.any(String),
+            exited: 1,
+            crashed: 1,
+            errored: 1,
+          },
+        ],
       },
-    ],
-  });
+    })
+    .start(_done);
+
+  runner.makeRequest('get', '/success');
+  runner.makeRequest('get', '/error_handled');
+  runner.makeRequest('get', '/error_unhandled');
+
+  await promise;
 });

dev-packages/node-integration-tests/suites/sessions/exited-session-aggregate/test.ts

@@ -1,41 +1,33 @@
-import path from 'path';
-import nock from 'nock';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
 
-import { TestEnv } from '../../../utils';
-
-// TODO: Convert this test to the new test runner
-// eslint-disable-next-line jest/no-disabled-tests
-test.skip('should aggregate successful sessions', async () => {
-  const env = await TestEnv.init(__dirname, `${path.resolve(__dirname, '..')}/server.ts`);
-
-  const envelope = await Promise.race([
-    env.getEnvelopeRequest({ url: `${env.url}/success`, endServer: false, envelopeType: 'sessions' }),
-    env.getEnvelopeRequest({ url: `${env.url}/success_next`, endServer: false, envelopeType: 'sessions' }),
-    env.getEnvelopeRequest({ url: `${env.url}/success_slow`, endServer: false, envelopeType: 'sessions' }),
-  ]);
-
-  nock.cleanAll();
-  env.server.close();
-
-  expect(envelope).toHaveLength(3);
-  expect(envelope[0]).toMatchObject({
-    sent_at: expect.any(String),
-    sdk: {
-      name: 'sentry.javascript.node',
-      version: expect.any(String),
-    },
-  });
+afterEach(() => {
+  cleanupChildProcesses();
+});
 
-  expect(envelope[1]).toMatchObject({
-    type: 'sessions',
+test('should aggregate successful sessions', async () => {
+  let _done: undefined | (() => void);
+  const promise = new Promise<void>(resolve => {
+    _done = resolve;
   });
 
-  expect(envelope[2]).toMatchObject({
-    aggregates: [
-      {
-        started: expect.any(String),
-        exited: 3,
+  const runner = createRunner(__dirname, 'server.ts')
+    .ignore('transaction', 'event', 'session')
+    .expectError()
+    .expect({
+      sessions: {
+        aggregates: [
+          {
+            started: expect.any(String),
+            exited: 3,
+          },
+        ],
       },
-    ],
-  });
+    })
+    .start(_done);
+
+  runner.makeRequest('get', '/success');
+  runner.makeRequest('get', '/success_next');
+  runner.makeRequest('get', '/success_slow');
+
+  await promise;
 });

dev-packages/node-integration-tests/utils/runner.ts

@@ -1,6 +1,6 @@
 import { spawn, spawnSync } from 'child_process';
 import { join } from 'path';
-import type { Envelope, EnvelopeItemType, Event, SerializedSession } from '@sentry/types';
+import type { Envelope, EnvelopeItemType, Event, SerializedSession, SessionAggregates } from '@sentry/types';
 import axios from 'axios';
 import { createBasicSentryServer } from './server';
 
@@ -113,6 +113,9 @@ type Expected =
     }
   | {
       session: Partial<SerializedSession> | ((event: SerializedSession) => void);
+    }
+  | {
+      sessions: Partial<SessionAggregates> | ((event: SessionAggregates) => void);
     };
 
 /** Creates a test runner */