launchdarkly-js-sdk-common 4.0.0 → 4.0.1

package/src/__tests__/EventSender-test.js

@@ -0,0 +1,252 @@
+import EventSender from '../EventSender';
+import * as utils from '../utils';
+
+import * as base64 from 'base64-js';
+
+import { respond, networkError } from './mockHttp';
+import * as stubPlatform from './stubPlatform';
+
+// These tests verify that EventSender executes the expected HTTP requests to deliver events. Since
+// the js-sdk-common package uses an abstraction of HTTP requests, these tests do not use HTTP but
+// rather use a test implementation of our HTTP abstraction; the individual platform-specific SDKs
+// are responsible for verifying that their own implementations of the same HTTP abstraction work
+// correctly with real networking.
+
+describe('EventSender', () => {
+  let platform;
+  const envId = 'env';
+
+  beforeEach(() => {
+    platform = stubPlatform.defaults();
+  });
+
+  function fakeImageCreator() {
+    const ret = function(url) {
+      ret.urls.push(url);
+    };
+    ret.urls = [];
+    return ret;
+  }
+
+  function base64URLDecode(str) {
+    let s = str;
+    while (s.length % 4 !== 0) {
+      s = s + '=';
+    }
+    s = s.replace(/_/g, '/').replace(/-/g, '+');
+    const decodedBytes = base64.toByteArray(s);
+    const decodedStr = String.fromCharCode.apply(String, decodedBytes);
+    return decodeURIComponent(escape(decodedStr));
+  }
+
+  function decodeOutputFromUrl(url, baseUrl) {
+    const prefix = baseUrl + '/a/' + envId + '.gif?d=';
+    if (!url.startsWith(prefix)) {
+      throw 'URL "' + url + '" did not have expected prefix "' + prefix + '"';
+    }
+    return JSON.parse(base64URLDecode(url.substring(prefix.length)));
+  }
+
+  describe('using image endpoint when CORS is not available', () => {
+    it('should encode events in a single chunk if they fit', async () => {
+      const server = platform.testing.http.newServer();
+      const imageCreator = fakeImageCreator();
+      const platformWithoutCors = { ...platform, httpAllowsPost: () => false, httpFallbackPing: imageCreator };
+      const sender = EventSender(platformWithoutCors, envId);
+      const event1 = { kind: 'identify', key: 'userKey1' };
+      const event2 = { kind: 'identify', key: 'userKey2' };
+      const events = [event1, event2];
+
+      await sender.sendEvents(events, server.url);
+
+      const urls = imageCreator.urls;
+      expect(urls.length).toEqual(1);
+      expect(decodeOutputFromUrl(urls[0], server.url)).toEqual(events);
+
+      expect(server.requests.length()).toEqual(0);
+    });
+
+    it('should send events in multiple chunks if necessary', async () => {
+      const server = platform.testing.http.newServer();
+      const imageCreator = fakeImageCreator();
+      const platformWithoutCors = { ...platform, httpAllowsPost: () => false, httpFallbackPing: imageCreator };
+      const sender = EventSender(platformWithoutCors, envId);
+      const events = [];
+      for (let i = 0; i < 80; i++) {
+        events.push({ kind: 'identify', key: 'thisIsALongUserKey' + i });
+      }
+
+      await sender.sendEvents(events, server.url);
+
+      const urls = imageCreator.urls;
+      expect(urls.length).toEqual(3);
+      expect(decodeOutputFromUrl(urls[0], server.url)).toEqual(events.slice(0, 31));
+      expect(decodeOutputFromUrl(urls[1], server.url)).toEqual(events.slice(31, 61));
+      expect(decodeOutputFromUrl(urls[2], server.url)).toEqual(events.slice(61, 80));
+
+      expect(server.requests.length()).toEqual(0);
+    });
+  });
+
+  describe('using POST when CORS is available', () => {
+    it('should send all events in request body', async () => {
+      const server = platform.testing.http.newServer();
+      server.byDefault(respond(202));
+      const sender = EventSender(platform, envId);
+      const events = [];
+      for (let i = 0; i < 80; i++) {
+        events.push({ kind: 'identify', key: 'thisIsALongUserKey' + i });
+      }
+      await sender.sendEvents(events, server.url + '/endpoint');
+
+      const r = await server.nextRequest();
+      expect(r.path).toEqual('/endpoint');
+      expect(r.method).toEqual('post');
+      expect(JSON.parse(r.body)).toEqual(events);
+    });
+
+    it('should send custom user-agent header', async () => {
+      const options = { sendLDHeaders: true };
+      const server = platform.testing.http.newServer();
+      server.byDefault(respond(202));
+      const sender = EventSender(platform, envId, options);
+      const event = { kind: 'identify', key: 'userKey' };
+      await sender.sendEvents([event], server.url);
+
+      const r = await server.nextRequest();
+      expect(r.headers['user-agent']).toEqual(utils.getLDUserAgentString(platform));
+      expect(r.headers['x-launchdarkly-wrapper']).toBeUndefined();
+    });
+
+    it('should send unique payload IDs', async () => {
+      const options = { sendLDHeaders: true };
+      const server = platform.testing.http.newServer();
+      server.byDefault(respond(202));
+      const sender = EventSender(platform, envId, options);
+      const event = { kind: 'identify', key: 'userKey' };
+      await sender.sendEvents([event], server.url, false);
+      await sender.sendEvents([event], server.url, false); // deliberately repeated
+
+      const r0 = await server.nextRequest();
+      const r1 = await server.nextRequest();
+      const id0 = r0.headers['x-launchdarkly-payload-id'];
+      const id1 = r1.headers['x-launchdarkly-payload-id'];
+      expect(id0).toBeTruthy();
+      expect(id1).toBeTruthy();
+      expect(id0).not.toEqual(id1);
+    });
+
+    it('should send wrapper info if present', async () => {
+      const options = { sendLDHeaders: true, wrapperName: 'FakeSDK' };
+      const server = platform.testing.http.newServer();
+      server.byDefault(respond(202));
+      const sender = EventSender(platform, envId, options);
+      const event = { kind: 'identify', key: 'userKey' };
+      await sender.sendEvents([event], server.url);
+
+      const r = await server.nextRequest();
+      expect(r.headers['user-agent']).toEqual(utils.getLDUserAgentString(platform));
+      expect(r.headers['x-launchdarkly-wrapper']).toEqual('FakeSDK');
+    });
+
+    it('should send transformed headers if requestHeaderTransform function is provided', async () => {
+      const headerTransform = input => {
+        const output = { ...input };
+        output['c'] = '30';
+        return output;
+      };
+      const options = { requestHeaderTransform: headerTransform };
+      const server = platform.testing.http.newServer();
+      server.byDefault(respond(202));
+      const sender = EventSender(platform, envId, options);
+      const event = { kind: 'identify', key: 'userKey' };
+      await sender.sendEvents([event], server.url);
+
+      const r = await server.nextRequest();
+      expect(r.headers['c']).toEqual('30');
+    });
+
+    describe('retry on recoverable HTTP error', () => {
+      const retryableStatuses = [400, 408, 429, 500, 503];
+      for (const i in retryableStatuses) {
+        const status = retryableStatuses[i];
+        it('status ' + status, async () => {
+          const server = platform.testing.http.newServer();
+          let n = 0;
+          server.byDefault((req, res) => {
+            n++;
+            respond(n >= 2 ? 200 : status)(req, res);
+          });
+          const sender = EventSender(platform, envId);
+          const event = { kind: 'false', key: 'userKey' };
+          await sender.sendEvents([event], server.url, false);
+
+          expect(server.requests.length()).toEqual(2);
+          const r0 = await server.nextRequest();
+          const r1 = await server.nextRequest();
+          expect(JSON.parse(r0.body)).toEqual([event]);
+          expect(JSON.parse(r1.body)).toEqual([event]);
+          const id0 = r0.headers['x-launchdarkly-payload-id'];
+          expect(id0).toBeTruthy();
+          expect(r1.headers['x-launchdarkly-payload-id']).toEqual(id0);
+        });
+      }
+    });
+
+    it('should not retry more than once', async () => {
+      const server = platform.testing.http.newServer();
+      let n = 0;
+      server.byDefault((req, res) => {
+        n++;
+        respond(n >= 3 ? 200 : 503)(req, res);
+      });
+      const sender = EventSender(platform, envId);
+      const event = { kind: 'false', key: 'userKey' };
+      await sender.sendEvents([event], server.url);
+
+      expect(server.requests.length()).toEqual(2);
+    });
+
+    it('should not retry on error 401', async () => {
+      const server = platform.testing.http.newServer();
+      server.byDefault(respond(401));
+      const sender = EventSender(platform, envId);
+      const event = { kind: 'false', key: 'userKey' };
+      await sender.sendEvents([event], server.url);
+
+      expect(server.requests.length()).toEqual(1);
+    });
+
+    it('should retry on I/O error', async () => {
+      const server = platform.testing.http.newServer();
+      let n = 0;
+      server.byDefault((req, res) => {
+        n++;
+        if (n >= 2) {
+          respond(200)(req, res);
+        } else {
+          networkError()(req, res);
+        }
+      });
+      const sender = EventSender(platform, envId);
+      const event = { kind: 'false', key: 'userKey' };
+      await sender.sendEvents([event], server.url);
+
+      expect(server.requests.length()).toEqual(2);
+      await server.nextRequest();
+      const r1 = await server.nextRequest();
+      expect(JSON.parse(r1.body)).toEqual([event]);
+    });
+  });
+
+  describe('When HTTP requests are not available at all', () => {
+    it('should silently discard events', async () => {
+      const server = platform.testing.http.newServer();
+      const sender = EventSender(stubPlatform.withoutHttp(), server.url, envId);
+      const event = { kind: 'false', key: 'userKey' };
+      await sender.sendEvents([event], server.url);
+
+      expect(server.requests.length()).toEqual(0);
+    });
+  });
+});

