@depup/launchdarkly-node-server-sdk 7.0.4-depup.0

package/test/evaluator-big-segments-test.js

@@ -0,0 +1,301 @@
+const { Evaluator, makeBigSegmentRef } = require('../evaluator');
+const {
+  basicUser,
+  eventFactory,
+  asyncEvaluate,
+  makeFlagWithSegmentMatch,
+  makeClauseThatMatchesUser,
+  prepareQueries,
+  makeSegmentMatchClause,
+  basicSingleKindUser,
+  basicMultiKindUser,
+  makeBooleanFlagWithRules,
+} = require('./evaluator_helpers');
+
+// Tests of flag evaluation involving Big Segments.
+
+describe.each([undefined, 'user'])('Evaluator - Big Segments user contexts', (unboundedContextKind) => {
+  it('segment is not matched if there is no way to query it', async () => {
+    const segment = {
+      key: 'test',
+      included: [ basicUser.key ], // included should be ignored for a big segment
+      version: 1,
+      unbounded: true,
+      generation: 1,
+      unboundedContextKind
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+    expect(detail.value).toBe(false);
+    expect(detail.reason.bigSegmentsStatus).toEqual('NOT_CONFIGURED');
+  });
+
+  it('segment with no generation is not matched', async () => {
+    const segment = {
+      key: 'test',
+      included: [ basicUser.key ], // included should be ignored for a big segment
+      version: 1,
+      unbounded: true,
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+    expect(detail.value).toBe(false);
+    expect(detail.reason.bigSegmentsStatus).toEqual('NOT_CONFIGURED');
+  });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('matched with include', async (context) => {
+    const segment = {
+      key: 'test',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+    };
+    const membership = { [makeBigSegmentRef(segment)]: true };
+    const e = Evaluator(prepareQueries({ segments: [segment], bigSegments: { [basicUser.key]: membership } }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(true);
+    expect(detail.reason.bigSegmentsStatus).toEqual('HEALTHY');
+  });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('matched with rule', async (context) => {
+    const segment = {
+      key: 'test',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+      rules: [
+        { clauses: [makeClauseThatMatchesUser(basicUser)] },
+      ]
+    };
+    const membership = {};
+    const e = Evaluator(prepareQueries({ segments: [segment], bigSegments: { [basicUser.key]: membership } }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(true);
+    expect(detail.reason.bigSegmentsStatus).toEqual('HEALTHY');
+  });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('unmatched by exclude regardless of rule', async (context) => {
+    const segment = {
+      key: 'test',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+      rules: [
+        { clauses: [makeClauseThatMatchesUser(basicUser)] },
+      ]
+    };
+    const membership = { [makeBigSegmentRef(segment)]: false };
+    const e = Evaluator(prepareQueries({ segments: [segment], bigSegments: { [basicUser.key]: membership } }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(false);
+    expect(detail.reason.bigSegmentsStatus).toEqual('HEALTHY');
+  });
+
+  it('status is returned from provider', async () => {
+    const segment = {
+      key: 'test',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+    };
+    const membership = { [makeBigSegmentRef(segment)]: true };
+    const queries = prepareQueries({ segments: [segment] });
+    queries.getBigSegmentsMembership = (key, cb) => {
+      cb([ membership, 'STALE' ]);
+    };
+    const e = Evaluator(queries);
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+    expect(detail.value).toBe(true);
+    expect(detail.reason.bigSegmentsStatus).toEqual('STALE');
+  });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('queries state only once per user even if flag references multiple segments', async (context) => {
+    const segment1 = {
+      key: 'segmentkey1',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+    };
+    const segment2 = {
+      key: 'segmentkey2',
+      version: 1,
+      unbounded: true,
+      generation: 3,
+    };
+    const flag = {
+      key: "key",
+      on: "true",
+      fallthrough: { variation: 0 },
+      variations: [ false, true ],
+      rules: [
+        { variation: 1, clauses: [ makeSegmentMatchClause(segment1) ]},
+        { variation: 1, clauses: [ makeSegmentMatchClause(segment2) ]},
+      ],
+    }
+
+    const membership = { [makeBigSegmentRef(segment2)]: true };
+    // The membership deliberately does not include segment1, because we want the first rule to be
+    // a non-match so that it will continue on and check segment2 as well.
+
+    const queries = prepareQueries({ segments: [segment1, segment2] });
+    let userQueryCount = 0;
+    queries.getBigSegmentsMembership = (key, cb) => {
+      userQueryCount++;
+      cb([ membership, 'HEALTHY' ]);
+    };
+
+    const e = Evaluator(queries);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(true);
+    expect(detail.reason.bigSegmentsStatus).toEqual('HEALTHY');
+
+    expect(userQueryCount).toEqual(1);
+  });
+});
+
+describe('Evaluator - Big Segments non-user', () => {
+  const targetKey = 'targetKey';
+  const targetContextKind = 'org';
+
+  const singleKindContext = {
+    kind: targetContextKind,
+    key: targetKey
+  };
+  const multiKindContext = {
+    kind: 'multi',
+  };
+  multiKindContext[targetContextKind] = {
+    key: targetKey
+  };
+
+  it.each([singleKindContext, multiKindContext])
+  ('matched with include for matching unboundedContextKind', async (context) => {
+    const segment = {
+      key: 'test',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+      unboundedContextKind: 'org'
+    };
+    const membership = { [makeBigSegmentRef(segment)]: true };
+    const e = Evaluator(prepareQueries({ segments: [segment], bigSegments: { [singleKindContext.key]: membership } }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(true);
+    expect(detail.reason.bigSegmentsStatus).toEqual('HEALTHY');
+  });
+
+  it.each([singleKindContext, multiKindContext])
+  ('not matched with include for unboundedContextKind which does not match', async (context) => {
+    const segment = {
+      key: 'test',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+      unboundedContextKind: 'party'
+    };
+    const membership = { [makeBigSegmentRef(segment)]: true };
+    const e = Evaluator(prepareQueries({ segments: [segment], bigSegments: { [singleKindContext.key]: membership } }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(false);
+    expect(detail.reason.bigSegmentsStatus).toBeUndefined();
+  });
+
+  it('cached membership by key', async () => {
+    const segment = {
+      key: 'bigSegment1',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+      unboundedContextKind: 'party'
+    };
+    const segment2 = {
+      key: 'bigSegment2',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+      unboundedContextKind: 'org'
+    };
+
+    const context = {
+      kind: 'multi',
+      party: {key: 'partyKey'},
+      org: {key: 'orgKey'},
+    };
+    const membership = { [makeBigSegmentRef(segment)]: true };
+    const membership2 = { [makeBigSegmentRef(segment2)]: true };
+    const e = Evaluator(prepareQueries({ segments: [segment, segment2], bigSegments: { [context.party.key]: membership, [context.org.key]: membership2 } }));
+    const flag = makeBooleanFlagWithRules([{clauses: [
+      makeSegmentMatchClause(segment),
+      makeSegmentMatchClause(segment2)
+    ], variation: 1}])
+
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(true);
+    expect(detail.reason.bigSegmentsStatus).toEqual('HEALTHY');
+  });
+
+  it.each([
+    ['HEALTYH', 'STALE', 'STALE'],
+    ['HEALTYH', 'STORE_ERROR', 'STORE_ERROR'],
+    ['HEALTYH', 'NOT_CONFIGURED', 'NOT_CONFIGURED'],
+    ['STALE', 'HEALTYH', 'STALE'],
+    ['STALE', 'STORE_ERROR', 'STORE_ERROR'],
+    ['STALE', 'NOT_CONFIGURED', 'NOT_CONFIGURED'],
+    ['STORE_ERROR', 'HEALTYH', 'STORE_ERROR'],
+    ['STORE_ERROR', 'STALE', 'STORE_ERROR'],
+    ['STORE_ERROR', 'NOT_CONFIGURED', 'NOT_CONFIGURED'],
+    ['NOT_CONFIGURED', 'HEALTYH', 'NOT_CONFIGURED'],
+    ['NOT_CONFIGURED', 'STALE', 'NOT_CONFIGURED'],
+    ['NOT_CONFIGURED', 'STORE_ERROR', 'NOT_CONFIGURED']
+  ])
+  ('worst status is returned given multiple queries with different status', async (status1, status2, result) => {
+    const segment = {
+      key: 'bigSegment1',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+      unboundedContextKind: 'party'
+    };
+    const segment2 = {
+      key: 'bigSegment2',
+      version: 1,
+      unbounded: true,
+      generation: 2,
+      unboundedContextKind: 'org'
+    };
+
+    const context = {
+      kind: 'multi',
+      party: {key: 'partyKey'},
+      org: {key: 'orgKey'},
+    };
+    const membership1 = { [makeBigSegmentRef(segment)]: true };
+    const membership2 = { [makeBigSegmentRef(segment2)]: true };
+    const queries = prepareQueries({ segments: [segment, segment2] });
+    const memberships = {[context.party.key]: [membership1, status1], [context.org.key]: [membership2, status2]};
+    queries.getBigSegmentsMembership = (key, cb) => {
+      cb(memberships[key]);
+    };
+
+    const e = Evaluator(queries);
+    const flag = makeBooleanFlagWithRules([{clauses: [
+      makeSegmentMatchClause(segment),
+      makeSegmentMatchClause(segment2)
+    ], variation: 1}])
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(true);
+    expect(detail.reason.bigSegmentsStatus).toEqual(result);
+  });
+});

package/test/evaluator-bucketing-test.js

@@ -0,0 +1,333 @@
+const { isExportDeclaration } = require('typescript');
+const { Evaluator, bucketContext } = require('../evaluator');
+const {
+  eventFactory,
+  asyncEvaluate,
+} = require('./evaluator_helpers');
+
+describe('rollout', () => {
+  it('selects bucket', async () => {
+    const user = { key: 'userkey' };
+    const flagKey = 'flagkey';
+    const salt = 'salt';
+
+    // First verify that with our test inputs, the bucket value will be greater than zero and less than 100000,
+    // so we can construct a rollout whose second bucket just barely contains that value
+    const bucketValue = Math.floor(bucketContext(user, flagKey, 'key', salt, null, 'user')[0] * 100000);
+    expect(bucketValue).toBeGreaterThan(0);
+    expect(bucketValue).toBeLessThan(100000);
+
+    const badVariationA = 0, matchedVariation = 1, badVariationB = 2;
+    const rollout = {
+      variations: [
+        { variation: badVariationA, weight: bucketValue }, // end of bucket range is not inclusive, so it will *not* match the target value
+        { variation: matchedVariation, weight: 1 }, // size of this bucket is 1, so it only matches that specific value
+        { variation: badVariationB, weight: 100000 - (bucketValue + 1) }
+      ]
+    };
+    const flag = {
+      key: flagKey,
+      salt: salt,
+      on: true,
+      fallthrough: { rollout: rollout },
+      variations: [null, null, null]
+    };
+    const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+    expect(err).toEqual(null);
+    expect(detail.variationIndex).toEqual(matchedVariation);
+  });
+
+  it('does not use the secondary key', async () => {
+    const userWithSecondary = { key: 'userkey', secondary: 'secondary' };
+    const userWithoutSecondary = { key: 'userkey' };
+    const flagKey = 'flagkey';
+    const salt = 'salt';
+
+    // The secondary attribute is no longer used, so we want to make sure a user with and without the attribute bucket
+    // the same.
+    const bucketValueWithSecondary = Math.floor(bucketContext(userWithSecondary, flagKey, 'key', salt, null, 'user')[0] * 100000);
+    const bucketValueWithoutSecondary = Math.floor(bucketContext(userWithoutSecondary, flagKey, 'key', salt, null, 'user')[0] * 100000);
+
+    expect(bucketValueWithSecondary).toEqual(bucketValueWithoutSecondary);
+  });
+
+  it('handles an invalid bucketBy', async () => {
+    const user = { key: 'userkey' };
+    const flagKey = 'flagkey';
+    const salt = 'salt';
+
+    const rollout = {
+      contextKind: 'user',
+      bucketBy: '//',
+      variations: [
+        { variation: 0, weight: 10000 },
+      ]
+    };
+    const flag = {
+      key: flagKey,
+      salt: salt,
+      on: true,
+      fallthrough: { rollout: rollout },
+      variations: [null, null, null]
+    };
+    const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+    expect(err).toBeDefined();
+    expect(detail.reason).toEqual({ kind: 'ERROR', errorKind: 'MALFORMED_FLAG' });
+    expect(detail.variationIndex).toEqual(null);
+  });
+
+  it('selects bucket for a single kind user context', async () => {
+    const context = { kind: 'user', key: 'userkey' };
+    const flagKey = 'flagkey';
+    const salt = 'salt';
+
+    const [bucket, hadContext] = bucketContext(context, flagKey, 'key', salt, null, 'user');
+    const bucketValue = Math.floor(bucket * 100000);
+    expect(bucketValue).toBeGreaterThan(0);
+    expect(bucketValue).toBeLessThan(100000);
+    expect(hadContext).toEqual(true);
+
+    const badVariationA = 0, matchedVariation = 1, badVariationB = 2;
+    const rollout = {
+      variations: [
+        { variation: badVariationA, weight: bucketValue }, // end of bucket range is not inclusive, so it will *not* match the target value
+        { variation: matchedVariation, weight: 1 }, // size of this bucket is 1, so it only matches that specific value
+        { variation: badVariationB, weight: 100000 - (bucketValue + 1) }
+      ]
+    };
+    const flag = {
+      key: flagKey,
+      salt: salt,
+      on: true,
+      fallthrough: { rollout: rollout },
+      variations: [null, null, null]
+    };
+    const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+    expect(err).toEqual(null);
+    expect(detail.variationIndex).toEqual(matchedVariation);
+  });
+
+  it('Uses the first bucket when the context does not contain the context kind of the rollout', async () => {
+    const context = { kind: 'org', key: 'orgKey' };
+    const flagKey = 'flagkey';
+    const salt = 'salt';
+
+    const [bucket, hadContext] = bucketContext(context, flagKey, 'key', salt, null, 'user')
+    const bucketValue = Math.floor(bucket * 100000);
+    expect(bucketValue).toEqual(0);
+    expect(hadContext).toEqual(false);
+
+    const rollout = {
+      contextKind: 'user',
+      variations: [
+        { variation: 0, weight: 1 }, // end of bucket range is not inclusive, so it will *not* match the target value
+        { variation: 1, weight: 1 }, // size of this bucket is 1, so it only matches that specific value
+        { variation: 2, weight: 100000 - (1 + 1) }
+      ]
+    };
+    const flag = {
+      key: flagKey,
+      salt: salt,
+      on: true,
+      fallthrough: { rollout: rollout },
+      variations: [null, null, null]
+    };
+    const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+    expect(err).toEqual(null);
+    expect(detail.variationIndex).toEqual(0);
+  });
+
+  it('Produces a non-zero bucket for a multi-kind context which contains the desired context kind', async () => {
+    const context = { kind: 'org', key: 'orgKey' };
+    const flagKey = 'flagkey';
+    const salt = 'salt';
+
+    const [bucket, hadContext] = bucketContext(context, flagKey, 'key', salt, null, 'org');
+    const bucketValue = Math.floor(bucket * 100000);
+    expect(bucketValue).toBeGreaterThan(0);
+    expect(bucketValue).toBeLessThan(100000);
+    expect(hadContext).toEqual(true);
+
+    const badVariationA = 0, matchedVariation = 1, badVariationB = 2;
+    const rollout = {
+      contextKind: 'org',
+      variations: [
+        { variation: badVariationA, weight: bucketValue }, // end of bucket range is not inclusive, so it will *not* match the target value
+        { variation: matchedVariation, weight: 1 }, // size of this bucket is 1, so it only matches that specific value
+        { variation: badVariationB, weight: 100000 - (bucketValue + 1) }
+      ]
+    };
+    const flag = {
+      key: flagKey,
+      salt: salt,
+      on: true,
+      fallthrough: { rollout: rollout },
+      variations: [null, null, null]
+    };
+    const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+    expect(err).toEqual(null);
+    expect(detail.variationIndex).toEqual(matchedVariation);
+  });
+
+  it('uses last bucket if bucket value is equal to total weight', async () => {
+    const user = { key: 'userkey' };
+    const flagKey = 'flagkey';
+    const salt = 'salt';
+
+    // We'll construct a list of variations that stops right at the target bucket value
+    const bucketValue = Math.floor(bucketContext(user, flagKey, 'key', salt)[0] * 100000);
+
+    const rollout = {
+      variations: [{ variation: 0, weight: bucketValue }]
+    };
+    const flag = {
+      key: flagKey,
+      salt: salt,
+      on: true,
+      fallthrough: { rollout: rollout },
+      variations: [null, null, null]
+    };
+    const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+    expect(err).toEqual(null);
+    expect(detail.variationIndex).toEqual(0);
+  });
+
+  describe('with seed', () => {
+    const seed = 61;
+    const flagKey = 'flagkey';
+    const salt = 'salt';
+    const rollout = {
+      kind: 'experiment',
+      seed,
+      variations: [
+        { variation: 0, weight: 10000 },
+        { variation: 1, weight: 20000 },
+        { variation: 0, weight: 70000, untracked: true },
+      ],
+    };
+    const flag = {
+      key: flagKey,
+      salt: salt,
+      on: true,
+      fallthrough: { rollout: rollout },
+      variations: [null, null, null],
+    };
+
+    it('buckets user into first variant of the experiment', async () => {
+      const user = { key: 'userKeyA' };
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+      expect(err).toEqual(null);
+      expect(detail.variationIndex).toEqual(0);
+      expect(detail.reason.inExperiment).toBe(true);
+    });
+
+    it('inExperiment is not set when the context kind is not present', async () => {
+      const user = { kind: 'org', key: 'userKeyA' };
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+      expect(err).toEqual(null);
+      expect(detail.variationIndex).toEqual(0);
+      expect(detail.reason.inExperiment).toBeUndefined();
+    });
+
+    it('uses seed to bucket user into second variant of the experiment', async () => {
+      const user = { key: 'userKeyB' };
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+      expect(err).toEqual(null);
+      expect(detail.variationIndex).toEqual(1);
+      expect(detail.reason.inExperiment).toBe(true);
+    });
+
+    it('buckets user outside of the experiment', async () => {
+      const user = { key: 'userKeyC' };
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+      expect(err).toEqual(null);
+      expect(detail.variationIndex).toEqual(0);
+      expect(detail.reason.inExperiment).toBe(undefined);
+    });
+
+    it('does not use bucketBy for experiments', async () => {
+      const user = { key: 'userKeyA', kind: 'user', mimic: 'userKeyC' };
+      const bucketByFlag = JSON.parse(JSON.stringify(flag));
+      bucketByFlag.fallthrough.rollout.bucketBy = "mimic";
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), bucketByFlag, user, eventFactory);
+      expect(err).toEqual(null);
+      expect(detail.variationIndex).toEqual(0);
+      expect(detail.reason.inExperiment).toBe(true);
+    });
+  });
+});
+
+describe('bucketContext', () => {
+  it('gets expected bucket values for specific keys', () => {
+    let user = { key: 'userKeyA' };
+    let [bucket] = bucketContext(user, 'hashKey', 'key', 'saltyA', null, 'user');
+    expect(bucket).toBeCloseTo(0.42157587, 7);
+
+    user = { key: 'userKeyB' };
+    [bucket] = bucketContext(user, 'hashKey', 'key', 'saltyA', null, 'user');
+    expect(bucket).toBeCloseTo(0.6708485, 7);
+
+    user = { key: 'userKeyC' };
+    [bucket] = bucketContext(user, 'hashKey', 'key', 'saltyA', null, 'user');
+    expect(bucket).toBeCloseTo(0.10343106, 7);
+  });
+
+  it('can bucket by int value (equivalent to string)', () => {
+    const user = {
+      key: 'userKey',
+      custom: {
+        intAttr: 33333,
+        stringAttr: '33333'
+      }
+    };
+    const [bucket] = bucketContext(user, 'hashKey', 'intAttr', 'saltyA', null, 'user');
+    const [bucket2] = bucketContext(user, 'hashKey', 'stringAttr', 'saltyA', null, 'user');
+    expect(bucket).toBeCloseTo(0.54771423, 7);
+    expect(bucket2).toBe(bucket);
+  });
+
+  it('cannot bucket by float value', () => {
+    const user = {
+      key: 'userKey',
+      custom: {
+        floatAttr: 33.5
+      }
+    };
+    const [bucket] = bucketContext(user, 'hashKey', 'floatAttr', 'saltyA', null, 'user');
+    expect(bucket).toBe(0);
+  });
+});
+
+describe('when seed is present', () => {
+  const seed = 61;
+  it('gets expected bucket values for specific keys', () => {
+    let user = { key: 'userKeyA' };
+    let [bucket] = bucketContext(user, 'hashKey', 'key', 'saltyA', seed, 'user');
+    expect(bucket).toBeCloseTo(0.09801207, 7);
+
+    user = { key: 'userKeyB' };
+    [bucket] = bucketContext(user, 'hashKey', 'key', 'saltyA', seed, 'user');
+    expect(bucket).toBeCloseTo(0.14483777, 7);
+
+    user = { key: 'userKeyC' };
+    [bucket] = bucketContext(user, 'hashKey', 'key', 'saltyA', seed, 'user');
+    expect(bucket).toBeCloseTo(0.9242641, 7);
+  });
+
+  it('should not generate a different bucket when hashKey or salt are changed', () => {
+    let user = { key: 'userKeyA' };
+    let [bucket] = bucketContext(user, 'hashKey', 'key', 'saltyA', seed, 'user');
+    let [bucketDifferentHashKey] = bucketContext(user, 'otherHashKey', 'key', 'saltyA', seed, 'user');
+    let [bucketDifferentSalt] = bucketContext(user, 'hashKey', 'key', 'otherSaltyA', seed, 'user');
+
+    expect(bucketDifferentHashKey).toBeCloseTo(bucket, 7);
+    expect(bucketDifferentSalt).toBeCloseTo(bucket, 7);
+  });
+
+  it('should generate a new bucket if the seed changes', () => {
+    const otherSeed = 60;
+    const user = { key: 'userKeyA' };
+    const [bucket] = bucketContext(user, 'hashKey', 'key', 'saltyA', otherSeed, 'user');
+    expect(bucket).toBeCloseTo(0.7008816, 7);
+  });
+});