launchdarkly-js-sdk-common 4.0.0 → 4.0.1

package/src/__tests__/mockHttp.js

@@ -0,0 +1,122 @@
+import * as url from 'url';
+import { AsyncQueue } from 'launchdarkly-js-test-helpers';
+
+// The js-sdk-common package does not do any HTTP requests itself, because the implementation of
+// HTTP is platform-dependent and must be provided by the individual SDKs (e.g. the browser SDK,
+// which uses XMLHttpRequest, versus the Electron SDK, which uses Node HTTP). So, for testing
+// this package, there is no point in using an HTTP capture tool like Sinon or a real embedded
+// HTTP server. Instead we use this simple implementation of the abstraction, which lets us set
+// up test handlers with a syntax that imitates our launchdarkly-js-test-helpers HTTP server.
+
+let lastServerId = 0;
+
+export function MockHttpState() {
+  const servers = {};
+
+  return {
+    newServer: () => {
+      lastServerId++;
+      const hostname = 'mock-server-' + lastServerId;
+      const server = newMockServer(hostname);
+      servers[hostname] = server;
+      return server;
+    },
+
+    doRequest: (method, requestUrl, headers, body, synchronous) => {
+      const urlParams = url.parse(requestUrl);
+      const server = servers[urlParams.host];
+      if (!server) {
+        return { promise: Promise.reject('unknown host: ' + urlParams.host) };
+      }
+      return server._doRequest(method, urlParams, headers, body, synchronous);
+    },
+  };
+}
+
+function newMockServer(hostname) {
+  let defaultHandler = respond(404);
+  const matchers = [];
+  const requests = new AsyncQueue();
+
+  function dispatch(req, resp) {
+    for (const i in matchers) {
+      if (matchers[i](req, resp)) {
+        return;
+      }
+    }
+    defaultHandler(req, resp);
+  }
+
+  const server = {
+    url: 'http://' + hostname,
+
+    requests,
+
+    nextRequest: async () => await requests.take(),
+
+    byDefault: handler => {
+      defaultHandler = handler;
+      return server;
+    },
+
+    forMethodAndPath: (method, path, handler) => {
+      const matcher = (req, resp) => {
+        if (req.method === method.toLowerCase() && req.path === path) {
+          handler(req, resp);
+          return true;
+        }
+        return false;
+      };
+      matchers.push(matcher);
+      return server;
+    },
+
+    close: () => {}, // currently we don't need to clean up the server state
+
+    _doRequest: (method, urlParams, headers, body) => {
+      const transformedHeaders = {};
+      Object.keys(headers || {}).forEach(key => {
+        transformedHeaders[key.toLowerCase()] = headers[key];
+      });
+      const req = {
+        method: method.toLowerCase(),
+        path: urlParams.path,
+        headers: transformedHeaders,
+        body,
+      };
+      requests.add(req);
+      const ret = {};
+      ret.promise = new Promise((resolve, reject) => {
+        const resp = { resolve, reject };
+        dispatch(req, resp);
+      });
+      return ret;
+    },
+  };
+
+  return server;
+}
+
+export function respond(status, headers, body) {
+  return (req, resp) => {
+    const respProps = {
+      // these are the properties our HTTP abstraction expects
+      status,
+      header: name => headers && headers[name.toLowerCase()],
+      body,
+    };
+    resp.resolve(respProps);
+  };
+}
+
+export function respondJson(data) {
+  return respond(200, { 'content-type': 'application/json' }, JSON.stringify(data));
+}
+
+export const fakeNetworkErrorValue = new Error('fake network error');
+
+export function networkError() {
+  return (req, resp) => {
+    resp.reject(fakeNetworkErrorValue);
+  };
+}

package/src/__tests__/promiseCoalescer-test.js

