prepare 3.2.10 release

package.json

@@ -46,7 +46,6 @@
     "@rollup/plugin-replace": "^2.2.0",
     "babel-eslint": "^10.1.0",
     "babel-jest": "^25.1.0",
-    "chai": "^4.1.2",
     "cross-env": "^5.1.4",
     "eslint": "^6.8.0",
     "eslint-config-prettier": "^2.9.0",

src/__tests__/LDClient-streaming-test.js

@@ -1,6 +1,6 @@
 import * as utils from '../utils';
 
-import { eventSink, sleepAsync, withCloseable } from 'launchdarkly-js-test-helpers';
+import { AsyncQueue, eventSink, sleepAsync, withCloseable } from 'launchdarkly-js-test-helpers';
 
 import EventSource from './EventSource-mock';
 import { respondJson } from './mockHttp';
@@ -250,6 +250,52 @@ describe('LDClient streaming', () => {
       });
     });
 
+    it("poll request triggered by stream ping can't overwrite another user's flags", async () => {
+      const otherUser = { key: 'otherUser' };
+      const initUserBase64 = utils.base64URLEncode(JSON.stringify(user));
+      const otherUserBase64 = utils.base64URLEncode(JSON.stringify(otherUser));
+
+      await withClientAndServer({}, async (client, server) => {
+        const reqRespQueue = new AsyncQueue();
+        server.byDefault((req, resp) => {
+          reqRespQueue.add({ req: req, resp: resp });
+        });
+
+        const initPromise = client.waitForInitialization();
+        const poll1 = await reqRespQueue.take();
+        expect(poll1.req.path).toContain(initUserBase64);
+        respondJson({ flagKey: { value: 1 } })(poll1.req, poll1.resp);
+        await initPromise;
+
+        // The flag value is now 1, from the initial poll
+        expect(client.variation('flagKey')).toEqual(1);
+
+        client.setStreaming(true);
+        const stream = await expectStreamConnecting(fullStreamUrlWithUser);
+
+        stream.eventSource.mockEmit('ping');
+        const poll2 = await reqRespQueue.take();
+        // poll2 is the poll request that was triggered by the ping; don't respond to it yet
+        expect(poll2.req.path).toContain(initUserBase64);
+
+        const identifyPromise = client.identify(otherUser);
+        const poll3 = await reqRespQueue.take();
+        // poll3 is the poll request for the identify
+        expect(poll3.req.path).toContain(otherUserBase64);
+
+        // Now let's say poll3 completes first, setting the flag value to 3 for the new user
+        respondJson({ flagKey: { value: 3 } })(poll3.req, poll3.resp);
+
+        // And then poll2, which was for the previous user, completes with a flag value of 2
+        respondJson({ flagKey: { value: 2 } })(poll2.req, poll2.resp);
+
+        await identifyPromise;
+
+        // The flag value should now be 3, not 2
+        expect(client.variation('flagKey')).toEqual(3);
+      });
+    });
+
     it('handles stream put message by updating flags', async () => {
       await withClientAndServer({}, async client => {
         await client.waitForInitialization();

src/index.js

@@ -334,9 +334,16 @@ export function initialize(env, user, specifiedOptions, platform, extraOptionDef
     stream.connect(ident.getUser(), hash, {
       ping: function() {
         logger.debug(messages.debugStreamPing());
+        const userAtTimeOfPingEvent = ident.getUser();
         requestor
-          .fetchFlagSettings(ident.getUser(), hash)
-          .then(requestedFlags => replaceAllFlags(requestedFlags || {}))
+          .fetchFlagSettings(userAtTimeOfPingEvent, hash)
+          .then(requestedFlags => {
+            // Check whether the current user is still the same - we don't want to overwrite the flags if
+            // the application has called identify() while this request was in progress
+            if (utils.deepEquals(userAtTimeOfPingEvent, ident.getUser())) {
+              replaceAllFlags(requestedFlags || {});
+            }
+          })
           .catch(err => {
             emitter.maybeReportError(new errors.LDFlagFetchError(messages.errorFetchingFlags(err)));
           });