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

package/src/__tests__/LDClient-test.js

@@ -127,7 +127,7 @@ describe('LDClient', () => {
       await withServers(async baseConfig => {
         await withClient(numericUser, baseConfig, async client => {
           await client.waitForInitialization();
-          expect(client.getUser()).toEqual(stringifiedNumericUser);
+          expect(client.getContext()).toEqual(stringifiedNumericUser);
         });
       });
     });
@@ -139,14 +139,14 @@ describe('LDClient', () => {
         await withClient(anonUser, baseConfig, async client0 => {
           await client0.waitForInitialization();
 
-          generatedUser = client0.getUser();
+          generatedUser = client0.getContext();
           expect(generatedUser.key).toEqual(expect.anything());
           expect(generatedUser).toMatchObject(anonUser);
         });
         await withClient(anonUser, baseConfig, async client1 => {
           await client1.waitForInitialization();
 
-          const newUser1 = client1.getUser();
+          const newUser1 = client1.getContext();
           expect(newUser1).toEqual(generatedUser);
         });
       });
@@ -161,7 +161,7 @@ describe('LDClient', () => {
         await withClient(anonUser, baseConfig, async client0 => {
           await client0.waitForInitialization();
 
-          generatedUser = client0.getUser();
+          generatedUser = client0.getContext();
           expect(generatedUser.key).toEqual(expect.anything());
           expect(generatedUser).toMatchObject(anonUser);
         });
@@ -169,7 +169,7 @@ describe('LDClient', () => {
         await withClient(anonUser, baseConfig, async client1 => {
           await client1.waitForInitialization();
 
-          const newUser1 = client1.getUser();
+          const newUser1 = client1.getContext();
           expect(newUser1.key).toEqual(expect.anything());
           expect(newUser1.key).not.toEqual(generatedUser.key);
           expect(newUser1).toMatchObject(anonUser);
@@ -466,12 +466,12 @@ describe('LDClient', () => {
 
           const identifyPromise = client.identify(user2);
           await sleepAsync(100); // sleep to jump some async ticks
-          expect(client.getUser()).toEqual(user);
+          expect(client.getContext()).toEqual(user);
 
           signal.add();
           await identifyPromise;
 
-          expect(client.getUser()).toEqual(user2);
+          expect(client.getContext()).toEqual(user2);
         });
       });
     });
@@ -498,7 +498,11 @@ describe('LDClient', () => {
       });
     });
 
