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

package/test/evaluator-segment-match-test.js

@@ -0,0 +1,310 @@
+
+const { Evaluator } = require('../evaluator');
+const {
+  basicUser,
+  basicSingleKindUser,
+  basicMultiKindUser,
+  eventFactory,
+  prepareQueries,
+  makeFlagWithSegmentMatch,
+  asyncEvaluate,
+  makeClauseThatMatchesUser,
+  makeClauseThatDoesNotMatchUser,
+} = require('./evaluator_helpers');
+
+// Tests of flag evaluation at the segment-matching level - for simple segments, not big segments.
+
+describe('Evaluator - segment match for user contexts', () => {
+  const matchClause = makeClauseThatMatchesUser(basicUser);
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('matches segment with explicitly included user', async (user) => {
+    const segment = {
+      key: 'test',
+      included: [ basicUser.key ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, user, eventFactory);
+    expect(detail.value).toBe(true);
+  });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('does not match segment with explicitly excluded user', async (user) => {
+    const segment = {
+      key: 'test',
+      excluded: [ basicUser.key ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, user, eventFactory);
+    expect(detail.value).toBe(false);
+  });
+
+
+  it('does not match a segment that does not exist', async () => {
+    const segment = {
+      key: 'test',
+      included: [ basicUser.key ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+    expect(detail.value).toBe(false);
+  });
+
+  it('does not match segment with unknown user', async () => {
+    const segment = {
+      key: 'test',
+      included: [ 'foo' ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const user = { key: 'bar' };
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, user, eventFactory);
+    expect(detail.value).toBe(false);
+  });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('matches segment with user who is both included and excluded', async (user) => {
+    const segment = {
+      key: 'test',
+      included: [ basicUser.key ],
+      excluded: [ basicUser.key ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, user, eventFactory);
+    expect(detail.value).toBe(true);
+  });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('matches segment with rule with full rollout', async (user) => {
+    const segment = {
+      key: 'test',
+      rules: [
+        {
+          clauses: [ matchClause ],
+          weight: 100000
+        }
+      ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, user, eventFactory);
+    expect(detail.value).toBe(true);
+  });
+
+  it('handles an invalid reference for bucketBy', async () => {
+    const segment = {
+      key: 'test',
+      rules: [
+        {
+          clauses: [ matchClause ],
+          weight: 100000,
+          bucketBy: '//',
+          contextKind: 'user'
+        }
+      ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+    expect(detail.reason).toEqual({ kind: 'ERROR', errorKind: 'MALFORMED_FLAG' });
+    expect(detail.value).toBe(null);
+  });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+  ('does not match segment with rule with zero rollout', async (user) => {
+    const segment = {
+      key: 'test',
+      rules: [
+        {
+          clauses: [ matchClause ],
+          weight: 0
+        }
+      ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, user, eventFactory);
+    expect(detail.value).toBe(false);
+  });
+
+  it('matches segment with multiple matching clauses', async () => {
+
+    const user = { key: 'foo', email: 'test@example.com', name: 'bob' };
+    const segment = {
+      key: 'test',
+      rules: [
+        {
+          clauses: [
+            {
+              attribute: 'email',
+              op: 'in',
+              values: [ user.email ]
+            },
+            {
+              attribute: 'name',
+              op: 'in',
+              values: [ user.name ]
+            }
+          ]
+        }
+      ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, user, eventFactory);
+    expect(detail.value).toBe(true);
+  });
+
+  it('does not match segment if one clause does not match', async () => {
+    const user = { key: 'foo', email: 'test@example.com', name: 'bob' };
+    const segment = {
+      key: 'test',
+      rules: [
+        {
+          clauses: [ makeClauseThatMatchesUser(user), makeClauseThatDoesNotMatchUser(user) ],
+        }
+      ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, user, eventFactory);
+    expect(detail.value).toBe(false);
+  });
+});
+
+const singleKind = { kind: 'org', key: 'orgKey' };
+const multiKind = { kind: 'multi', org: { key: 'orgKey' } };
+
+describe('Evaluator - segment match for non-user contexts', () => {
+  it.each([singleKind, multiKind])
+  ('matches segment with explicitly included context', async (context) => {
+    const segment = {
+      key: 'test',
+      includedContexts: [ {contextKind: 'org', values: [singleKind.key]} ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(true);
+  });
+
+  it.each([singleKind, multiKind])
+  ('matches nested segments', async (context) => {
+    const segment1 = {
+      key: 'segment1',
+      includedContexts: [ {contextKind: 'org', values: [singleKind.key]} ],
+      version: 1
+    };
+    const segment2 = {
+      key: 'segment2',
+      rules: [
+        {
+          clauses: [ { attribute: '', op: 'segmentMatch', values: [segment1.key] } ],
+          weight: 100000
+        }
+      ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment1, segment2] }));
+    const flag = makeFlagWithSegmentMatch(segment2);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(true);
+  });
+
+  it('does not exceed callstack side for circular segments', async () => {
+    const segment = {
+      key: 'segment',
+      rules: [
+        {
+          clauses: [ { attribute: '', op: 'segmentMatch', values: ['segment'] } ],
+          weight: 100000
+        }
+      ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, singleKind, eventFactory);
+    expect(detail.reason).toEqual({ kind: 'ERROR', errorKind: 'MALFORMED_FLAG' });
+    expect(detail.value).toBe(null);
+  });
+
+  it('allows for the same segment to be references in multiple clauses', async () => {
+    const segment1 = {
+      key: 'segment1',
+      includedContexts: [ {contextKind: 'org', values: [singleKind.key]} ],
+      version: 1
+    };
+    const segment2 = {
+      key: 'segment2',
+      rules: [
+        {
+          clauses: [
+            { attribute: '', op: 'segmentMatch', values: [segment1.key] },
+            { attribute: '', op: 'segmentMatch', values: [segment1.key] }
+          ],
+          weight: 100000
+        }
+      ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment1, segment2] }));
+    const flag = makeFlagWithSegmentMatch(segment2);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, singleKind, eventFactory);
+    expect(detail.value).toBe(true);
+  });
+
+  it.each([singleKind, multiKind])
+  ('does not match segment for matching kind but missing key', async (context) => {
+    const segment = {
+      key: 'test',
+      includedContexts: [ {kind: 'org', values: ['otherKey']} ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(false);
+  });
+
+  it.each([singleKind, multiKind])
+  ('does not match segment with explicitly excluded context', async (context) => {
+    const segment = {
+      key: 'test',
+      excludedContexts: [ {kind: 'org', values: [singleKind.key]} ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(false);
+  });
+
+  it.each([singleKind, multiKind])
+  ('does not match segment for wrong kind', async (context) => {
+    const segment = {
+      key: 'test',
+      includedContexts: [ {kind: 'notOrg', values: [singleKind.key]} ],
+      version: 1
+    };
+    const e = Evaluator(prepareQueries({ segments: [segment] }));
+    const flag = makeFlagWithSegmentMatch(segment);
+    const [ err, detail, events ] = await asyncEvaluate(e, flag, context, eventFactory);
+    expect(detail.value).toBe(false);
+  });
+});

package/test/evaluator_helpers.js

@@ -0,0 +1,106 @@
+const { EventFactory } = require('../event_factory');
+
+// All three of these users should represent the same user.
+const basicUser = { key: 'userkey' };
+const basicSingleKindUser = { kind: 'user', key: 'userkey' };
+const basicMultiKindUser = { kind: 'multi', user: { key: 'userkey' } };
+
+const eventFactory = EventFactory(false);
+
+// Evaluator.evaluate uses a callback instead of a promise because it's a slightly more efficient
+// way to pass multiple return values. But for the purposes of our tests, it's much easier to use
+// a promise and async/await, so we'll transform it with this helper. Unlike usual Node promise
+// semantics, here we treat "err" as just another return parameter rather than throwing an error
+// (because the other parameters can still be non-null even if there's an error).
+function asyncEvaluate(evaluator, flag, user, eventFactory) {
+  return new Promise(resolve => {
+    evaluator.evaluate(flag, user, eventFactory, (err, detail, events) => resolve([err, detail, events]));
+  });
+}
+
+function makeFlagWithRules(rules, fallthrough) {
+  if (!fallthrough) {
+    fallthrough = { variation: 0 };
+  }
+  return {
+    key: 'feature',
+    on: true,
+    rules: rules,
+    targets: [],
+    fallthrough: fallthrough,
+    offVariation: 1,
+    variations: ['a', 'b', 'c']
+  };
+}
+
+function makeBooleanFlagWithRules(rules) {
+  return {
+    key: 'feature',
+    on: true,
+    prerequisites: [],
+    rules: rules,
+    targets: [],
+    salt: '',
+    fallthrough: { variation: 0 },
+    offVariation: 0,
+    variations: [false, true],
+    version: 1
+  };
+}
+
+function makeBooleanFlagWithOneClause(clause) {
+  return makeBooleanFlagWithRules([{ clauses: [clause], variation: 1 }]);
+}
+
+function makeFlagWithSegmentMatch(segment) {
+  return makeBooleanFlagWithOneClause(makeSegmentMatchClause(segment));
+}
+
+function makeClauseThatMatchesUser(user) {
+  return { attribute: 'key', op: 'in', values: [user.key] };
+}
+
+function makeClauseThatDoesNotMatchUser(user) {
+  return { attribute: 'key', op: 'in', values: ['not-' + user.key] };
+}
+
+function makeSegmentMatchClause(segment) {
+  return { attribute: '', op: 'segmentMatch', values: [segment.key] };
+}
+
+function prepareQueries(data) {
+  let flagsMap = {}, segmentsMap = {};
+  for (const f of (data.flags || [])) {
+    flagsMap[f.key] = f;
+  }
+  for (const s of (data.segments || [])) {
+    segmentsMap[s.key] = s;
+  }
+  return {
+    getFlag: (key, cb) => cb(flagsMap[key]),
+    getSegment: (key, cb) => cb(segmentsMap[key]),
+    getBigSegmentsMembership: (key, cb) => {
+      if (data.bigSegments) {
+        cb([data.bigSegments[key], 'HEALTHY']);
+      } else {
+        cb(null);
+      }
+    },
+  };
+}
+
+module.exports = {
+  basicUser,
+  basicSingleKindUser,
+  basicMultiKindUser,
+  eventFactory,
+  asyncEvaluate,
+  makeFlagWithRules,
+  makeBooleanFlagWithRules,
+  makeBooleanFlagWithOneClause,
+  makeFlagWithSegmentMatch,
+  makeClauseThatMatchesUser,
+  makeClauseThatDoesNotMatchUser,
+  makeSegmentMatchClause,
+  prepareQueries,
+};