package/src/__tests__/EventSource-mock.js

@@ -0,0 +1,61 @@
+import EventEmitter from 'events';
+
+export default function EventSource(url) {
+  this.__emitter = new EventEmitter();
+
+  this.onerror = undefined;
+  this.onopen = undefined;
+  this.onmessage = undefined;
+  this.readyState = EventSource.CONNECTING;
+
+  this.addEventListener = addEventListener;
+  this.removeEventListener = removeEventListener;
+  this.close = close;
+
+  this.mockUrl = url;
+  this.mockEmit = mockEmit;
+  this.mockError = mockError;
+  this.mockOpen = mockOpen;
+  this.mockMessage = mockMessage;
+
+  function addEventListener(eventName, callback) {
+    this.__emitter.on(eventName, callback);
+  }
+
+  function removeEventListener(eventName, callback) {
+    this.__emitter.off(eventName, callback);
+  }
+
+  function close() {
+    this.readyState = EventSource.CLOSED;
+  }
+
+  function mockEmit(eventName, param) {
+    if (this.readyState !== EventSource.CLOSED) {
+      this.__emitter.emit(eventName, param);
+    }
+  }
+
+  function mockError(error) {
+    if (this.readyState !== EventSource.CLOSED) {
+      this.onerror && this.onerror(error);
+    }
+  }
+
+  function mockOpen(error) {
+    if (this.readyState === EventSource.CONNECTING) {
+      this.readyState = EventSource.OPEN;
+      this.onopen && this.onopen(error);
+    }
+  }
+
+  function mockMessage(message) {
+    if (this.readyState === EventSource.OPEN) {
+      this.onmessage && this.onmessage(message);
+    }
+  }
+}
+
+EventSource.CONNECTING = 0;
+EventSource.OPEN = 1;
+EventSource.CLOSED = 2;

