launchdarkly-js-sdk-common 4.3.2 → 5.0.0-alpha.1

package/src/__tests__/EventProcessor-test.js

@@ -9,9 +9,20 @@ import { MockEventSender } from './testUtils';
 // various inputs. The actual delivery of data is done by EventSender, which has its own
 // tests; here, we use a mock EventSender.
 
-describe('EventProcessor', () => {
-  const user = { key: 'userKey', name: 'Red' };
-  const filteredUser = { key: 'userKey', privateAttrs: ['name'] };
+describe.each([
+  [{ key: 'userKey', name: 'Red' }, { key: 'userKey', kind: 'user', _meta: { redactedAttributes: ['/name'] } }],
+  [
+    { kind: 'user', key: 'userKey', name: 'Red' },
+    { key: 'userKey', kind: 'user', _meta: { redactedAttributes: ['/name'] } },
+  ],
+  [
+    { kind: 'multi', user: { key: 'userKey', name: 'Red' } },
+    { kind: 'multi', user: { key: 'userKey', _meta: { redactedAttributes: ['/name'] } } },
+  ],
+])('EventProcessor', (context, filteredContext) => {
+  // const user = { key: 'userKey', name: 'Red' };
+  const eventContext = { ...context, kind: context.kind || 'user' };
+  // const filteredUser = { key: 'userKey', kind: 'user', _meta: { redactedAttributes: ['/name'] } };
   const eventsUrl = '/fake-url';
   const envId = 'env';
   const logger = stubPlatform.logger();
@@ -47,11 +58,11 @@ describe('EventProcessor', () => {
 
   function checkUserInline(e, source, inlineUser) {
     if (inlineUser) {
-      expect(e.user).toEqual(inlineUser);
-      expect(e.userKey).toBeUndefined();
+      expect(e.context).toEqual(inlineUser);
+      expect(e.contextKeys).toBeUndefined();
     } else {
-      expect(e.userKey).toEqual(source.user.key);
-      expect(e.user).toBeUndefined();
+      expect(e.contextKeys).toEqual({ user: source.context.key || source.context.user.key });
+      expect(e.context).toBeUndefined();
     }
   }
 
@@ -67,13 +78,13 @@ describe('EventProcessor', () => {
     checkUserInline(e, source, inlineUser);
   }
 
-  function checkCustomEvent(e, source, inlineUser) {
+  function checkCustomEvent(e, source) {
     expect(e.kind).toEqual('custom');
     expect(e.creationDate).toEqual(source.creationDate);
     expect(e.key).toEqual(source.key);
     expect(e.data).toEqual(source.data);
     expect(e.metricValue).toEqual(source.metricValue);
-    checkUserInline(e, source, inlineUser);
+    checkUserInline(e, source);
   }
 
   function checkSummaryEvent(e) {
@@ -82,7 +93,7 @@ describe('EventProcessor', () => {
 
   it('should enqueue identify event', async () => {
     await withProcessorAndSender(defaultConfig, async (ep, mockEventSender) => {
-      const event = { kind: 'identify', creationDate: 1000, key: user.key, user: user };
+      const event = { kind: 'identify', creationDate: 1000, context: eventContext };
       ep.enqueue(event);
       await ep.flush();
 
@@ -94,7 +105,7 @@ describe('EventProcessor', () => {
   it('filters user in identify event', async () => {
     const config = { ...defaultConfig, allAttributesPrivate: true };
     await withProcessorAndSender(config, async (ep, mockEventSender) => {
-      const event = { kind: 'identify', creationDate: 1000, key: user.key, user: user };
+      const event = { kind: 'identify', creationDate: 1000, context: eventContext };
       ep.enqueue(event);
       await ep.flush();
 
@@ -103,8 +114,8 @@ describe('EventProcessor', () => {
         {
           kind: 'identify',
           creationDate: event.creationDate,
-          key: user.key,
-          user: filteredUser,
+
+          context: filteredContext,
         },
       ]);
     });
@@ -116,7 +127,7 @@ describe('EventProcessor', () => {
         kind: 'feature',
         creationDate: 1000,
         key: 'flagkey',
-        user: user,
+        context: eventContext,
         trackEvents: true,
       };
       ep.enqueue(event);
@@ -130,36 +141,15 @@ describe('EventProcessor', () => {
     });
   });
 
-  it('can include inline user in feature event', async () => {
-    const config = { ...defaultConfig, inlineUsersInEvents: true };
-    await withProcessorAndSender(config, async (ep, mockEventSender) => {
-      const event = {
-        kind: 'feature',
-        creationDate: 1000,
-        key: 'flagkey',
-        user: user,
-        trackEvents: true,
-      };
-      ep.enqueue(event);
-      await ep.flush();
-
-      expect(mockEventSender.calls.length()).toEqual(1);
-      const output = (await mockEventSender.calls.take()).events;
-      expect(output.length).toEqual(2);
-      checkFeatureEvent(output[0], event, false, user);
-      checkSummaryEvent(output[1]);
-    });
-  });
-
   it('can include reason in feature event', async () => {
-    const config = { ...defaultConfig, inlineUsersInEvents: true };
+    const config = { ...defaultConfig };
     const reason = { kind: 'FALLTHROUGH' };
     await withProcessorAndSender(config, async (ep, mockEventSender) => {
       const event = {
         kind: 'feature',
         creationDate: 1000,
         key: 'flagkey',
-        user: user,
+        context: eventContext,
         trackEvents: true,
         reason: reason,
       };
@@ -169,28 +159,7 @@ describe('EventProcessor', () => {
       expect(mockEventSender.calls.length()).toEqual(1);
       const output = (await mockEventSender.calls.take()).events;
       expect(output.length).toEqual(2);
-      checkFeatureEvent(output[0], event, false, user);
-      checkSummaryEvent(output[1]);
-    });
-  });
-
-  it('filters user in feature event', async () => {
-    const config = { ...defaultConfig, allAttributesPrivate: true, inlineUsersInEvents: true };
-    await withProcessorAndSender(config, async (ep, mockEventSender) => {
-      const event = {
-        kind: 'feature',
-        creationDate: 1000,
-        key: 'flagkey',
-        user: user,
-        trackEvents: true,
-      };
-      ep.enqueue(event);
-      await ep.flush();
-
-      expect(mockEventSender.calls.length()).toEqual(1);
-      const output = (await mockEventSender.calls.take()).events;
-      expect(output.length).toEqual(2);
-      checkFeatureEvent(output[0], event, false, filteredUser);
+      checkFeatureEvent(output[0], event, false);
       checkSummaryEvent(output[1]);
     });
   });
@@ -201,7 +170,7 @@ describe('EventProcessor', () => {
       const e = {
         kind: 'feature',
         creationDate: 1000,
-        user: user,
+        context: eventContext,
         key: 'flagkey',
         version: 11,
         variation: 1,
@@ -215,7 +184,7 @@ describe('EventProcessor', () => {
       expect(mockEventSender.calls.length()).toEqual(1);
       const output = (await mockEventSender.calls.take()).events;
       expect(output.length).toEqual(2);
-      checkFeatureEvent(output[0], e, true, user);
+      checkFeatureEvent(output[0], e, true, { ...context, kind: context.kind || 'user' });
       checkSummaryEvent(output[1]);
     });
   });
@@ -227,7 +196,7 @@ describe('EventProcessor', () => {
       const e = {
         kind: 'feature',
         creationDate: 1000,
-        user: user,
+        context: eventContext,
         key: 'flagkey',
         version: 11,
         variation: 1,
@@ -242,7 +211,7 @@ describe('EventProcessor', () => {
       expect(mockEventSender.calls.length()).toEqual(1);
       const output = (await mockEventSender.calls.take()).events;
       expect(output.length).toEqual(2);
-      checkFeatureEvent(output[0], e, true, filteredUser);
+      checkFeatureEvent(output[0], e, true, filteredContext);
       checkSummaryEvent(output[1]);
     });
   });
@@ -253,7 +222,7 @@ describe('EventProcessor', () => {
       const e = {
         kind: 'feature',
         creationDate: 1000,
-        user: user,
+        context: eventContext,
         key: 'flagkey',
         version: 11,
         variation: 1,
@@ -268,7 +237,7 @@ describe('EventProcessor', () => {
       const output = (await mockEventSender.calls.take()).events;
       expect(output.length).toEqual(3);
       checkFeatureEvent(output[0], e, false);
-      checkFeatureEvent(output[1], e, true, user);
+      checkFeatureEvent(output[1], e, true, { ...context, kind: context.kind || 'user' });
       checkSummaryEvent(output[2]);
     });
   });
@@ -280,7 +249,7 @@ describe('EventProcessor', () => {
       mockEventSender.setServerTime(serverTime);
 
       // Send and flush an event we don't care about, just to set the last server time
-      ep.enqueue({ kind: 'identify', user: { key: 'otherUser' } });
+      ep.enqueue({ kind: 'identify', context: { key: 'otherUser' } });
       await ep.flush();
 
       // Now send an event with debug mode on, with a "debug until" time that is further in
@@ -289,7 +258,7 @@ describe('EventProcessor', () => {
       const e = {
         kind: 'feature',
         creationDate: 1000,
-        user: user,
+        context: eventContext,
         key: 'flagkey',
         version: 11,
         variation: 1,
@@ -316,7 +285,7 @@ describe('EventProcessor', () => {
       mockEventSender.setServerTime(serverTime);
 
       // Send and flush an event we don't care about, just to set the last server time
-      ep.enqueue({ kind: 'identify', user: { key: 'otherUser' } });
+      ep.enqueue({ kind: 'identify', context: { key: 'otherUser' } });
       await ep.flush();
 
       // Now send an event with debug mode on, with a "debug until" time that is further in
@@ -325,7 +294,7 @@ describe('EventProcessor', () => {
       const e = {
         kind: 'feature',
         creationDate: 1000,
-        user: user,
+        context: eventContext,
         key: 'flagkey',
         version: 11,
         variation: 1,
@@ -351,7 +320,7 @@ describe('EventProcessor', () => {
         return {
           kind: 'feature',
           creationDate: date,
-          user: user,
+          context: eventContext,
           key: key,
           version: version,
           variation: variation,
@@ -391,7 +360,7 @@ describe('EventProcessor', () => {
       const e = {
         kind: 'custom',
         creationDate: 1000,
-        user: user,
+        context: eventContext,
         key: 'eventkey',
         data: { thing: 'stuff' },
         metricValue: 1.5,
@@ -406,51 +375,11 @@ describe('EventProcessor', () => {
     });
   });
 
-  it('can include inline user in custom event', async () => {
-    const config = { ...defaultConfig, inlineUsersInEvents: true };
-    await withProcessorAndSender(config, async (ep, mockEventSender) => {
-      const e = {
-        kind: 'custom',
-        creationDate: 1000,
-        user: user,
-        key: 'eventkey',
-        data: { thing: 'stuff' },
-      };
-      ep.enqueue(e);
-      await ep.flush();
-
-      expect(mockEventSender.calls.length()).toEqual(1);
-      const output = (await mockEventSender.calls.take()).events;
-      expect(output.length).toEqual(1);
-      checkCustomEvent(output[0], e, user);
-    });
-  });
-
-  it('filters user in custom event', async () => {
-    const config = { ...defaultConfig, allAttributesPrivate: true, inlineUsersInEvents: true };
-    await withProcessorAndSender(config, async (ep, mockEventSender) => {
-      const e = {
-        kind: 'custom',
-        creationDate: 1000,
-        user: user,
-        key: 'eventkey',
-        data: { thing: 'stuff' },
-      };
-      ep.enqueue(e);
-      await ep.flush();
-
-      expect(mockEventSender.calls.length()).toEqual(1);
-      const output = (await mockEventSender.calls.take()).events;
-      expect(output.length).toEqual(1);
-      checkCustomEvent(output[0], e, filteredUser);
-    });
-  });
-
   it('enforces event capacity', async () => {
     const config = { ...defaultConfig, eventCapacity: 1, logger: stubPlatform.logger() };
-    const e0 = { kind: 'custom', creationDate: 1000, user: user, key: 'key0' };
-    const e1 = { kind: 'custom', creationDate: 1001, user: user, key: 'key1' };
-    const e2 = { kind: 'custom', creationDate: 1002, user: user, key: 'key2' };
+    const e0 = { kind: 'custom', creationDate: 1000, context: eventContext, key: 'key0' };
+    const e1 = { kind: 'custom', creationDate: 1001, context: eventContext, key: 'key1' };
+    const e2 = { kind: 'custom', creationDate: 1002, context: eventContext, key: 'key2' };
     await withProcessorAndSender(config, async (ep, mockEventSender) => {
       ep.enqueue(e0);
       ep.enqueue(e1);
@@ -475,7 +404,7 @@ describe('EventProcessor', () => {
 
   async function verifyUnrecoverableHttpError(status) {
     await withProcessorAndSender(defaultConfig, async (ep, mockEventSender) => {
-      const e = { kind: 'identify', creationDate: 1000, user: user };
+      const e = { kind: 'identify', creationDate: 1000, context: eventContext };
       ep.enqueue(e);
       mockEventSender.setStatus(status);
       await ep.flush();
@@ -490,7 +419,7 @@ describe('EventProcessor', () => {
 
   async function verifyRecoverableHttpError(status) {
     await withProcessorAndSender(defaultConfig, async (ep, mockEventSender) => {
-      const e = { kind: 'identify', creationDate: 1000, user: user };
+      const e = { kind: 'identify', creationDate: 1000, context: eventContext };
       ep.enqueue(e);
       mockEventSender.setStatus(status);
       await ep.flush();
@@ -517,8 +446,8 @@ describe('EventProcessor', () => {
 
   describe('interaction with diagnostic events', () => {
     it('sets eventsInLastBatch on flush', async () => {
-      const e0 = { kind: 'custom', creationDate: 1000, user: user, key: 'key0' };
-      const e1 = { kind: 'custom', creationDate: 1001, user: user, key: 'key1' };
+      const e0 = { kind: 'custom', creationDate: 1000, context: eventContext, key: 'key0' };
+      const e1 = { kind: 'custom', creationDate: 1001, context: eventContext, key: 'key1' };
       await withDiagnosticProcessorAndSender(defaultConfig, async (ep, mockEventSender, diagnosticAccumulator) => {
         expect(diagnosticAccumulator.getProps().eventsInLastBatch).toEqual(0);
 
@@ -536,9 +465,9 @@ describe('EventProcessor', () => {
 
     it('increments droppedEvents when capacity is exceeded', async () => {
       const config = { ...defaultConfig, eventCapacity: 1, logger: stubPlatform.logger() };
-      const e0 = { kind: 'custom', creationDate: 1000, user: user, key: 'key0' };
-      const e1 = { kind: 'custom', creationDate: 1001, user: user, key: 'key1' };
-      const e2 = { kind: 'custom', creationDate: 1002, user: user, key: 'key2' };
+      const e0 = { kind: 'custom', creationDate: 1000, context: eventContext, key: 'key0' };
+      const e1 = { kind: 'custom', creationDate: 1001, context: eventContext, key: 'key1' };
+      const e2 = { kind: 'custom', creationDate: 1002, context: eventContext, key: 'key2' };
       await withDiagnosticProcessorAndSender(config, async (ep, mockEventSender, diagnosticAccumulator) => {
         ep.enqueue(e0);
         ep.enqueue(e1);

package/src/__tests__/LDClient-events-test.js

@@ -50,26 +50,7 @@ describe('LDClient events', () => {
 
   function expectIdentifyEvent(e, user) {
     expect(e.kind).toEqual('identify');
-    expect(e.user).toEqual(user);
-  }
-
-  function expectAliasEvent(e, user, previousUser) {
-    function userContextKind(user) {
-      return user.anonymous ? 'anonymousUser' : 'user';
-    }
-    expect(e.kind).toEqual('alias');
-    expect(e.key).toEqual(user.key);
-    expect(e.previousKey).toEqual(previousUser.key);
-    expect(e.contextKind).toEqual(userContextKind(user));
-    expect(e.previousContextKind).toEqual(userContextKind(previousUser));
-  }
-
-  function expectContextKindInEvent(e, user) {
-    if (user.anonymous) {
-      expect(e.contextKind).toEqual('anonymousUser');
-    } else {
-      expect(e.contextKind).toBe(undefined);
-    }
+    expect(e.context).toEqual(user);
   }
 
   function expectFeatureEvent({
@@ -91,7 +72,7 @@ describe('LDClient events', () => {
     expect(e.default).toEqual(defaultVal);
     expect(e.trackEvents).toEqual(trackEvents);
     expect(e.debugEventsUntilDate).toEqual(debugEventsUntilDate);
-    expectContextKindInEvent(e, user);
+    expect(e.context).toEqual(user);
   }
 
   it('sends an identify event at startup', async () => {
@@ -129,126 +110,6 @@ describe('LDClient events', () => {
     });
   });
 
-  it('sends an alias event when alias() is called', async () => {
-    await withClientAndEventProcessor(user, {}, async (client, ep) => {
-      const anon1 = { key: 'user1', anonymous: true };
-      const anon2 = { key: 'user2', anonymous: true };
-      const known1 = { key: 'user3' };
-      const known2 = { key: 'user4' };
-      await client.waitForInitialization();
-      expect(ep.events.length).toEqual(1);
-
-      await client.alias(anon2, anon1);
-      expectAliasEvent(ep.events[1], anon2, anon1);
-
-      await client.alias(known1, anon1);
-      expectAliasEvent(ep.events[2], known1, anon1);
-
-      await client.alias(known2, known1);
-      expectAliasEvent(ep.events[3], known2, known1);
-
-      await client.alias(anon1, known1);
-      expectAliasEvent(ep.events[4], anon1, known1);
-
-      expect(ep.events.length).toEqual(5);
-    });
-  });
-
-  it('sends an alias event when identify() is called for anon to known', async () => {
-    // need a server because it'll do a polling request when we call identify
-    await withServer(async server => {
-      const anonUser = { key: 'anon-user', anonymous: true };
-      const knownUser = { key: 'known-user' };
-      await withClientAndEventProcessor(anonUser, { baseUrl: server.url }, async (client, ep) => {
-        await client.waitForInitialization();
-
-        expect(ep.events.length).toEqual(1);
-        expectIdentifyEvent(ep.events[0], anonUser);
-
-        await client.identify(knownUser);
-        expect(ep.events.length).toEqual(3);
-        expectIdentifyEvent(ep.events[1], knownUser);
-        expectAliasEvent(ep.events[2], knownUser, anonUser);
-      });
-    });
-  });
-
-  it('does not send an alias event when identify() is called if auto-aliasing is disabled', async () => {
-    // need a server because it'll do a polling request when we call identify
-    await withServer(async server => {
-      const anonUser = { key: 'anon-user', anonymous: true };
-      const knownUser = { key: 'known-user' };
-      await withClientAndEventProcessor(
-        anonUser,
-        { baseUrl: server.url, autoAliasingOptOut: true },
-        async (client, ep) => {
-          await client.waitForInitialization();
-
-          expect(ep.events.length).toEqual(1);
-          expectIdentifyEvent(ep.events[0], anonUser);
-
-          await client.identify(knownUser);
-          expect(ep.events.length).toEqual(2); //no additional alias events
-          expectIdentifyEvent(ep.events[1], knownUser);
-        }
-      );
-    });
-  });
-
-  it('does not send an alias event when identify() is called for known to anon', async () => {
-    // need a server because it'll do a polling request when we call identify
-    await withServer(async server => {
-      const knownUser = { key: 'known-user' };
-      const anonUser = { key: 'anon-user', anonymous: true };
-      await withClientAndEventProcessor(knownUser, { baseUrl: server.url }, async (client, ep) => {
-        await client.waitForInitialization();
-
-        expect(ep.events.length).toEqual(1);
-        expectIdentifyEvent(ep.events[0], knownUser);
-
-        await client.identify(anonUser);
-        expect(ep.events.length).toEqual(2); //no additional alias events
-        expectIdentifyEvent(ep.events[1], anonUser);
-      });
-    });
-  });
-
-  it('does not send an alias event when identify() is called for anon to anon', async () => {
-    // need a server because it'll do a polling request when we call identify
-    await withServer(async server => {
-      const anonUser1 = { key: 'anon-user1', anonymous: true };
-      const anonUser2 = { key: 'anon-user2', anonymous: true };
-      await withClientAndEventProcessor(anonUser1, { baseUrl: server.url }, async (client, ep) => {
-        await client.waitForInitialization();
-
-        expect(ep.events.length).toEqual(1);
-        expectIdentifyEvent(ep.events[0], anonUser1);
-
-        await client.identify(anonUser2);
-        expect(ep.events.length).toEqual(2); //no additional alias events
-        expectIdentifyEvent(ep.events[1], anonUser2);
-      });
-    });
-  });
-
-  it('does not send an alias event when identify() is called for known to known', async () => {
-    // need a server because it'll do a polling request when we call identify
-    await withServer(async server => {
-      const knownUser1 = { key: 'known-user1' };
-      const knownUser2 = { key: 'known-user2' };
-      await withClientAndEventProcessor(knownUser1, { baseUrl: server.url }, async (client, ep) => {
-        await client.waitForInitialization();
-
-        expect(ep.events.length).toEqual(1);
-        expectIdentifyEvent(ep.events[0], knownUser1);
-
-        await client.identify(knownUser2);
-        expect(ep.events.length).toEqual(2); //no additional alias events
-        expectIdentifyEvent(ep.events[1], knownUser2);
-      });
-    });
-  });
-
   it('stringifies user attributes in the identify event when identify() is called', async () => {
     // This just verifies that the event is being sent with the sanitized user, not the user that was passed in
     await withServer(async server => {
@@ -435,7 +296,7 @@ describe('LDClient events', () => {
   it('does not send a feature event for a new flag value if there is a state provider', async () => {
     const oldFlags = { foo: { value: 'a', variation: 1, version: 2, flagVersion: 2000 } };
     const newFlags = { foo: { value: 'b', variation: 2, version: 3, flagVersion: 2001 } };
-    const sp = stubPlatform.mockStateProvider({ environment: envName, user: user, flags: oldFlags });
+    const sp = stubPlatform.mockStateProvider({ environment: envName, context: user, flags: oldFlags });
     await withServer(async server => {
       server.byDefault(respondJson(newFlags));
       const extraConfig = { stateProvider: sp, baseUrl: server.url };
@@ -546,10 +407,9 @@ describe('LDClient events', () => {
       const trackEvent = ep.events[1];
       expect(trackEvent.kind).toEqual('custom');
       expect(trackEvent.key).toEqual('eventkey');
-      expect(trackEvent.user).toEqual(user);
+      expect(trackEvent.context).toEqual(user);
       expect(trackEvent.data).toEqual(undefined);
       expect(trackEvent.url).toEqual(fakeUrl);
-      expectContextKindInEvent(trackEvent, user);
     });
   });
 
@@ -565,10 +425,9 @@ describe('LDClient events', () => {
         const trackEvent = ep.events[1];
         expect(trackEvent.kind).toEqual('custom');
         expect(trackEvent.key).toEqual('eventkey');
-        expect(trackEvent.user).toEqual(anonUser);
+        expect(trackEvent.context).toEqual(anonUser);
         expect(trackEvent.data).toEqual(undefined);
         expect(trackEvent.url).toEqual(fakeUrl);
-        expectContextKindInEvent(trackEvent, anonUser);
       });
     });
   });
@@ -584,10 +443,9 @@ describe('LDClient events', () => {
       const trackEvent = ep.events[1];
       expect(trackEvent.kind).toEqual('custom');
       expect(trackEvent.key).toEqual('eventkey');
-      expect(trackEvent.user).toEqual(user);
+      expect(trackEvent.context).toEqual(user);
       expect(trackEvent.data).toEqual(eventData);
       expect(trackEvent.url).toEqual(fakeUrl);
-      expectContextKindInEvent(trackEvent, user);
     });
   });
 
@@ -603,11 +461,10 @@ describe('LDClient events', () => {
       const trackEvent = ep.events[1];
       expect(trackEvent.kind).toEqual('custom');
       expect(trackEvent.key).toEqual('eventkey');
-      expect(trackEvent.user).toEqual(user);
+      expect(trackEvent.context).toEqual(user);
       expect(trackEvent.data).toEqual(eventData);
       expect(trackEvent.metricValue).toEqual(metricValue);
       expect(trackEvent.url).toEqual(fakeUrl);
-      expectContextKindInEvent(trackEvent, user);
     });
   });
 
@@ -646,12 +503,12 @@ describe('LDClient events', () => {
   it('should warn about missing user on first event', async () => {
     await withClientAndEventProcessor(null, {}, async client => {
       client.track('eventkey', null);
-      expect(platform.testing.logger.output.warn).toEqual([messages.eventWithoutUser()]);
+      expect(platform.testing.logger.output.warn).toEqual([messages.eventWithoutContext()]);
     });
   });
 
   it('allows stateProvider to take over sending an event', async () => {
-    const sp = stubPlatform.mockStateProvider({ environment: envName, user: user, flags: {} });
+    const sp = stubPlatform.mockStateProvider({ environment: envName, context: user, flags: {} });
     const divertedEvents = [];
     sp.enqueueEvent = event => divertedEvents.push(event);
 

package/src/__tests__/LDClient-inspectors-test.js

@@ -59,7 +59,7 @@ describe('given a streaming client with registered inspectors', () => {
     platform = stubPlatform.defaults();
     const server = platform.testing.http.newServer();
     server.byDefault(respondJson({}));
-    const config = { streaming: true, baseUrl: server.url, inspectors };
+    const config = { streaming: true, baseUrl: server.url, inspectors, sendEvents: false };
     client = platform.testing.makeClient(envName, user, config);
     await client.waitUntilReady();
   });