prepare 3.2.3 release (#17)

Author: LaunchDarklyCI

src/EventEmitter.js

@@ -27,8 +27,12 @@ export default function EventEmitter(logger) {
     if (!events[event]) {
       return;
     }
-    for (let i = 0; i < events[event].length; i++) {
-      events[event][i].handler.apply(events[event][i].context, Array.prototype.slice.call(arguments, 1));
+    // Copy the list of handlers before iterating, in case any handler adds or removes another handler.
+    // Any such changes should not affect what we do here-- we want to notify every handler that existed
+    // at the moment that the event was fired.
+    const copiedHandlers = events[event].slice(0);
+    for (let i = 0; i < copiedHandlers.length; i++) {
+      copiedHandlers[i].handler.apply(copiedHandlers[i].context, Array.prototype.slice.call(arguments, 1));
     }
   };
 

src/InitializationState.js

@@ -0,0 +1,83 @@
+// This file provides an abstraction of the client's startup state.
+//
+// Startup can either succeed or fail exactly once; calling signalSuccess() or signalFailure()
+// after that point has no effect.
+//
+// On success, we fire both an "initialized" event and a "ready" event. Both the waitForInitialization()
+// promise and the waitUntilReady() promise are resolved in this case.
+//
+// On failure, we fire both a "failed" event (with the error as a parameter) and a "ready" event.
+// The waitForInitialization() promise is rejected, but the waitUntilReady() promise is resolved.
+//
+// To complicate things, we must *not* create the waitForInitialization() promise unless it is
+// requested, because otherwise failures would cause an *unhandled* rejection which can be a
+// serious problem in some environments. So we use a somewhat roundabout system for tracking the
+// initialization state and lazily creating this promise.
+
+const readyEvent = 'ready',
+  successEvent = 'initialized',
+  failureEvent = 'failed';
+
+function InitializationStateTracker(eventEmitter) {
+  let succeeded = false,
+    failed = false,
+    failureValue = null,
+    initializationPromise = null;
+
+  const readyPromise = new Promise(resolve => {
+    const onReady = () => {
+      eventEmitter.off(readyEvent, onReady); // we can't use "once" because it's not available on some JS platforms
+      resolve();
+    };
+    eventEmitter.on(readyEvent, onReady);
+  }).catch(() => {}); // this Promise should never be rejected, but the catch handler is a safety measure
+
+  return {
+    getInitializationPromise: () => {
+      if (initializationPromise) {
+        return initializationPromise;
+      }
+      if (succeeded) {
+        return Promise.resolve();
+      }
+      if (failed) {
+        return Promise.reject(failureValue);
+      }
+      initializationPromise = new Promise((resolve, reject) => {
+        const onSuccess = () => {
+          eventEmitter.off(successEvent, onSuccess);
+          resolve();
+        };
+        const onFailure = err => {
+          eventEmitter.off(failureEvent, onFailure);
+          reject(err);
+        };
+        eventEmitter.on(successEvent, onSuccess);
+        eventEmitter.on(failureEvent, onFailure);
+      });
+      return initializationPromise;
+    },
+
+    getReadyPromise: () => readyPromise,
+
+    signalSuccess: () => {
+      if (!succeeded && !failed) {
+        succeeded = true;
+        eventEmitter.emit(successEvent);
+        eventEmitter.emit(readyEvent);
+      }
+    },
+
+    signalFailure: err => {
+      if (!succeeded && !failed) {
+        failed = true;
+        failureValue = err;
+        eventEmitter.emit(failureEvent, err);
+        eventEmitter.emit(readyEvent);
+      }
+      eventEmitter.maybeReportError(err); // the "error" event can be emitted more than once, unlike the others
+    },
+  };
+}
+
+module.exports = InitializationStateTracker;

src/__tests__/LDClient-test.js

@@ -1,5 +1,4 @@
 import * as LDClient from '../index';
-import * as errors from '../errors';
 import * as messages from '../messages';
 import * as utils from '../utils';
 
@@ -43,7 +42,7 @@ describe('LDClient', () => {
   });
 
   describe('initialization', () => {
-    it('should trigger the ready event', async () => {
+    it('triggers "ready" event', async () => {
       await withServers(async baseConfig => {
         await withClient(user, baseConfig, async client => {
           const gotReady = eventSink(client, 'ready');
@@ -54,7 +53,7 @@ describe('LDClient', () => {
       });
     });
 
-    it('should trigger the initialized event', async () => {
+    it('triggers "initialized" event', async () => {
       await withServers(async baseConfig => {
         await withClient(user, baseConfig, async client => {
           const gotInited = eventSink(client, 'initialized');
@@ -63,49 +62,18 @@ describe('LDClient', () => {
       });
     });
 
-    it('should emit an error when initialize is called without an environment key', async () => {
-      const client = platform.testing.makeClient('', user);
-      const gotError = eventSink(client, 'error');
-
-      const err = await gotError.take();
-      expect(err.message).toEqual(messages.environmentNotSpecified());
-    });
-
-    it('should emit an error when an invalid environment key is specified', async () => {
-      await withServers(async (baseConfig, pollServer) => {
-        pollServer.byDefault(respond(404));
-        await withClient(user, baseConfig, async client => {
-          const gotError = eventSink(client, 'error');
-
-          await expect(client.waitForInitialization()).rejects.toThrow();
-
-          const err = await gotError.take();
-          expect(err).toEqual(new errors.LDInvalidEnvironmentIdError(messages.environmentNotFound()));
-        });
-      });
-    });
-
-    it('should emit a failure event when an invalid environment key is specified', async () => {
-      await withServers(async (baseConfig, pollServer) => {
-        pollServer.byDefault(respond(404));
+    it('resolves waitForInitialization promise', async () => {
+      await withServers(async baseConfig => {
         await withClient(user, baseConfig, async client => {
-          const gotFailed = eventSink(client, 'failed');
-
-          await expect(client.waitForInitialization()).rejects.toThrow();
-
-          const err = await gotFailed.take();
-          expect(err).toEqual(new errors.LDInvalidEnvironmentIdError(messages.environmentNotFound()));
+          await client.waitForInitialization();
         });
       });
     });
 
-    it('returns default values when an invalid environment key is specified', async () => {
-      await withServers(async (baseConfig, pollServer) => {
-        pollServer.byDefault(respond(404));
+    it('resolves waitUntilReady promise', async () => {
+      await withServers(async baseConfig => {
         await withClient(user, baseConfig, async client => {
-          await expect(client.waitForInitialization()).rejects.toThrow();
-
-          expect(client.variation('flag-key', 1)).toEqual(1);
+          await client.waitUntilReady();
         });
       });
     });
@@ -145,19 +113,6 @@ describe('LDClient', () => {
       expect(result).toEqual(1);
     });
 
-    it('should emit an error event if there was an error fetching flags', async () => {
-      await withServers(async (baseConfig, pollServer) => {
-        pollServer.byDefault(respond(503));
-        await withClient(user, baseConfig, async client => {
-          const gotError = eventSink(client, 'error');
-
-          await expect(client.waitForInitialization()).rejects.toThrow();
-          const err = await gotError.take();
-          expect(err).toEqual(new errors.LDFlagFetchError(messages.errorFetchingFlags(503)));
-        });
-      });
-    });
-
     async function verifyCustomHeader(sendLDHeaders, shouldGetHeaders) {
       await withServers(async (baseConfig, pollServer) => {
         await withClient(user, { ...baseConfig, sendLDHeaders }, async client => {
@@ -231,6 +186,87 @@ describe('LDClient', () => {
     });
   });
 
+  describe('failed initialization', () => {
+    function doErrorTests(expectedMessage, doWithClientAsyncFn) {
+      async function runTest(asyncTest) {
+        try {
+          await doWithClientAsyncFn(asyncTest);
+        } finally {
+          // sleep briefly so any unhandled promise rejections will show up in this test, instead of
+          // in a later test
+          await sleepAsync(2);
+        }
+      }
+
+      it('rejects waitForInitialization promise', async () => {
+        await runTest(async client => {
+          await expect(client.waitForInitialization()).rejects.toThrow();
+        });
+      });
+
+      it('resolves waitUntilReady promise', async () => {
+        await runTest(async client => {
+          await client.waitUntilReady();
+        });
+      });
+
+      it('emits "error" event', async () => {
+        await runTest(async client => {
+          const gotError = eventSink(client, 'error');
+          const err = await gotError.take();
+          expect(err.message).toEqual(expectedMessage);
+        });
+      });
+
+      it('emits "failed" event', async () => {
+        await runTest(async client => {
+          const gotFailed = eventSink(client, 'failed');
+          const err = await gotFailed.take();
+          expect(err.message).toEqual(expectedMessage);
+        });
+      });
+
+      it('emits "ready" event', async () => {
+        await runTest(async client => {
+          const gotReady = eventSink(client, 'ready');
+          await gotReady.take();
+        });
+      });
+
+      it('returns default values', async () => {
+        await runTest(async client => {
+          await client.waitUntilReady();
+          expect(client.variation('flag-key', 1)).toEqual(1);
+        });
+      });
+    }
+
+    describe('environment key not specified', () => {
+      doErrorTests(
+        messages.environmentNotSpecified(),
+        async callback => await withCloseable(platform.testing.makeClient('', user), callback)
+      );
+    });
+
+    describe('invalid environment key (404 error)', () => {
+      doErrorTests(messages.environmentNotFound(), async callback => {
+        await withServers(async (baseConfig, pollServer) => {
+          pollServer.byDefault(respond(404));
+          await withClient(user, baseConfig, callback);
+        });
+      });
+    });
+
+    describe('HTTP error other than 404 on initial poll', () => {
+      doErrorTests(messages.errorFetchingFlags(503), async callback => {
+        await withServers(async (baseConfig, pollServer) => {
+          pollServer.byDefault(respond(503));
+          await withClient(user, baseConfig, callback);
+        });
+      });
+    });
+  });
+
   describe('initialization with bootstrap object', () => {
     it('should not fetch flag settings', async () => {
       await withServers(async (baseConfig, pollServer) => {
@@ -271,42 +307,6 @@ describe('LDClient', () => {
     });
   });
 
-  describe('waitUntilReady', () => {
-    it('should resolve waitUntilReady promise when ready', async () => {
-      await withServers(async baseConfig => {
-        await withClient(user, baseConfig, async client => {
-          const gotReady = eventSink(client, 'ready');
-
-          await gotReady.take();
-          await client.waitUntilReady();
-        });
-      });
-    });
-  });
-
-  describe('waitForInitialization', () => {
-    it('resolves promise on successful init', async () => {
-      await withServers(async baseConfig => {
-        await withClient(user, baseConfig, async client => {
-          const gotReady = eventSink(client, 'ready');
-
-          await gotReady.take();
-          await client.waitForInitialization();
-        });
-      });
-    });
-
-    it('rejects promise if flags request fails', async () => {
-      await withServers(async (baseConfig, pollServer) => {
-        pollServer.byDefault(respond(404));
-        await withClient(user, baseConfig, async client => {
-          const err = new errors.LDInvalidEnvironmentIdError(messages.environmentNotFound());
-          await expect(client.waitForInitialization()).rejects.toThrow(err);
-        });
-      });
-    });
-  });
-
   describe('variation', () => {
     it('returns value for an existing flag - from bootstrap', async () => {
       const config = {