Finalize tests

Author: Luca Forstner

packages/node/test/transports/new/http.test.ts

@@ -13,14 +13,20 @@ jest.mock('@sentry/core', () => {
   };
 });
 
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const httpProxyAgent = require('https-proxy-agent');
+jest.mock('https-proxy-agent', () => {
+  return jest.fn().mockImplementation(() => new http.Agent({ keepAlive: false, maxSockets: 30, timeout: 2000 }));
+});
+
 const SUCCESS = 200;
 const RATE_LIMIT = 429;
 const INVALID = 400;
 const FAILED = 500;
 
 interface TestServerOptions {
   statusCode: number;
-  responseHeaders: Record<string, string | string[] | undefined>;
+  responseHeaders?: Record<string, string | string[] | undefined>;
 }
 
 let testServer: http.Server | undefined;
@@ -44,14 +50,14 @@ function setupTestServer(
     res.end();
   });
 
-  testServer.listen(12345);
+  testServer.listen(8099);
 
   return new Promise(resolve => {
     testServer?.on('listening', resolve);
   });
 }
 
-const testServerUrl = 'http://localhost:12345';
+const TEST_SERVER_URL = 'http://localhost:8099';
 
 const EVENT_ENVELOPE = createEnvelope<EventEnvelope>({ event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' }, [
   [{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }] as EventItem,
@@ -70,26 +76,26 @@ describe('makeNewHttpTransport()', () => {
 
   describe('.send()', () => {
     it('should correctly return successful server response', async () => {
-      await setupTestServer({ statusCode: SUCCESS, responseHeaders: {} });
+      await setupTestServer({ statusCode: SUCCESS });
 
-      const transport = makeNewHttpTransport({ url: testServerUrl });
+      const transport = makeNewHttpTransport({ url: TEST_SERVER_URL });
       const transportResponse = await transport.send(EVENT_ENVELOPE);
 
       expect(transportResponse).toEqual(expect.objectContaining({ status: 'success' }));
     });
 
     it('should correctly send envelope to server', async () => {
-      await setupTestServer({ statusCode: SUCCESS, responseHeaders: {} }, (req, body) => {
+      await setupTestServer({ statusCode: SUCCESS }, (req, body) => {
         expect(req.method).toBe('POST');
         expect(body).toBe(SERIALIZED_EVENT_ENVELOPE);
       });
 
-      const transport = makeNewHttpTransport({ url: testServerUrl });
+      const transport = makeNewHttpTransport({ url: TEST_SERVER_URL });
       await transport.send(EVENT_ENVELOPE);
     });
 
     it('should correctly send user-provided headers to server', async () => {
-      await setupTestServer({ statusCode: SUCCESS, responseHeaders: {} }, req => {
+      await setupTestServer({ statusCode: SUCCESS }, req => {
         expect(req.headers).toEqual(
           expect.objectContaining({
             // node http module lower-cases incoming headers
@@ -100,7 +106,7 @@ describe('makeNewHttpTransport()', () => {
       });
 
       const transport = makeNewHttpTransport({
-        url: testServerUrl,
+        url: TEST_SERVER_URL,
         headers: {
           'X-Some-Custom-Header-1': 'value1',
           'X-Some-Custom-Header-2': 'value2',
@@ -115,9 +121,9 @@ describe('makeNewHttpTransport()', () => {
       [INVALID, 'invalid'],
       [FAILED, 'failed'],
     ])('should correctly reject bad server response (status %i)', async (serverStatusCode, expectedStatus) => {
-      await setupTestServer({ statusCode: serverStatusCode, responseHeaders: {} });
+      await setupTestServer({ statusCode: serverStatusCode });
 
-      const transport = makeNewHttpTransport({ url: testServerUrl });
+      const transport = makeNewHttpTransport({ url: TEST_SERVER_URL });
       await expect(transport.send(EVENT_ENVELOPE)).rejects.toEqual(expect.objectContaining({ status: expectedStatus }));
     });
 
@@ -130,7 +136,7 @@ describe('makeNewHttpTransport()', () => {
         },
       });
 
-      const transport = makeNewHttpTransport({ url: testServerUrl });
+      const transport = makeNewHttpTransport({ url: TEST_SERVER_URL });
       const transportResponse = await transport.send(EVENT_ENVELOPE);
 
       expect(transportResponse).toEqual(expect.objectContaining({ status: 'success' }));
@@ -145,13 +151,88 @@ describe('makeNewHttpTransport()', () => {
         },
       });
 
-      const transport = makeNewHttpTransport({ url: testServerUrl });
+      const transport = makeNewHttpTransport({ url: TEST_SERVER_URL });
       const transportResponse = await transport.send(EVENT_ENVELOPE);
 
       expect(transportResponse).toEqual(expect.objectContaining({ status: 'success' }));
     });
   });
 
+  describe('proxy', () => {
+    it('can be configured through option', () => {
+      makeNewHttpTransport({
+        url: 'http://[email protected]:8989/mysubpath/50622',
+        proxy: 'http://example.com',
+      });
+
+      expect(httpProxyAgent).toHaveBeenCalledTimes(1);
+      expect(httpProxyAgent).toHaveBeenCalledWith('http://example.com');
+    });
+
+    it('can be configured through env variables option', () => {
+      process.env.http_proxy = 'http://example.com';
+      makeNewHttpTransport({
+        url: 'http://[email protected]:8989/mysubpath/50622',
+      });
+
+      expect(httpProxyAgent).toHaveBeenCalledTimes(1);
+      expect(httpProxyAgent).toHaveBeenCalledWith('http://example.com');
+      delete process.env.http_proxy;
+    });
+
+    it('client options have priority over env variables', () => {
+      process.env.http_proxy = 'http://foo.com';
+      makeNewHttpTransport({
+        url: 'http://[email protected]:8989/mysubpath/50622',
+        proxy: 'http://bar.com',
+      });
+
+      expect(httpProxyAgent).toHaveBeenCalledTimes(1);
+      expect(httpProxyAgent).toHaveBeenCalledWith('http://bar.com');
+      delete process.env.http_proxy;
+    });
+
+    it('no_proxy allows for skipping specific hosts', () => {
+      process.env.no_proxy = 'sentry.io';
+      makeNewHttpTransport({
+        url: 'http://[email protected]:8989/mysubpath/50622',
+        proxy: 'http://example.com',
+      });
+
+      expect(httpProxyAgent).not.toHaveBeenCalled();
+
+      delete process.env.no_proxy;
+    });
+
+    it('no_proxy works with a port', () => {
+      process.env.http_proxy = 'http://example.com:8080';
+      process.env.no_proxy = 'sentry.io:8989';
+
+      makeNewHttpTransport({
+        url: 'http://[email protected]:8989/mysubpath/50622',
+      });
+
+      expect(httpProxyAgent).not.toHaveBeenCalled();
+
+      delete process.env.no_proxy;
+      delete process.env.http_proxy;
+    });
+
+    it('no_proxy works with multiple comma-separated hosts', () => {
+      process.env.http_proxy = 'http://example.com:8080';
+      process.env.no_proxy = 'example.com,sentry.io,wat.com:1337';
+
+      makeNewHttpTransport({
+        url: 'http://[email protected]:8989/mysubpath/50622',
+      });
+
+      expect(httpProxyAgent).not.toHaveBeenCalled();
+
+      delete process.env.no_proxy;
+      delete process.env.http_proxy;
+    });
+  });
+
   it('should register TransportRequestExecutor that returns the correct object from server response (rate limit)', async () => {
     await setupTestServer({
       statusCode: RATE_LIMIT,
@@ -161,7 +242,7 @@ describe('makeNewHttpTransport()', () => {
       },
     });
 
-    makeNewHttpTransport({ url: testServerUrl });
+    makeNewHttpTransport({ url: TEST_SERVER_URL });
     const registeredRequestExecutor = (createTransport as jest.Mock).mock.calls[0][1];
 
     const executorResult = registeredRequestExecutor({
@@ -180,13 +261,12 @@ describe('makeNewHttpTransport()', () => {
     );
   });
 
-  it('should register TransportRequestExecutor that returns the correct object from server response (success)', async () => {
+  it('should register TransportRequestExecutor that returns the correct object from server response (OK)', async () => {
     await setupTestServer({
       statusCode: SUCCESS,
-      responseHeaders: {},
     });
 
-    makeNewHttpTransport({ url: testServerUrl });
+    makeNewHttpTransport({ url: TEST_SERVER_URL });
     const registeredRequestExecutor = (createTransport as jest.Mock).mock.calls[0][1];
 
     const executorResult = registeredRequestExecutor({
@@ -205,7 +285,7 @@ describe('makeNewHttpTransport()', () => {
     );
   });
 
-  it('should register TransportRequestExecutor that returns the correct object from server response (success but rate-limit)', async () => {
+  it('should register TransportRequestExecutor that returns the correct object from server response (OK with rate-limit headers)', async () => {
     await setupTestServer({
       statusCode: SUCCESS,
       responseHeaders: {
@@ -214,7 +294,7 @@ describe('makeNewHttpTransport()', () => {
       },
     });
 
-    makeNewHttpTransport({ url: testServerUrl });
+    makeNewHttpTransport({ url: TEST_SERVER_URL });
     const registeredRequestExecutor = (createTransport as jest.Mock).mock.calls[0][1];
 
     const executorResult = registeredRequestExecutor({
@@ -232,4 +312,32 @@ describe('makeNewHttpTransport()', () => {
       }),
     );
   });
+
+  it('should register TransportRequestExecutor that returns the correct object from server response (NOK with rate-limit headers)', async () => {
+    await setupTestServer({
+      statusCode: RATE_LIMIT,
+      responseHeaders: {
+        'Retry-After': '2700',
+        'X-Sentry-Rate-Limits': '60::organization, 2700::organization',
+      },
+    });
+
+    makeNewHttpTransport({ url: TEST_SERVER_URL });
+    const registeredRequestExecutor = (createTransport as jest.Mock).mock.calls[0][1];
+
+    const executorResult = registeredRequestExecutor({
+      body: serializeEnvelope(EVENT_ENVELOPE),
+      category: 'error',
+    });
+
+    await expect(executorResult).resolves.toEqual(
+      expect.objectContaining({
+        headers: {
+          'retry-after': '2700',
+          'x-sentry-rate-limits': '60::organization, 2700::organization',
+        },
+        statusCode: RATE_LIMIT,
+      }),
+    );
+  });
 });