add further warning & tests

getsentry · Dec 4, 2023 · 82f8154 · 82f8154
1 parent 5f65bbe
commit 82f8154
Show file tree

Hide file tree

Showing 6 changed files with 206 additions and 116 deletions.
diff --git a/packages/replay/src/coreHandlers/util/networkUtils.ts b/packages/replay/src/coreHandlers/util/networkUtils.ts
@@ -75,14 +75,18 @@ export function getBodyString(body: unknown): [string | undefined, NetworkMetaWa
     if (body instanceof FormData) {
       return [_serializeFormData(body)];
     }
+
+    if (!body) {
+      return [undefined];
+    }
   } catch {
     DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);
     return [undefined, 'BODY_PARSE_ERROR'];
   }
 
   DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);
 
-  return [undefined];
+  return [undefined, 'UNPARSEABLE_BODY_TYPE'];
 }
 
 /** Merge a warning into an existing network request/response. */

diff --git a/packages/replay/src/coreHandlers/util/xhrUtils.ts b/packages/replay/src/coreHandlers/util/xhrUtils.ts
@@ -172,12 +172,13 @@ function _getXhrResponseBody(xhr: XMLHttpRequest): [string | undefined, NetworkM
  * Blob
  * Document
  * POJO
+ *
+ * Exported only for tests.
  */
 export function _parseXhrResponse(
   body: XMLHttpRequest['response'],
   responseType: XMLHttpRequest['responseType'],
 ): [string | undefined, NetworkMetaWarning?] {
-  logger.log(body, responseType, typeof body);
   try {
     if (typeof body === 'string') {
       return [body];
@@ -190,14 +191,18 @@ export function _parseXhrResponse(
     if (responseType === 'json' && body && typeof body === 'object') {
       return [JSON.stringify(body)];
     }
+
+    if (!body) {
+      return [undefined];
+    }
   } catch {
     __DEBUG_BUILD__ && logger.warn('[Replay] Failed to serialize body', body);
     return [undefined, 'BODY_PARSE_ERROR'];
   }
 
   __DEBUG_BUILD__ && logger.info('[Replay] Skipping network body because of body type', body);
 
-  return [undefined];
+  return [undefined, 'UNPARSEABLE_BODY_TYPE'];
 }
 
 function _getBodySize(

diff --git a/packages/replay/src/types/request.ts b/packages/replay/src/types/request.ts
@@ -3,7 +3,12 @@ type JsonArray = unknown[];
 
 export type NetworkBody = JsonObject | JsonArray | string;
 
-export type NetworkMetaWarning = 'MAYBE_JSON_TRUNCATED' | 'TEXT_TRUNCATED' | 'URL_SKIPPED' | 'BODY_PARSE_ERROR';
+export type NetworkMetaWarning =
+  | 'MAYBE_JSON_TRUNCATED'
+  | 'TEXT_TRUNCATED'
+  | 'URL_SKIPPED'
+  | 'BODY_PARSE_ERROR'
+  | 'UNPARSEABLE_BODY_TYPE';
 
 interface NetworkMeta {
   warnings?: NetworkMetaWarning[];

diff --git a/packages/replay/test/unit/coreHandlers/util/fetchUtils.test.ts b/packages/replay/test/unit/coreHandlers/util/fetchUtils.test.ts
@@ -2,136 +2,138 @@ import { TextEncoder } from 'util';
 
 import { _getResponseInfo } from '../../../../src/coreHandlers/util/fetchUtils';
 
-describe('_getResponseInfo', () => {
-  it('works with captureDetails: false', async () => {
-    const res = await _getResponseInfo(
-      false,
-      {
-        networkCaptureBodies: true,
-        textEncoder: new TextEncoder(),
-        networkResponseHeaders: [],
-      },
-      undefined,
-      undefined,
-    );
+describe('Unit | coreHandlers | util | fetchUtils', () => {
+  describe('_getResponseInfo', () => {
+    it('works with captureDetails: false', async () => {
+      const res = await _getResponseInfo(
+        false,
+        {
+          networkCaptureBodies: true,
+          textEncoder: new TextEncoder(),
+          networkResponseHeaders: [],
+        },
+        undefined,
+        undefined,
+      );
 
-    expect(res).toEqual(undefined);
-  });
+      expect(res).toEqual(undefined);
+    });
 
-  it('works with captureDetails: false & responseBodySize', async () => {
-    const res = await _getResponseInfo(
-      false,
-      {
-        networkCaptureBodies: true,
-        textEncoder: new TextEncoder(),
-        networkResponseHeaders: [],
-      },
-      undefined,
-      123,
-    );
+    it('works with captureDetails: false & responseBodySize', async () => {
+      const res = await _getResponseInfo(
+        false,
+        {
+          networkCaptureBodies: true,
+          textEncoder: new TextEncoder(),
+          networkResponseHeaders: [],
+        },
+        undefined,
+        123,
+      );
 
-    expect(res).toEqual({
-      headers: {},
-      size: 123,
-      _meta: {
-        warnings: ['URL_SKIPPED'],
-      },
+      expect(res).toEqual({
+        headers: {},
+        size: 123,
+        _meta: {
+          warnings: ['URL_SKIPPED'],
+        },
+      });
     });
-  });
 
-  it('works with text body', async () => {
-    const response = {
-      headers: {
-        has: () => {
-          return false;
-        },
-        get: () => {
-          return undefined;
+    it('works with text body', async () => {
+      const response = {
+        headers: {
+          has: () => {
+            return false;
+          },
+          get: () => {
+            return undefined;
+          },
         },
-      },
-      clone: () => response,
-      text: () => Promise.resolve('text body'),
-    } as unknown as Response;
+        clone: () => response,
+        text: () => Promise.resolve('text body'),
+      } as unknown as Response;
 
-    const res = await _getResponseInfo(
-      true,
-      {
-        networkCaptureBodies: true,
-        textEncoder: new TextEncoder(),
-        networkResponseHeaders: [],
-      },
-      response,
-      undefined,
-    );
+      const res = await _getResponseInfo(
+        true,
+        {
+          networkCaptureBodies: true,
+          textEncoder: new TextEncoder(),
+          networkResponseHeaders: [],
+        },
+        response,
+        undefined,
+      );
 
-    expect(res).toEqual({
-      headers: {},
-      size: 9,
-      body: 'text body',
+      expect(res).toEqual({
+        headers: {},
+        size: 9,
+        body: 'text body',
+      });
     });
-  });
 
-  it('works with body that fails', async () => {
-    const response = {
-      headers: {
-        has: () => {
-          return false;
+    it('works with body that fails', async () => {
+      const response = {
+        headers: {
+          has: () => {
+            return false;
+          },
+          get: () => {
+            return undefined;
+          },
         },
-        get: () => {
-          return undefined;
-        },
-      },
-      clone: () => response,
-      text: () => Promise.reject('cannot read'),
-    } as unknown as Response;
+        clone: () => response,
+        text: () => Promise.reject('cannot read'),
+      } as unknown as Response;
 
-    const res = await _getResponseInfo(
-      true,
-      {
-        networkCaptureBodies: true,
-        textEncoder: new TextEncoder(),
-        networkResponseHeaders: [],
-      },
-      response,
-      undefined,
-    );
+      const res = await _getResponseInfo(
+        true,
+        {
+          networkCaptureBodies: true,
+          textEncoder: new TextEncoder(),
+          networkResponseHeaders: [],
+        },
+        response,
+        undefined,
+      );
 
-    expect(res).toEqual({
-      _meta: { warnings: ['BODY_PARSE_ERROR'] },
-      headers: {},
-      size: undefined,
+      expect(res).toEqual({
+        _meta: { warnings: ['BODY_PARSE_ERROR'] },
+        headers: {},
+        size: undefined,
+      });
     });
-  });
 
-  it('works with body that times out', async () => {
-    const response = {
-      headers: {
-        has: () => {
-          return false;
-        },
-        get: () => {
-          return undefined;
+    it('works with body that times out', async () => {
+      const response = {
+        headers: {
+          has: () => {
+            return false;
+          },
+          get: () => {
+            return undefined;
+          },
         },
-      },
-      clone: () => response,
-      text: () => new Promise(resolve => setTimeout(() => resolve('text body'), 1000)),
-    } as unknown as Response;
+        clone: () => response,
+        text: () => new Promise(resolve => setTimeout(() => resolve('text body'), 1000)),
+      } as unknown as Response;
 
-    const res = await _getResponseInfo(
-      true,
-      {
-        networkCaptureBodies: true,
-        textEncoder: new TextEncoder(),
-        networkResponseHeaders: [],
-      },
-      response,
-      undefined,
-    );
+      const res = await _getResponseInfo(
+        true,
+        {
+          networkCaptureBodies: true,
+          textEncoder: new TextEncoder(),
+          networkResponseHeaders: [],
+        },
+        response,
+        undefined,
+      );
 
-    expect(res).toEqual({
-      _meta: { warnings: ['BODY_PARSE_ERROR'] },
-      headers: {},
-      size: undefined,
+      expect(res).toEqual({
+        _meta: { warnings: ['BODY_PARSE_ERROR'] },
+        headers: {},
+        size: undefined,
+      });
     });
   });
 });
diff --git a/packages/replay/test/unit/coreHandlers/util/networkUtils.test.ts b/packages/replay/test/unit/coreHandlers/util/networkUtils.test.ts
@@ -4,6 +4,7 @@ import { NETWORK_BODY_MAX_SIZE } from '../../../../src/constants';
 import {
   buildNetworkRequestOrResponse,
   getBodySize,
+  getBodyString,
   getFullUrl,
   parseContentLengthHeader,
 } from '../../../../src/coreHandlers/util/networkUtils';
@@ -248,4 +249,39 @@ describe('Unit | coreHandlers | util | networkUtils', () => {
       expect(actual).toBe(expected);
     });
   });
+
+  describe('getBodyString', () => {
+    it('works with a string', () => {
+      const actual = getBodyString('abc');
+      expect(actual).toEqual(['abc']);
+    });
+
+    it('works with URLSearchParams', () => {
+      const body = new URLSearchParams();
+      body.append('name', 'Anne');
+      body.append('age', '32');
+      const actual = getBodyString(body);
+      expect(actual).toEqual(['name=Anne&age=32']);
+    });
+
+    it('works with FormData', () => {
+      const body = new FormData();
+      body.append('name', 'Anne');
+      body.append('age', '32');
+      const actual = getBodyString(body);
+      expect(actual).toEqual(['name=Anne&age=32']);
+    });
+
+    it('works with empty  data', () => {
+      const body = undefined;
+      const actual = getBodyString(body);
+      expect(actual).toEqual([undefined]);
+    });
+
+    it('works with other type of data', () => {
+      const body = {};
+      const actual = getBodyString(body);
+      expect(actual).toEqual([undefined, 'UNPARSEABLE_BODY_TYPE']);
+    });
+  });
 });