-    it('returns an error and does not update flags when identify is called with invalid user', async () => {
+    it.each([
+      { country: 'US' }, // Legacy user with no key, and not anonymous.
+      { kind: 'user' }, // A single kind that is not anonymous and has no key.
+      { kind: 'multi', app: { anonymous: true }, org: {}, user: { key: 'yes' } }, // Multi kind with 1 non-anonymous context without a key.
+    ])('returns an error and does not update flags when identify is called with invalid contexts', async badContext => {
       const flags0 = { 'enable-foo': { value: false } };
       const flags1 = { 'enable-foo': { value: true } };
       await withServers(async (baseConfig, pollServer) => {
@@ -516,8 +520,7 @@ describe('LDClient', () => {
           expect(client.variation('enable-foo')).toBe(false);
           expect(pollServer.requests.length()).toEqual(1);
 
-          const userWithNoKey = { country: 'US' };
-          await expect(client.identify(userWithNoKey)).rejects.toThrow();
+          await expect(client.identify(badContext)).rejects.toThrow();
 
           expect(client.variation('enable-foo')).toBe(false);
           expect(pollServer.requests.length()).toEqual(1);
@@ -533,7 +536,7 @@ describe('LDClient', () => {
           const anonUser = { anonymous: true, country: 'US' };
           await client.identify(anonUser);
 
-          const newUser = client.getUser();
+          const newUser = client.getContext();
           expect(newUser.key).toEqual(expect.anything());
           expect(newUser).toMatchObject(anonUser);
         });
@@ -546,7 +549,7 @@ describe('LDClient', () => {
       const user = { key: 'user' };
       const state = {
         environment: 'env',
-        user: user,
+        context: user,
         flags: { flagkey: { value: 'value' } },
       };
       const sp = stubPlatform.mockStateProvider(state);
@@ -575,7 +578,7 @@ describe('LDClient', () => {
       const user = { key: 'user' };
       const state = {
         environment: 'env',
-        user: user,
+        context: user,
         flags: { flagkey: { value: 'value' } },
       };
       const sp = stubPlatform.mockStateProvider(null);
@@ -592,7 +595,7 @@ describe('LDClient', () => {
       const user = { key: 'user' };
       const state0 = {
         environment: 'env',
-        user: user,
+        context: user,
         flags: { flagkey: { value: 'value0' } },
       };
       const sp = stubPlatform.mockStateProvider(state0);
@@ -618,7 +621,7 @@ describe('LDClient', () => {
     it('disables identify()', async () => {
       const user = { key: 'user' };
       const user1 = { key: 'user1' };
-      const state = { environment: 'env', user: user, flags: { flagkey: { value: 'value' } } };
+      const state = { environment: 'env', context: user, flags: { flagkey: { value: 'value' } } };
       const sp = stubPlatform.mockStateProvider(state);
 
       await withServers(async (baseConfig, pollServer) => {

package/src/__tests__/TransientContextProcessor-test.js

@@ -0,0 +1,115 @@
+import AnonymousContextProcessor from '../AnonymousContextProcessor';
+
+describe('AnonymousContextProcessor', () => {
+  let localStorage;
+  let logger;
+  let uv;
+
+  beforeEach(() => {
+    localStorage = {};
+    logger = {
+      warn: jest.fn(),
+    };
+    uv = new AnonymousContextProcessor(localStorage, logger);
+  });
+
+  it('rejects null user', async () => {
+    await expect(uv.processContext(null)).rejects.toThrow();
+  });
+
+  it('leaves user with string key unchanged', async () => {
+    const u = { key: 'someone', name: 'me' };
+    expect(await uv.processContext(u)).toEqual(u);
+  });
+
+  it('stringifies non-string key', async () => {
+    const u0 = { key: 123, name: 'me' };
+    const u1 = { key: '123', name: 'me' };
+    expect(await uv.processContext(u0)).toEqual(u1);
+  });
+
+  it('uses cached key for anonymous user', async () => {
+    const cachedKey = 'thing';
+    let storageKey;
+    localStorage.get = async key => {
+      storageKey = key;
+      return cachedKey;
+    };
+    const u = { anonymous: true };
+    expect(await uv.processContext(u)).toEqual({ key: cachedKey, anonymous: true });
+    expect(storageKey).toEqual('ld:$anonUserId');
+  });
+
+  it('generates and stores key for anonymous user', async () => {
+    let storageKey;
+    let storedValue;
+    localStorage.get = async () => null;
+    localStorage.set = async (key, value) => {
+      storageKey = key;
+      storedValue = value;
+    };
+    const u0 = { anonymous: true };
+    const u1 = await uv.processContext(u0);
+    expect(storedValue).toEqual(expect.anything());
+    expect(u1).toEqual({ key: storedValue, anonymous: true });
+    expect(storageKey).toEqual('ld:$anonUserId');
+  });
+
+  it('generates and stores a key for each anonymous context in a multi-kind context', async () => {
+    const context = {
+      kind: 'multi',
+      user: { anonymous: true },
+      org: { anonymous: true },
+      app: { key: 'app' },
+    };
+
+    const storage = {};
+    localStorage.get = async key => storage[key];
+    localStorage.set = async (key, value) => {
+      storage[key] = value;
+    };
+
+    const processed = await uv.processContext(context);
+    expect(processed.user.key).toBeDefined();
+    expect(processed.user.key).not.toEqual(processed.org.key);
+    expect(processed.org.key).toBeDefined();
+    expect(processed.app.key).toEqual('app');
+  });
+
+  it('uses cached keys for context kinds that have already been generated', async () => {
+    const context = {
+      kind: 'multi',
+      user: { anonymous: true },
+      org: { anonymous: true },
+      another: { anonymous: true },
+      app: { key: 'app' },
+    };
+
+    const storage = {
+      'ld:$contextKey:org': 'cachedOrgKey',
+      'ld:$anonUserId': 'cachedUserKey',
+    };
+    localStorage.get = async key => storage[key];
+    localStorage.set = async (key, value) => {
+      storage[key] = value;
+    };
+
+    const processed = await uv.processContext(context);
+    expect(processed.user.key).toEqual('cachedUserKey');
+    expect(processed.org.key).toEqual('cachedOrgKey');
+    expect(processed.another.key).toBeDefined();
+    expect(processed.app.key).toEqual('app');
+  });
+
+  it.each([{ anonymous: true }, { kind: 'user', anonymous: true }, { kind: 'multi', user: { anonymous: true } }])(
+    'uses the same key to store any user context (legacy, single, multi)',
+    async context => {
+      const storage = {};
+      localStorage.get = async key => expect(key).toEqual('ld:$anonUserId');
+      localStorage.set = async (key, value) => {
+        storage[key] = value;
+      };
+      await uv.processContext(context);
+    }
+  );
+});

package/src/__tests__/attributeReference-test.js

@@ -0,0 +1,400 @@
+const AttributeReference = require('../attributeReference');
+
+describe('when filtering attributes by reference', () => {
+  it('should be able to remove a top level value', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['ld']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual(['/ld']);
+  });
+
+  it('should be able to exclude a nested value', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['/launchdarkly/u2c']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {},
+      ld: false,
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual(['/launchdarkly/u2c']);
+  });
+
+  it('sould be able to exclude an object', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['launchdarkly']
+    );
+    expect(cloned).toEqual({
+      ld: false,
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual(['/launchdarkly']);
+  });
+
+  it('sould be able to exclude an array', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['foo']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual(['/foo']);
+  });
+
+  it('should not allow exclude an array index', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['foo/0']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual([]);
+  });
+
+  it('should not allow exclude a property inside an index of an array.', () => {
+    const objWithArrayOfObjects = {
+      array: [
+        {
+          toRemove: true,
+          toLeave: true,
+        },
+      ],
+    };
+
+    const { cloned, excluded } = AttributeReference.cloneExcluding(objWithArrayOfObjects, ['array/0/toRemove']);
+    expect(cloned).toEqual(objWithArrayOfObjects);
+    expect(excluded).toEqual([]);
+  });
+
+  it('should not allow exclude the root object', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['/']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual([]);
+  });
+
+  it('should allow exclude a null value', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['null']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+    });
+    expect(excluded).toEqual(['/null']);
+  });
+
+  it('should not allow exclude a value inside null', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['/null/null']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual([]);
+  });
+
+  it('should not allow exclude a value inside explicit undefined', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['undefined/null']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual([]);
+  });
+
+  it('should allow removing an explicit undefined value', () => {
+    const objToClone = { undefined: undefined };
+    const { cloned, excluded } = AttributeReference.cloneExcluding(objToClone, ['undefined']);
+    expect(cloned).toEqual({});
+    expect(excluded).toEqual(['/undefined']);
+  });
+
+  it('should allow removing references with escape characters', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['/a~1b', '/m~0n']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      foo: ['bar', 'baz'],
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual(['/a~1b', '/m~0n']);
+  });
+
+  it('should allow removing literals without escape characters', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      ['a/b', 'm~n']
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      foo: ['bar', 'baz'],
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual(['/a~1b', '/m~0n']);
+  });
+
+  it('should handle cycles', () => {
+    const item = {};
+    const objWithCycle = {
+      item,
+      name: 'test',
+      remove: 'remove',
+    };
+    item.parent = objWithCycle;
+    const { cloned, excluded } = AttributeReference.cloneExcluding(objWithCycle, ['remove']);
+    expect(cloned).toEqual({
+      item: {},
+      name: 'test',
+    });
+    expect(excluded).toEqual(['/remove']);
+  });
+
+  it('should allow non-circular reference and should treat them independently for filtering', () => {
+    const item = { value: 'value' };
+    const objWithSharedPeer = {
+      item: item,
+      second: item,
+      third: item,
+      fourth: item,
+    };
+    const { cloned, excluded } = AttributeReference.cloneExcluding(objWithSharedPeer, ['third', '/second/value']);
+    expect(cloned).toEqual({
+      item: { value: 'value' },
+      second: {},
+      fourth: { value: 'value' },
+    });
+    expect(excluded).toEqual(['/second/value', '/third']);
+  });
+
+  it('should allow for an empty reference list', () => {
+    const { cloned, excluded } = AttributeReference.cloneExcluding(
+      {
+        launchdarkly: {
+          u2c: true,
+        },
+        ld: false,
+        foo: ['bar', 'baz'],
+        'a/b': 1,
+        'm~n': 2,
+        ' ': ' ',
+        null: null,
+      },
+      []
+    );
+    expect(cloned).toEqual({
+      launchdarkly: {
+        u2c: true,
+      },
+      ld: false,
+      foo: ['bar', 'baz'],
+      'a/b': 1,
+      'm~n': 2,
+      ' ': ' ',
+      null: null,
+    });
+    expect(excluded).toEqual([]);
+  });
+});
+
+describe('when given a literal', () => {
+  it('can convert it to a reference', () => {
+    expect(AttributeReference.literalToReference('/~why')).toEqual('/~1~0why');
+  });
+});

package/src/__tests__/configuration-test.js

@@ -44,24 +44,26 @@ describe('configuration', () => {
     await listener.expectNoErrors();
   }
 
-  function checkDeprecated(oldName, newName, value) {
-    const desc = newName
-      ? 'allows "' + oldName + '" as a deprecated equivalent to "' + newName + '"'
-      : 'warns that "' + oldName + '" is deprecated';
-    it(desc, async () => {
-      const listener = errorListener();
-      const config0 = {};
-      config0[oldName] = value;
-      const config1 = configuration.validate(config0, listener.emitter, null, listener.logger);
-      if (newName) {
-        expect(config1[newName]).toBe(value);
-        expect(config1[oldName]).toBeUndefined();
-      } else {
-        expect(config1[oldName]).toEqual(value);
-      }
-      await listener.expectWarningOnly(messages.deprecated(oldName, newName));
-    });
-  }
+  // As of the latest major version, there are no deprecated options. This logic can be restored
+  // the next time we deprecate something.
+  // function checkDeprecated(oldName, newName, value) {
+  //   const desc = newName
+  //     ? 'allows "' + oldName + '" as a deprecated equivalent to "' + newName + '"'
+  //     : 'warns that "' + oldName + '" is deprecated';
+  //   it(desc, async () => {
+  //     const listener = errorListener();
+  //     const config0 = {};
+  //     config0[oldName] = value;
+  //     const config1 = configuration.validate(config0, listener.emitter, null, listener.logger);
+  //     if (newName) {
+  //       expect(config1[newName]).toBe(value);
+  //       expect(config1[oldName]).toBeUndefined();
+  //     } else {
+  //       expect(config1[oldName]).toEqual(value);
+  //     }
+  //     await listener.expectWarningOnly(messages.deprecated(oldName, newName));
+  //   });
+  // }
 
   function checkBooleanProperty(name) {
     it('enforces boolean type and default for "' + name + '"', async () => {
@@ -100,15 +102,12 @@ describe('configuration', () => {
   checkBooleanProperty('sendEvents');
   checkBooleanProperty('allAttributesPrivate');
   checkBooleanProperty('sendLDHeaders');
-  checkBooleanProperty('inlineUsersInEvents');
   checkBooleanProperty('sendEventsOnlyForVariation');
   checkBooleanProperty('useReport');
   checkBooleanProperty('evaluationReasons');
   checkBooleanProperty('diagnosticOptOut');
   checkBooleanProperty('streaming');
 
-  checkDeprecated('allowFrequentDuplicateEvents', undefined, true);
-
   function checkNumericProperty(name, validValue) {
     it('enforces numeric type and default for "' + name + '"', async () => {
       await expectDefault(name);