@@ -0,0 +1,128 @@
+import promiseCoalescer from '../promiseCoalescer';
+
+describe('promiseCoalescer', () => {
+  function instrumentedPromise() {
+    let resolveFn, rejectFn;
+    const p = new Promise((resolve, reject) => {
+      resolveFn = resolve;
+      rejectFn = reject;
+    });
+    p.resolve = resolveFn;
+    p.reject = rejectFn;
+    return p;
+  }
+
+  describe('with a single promise', () => {
+    it('resolves', async () => {
+      const c = promiseCoalescer();
+      const p = instrumentedPromise();
+      c.addPromise(p);
+      p.resolve(3);
+      const result = await c.resultPromise;
+      expect(result).toEqual(3);
+    });
+
+    it('rejects', async () => {
+      const c = promiseCoalescer();
+      const p = instrumentedPromise();
+      c.addPromise(p);
+      p.reject(new Error('no'));
+      await expect(c.resultPromise).rejects.toThrow('no');
+    });
+
+    it('does not call cancelFn', async () => {
+      const fn = jest.fn();
+      const c = promiseCoalescer();
+      const p = instrumentedPromise();
+      c.addPromise(p, fn);
+      p.resolve(3);
+      await c.resultPromise;
+      expect(fn).not.toHaveBeenCalled();
+    });
+
+    it('calls finallyFn', async () => {
+      const fn = jest.fn();
+      const c = promiseCoalescer(fn);
+      const p = instrumentedPromise();
+      c.addPromise(p, fn);
+      expect(fn).not.toHaveBeenCalled();
+      p.resolve(3);
+      await c.resultPromise;
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('with multiple promises', () => {
+    it('resolves only from the last one', async () => {
+      const c = promiseCoalescer();
+      const p1 = instrumentedPromise();
+      const p2 = instrumentedPromise();
+      const p3 = instrumentedPromise();
+      c.addPromise(p1);
+      c.addPromise(p2);
+      c.addPromise(p3);
+      p2.resolve(2);
+      p3.resolve(3);
+      p1.resolve(1);
+      const result = await c.resultPromise;
+      expect(result).toEqual(3);
+    });
+
+    it('rejects only from the last one', async () => {
+      const c = promiseCoalescer();
+      const p1 = instrumentedPromise();
+      const p2 = instrumentedPromise();
+      const p3 = instrumentedPromise();
+      c.addPromise(p1);
+      c.addPromise(p2);
+      c.addPromise(p3);
+      p2.resolve(2);
+      p3.reject(new Error('no'));
+      p1.resolve(new Error('maybe'));
+      await expect(c.resultPromise).rejects.toThrow('no');
+    });
+
+    it('calls cancelFn on all but the last', async () => {
+      const fn1 = jest.fn();
+      const fn2 = jest.fn();
+      const fn3 = jest.fn();
+      const c = promiseCoalescer();
+      const p1 = instrumentedPromise();
+      const p2 = instrumentedPromise();
+      const p3 = instrumentedPromise();
+      c.addPromise(p1, fn1);
+      expect(fn1).not.toHaveBeenCalled();
+      c.addPromise(p2, fn2);
+      expect(fn1).toHaveBeenCalledTimes(1);
+      expect(fn2).not.toHaveBeenCalled();
+      c.addPromise(p3, fn3);
+      expect(fn1).toHaveBeenCalledTimes(1);
+      expect(fn2).toHaveBeenCalledTimes(1);
+      expect(fn3).not.toHaveBeenCalled();
+      p2.resolve(2);
+      p3.resolve(3);
+      p1.resolve(1);
+      await c.resultPromise;
+      expect(fn3).not.toHaveBeenCalled();
+    });
+
+    it('calls finallyFn', async () => {
+      const fn = jest.fn();
+      const c = promiseCoalescer(fn);
+      const p1 = instrumentedPromise();
+      const p2 = instrumentedPromise();
+      const p3 = instrumentedPromise();
+      c.addPromise(p1);
+      expect(fn).not.toHaveBeenCalled();
+      c.addPromise(p2);
+      expect(fn).not.toHaveBeenCalled();
+      c.addPromise(p3);
+      expect(fn).not.toHaveBeenCalled();
+      p2.resolve(2);
+      p3.resolve(3);
+      p1.resolve(1);
+      await c.resultPromise;
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/__tests__/stubPlatform.js

@@ -0,0 +1,148 @@
+import * as LDClient from '../index';
+import EventEmitter from '../EventEmitter';
+
+import { AsyncQueue, sleepAsync } from 'launchdarkly-js-test-helpers';
+
+import EventSource from './EventSource-mock';
+import { MockHttpState } from './mockHttp';
+
+// This file provides a stub implementation of the internal platform API for use in tests.
+//
+// The SDK expects the platform object to have the following properties and methods:
+//
+// httpRequest?: (method, url, headers, body, sync) => requestProperties
+//   requestProperties.promise: Promise     // resolves to { status, header: (name) => value, body } or rejects for a network error
+//   requestProperties.cancel?: () => void  // provided if it's possible to cancel requests in this implementation
+// httpAllowsPost: boolean        // true if we can do cross-origin POST requests
+// httpFallbackPing?: (url) => {} // method for doing an HTTP GET without awaiting the result (i.e. browser image mechanism)
+// getCurrentUrl: () => string    // returns null if we're not in a browser
+// isDoNotTrack: () => boolean
+// localStorage: {
+//   get: (key: string, callback: (err: Error, data: string) => void) => void
+//   set: (key: string, data: string, callback: (err: Error) => void) => void
+//   clear: (key: string, callback: (err: Error) => void) => void
+// }
+// eventSourceFactory?: (url: string, options: object) => EventSource
+//   // note that the options are ignored by the browser's built-in EventSource; they only work with polyfills
+// eventSourceIsActive?: (es: EventSource) => boolean  // returns true if it's open or connecting
+// eventSourceAllowsReport?: boolean  // returns true if we can set { method: 'REPORT' } in the options
+// diagnosticSdkData: object  // provides the "sdk" property in diagnostic events
+// diagnosticPlatformData: object  // provides the "platform" property in diagnostic events
+// diagnosticUseCombinedEvent: boolean  // true if diagnostic events should use the combined model (browser SDK)
+// uuid: () => string   // function to generate a UUID (this is done differently in browsers vs. Node)
+// userAgent: string
+// userAgentHeaderName?: string  // custom header name to use instead of User-Agent
+// version?: string  // the SDK version for the User-Agent header, if that is *not* the same as the version of launchdarkly-js-sdk-common
+
+export function defaults() {
+  const localStore = {};
+  const mockHttpState = MockHttpState();
+  const eventSourcesCreated = new AsyncQueue();
+  let currentUrl = null;
+  let doNotTrack = false;
+
+  const p = {
+    httpRequest: mockHttpState.doRequest,
+    diagnosticSdkData: { name: 'stub-sdk' },
+    diagnosticPlatformData: { name: 'stub-platform' },
+    httpAllowsPost: () => true,
+    httpAllowsSync: () => true,
+    getCurrentUrl: () => currentUrl,
+    isDoNotTrack: () => doNotTrack,
+    eventSourceFactory: (url, options) => {
+      const es = new EventSource(url);
+      es.options = options;
+      eventSourcesCreated.add({ eventSource: es, url, options });
+      return es;
+    },
+    eventSourceIsActive: es => es.readyState === EventSource.OPEN || es.readyState === EventSource.CONNECTING,
+    localStorage: {
+      get: key =>
+        new Promise(resolve => {
+          resolve(localStore[key]);
+        }),
+      set: (key, value) =>
+        new Promise(resolve => {
+          localStore[key] = value;
+          resolve();
+        }),
+      clear: key =>
+        new Promise(resolve => {
+          delete localStore[key];
+          resolve();
+        }),
+    },
+    userAgent: 'stubClient',
+    version: '1.2.3',
+
+    // extra methods used for testing
+    testing: {
+      logger: logger(),
+
+      http: mockHttpState,
+
+      eventSourcesCreated,
+
+      makeClient: (env, user, options = {}) => {
+        const config = { logger: p.testing.logger, ...options };
+        // We want to simulate what the platform-specific SDKs will do in their own initialization functions.
+        // They will call the common package's LDClient.initialize() and receive the clientVars object which
+        // contains both the underlying client (in its "client" property) and some internal methods that the
+        // platform-specific SDKs can use to do internal stuff. One of those is start(), which they will
+        // call after doing any other initialization things they may need to do.
+        const clientVars = LDClient.initialize(env, user, config, p);
+        clientVars.start();
+        return clientVars.client;
+      },
+
+      setCurrentUrl: url => {
+        currentUrl = url;
+      },
+
+      setDoNotTrack: value => {
+        doNotTrack = value;
+      },
+
+      getLocalStorageImmediately: key => localStore[key],
+
+      setLocalStorageImmediately: (key, value) => {
+        localStore[key] = value;
+      },
+
+      expectStream: async url => {
+        await sleepAsync(0); // in case the stream is created by a deferred task
+        expect(eventSourcesCreated.length()).toBeGreaterThanOrEqual(1);
+        const created = await eventSourcesCreated.take();
+        if (url) {
+          expect(created.url).toEqual(url);
+        }
+        return created;
+      },
+    },
+  };
+  return p;
+}
+
+export function withoutHttp() {
+  const e = defaults();
+  delete e.httpRequest;
+  return e;
+}
+
+export function logger() {
+  const logger = {};
+  ['debug', 'info', 'warn', 'error'].forEach(level => {
+    logger[level] = msg => logger.output[level].push(typeof msg === 'function' ? msg() : msg);
+  });
+  logger.reset = () => {
+    logger.output = { debug: [], info: [], warn: [], error: [] };
+  };
+  logger.reset();
+  return logger;
+}
+
+export function mockStateProvider(initialState) {
+  const sp = EventEmitter();
+  sp.getInitialState = () => initialState;
+  return sp;
+}

package/src/__tests__/testUtils.js

@@ -0,0 +1,77 @@
+import { AsyncQueue } from 'launchdarkly-js-test-helpers';
+
+export const numericUser = {
+  key: 1,
+  secondary: 2,
+  ip: 3,
+  country: 4,
+  email: 5,
+  firstName: 6,
+  lastName: 7,
+  avatar: 8,
+  name: 9,
+  anonymous: false,
+  custom: { age: 99 },
+};
+
+// This returns a Promise with a .callback property that is a plain callback function; when
+// called, it will resolve the promise with either a single value or an array of arguments.
+export function promiseListener() {
+  let cb;
+  const p = new Promise(resolve => {
+    cb = function(value) {
+      if (arguments.length > 1) {
+        resolve(Array.prototype.slice.call(arguments));
+      } else {
+        resolve(value);
+      }
+    };
+  });
+  p.callback = cb;
+  return p;
+}
+
+export const stringifiedNumericUser = {
+  key: '1',
+  secondary: '2',
+  ip: '3',
+  country: '4',
+  email: '5',
+  firstName: '6',
+  lastName: '7',
+  avatar: '8',
+  name: '9',
+  anonymous: false,
+  custom: { age: 99 },
+};
+
+export function makeBootstrap(flagsData) {
+  const ret = { $flagsState: {} };
+  for (const key in flagsData) {
+    const state = { ...flagsData[key] };
+    ret[key] = state.value;
+    delete state.value;
+    ret.$flagsState[key] = state;
+  }
+  return ret;
+}
+
+export function MockEventSender() {
+  const calls = new AsyncQueue();
+  let serverTime = null;
+  let status = 200;
+  const sender = {
+    calls,
+    sendEvents: (events, url) => {
+      calls.add({ events, url });
+      return Promise.resolve({ serverTime, status });
+    },
+    setServerTime: time => {
+      serverTime = time;
+    },
+    setStatus: respStatus => {
+      status = respStatus;
+    },
+  };
+  return sender;
+}

package/src/__tests__/utils-test.js

@@ -0,0 +1,148 @@
+import {
+  base64URLEncode,
+  getLDHeaders,
+  transformHeaders,
+  getLDUserAgentString,
+  wrapPromiseCallback,
+  chunkUserEventsForUrl,
+} from '../utils';
+
+import * as stubPlatform from './stubPlatform';
+
+describe('utils', () => {
+  describe('wrapPromiseCallback', () => {
+    it('should resolve to the value', done => {
+      const promise = wrapPromiseCallback(Promise.resolve('woohoo'));
+      promise.then(value => {
+        expect(value).toEqual('woohoo');
+        done();
+      });
+    });
+
+    it('should reject with the error', done => {
+      const error = new Error('something went wrong');
+      const promise = wrapPromiseCallback(Promise.reject(error));
+      promise.catch(error => {
+        expect(error).toEqual(error);
+        done();
+      });
+    });
+
+    it('should call the callback with a value if the promise resolves', done => {
+      const promise = wrapPromiseCallback(Promise.resolve('woohoo'), (error, value) => {
+        expect(promise).toBeUndefined();
+        expect(error).toBeNull();
+        expect(value).toEqual('woohoo');
+        done();
+      });
+    });
+
+    it('should call the callback with an error if the promise rejects', done => {
+      const actualError = new Error('something went wrong');
+      const promise = wrapPromiseCallback(Promise.reject(actualError), (error, value) => {
+        expect(promise).toBeUndefined();
+        expect(error).toEqual(actualError);
+        expect(value).toBeNull();
+        done();
+      });
+    });
+  });
+
+  describe('getLDHeaders', () => {
+    it('sends no headers unless sendLDHeaders is true', () => {
+      const platform = stubPlatform.defaults();
+      const headers = getLDHeaders(platform, {});
+      expect(headers).toEqual({});
+    });
+
+    it('adds user-agent header', () => {
+      const platform = stubPlatform.defaults();
+      const headers = getLDHeaders(platform, { sendLDHeaders: true });
+      expect(headers).toMatchObject({ 'User-Agent': getLDUserAgentString(platform) });
+    });
+
+    it('adds user-agent header with custom name', () => {
+      const platform = stubPlatform.defaults();
+      platform.userAgentHeaderName = 'X-Fake-User-Agent';
+      const headers = getLDHeaders(platform, { sendLDHeaders: true });
+      expect(headers).toMatchObject({ 'X-Fake-User-Agent': getLDUserAgentString(platform) });
+    });
+
+    it('adds wrapper info if specified, without version', () => {
+      const platform = stubPlatform.defaults();
+      const headers = getLDHeaders(platform, { sendLDHeaders: true, wrapperName: 'FakeSDK' });
+      expect(headers).toMatchObject({
+        'User-Agent': getLDUserAgentString(platform),
+        'X-LaunchDarkly-Wrapper': 'FakeSDK',
+      });
+    });
+
+    it('adds wrapper info if specified, with version', () => {
+      const platform = stubPlatform.defaults();
+      const headers = getLDHeaders(platform, { sendLDHeaders: true, wrapperName: 'FakeSDK', wrapperVersion: '9.9' });
+      expect(headers).toMatchObject({
+        'User-Agent': getLDUserAgentString(platform),
+        'X-LaunchDarkly-Wrapper': 'FakeSDK/9.9',
+      });
+    });
+  });
+
+  describe('transformHeaders', () => {
+    it('does not modify the headers if the option is not available', () => {
+      const inputHeaders = { a: '1', b: '2' };
+      const headers = transformHeaders(inputHeaders, {});
+      expect(headers).toEqual(inputHeaders);
+    });
+
+    it('modifies the headers if the option has a transform', () => {
+      const inputHeaders = { c: '3', d: '4' };
+      const outputHeaders = { c: '9', d: '4', e: '5' };
+      const headerTransform = input => {
+        const output = { ...input };
+        output['c'] = '9';
+        output['e'] = '5';
+        return output;
+      };
+      const headers = transformHeaders(inputHeaders, { requestHeaderTransform: headerTransform });
+      expect(headers).toEqual(outputHeaders);
+    });
+
+    it('cannot mutate the input header object', () => {
+      const inputHeaders = { f: '6' };
+      const expectedInputHeaders = { f: '6' };
+      const headerMutate = input => {
+        input['f'] = '7'; // eslint-disable-line no-param-reassign
+        return input;
+      };
+      transformHeaders(inputHeaders, { requestHeaderTransform: headerMutate });
+      expect(inputHeaders).toEqual(expectedInputHeaders);
+    });
+  });
+
+  describe('getLDUserAgentString', () => {
+    it('uses platform user-agent and package version by default', () => {
+      const platform = stubPlatform.defaults();
+      platform.version = undefined;
+      const ua = getLDUserAgentString(platform);
+      expect(ua).toEqual('stubClient/' + VERSION);
+    });
+
+    it('uses platform user-agent and platform version if provided', () => {
+      const platform = stubPlatform.defaults();
+      platform.version = '7.8.9';
+      const ua = getLDUserAgentString(platform);
+      expect(ua).toEqual('stubClient/7.8.9');
+    });
+  });
+
+  describe('chunkUserEventsForUrl', () => {
+    it('should properly chunk the list of events', () => {
+      const user = { key: 'foo' };
+      const event = { kind: 'identify', key: user.key };
+      const eventLength = base64URLEncode(JSON.stringify(event)).length;
+      const events = [event, event, event, event, event];
+      const chunks = chunkUserEventsForUrl(eventLength * 2, events);
+      expect(chunks).toEqual([[event, event], [event, event], [event]]);
+    });
+  });
+});