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

package/test/evaluator-flag-test.js

@@ -0,0 +1,452 @@
+const { Evaluator } = require('../evaluator');
+const {
+  basicUser,
+  eventFactory,
+  prepareQueries,
+  makeFlagWithRules,
+  asyncEvaluate,
+  makeClauseThatDoesNotMatchUser,
+} = require('./evaluator_helpers');
+
+// Tests of flag evaluation at the highest level. Rule-level and clause-level behavior is covered
+// in detail in evaluator-rule-test, evaluator-clause-test, and evaluator-segment-match-test.
+
+describe('Evaluator - basic flag behavior', () => {
+  describe('flag is off', () => {
+    it('returns off variation', async () => {
+      const flag = {
+        key: 'feature',
+        on: false,
+        offVariation: 1,
+        fallthrough: { variation: 0 },
+        variations: ['a', 'b', 'c']
+      };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(detail).toMatchObject({ value: 'b', variationIndex: 1, reason: { kind: 'OFF' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('returns null if off variation is unspecified', async () => {
+      const flag = {
+        key: 'feature',
+        on: false,
+        fallthrough: { variation: 0 },
+        variations: ['a', 'b', 'c']
+      };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'OFF' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('returns error if off variation is too high', async () => {
+      const flag = {
+        key: 'feature',
+        on: false,
+        offVariation: 99,
+        fallthrough: { variation: 0 },
+        variations: ['a', 'b', 'c']
+      };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(err).toEqual(Error('Invalid variation index in flag'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('returns error if off variation is negative', async () => {
+      const flag = {
+        key: 'feature',
+        on: false,
+        offVariation: -1,
+        fallthrough: { variation: 0 },
+        variations: ['a', 'b', 'c']
+      };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(err).toEqual(Error('Invalid variation index in flag'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' } });
+      expect(events).toBeUndefined();
+    });
+  });
+
+  describe('fallthrough - flag is on and no rules match', () => {
+    const noMatchClause = makeClauseThatDoesNotMatchUser(basicUser);
+
+    it('returns fallthrough variation', async () => {
+      var rule = { id: 'id', clauses: [noMatchClause], variation: 2 };
+      const flag = makeFlagWithRules([rule], { variation: 0 });
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(detail).toMatchObject({ value: 'a', variationIndex: 0, reason: { kind: 'FALLTHROUGH' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('returns error if fallthrough variation is too high', async () => {
+      var rule = { id: 'id', clauses: [noMatchClause], variation: 99 };
+      const flag = makeFlagWithRules([rule], { variation: 99 });
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(err).toEqual(Error('Invalid variation index in flag'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' }});
+      expect(events).toBeUndefined();
+    });
+
+    it('returns error if fallthrough variation is negative', async () => {
+      var rule = { id: 'id', clauses: [noMatchClause], variation: 99 };
+      const flag = makeFlagWithRules([rule], { variation: -1 });
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(err).toEqual(Error('Invalid variation index in flag'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' }});
+      expect(events).toBeUndefined();
+    });
+
+    it('returns error if fallthrough has no variation or rollout', async () => {
+      var rule = { id: 'id', clauses: [noMatchClause], variation: 99 };
+      const flag = makeFlagWithRules([rule], { });
+      var user = { key: 'x' };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(err).toEqual(Error('Variation/rollout object with no variation or rollout'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' }});
+      expect(events).toBeUndefined();
+    });
+
+    it('returns error if fallthrough has rollout with no variations', async () => {
+      var rule = { id: 'id', clauses: [noMatchClause], variation: 99 };
+      const flag = makeFlagWithRules([rule], { rollout: { variations: [] } });
+      var user = { key: 'x' };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(err).toEqual(Error('Variation/rollout object with no variation or rollout'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' }});
+      expect(events).toBeUndefined();
+    });
+  });
+
+  describe('prerequisites', () => {
+    it('returns off variation if prerequisite is not found', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        prerequisites: [{key: 'badfeature', variation: 1}],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      };
+      const e = Evaluator(prepareQueries({}));
+      const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+      expect(detail).toMatchObject({ value: 'b', variationIndex: 1,
+        reason: { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'badfeature' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('returns off variation and event if prerequisite is off', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        prerequisites: [{key: 'feature1', variation: 1}],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        targets: [],
+        rules: [],
+        variations: ['a', 'b', 'c'],
+        version: 1
+      };
+      const flag1 = {
+        key: 'feature1',
+        on: false,
+        offVariation: 1,
+        // note that even though it returns the desired variation, it is still off and therefore not a match
+        fallthrough: { variation: 0 },
+        targets: [],
+        rules: [],
+        variations: ['d', 'e'],
+        version: 2
+      };
+      const e = Evaluator(prepareQueries({flags: [flag, flag1]}));
+      const eventsShouldBe = [
+        { kind: 'feature', key: 'feature1', variation: 1, value: 'e', version: 2, prereqOf: 'feature0' }
+      ];
+      const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+      expect(detail).toMatchObject({ value: 'b', variationIndex: 1,
+        reason: { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'feature1' } });
+      expect(events).toMatchObject(eventsShouldBe);
+    });
+
+    it('returns off variation and event if prerequisite is not met', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        prerequisites: [{key: 'feature1', variation: 1}],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        targets: [],
+        rules: [],
+        variations: ['a', 'b', 'c'],
+        version: 1
+      };
+      const flag1 = {
+        key: 'feature1',
+        on: true,
+        fallthrough: { variation: 0 },
+        targets: [],
+        rules: [],
+        variations: ['d', 'e'],
+        version: 2
+      };
+      const e = Evaluator(prepareQueries({ flags: [flag, flag1] }));
+      const eventsShouldBe = [
+        { kind: 'feature', key: 'feature1', variation: 0, value: 'd', version: 2, prereqOf: 'feature0' }
+      ];
+      const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+      expect(detail).toMatchObject({ value: 'b', variationIndex: 1,
+        reason: { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'feature1' } });
+      expect(events).toMatchObject(eventsShouldBe);
+    });
+
+    it('returns fallthrough variation and event if prerequisite is met and there are no rules', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        prerequisites: [{key: 'feature1', variation: 1}],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        targets: [],
+        rules: [],
+        variations: ['a', 'b', 'c'],
+        version: 1
+      };
+      const flag1 = {
+        key: 'feature1',
+        on: true,
+        fallthrough: { variation: 1 },
+        targets: [],
+        rules: [],
+        variations: ['d', 'e'],
+        version: 2
+      };
+      const e = Evaluator(prepareQueries({ flags: [flag, flag1] }))
+      const eventsShouldBe = [
+        { kind: 'feature', key: 'feature1', variation: 1, value: 'e', version: 2, prereqOf: 'feature0' }
+      ];
+      const [ err, detail, events ] = await asyncEvaluate(e, flag, basicUser, eventFactory);
+      expect(detail).toMatchObject({ value: 'a', variationIndex: 0, reason: { kind: 'FALLTHROUGH' } });
+      expect(events).toMatchObject(eventsShouldBe);
+    });
+  });
+
+  describe('targets', () => {
+    it('matches user from targets', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        targets: [
+          {
+            variation: 2,
+            values: ['some', 'userkey', 'or', 'other']
+          }
+        ],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      };
+      const user = { key: 'userkey' };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+      expect(detail).toMatchObject({ value: 'c', variationIndex: 2, reason: { kind: 'TARGET_MATCH' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('does not break when there are no values in a target', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        targets: [
+          {
+            variation: 2,
+          }
+        ],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      };
+      const user = { key: 'userkey' };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, user, eventFactory);
+      expect(detail).toMatchObject({ value: 'a', variationIndex: 0, reason: { kind: 'FALLTHROUGH' } });
+      expect(events).toBeUndefined();
+    });
+    
+    it('matches single kind user from targets', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        targets: [
+          {
+            variation: 2,
+            values: ['some', 'userkey', 'or', 'other']
+          }
+        ],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      };
+      const context = { kind: 'user', key: 'userkey' };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+      expect(detail).toMatchObject({ value: 'c', variationIndex: 2, reason: { kind: 'TARGET_MATCH' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('matches single kind non-user from contextTargets', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        contextTargets: [
+          {
+            variation: 2,
+            values: ['some', 'nonUserkey', 'or', 'other'],
+            contextKind: 'non-user'
+          }
+        ],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      };
+      const context = { kind: 'non-user', key: 'nonUserkey' };
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+      expect(detail).toMatchObject({ value: 'c', variationIndex: 2, reason: { kind: 'TARGET_MATCH' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('matches multi-kind context with user from targets', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        targets: [
+          {
+            variation: 2,
+            values: ['some', 'userkey', 'or', 'other']
+          }
+        ],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      };
+      const context = { kind: 'multi', user: {key: 'userkey' }};
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+      expect(detail).toMatchObject({ value: 'c', variationIndex: 2, reason: { kind: 'TARGET_MATCH' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('matches a user in a multi-kind context with contextTargets order', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        targets: [
+          {
+            variation: 2,
+            values: ['some', 'userkey', 'or', 'other']
+          }
+        ],
+        contextTargets: [{
+          variation: 2,
+          contextKind: 'user',
+          values: []
+        },{
+          variation: 1,
+          contextKind: 'farm',
+          values: ['cat']
+        }],
+        fallthrough: { variation: 0},
+        offVariation: 0,
+        variations: ['a', 'b', 'c']
+      };
+
+      const context = { kind: 'multi', farm: {key: 'cat' }, user: {key: 'userkey' }};
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+      expect(detail).toMatchObject({ value: 'c', variationIndex: 2, reason: { kind: 'TARGET_MATCH' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('does not match a user in a multi-kind context with contextTargets order if key is not present', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        targets: [
+          {
+            variation: 2,
+            values: ['some', 'userkey', 'or', 'other']
+          }
+        ],
+        contextTargets: [{
+          variation: 2,
+          contextKind: 'user',
+          values: []
+        },{
+          variation: 1,
+          contextKind: 'farm',
+          values: ['cat']
+        }],
+        fallthrough: { variation: 0},
+        offVariation: 0,
+        variations: ['a', 'b', 'c']
+      };
+
+      const context = { kind: 'multi', farm: {key: 'dog' }, user: {key: 'cat' }};
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+      expect(detail).toMatchObject({ value: 'a', variationIndex: 0, reason: { kind: 'FALLTHROUGH' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('matches contextTargets order with a non-user match ahead of a user.', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        targets: [
+          {
+            variation: 2,
+            values: ['some', 'userkey', 'or', 'other']
+          }
+        ],
+        contextTargets: [{
+          variation: 1,
+          contextKind: 'farm',
+          values: ['cat']
+        }, {
+          variation: 2,
+          contextKind: 'user',
+          values: []
+        }],
+        fallthrough: { variation: 0},
+        offVariation: 0,
+        variations: ['a', 'b', 'c']
+      };
+
+      const context = { kind: 'multi', farm: {key: 'cat' }, user: {key: 'userkey' }};
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+      expect(detail).toMatchObject({ value: 'b', variationIndex: 1, reason: { kind: 'TARGET_MATCH' } });
+      expect(events).toBeUndefined();
+    });
+
+    it('matches a context in a multi-kind context with a contextTarget', async () => {
+      const flag = {
+        key: 'feature0',
+        on: true,
+        rules: [],
+        contextTargets: [{
+          variation: 1,
+          contextKind: 'farm',
+          values: ['cat']
+        }],
+        fallthrough: { variation: 0},
+        offVariation: 0,
+        variations: ['a', 'b', 'c']
+      };
+
+      const context = { kind: 'multi', farm: {key: 'cat' }};
+      const [ err, detail, events ] = await asyncEvaluate(Evaluator(), flag, context, eventFactory);
+      expect(detail).toMatchObject({ value: 'b', variationIndex: 1, reason: { kind: 'TARGET_MATCH' } });
+      expect(events).toBeUndefined();
+    });
+  });
+});

package/test/evaluator-pre-conditions-test.js

@@ -0,0 +1,105 @@
+const { Evaluator } = require('../evaluator');
+
+const {
+  eventFactory,
+  asyncEvaluate,
+} = require('./evaluator_helpers');
+
+describe('when given a bad context', () => {
+  it('handles a legacy user without a key', async () => {
+    const [err, detail, events] = await asyncEvaluate(Evaluator(), {}, {}, eventFactory);
+    expect(detail).toEqual({
+      value: null,
+      variationIndex: null,
+      reason: {
+        kind: 'ERROR',
+        errorKind: 'USER_NOT_SPECIFIED'
+      }
+    });
+  });
+
+  it('handles a single kind context without a key', async () => {
+    const [err, detail, events] = await asyncEvaluate(Evaluator(), {}, {
+      kind: 'user'
+    }, eventFactory);
+    expect(detail).toEqual({
+      value: null,
+      variationIndex: null,
+      reason: {
+        kind: 'ERROR',
+        errorKind: 'USER_NOT_SPECIFIED'
+      }
+    });
+  });
+
+
+  it.each(["", " ", "#^&%&^", "almost ", 8, true, {}])
+    ('handles a single kind context with an invalid kind', async (kind) => {
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), {}, {
+        kind,
+        key: 'goodKey'
+      }, eventFactory);
+      expect(detail).toEqual({
+        value: null,
+        variationIndex: null,
+        reason: {
+          kind: 'ERROR',
+          errorKind: 'USER_NOT_SPECIFIED'
+        }
+      });
+    });
+
+  // For a multi-kind context the act of making something a key will
+  // produce a string. So testing non-string types is just testing
+  // the characters they contain.
+  it.each(["", " ", "#^&%&^", "almost "])
+    ('handles a multi kind context with an invalid kind', async (kind) => {
+      const context = {
+        kind: 'multi',
+      };
+      context[kind] = {
+        key: 'goodKey'
+      }
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), {}, context, eventFactory);
+      expect(detail).toEqual({
+        value: null,
+        variationIndex: null,
+        reason: {
+          kind: 'ERROR',
+          errorKind: 'USER_NOT_SPECIFIED'
+        }
+      });
+    });
+
+  it.each([undefined, null])
+    ('handles a multi kind context with a context missing a key', async (key) => {
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), {}, {
+        kind: 'multi',
+        user: {
+          key
+        }
+      }, eventFactory);
+      expect(detail).toEqual({
+        value: null,
+        variationIndex: null,
+        reason: {
+          kind: 'ERROR',
+          errorKind: 'USER_NOT_SPECIFIED'
+        }
+      });
+    });
+});
+
+it('handles a missing flag', async () => {
+  const [err, detail, events] = await asyncEvaluate(Evaluator(), undefined, {
+    key: "userKey"
+  }, eventFactory);
+  expect(detail).toEqual({
+    value: null,
+    variationIndex: null,
+    reason: {
+      kind: 'ERROR',
+      errorKind: 'FLAG_NOT_FOUND'
+    }
+  });
+});

package/test/evaluator-rule-test.js

@@ -0,0 +1,131 @@
+const { Evaluator } = require('../evaluator');
+const {
+  basicUser,
+  basicSingleKindUser,
+  basicMultiKindUser,
+  eventFactory,
+  makeFlagWithRules,
+  asyncEvaluate,
+  makeClauseThatMatchesUser,
+  makeClauseThatDoesNotMatchUser,
+} = require('./evaluator_helpers');
+
+// Tests of flag evaluation at the rule level. Clause-level behavior is covered in detail in
+// evaluator-clause-test and evaluator-segment-match-test.
+
+// const basicUser = { key: 'userkey' };
+// const singleKindUser = { kind: 'user', key: 'userkey' };
+// const multiKindWithUser = { kind: 'multi', user: { key: 'userkey' } };
+
+describe('Evaluator - rules with user kinds', () => {
+  const matchClause = makeClauseThatMatchesUser(basicUser);
+  const noMatchClause = makeClauseThatDoesNotMatchUser(basicUser);
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+    ('matches user from rules', async (userToTest) => {
+      const rule0 = { id: 'id0', clauses: [noMatchClause], variation: 1 };
+      const rule1 = { id: 'id1', clauses: [matchClause], variation: 2 };
+      const flag = makeFlagWithRules([rule0, rule1]);
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, userToTest, eventFactory);
+      expect(detail).toMatchObject({
+        value: 'c', variationIndex: 2,
+        reason: { kind: 'RULE_MATCH', ruleIndex: 1, ruleId: 'id1' }
+      });
+      expect(events).toBeUndefined();
+    });
+
+
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+    ('returns error if rule variation is too high', async (userToTest) => {
+      const rule = { id: 'id', clauses: [matchClause], variation: 99 };
+      const flag = makeFlagWithRules([rule]);
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, userToTest, eventFactory);
+      expect(err).toEqual(Error('Invalid variation index in flag'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' } });
+      expect(events).toBeUndefined();
+    });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+    ('returns error if rule variation is negative', async (userToTest) => {
+      const rule = { id: 'id', clauses: [matchClause], variation: -1 };
+      const flag = makeFlagWithRules([rule]);
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, userToTest, eventFactory);
+      expect(err).toEqual(Error('Invalid variation index in flag'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' } });
+      expect(events).toBeUndefined();
+    });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+    ('returns error if rule has no variation or rollout', async (userToTest) => {
+      const rule = { id: 'id', clauses: [matchClause] };
+      const flag = makeFlagWithRules([rule]);
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, basicUser, eventFactory);
+      expect(err).toEqual(Error('Variation/rollout object with no variation or rollout'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' } });
+      expect(events).toBeUndefined();
+    });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+    ('returns error if rule has rollout with no variations', async (userToTest) => {
+      const rule = { id: 'id', clauses: [matchClause], rollout: { variations: [] } };
+      const flag = makeFlagWithRules([rule]);
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, userToTest, eventFactory);
+      expect(err).toEqual(Error('Variation/rollout object with no variation or rollout'));
+      expect(detail).toMatchObject({ value: null, variationIndex: null, reason: { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' } });
+      expect(events).toBeUndefined();
+    });
+
+  it.each([basicUser, basicSingleKindUser, basicMultiKindUser])
+    ('does not overflow the call stack when evaluating a huge number of rules', async (userToTest) => {
+      const ruleCount = 5000;
+      const flag = {
+        key: 'flag',
+        targets: [],
+        on: true,
+        variations: [false, true],
+        fallthrough: { variation: 0 }
+      };
+      // Note, for this test to be meaningful, the rules must *not* match the user, since we
+      // stop evaluating rules on the first match.
+      const rules = [];
+      for (var i = 0; i < ruleCount; i++) {
+        rules.push({ clauses: [noMatchClause], variation: 1 });
+      }
+      flag.rules = rules;
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, userToTest, eventFactory);
+      expect(err).toEqual(null);
+      expect(detail.value).toEqual(false);
+    });
+});
+
+describe('Evaluator - rules with non-user kinds', () => {
+  const targetKey = 'targetKey';
+  const targetContextKind = 'org';
+  const matchClause = { attribute: 'key', op: 'in', values: [targetKey], contextKind: targetContextKind }
+  const noMatchClause = { attribute: 'key', op: 'in', values: ['not-' + targetKey], contextKind: targetContextKind }
+
+  const singleKindContext = {
+    kind: targetContextKind,
+    key: targetKey
+  };
+  const multiKindContext = {
+    kind: 'multi',
+  };
+  multiKindContext[targetContextKind] = {
+    key: targetKey
+  };
+
+  it.each([singleKindContext, multiKindContext])
+    ('matches user from rules', async (contextToTest) => {
+      const rule0 = { id: 'id0', clauses: [noMatchClause], variation: 1 };
+      const rule1 = { id: 'id1', clauses: [matchClause], variation: 2 };
+      const flag = makeFlagWithRules([rule0, rule1]);
+      const [err, detail, events] = await asyncEvaluate(Evaluator(), flag, contextToTest, eventFactory);
+      expect(detail).toMatchObject({
+        value: 'c', variationIndex: 2,
+        reason: { kind: 'RULE_MATCH', ruleIndex: 1, ruleId: 'id1' }
+      });
+      expect(events).toBeUndefined();
+    });
+});