Parse binary envelopes in tests

Author: timfish

packages/utils/test/envelope.test.ts

@@ -1,6 +1,12 @@
 import { EventEnvelope } from '@sentry/types';
 
-import { addItemToEnvelope, createEnvelope, forEachEnvelopeItem, serializeStringEnvelope } from '../src/envelope';
+import {
+  addItemToEnvelope,
+  createEnvelope,
+  forEachEnvelopeItem,
+  serializeStringEnvelope,
+  serializeEnvelope,
+} from '../src/envelope';
 import { parseEnvelope } from './testutils';
 
 describe('envelope', () => {
@@ -29,43 +35,56 @@ describe('envelope', () => {
   describe('addItemToEnvelope()', () => {
     it('adds an item to an envelope', () => {
       const env = createEnvelope<EventEnvelope>({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' }, []);
-      const parsedEnvelope = parseEnvelope(serializeStringEnvelope(env));
-      expect(parsedEnvelope).toHaveLength(1);
-      expect(parsedEnvelope[0]).toEqual({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' });
+      let [envHeaders, items] = parseEnvelope(serializeEnvelope(env));
+      expect(items).toHaveLength(0);
+      expect(envHeaders).toEqual({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' });
 
       const newEnv = addItemToEnvelope<EventEnvelope>(env, [
         { type: 'event' },
         { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' },
       ]);
-      const parsedNewEnvelope = parseEnvelope(serializeStringEnvelope(newEnv));
-      expect(parsedNewEnvelope).toHaveLength(3);
-      expect(parsedNewEnvelope[0]).toEqual({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' });
-      expect(parsedNewEnvelope[1]).toEqual({ type: 'event' });
-      expect(parsedNewEnvelope[2]).toEqual({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' });
+
+      [envHeaders, items] = parseEnvelope(serializeEnvelope(newEnv));
+      expect(envHeaders).toEqual({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' });
+      expect(items).toHaveLength(1);
+      expect(items[0]).toEqual([{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }]);
     });
   });
 
   describe('forEachEnvelopeItem', () => {
     it('loops through an envelope', () => {
       const items: EventEnvelope[1] = [
         [{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }],
-        [{ type: 'attachment', filename: 'bar.txt', length: 6 }, new Uint8Array(6)],
-        [{ type: 'attachment', filename: 'foo.txt', length: 6 }, new Uint8Array(6)],
+        [{ type: 'attachment', filename: 'bar.txt', length: 6 }, Uint8Array.from([1, 2, 3, 4, 5, 6])],
+        [{ type: 'attachment', filename: 'foo.txt', length: 6 }, Uint8Array.from([7, 8, 9, 10, 11, 12])],
       ];
 
       const env = createEnvelope<EventEnvelope>(
         { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' },
         items,
       );
 
-      expect.assertions(6);
+      expect.assertions(11);
 
       let iteration = 0;
       forEachEnvelopeItem(env, (item, type) => {
         expect(item).toBe(items[iteration]);
         expect(type).toBe(items[iteration][0].type);
         iteration = iteration + 1;
       });
+
+      const [parsedHeaders, parsedItems] = parseEnvelope(serializeEnvelope(env));
+      expect(parsedHeaders).toEqual({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' });
+      expect(parsedItems).toHaveLength(3);
+      expect(items[0]).toEqual([{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }]);
+      expect(items[1]).toEqual([
+        { type: 'attachment', filename: 'bar.txt', length: 6 },
+        Uint8Array.from([1, 2, 3, 4, 5, 6]),
+      ]);
+      expect(items[2]).toEqual([
+        { type: 'attachment', filename: 'foo.txt', length: 6 },
+        Uint8Array.from([7, 8, 9, 10, 11, 12]),
+      ]);
     });
   });
 });

packages/utils/test/testutils.ts

@@ -1,3 +1,5 @@
+import { Envelope, BaseEnvelopeHeaders, BaseEnvelopeItemHeaders } from '@sentry/types';
+
 export const testOnlyIfNodeVersionAtLeast = (minVersion: number): jest.It => {
   const currentNodeVersion = process.env.NODE_VERSION;
 
@@ -12,6 +14,57 @@ export const testOnlyIfNodeVersionAtLeast = (minVersion: number): jest.It => {
   return it;
 };
 
-export function parseEnvelope(env: string): Array<Record<any, any>> {
-  return env.split('\n').map(e => JSON.parse(e));
+/**
+ * A naive binary envelope parser
+ */
+export function parseEnvelope(env: string | Uint8Array): Envelope {
+  if (typeof env === 'string') {
+    env = new TextEncoder().encode(env);
+  }
+
+  let envelopeHeaders: BaseEnvelopeHeaders | undefined;
+  let lastItemHeader: BaseEnvelopeItemHeaders | undefined;
+  const items: [any, any][] = [];
+
+  let binaryLength = 0;
+  while (env.length) {
+    // Next length is either the binary length from the previous header
+    // or the next newline character
+    let i = binaryLength || env.indexOf(0xa);
+
+    // If no newline was found, assume this is the last block
+    if (i < 0) {
+      i = env.length;
+    }
+
+    // If we read out a length in the previous header, assume binary
+    if (binaryLength > 0) {
+      const bin = env.slice(0, binaryLength);
+      binaryLength = 0;
+      items.push([lastItemHeader, bin]);
+    } else {
+      const json = JSON.parse(new TextDecoder().decode(env.slice(0, i + 1)));
+
+      if (typeof json.length === 'number') {
+        binaryLength = json.length;
+      }
+
+      // First json is always the envelope headers
+      if (!envelopeHeaders) {
+        envelopeHeaders = json;
+      } else {
+        // If there is a type property, assume this is an item header
+        if ('type' in json) {
+          lastItemHeader = json;
+        } else {
+          items.push([lastItemHeader, json]);
+        }
+      }
+    }
+
+    // Replace the buffer with the previous block and newline removed
+    env = env.slice(i + 1);
+  }
+
+  return [envelopeHeaders as BaseEnvelopeHeaders, items];
 }