package/src/__tests__/EventSummarizer-test.js

@@ -0,0 +1,103 @@
+import EventSummarizer from '../EventSummarizer';
+
+// These tests cover only the logic for counting feature requests in summary data.
+
+describe('EventSummarizer', () => {
+  const user = { key: 'key1' };
+
+  it('does nothing for identify event', () => {
+    const es = EventSummarizer();
+    const snapshot = es.getSummary();
+    es.summarizeEvent({ kind: 'identify', creationDate: 1000, user: user });
+    expect(es.getSummary()).toEqual(snapshot);
+  });
+
+  it('does nothing for custom event', () => {
+    const es = EventSummarizer();
+    const snapshot = es.getSummary();
+    es.summarizeEvent({ kind: 'custom', creationDate: 1000, key: 'eventkey', user: user });
+    expect(es.getSummary()).toEqual(snapshot);
+  });
+
+  it('sets start and end dates for feature events', () => {
+    const es = EventSummarizer();
+    const event1 = { kind: 'feature', creationDate: 2000, key: 'key', user: user };
+    const event2 = { kind: 'feature', creationDate: 1000, key: 'key', user: user };
+    const event3 = { kind: 'feature', creationDate: 1500, key: 'key', user: user };
+    es.summarizeEvent(event1);
+    es.summarizeEvent(event2);
+    es.summarizeEvent(event3);
+    const data = es.getSummary();
+
+    expect(data.startDate).toEqual(1000);
+    expect(data.endDate).toEqual(2000);
+  });
+
+  function makeEvent(key, version, variation, value, defaultVal) {
+    return {
+      kind: 'feature',
+      creationDate: 1000,
+      key: key,
+      version: version,
+      user: user,
+      variation: variation,
+      value: value,
+      default: defaultVal,
+    };
+  }
+
+  it('increments counters for feature events', () => {
+    const es = EventSummarizer();
+    const event1 = makeEvent('key1', 11, 1, 100, 111);
+    const event2 = makeEvent('key1', 11, 2, 200, 111);
+    const event3 = makeEvent('key2', 22, 1, 999, 222);
+    const event4 = makeEvent('key1', 11, 1, 100, 111);
+    const event5 = makeEvent('badkey', null, null, 333, 333);
+    es.summarizeEvent(event1);
+    es.summarizeEvent(event2);
+    es.summarizeEvent(event3);
+    es.summarizeEvent(event4);
+    es.summarizeEvent(event5);
+    const data = es.getSummary();
+
+    data.features.key1.counters.sort((a, b) => a.value - b.value);
+    const expectedFeatures = {
+      key1: {
+        default: 111,
+        counters: [
+          { value: 100, variation: 1, version: 11, count: 2 },
+          { value: 200, variation: 2, version: 11, count: 1 },
+        ],
+      },
+      key2: {
+        default: 222,
+        counters: [{ value: 999, variation: 1, version: 22, count: 1 }],
+      },
+      badkey: {
+        default: 333,
+        counters: [{ value: 333, unknown: true, count: 1 }],
+      },
+    };
+    expect(data.features).toEqual(expectedFeatures);
+  });
+
+  it('distinguishes between zero and null/undefined in feature variation', () => {
+    const es = EventSummarizer();
+    const event1 = makeEvent('key1', 11, 0, 100, 111);
+    const event2 = makeEvent('key1', 11, null, 111, 111);
+    const event3 = makeEvent('key1', 11, undefined, 111, 111);
+    es.summarizeEvent(event1);
+    es.summarizeEvent(event2);
+    es.summarizeEvent(event3);
+    const data = es.getSummary();
+
+    data.features.key1.counters.sort((a, b) => a.value - b.value);
+    const expectedFeatures = {
+      key1: {
+        default: 111,
+        counters: [{ variation: 0, value: 100, version: 11, count: 1 }, { value: 111, version: 11, count: 2 }],
+      },
+    };
+    expect(data.features).toEqual(expectedFeatures);
+  });
+});