test: Browser transports tests

Author: kamilogorek

packages/browser/src/transports/base.ts

@@ -1,4 +1,4 @@
-import { SentryError } from '@sentry/core';
+import { DSN, SentryError } from '@sentry/core';
 import {
   DSNComponents,
   SentryEvent,
@@ -12,16 +12,16 @@ export abstract class BaseTransport implements Transport {
   /**
    * @inheritDoc
    */
-  public endpointUrl: string;
+  public url: string;
 
   public constructor(public options: TransportOptions) {
-    this.endpointUrl = this.composeEndpointUrl(options.dsn);
+    this.url = this.composeUrl(new DSN(options.dsn));
   }
 
   /**
    * @inheritDoc
    */
-  public composeEndpointUrl(dsn: DSNComponents): string {
+  public composeUrl(dsn: DSNComponents): string {
     const auth = {
       sentry_key: dsn.user,
       sentry_secret: '',

packages/browser/src/transports/fetch.ts

@@ -22,6 +22,6 @@ export class FetchTransport extends BaseTransport {
     };
 
     // TODO: Safe _window access
-    return window.fetch(this.endpointUrl, defaultOptions);
+    return window.fetch(this.url, defaultOptions);
   }
 }

packages/browser/src/transports/xhr.ts

@@ -23,7 +23,7 @@ export class XHRTransport extends BaseTransport {
         reject(request);
       };
 
-      request.open('POST', this.endpointUrl);
+      request.open('POST', this.url);
       request.send(serialize(event));
     });
   }

packages/browser/test/transports/base.test.ts

@@ -0,0 +1,37 @@
+import { DSNComponents } from '@sentry/types';
+import { expect } from 'chai';
+import { BaseTransport } from '../../src/transports/base';
+
+const testDSN = 'https://[email protected]/42';
+
+class SimpleTransport extends BaseTransport {}
+// tslint:disable-next-line:max-classes-per-file
+class ComplexTransport extends BaseTransport {
+  public composeUrl(dsn: DSNComponents): string {
+    return `https://${dsn.host}/${dsn.user}`;
+  }
+}
+
+describe('BaseTransport', () => {
+  it('doesnt provide send() implementation', async () => {
+    const transport = new SimpleTransport({ dsn: testDSN });
+
+    try {
+      await transport.send({});
+    } catch (e) {
+      expect(e.message).equal('Transport Class has to implement `send` method');
+    }
+  });
+
+  it('provides composeEndpointUrl() implementation', () => {
+    const transport = new SimpleTransport({ dsn: testDSN });
+    expect(transport.url).equal(
+      'https://sentry.io/api/42/store/?sentry_key=123&sentry_version=7',
+    );
+  });
+
+  it('allows overriding composeEndpointUrl() implementation', () => {
+    const transport = new ComplexTransport({ dsn: testDSN });
+    expect(transport.url).equal('https://sentry.io/123');
+  });
+});

packages/browser/test/transports/fetch.test.ts

@@ -0,0 +1,77 @@
+import { Transport } from '@sentry/types';
+import { expect } from 'chai';
+import { SinonStub, stub } from 'sinon';
+import { FetchTransport } from '../../src/transports/fetch';
+
+const testDSN = 'https://[email protected]/42';
+const transportUrl =
+  'https://sentry.io/api/42/store/?sentry_key=123&sentry_version=7';
+const payload = {
+  event_id: '1337',
+  message: 'Pickle Rick',
+  user: {
+    username: 'Morty',
+  },
+};
+
+let fetch: SinonStub;
+let transport: Transport;
+
+describe('FetchTransport', () => {
+  beforeEach(() => {
+    fetch = stub(window, 'fetch');
+    transport = new FetchTransport({ dsn: testDSN });
+  });
+
+  afterEach(() => {
+    fetch.restore();
+  });
+
+  it('inherits composeEndpointUrl() implementation', () => {
+    expect(transport.url).equal(transportUrl);
+  });
+
+  describe('send()', async () => {
+    it('sends a request to Sentry servers', async () => {
+      const response = new Response('', {
+        status: 200,
+      });
+
+      fetch.returns(Promise.resolve(response));
+
+      return transport.send(payload).then(res => {
+        expect(res.status).equal(200);
+        expect(fetch.calledOnce).equal(true);
+        expect(
+          fetch.calledWith(transportUrl, {
+            body: JSON.stringify(payload),
+            keepalive: true,
+            method: 'POST',
+            referrerPolicy: 'origin',
+          }),
+        ).equal(true);
+      });
+    });
+
+    it('rejects with non-200 status code', async () => {
+      const response = new Response('', {
+        status: 403,
+      });
+
+      fetch.returns(Promise.reject(response));
+
+      return transport.send(payload).catch(res => {
+        expect(res.status).equal(403);
+        expect(fetch.calledOnce).equal(true);
+        expect(
+          fetch.calledWith(transportUrl, {
+            body: JSON.stringify(payload),
+            keepalive: true,
+            method: 'POST',
+            referrerPolicy: 'origin',
+          }),
+        ).equal(true);
+      });
+    });
+  });
+});

packages/browser/test/transports/xhr.test.ts

@@ -0,0 +1,62 @@
+import { Transport } from '@sentry/types';
+import { expect } from 'chai';
+import { fakeServer, SinonFakeServer } from 'sinon';
+import { XHRTransport } from '../../src/transports/xhr';
+
+const testDSN = 'https://[email protected]/42';
+const transportUrl =
+  'https://sentry.io/api/42/store/?sentry_key=123&sentry_version=7';
+const payload = {
+  event_id: '1337',
+  message: 'Pickle Rick',
+  user: {
+    username: 'Morty',
+  },
+};
+
+let server: SinonFakeServer;
+let transport: Transport;
+
+describe('XHRTransport', () => {
+  beforeEach(() => {
+    server = fakeServer.create();
+    server.respondImmediately = true;
+    transport = new XHRTransport({ dsn: testDSN });
+  });
+
+  afterEach(() => {
+    server.restore();
+  });
+
+  it('inherits composeEndpointUrl() implementation', () => {
+    expect(transport.url).equal(transportUrl);
+  });
+
+  describe('send()', async () => {
+    it('sends a request to Sentry servers', async () => {
+      server.respondWith('POST', transportUrl, [200, {}, '']);
+
+      return transport.send(payload).then(res => {
+        expect(res.status).equal(200);
+
+        const request = server.requests[0];
+        expect(server.requests.length).equal(1);
+        expect(request.method).equal('POST');
+        expect(JSON.parse(request.requestBody)).deep.equal(payload);
+      });
+    });
+
+    it('rejects with non-200 status code', async () => {
+      server.respondWith('POST', transportUrl, [403, {}, '']);
+
+      return transport.send(payload).catch(res => {
+        expect(res.status).equal(403);
+
+        const request = server.requests[0];
+        expect(server.requests.length).equal(1);
+        expect(request.method).equal('POST');
+        expect(JSON.parse(request.requestBody)).deep.equal(payload);
+      });
+    });
+  });
+});

packages/types/src/index.ts

@@ -150,14 +150,15 @@ export interface Integration {
   install(): void;
 }
 
+/** TODO */
 export interface TransportOptions {
-  dsn: DSNComponents;
+  dsn: DSNLike;
 }
 
 /** TODO */
 export interface Transport {
-  endpointUrl: string;
-  composeEndpointUrl(dsn: DSNComponents): string;
+  url: string;
+  composeUrl(dsn: DSNComponents): string;
   send(event: SentryEvent): Promise<Response | XMLHttpRequest>;
 }