fix and clean up tests

Author: lobsterkatie

packages/core/test/lib/request.test.ts

@@ -1,21 +1,30 @@
-import { Event, TransactionSamplingMethod } from '@sentry/types';
+import { DebugMeta, Event, SentryRequest, TransactionSamplingMethod } from '@sentry/types';
 
 import { API } from '../../src/api';
 import { eventToSentryRequest } from '../../src/request';
 
 describe('eventToSentryRequest', () => {
-  let api: API;
+  function parseEnvelopeRequest(request: SentryRequest): any {
+    const [envelopeHeaderString, itemHeaderString, eventString] = request.body.split('\n');
+
+    return {
+      envelopeHeader: JSON.parse(envelopeHeaderString),
+      itemHeader: JSON.parse(itemHeaderString),
+      event: JSON.parse(eventString),
+    };
+  }
+
+  const api = new API('https://[email protected]/12312012', {
+    sdk: {
+      integrations: ['AWSLambda'],
+      name: 'sentry.javascript.browser',
+      version: `12.31.12`,
+      packages: [{ name: 'npm:@sentry/browser', version: `12.31.12` }],
+    },
+  });
   let event: Event;
 
   beforeEach(() => {
-    api = new API('https://[email protected]/12312012', {
-      sdk: {
-        integrations: ['AWSLambda'],
-        name: 'sentry.javascript.browser',
-        version: `12.31.12`,
-        packages: [{ name: 'npm:@sentry/browser', version: `6.6.6` }],
-      },
-    });
     event = {
       contexts: { trace: { trace_id: '1231201211212012', span_id: '12261980', op: 'pageload' } },
       environment: 'dogpark',
@@ -28,68 +37,63 @@ describe('eventToSentryRequest', () => {
     };
   });
 
-  [
-    { method: TransactionSamplingMethod.Rate, rate: '0.1121', dog: 'Charlie' },
-    { method: TransactionSamplingMethod.Sampler, rate: '0.1231', dog: 'Maisey' },
-    { method: TransactionSamplingMethod.Inheritance, dog: 'Cory' },
-    { method: TransactionSamplingMethod.Explicit, dog: 'Bodhi' },
-
-    // this shouldn't ever happen (at least the method should always be included in tags), but good to know that things
-    // won't blow up if it does
-    { dog: 'Lucy' },
-  ].forEach(({ method, rate, dog }) => {
-    it(`adds transaction sampling information to item header - ${method}, ${rate}, ${dog}`, () => {
-      // TODO kmclb - once tag types are loosened, don't need to cast to string here
-      event.tags = { __sentry_samplingMethod: String(method), __sentry_sampleRate: String(rate), dog };
-
-      const result = eventToSentryRequest(event, api);
-
-      const [envelopeHeaderString, itemHeaderString, eventString] = result.body.split('\n');
-
-      const envelope = {
-        envelopeHeader: JSON.parse(envelopeHeaderString),
-        itemHeader: JSON.parse(itemHeaderString),
-        event: JSON.parse(eventString),
-      };
-
-      // the right stuff is added to the item header
-      expect(envelope.itemHeader).toEqual({
-        type: 'transaction',
-        // TODO kmclb - once tag types are loosened, don't need to cast to string here
-        sample_rates: [{ id: String(method), rate: String(rate) }],
-      });
-
-      // show that it pops the right tags and leaves the rest alone
-      expect('__sentry_samplingMethod' in envelope.event.tags).toBe(false);
-      expect('__sentry_sampleRate' in envelope.event.tags).toBe(false);
-      expect('dog' in envelope.event.tags).toBe(true);
-    });
+  it(`adds transaction sampling information to item header`, () => {
+    event.debug_meta = { transactionSampling: { method: TransactionSamplingMethod.Rate, rate: 0.1121 } };
+
+    const result = eventToSentryRequest(event, api);
+    const envelope = parseEnvelopeRequest(result);
+
+    expect(envelope.itemHeader).toEqual(
+      expect.objectContaining({
+        sample_rates: [{ id: TransactionSamplingMethod.Rate, rate: 0.1121 }],
+      }),
+    );
   });
 
-  it('adds sdk info to envelope header', () => {
+  it('removes transaction sampling information (and only that) from debug_meta', () => {
+    event.debug_meta = {
+      transactionSampling: { method: TransactionSamplingMethod.Sampler, rate: 0.1121 },
+      dog: 'Charlie',
+    } as DebugMeta;
+
     const result = eventToSentryRequest(event, api);
+    const envelope = parseEnvelopeRequest(result);
 
-    const envelopeHeaderString = result.body.split('\n')[0];
-    const parsedHeader = JSON.parse(envelopeHeaderString);
+    expect('transactionSampling' in envelope.event.debug_meta).toBe(false);
+    expect('dog' in envelope.event.debug_meta).toBe(true);
+  });
 
-    expect(parsedHeader).toEqual(
+  it('removes debug_meta entirely if it ends up empty', () => {
+    event.debug_meta = {
+      transactionSampling: { method: TransactionSamplingMethod.Rate, rate: 0.1121 },
+    } as DebugMeta;
+
+    const result = eventToSentryRequest(event, api);
+    const envelope = parseEnvelopeRequest(result);
+
+    expect('debug_meta' in envelope.event).toBe(false);
+  });
+
+  it('adds sdk info to envelope header', () => {
+    const result = eventToSentryRequest(event, api);
+    const envelope = parseEnvelopeRequest(result);
+
+    expect(envelope.envelopeHeader).toEqual(
       expect.objectContaining({ sdk: { name: 'sentry.javascript.browser', version: '12.31.12' } }),
     );
   });
 
   it('adds sdk info to event body', () => {
     const result = eventToSentryRequest(event, api);
+    const envelope = parseEnvelopeRequest(result);
 
-    const eventString = result.body.split('\n')[2];
-    const parsedEvent = JSON.parse(eventString);
-
-    expect(parsedEvent).toEqual(
+    expect(envelope.event).toEqual(
       expect.objectContaining({
         sdk: {
           integrations: ['AWSLambda'],
           name: 'sentry.javascript.browser',
           version: `12.31.12`,
-          packages: [{ name: 'npm:@sentry/browser', version: `6.6.6` }],
+          packages: [{ name: 'npm:@sentry/browser', version: `12.31.12` }],
         },
       }),
     );
@@ -99,22 +103,21 @@ describe('eventToSentryRequest', () => {
     event.sdk = {
       integrations: ['Clojure'],
       name: 'foo',
-      packages: [{ name: 'npm:@sentry/clj', version: `6.6.6` }],
+      packages: [{ name: 'npm:@sentry/clj', version: `12.31.12` }],
       version: '1337',
     };
-    const result = eventToSentryRequest(event, api);
 
-    const eventString = result.body.split('\n')[2];
-    const parsedEvent = JSON.parse(eventString);
+    const result = eventToSentryRequest(event, api);
+    const envelope = parseEnvelopeRequest(result);
 
-    expect(parsedEvent).toEqual(
+    expect(envelope.event).toEqual(
       expect.objectContaining({
         sdk: {
           integrations: ['Clojure', 'AWSLambda'],
           name: 'foo',
           packages: [
-            { name: 'npm:@sentry/clj', version: `6.6.6` },
-            { name: 'npm:@sentry/browser', version: `6.6.6` },
+            { name: 'npm:@sentry/clj', version: `12.31.12` },
+            { name: 'npm:@sentry/browser', version: `12.31.12` },
           ],
           version: '1337',
         },

packages/tracing/test/hub.test.ts

@@ -2,18 +2,21 @@
 import { BrowserClient } from '@sentry/browser';
 import { getMainCarrier, Hub } from '@sentry/hub';
 import * as hubModule from '@sentry/hub';
+import { TransactionSamplingMethod } from '@sentry/types';
 import * as utilsModule from '@sentry/utils'; // for mocking
 import { getGlobalObject, isNodeEnv, logger } from '@sentry/utils';
 import * as nodeHttpModule from 'http';
 
 import { BrowserTracing } from '../src/browser/browsertracing';
 import { addExtensionMethods } from '../src/hubextensions';
+import { Transaction } from '../src/transaction';
 import { extractTraceparentData, TRACEPARENT_REGEXP } from '../src/utils';
 import { addDOMPropertiesToGlobal, getSymbolObjectKeyByName } from './testutils';
 
 addExtensionMethods();
 
 const mathRandom = jest.spyOn(Math, 'random');
+jest.spyOn(Transaction.prototype, 'setMetadata');
 
 // we have to add things into the real global object (rather than mocking the return value of getGlobalObject) because
 // there are modules which call getGlobalObject as they load, which is seemingly too early for jest to intervene
@@ -27,7 +30,7 @@ describe('Hub', () => {
   });
 
   afterEach(() => {
-    jest.restoreAllMocks();
+    jest.clearAllMocks();
     jest.useRealTimers();
   });
 
@@ -259,35 +262,39 @@ describe('Hub', () => {
       it('should record sampling method when sampling decision is explicitly set', () => {
         const tracesSampler = jest.fn().mockReturnValue(0.1121);
         const hub = new Hub(new BrowserClient({ tracesSampler }));
-        const transaction = hub.startTransaction({ name: 'dogpark', sampled: true });
+        hub.startTransaction({ name: 'dogpark', sampled: true });
 
-        expect(transaction.tags).toEqual(expect.objectContaining({ __sentry_samplingMethod: 'explicitly_set' }));
+        expect(Transaction.prototype.setMetadata).toHaveBeenCalledWith({
+          transactionSampling: { method: TransactionSamplingMethod.Explicit },
+        });
       });
 
       it('should record sampling method and rate when sampling decision comes from tracesSampler', () => {
         const tracesSampler = jest.fn().mockReturnValue(0.1121);
         const hub = new Hub(new BrowserClient({ tracesSampler }));
-        const transaction = hub.startTransaction({ name: 'dogpark' });
+        hub.startTransaction({ name: 'dogpark' });
 
-        expect(transaction.tags).toEqual(
-          expect.objectContaining({ __sentry_samplingMethod: 'client_sampler', __sentry_sampleRate: '0.1121' }),
-        );
+        expect(Transaction.prototype.setMetadata).toHaveBeenCalledWith({
+          transactionSampling: { method: TransactionSamplingMethod.Sampler, rate: 0.1121 },
+        });
       });
 
       it('should record sampling method when sampling decision is inherited', () => {
         const hub = new Hub(new BrowserClient({ tracesSampleRate: 0.1121 }));
-        const transaction = hub.startTransaction({ name: 'dogpark', parentSampled: true });
+        hub.startTransaction({ name: 'dogpark', parentSampled: true });
 
-        expect(transaction.tags).toEqual(expect.objectContaining({ __sentry_samplingMethod: 'inheritance' }));
+        expect(Transaction.prototype.setMetadata).toHaveBeenCalledWith({
+          transactionSampling: { method: TransactionSamplingMethod.Inheritance },
+        });
       });
 
       it('should record sampling method and rate when sampling decision comes from traceSampleRate', () => {
         const hub = new Hub(new BrowserClient({ tracesSampleRate: 0.1121 }));
-        const transaction = hub.startTransaction({ name: 'dogpark' });
+        hub.startTransaction({ name: 'dogpark' });
 
-        expect(transaction.tags).toEqual(
-          expect.objectContaining({ __sentry_samplingMethod: 'client_rate', __sentry_sampleRate: '0.1121' }),
-        );
+        expect(Transaction.prototype.setMetadata).toHaveBeenCalledWith({
+          transactionSampling: { method: TransactionSamplingMethod.Rate, rate: 0.1121 },
+        });
       });
     });