public void BigSegmentStateIsQueriedOnlyOncePerUserEvenIfFlagReferencesMultipleSegments()
        {
            var segment1    = new SegmentBuilder("segmentkey1").Unbounded(true).Generation(2).Build();
            var segment2    = new SegmentBuilder("segmentkey2").Unbounded(true).Generation(3).Build();
            var bigSegments = new MockBigSegmentProvider();
            var membership  = MockMembership.New().Include(segment2);

            bigSegments.Membership[baseUser.Key] = membership;
            var flag = new FeatureFlagBuilder("key").On(true)
                       .Variations(LdValue.Of(false), LdValue.Of(true))
                       .FallthroughVariation(0)
                       .Rules(
                new RuleBuilder().Variation(1).Clauses(ClauseBuilder.ShouldMatchSegment(segment1.Key)).Build(),
                new RuleBuilder().Variation(1).Clauses(ClauseBuilder.ShouldMatchSegment(segment2.Key)).Build()
                )
                       .Build();
            var evaluator = BasicEvaluator.WithStoredSegments(segment1, segment2).WithBigSegments(bigSegments);

            var result = evaluator.Evaluate(flag, baseUser, EventFactory.Default);

            Assert.Equal(LdValue.Of(true), result.Result.Value);
            Assert.Equal(BigSegmentsStatus.Healthy, result.Result.Reason.BigSegmentsStatus);

            Assert.Equal(1, bigSegments.MembershipQueryCount);
            Assert.Equal(new List <string> {
                MakeBigSegmentRef(segment1), MakeBigSegmentRef(segment2)
            },
                         membership.Queries);
        }
        public void MatchedWithInclude()
        {
            var segment     = new SegmentBuilder("segmentkey").Unbounded(true).Generation(2).Build();
            var bigSegments = new MockBigSegmentProvider();

            bigSegments.Membership[baseUser.Key] = MockMembership.New().Include(segment);
            var flag      = new FeatureFlagBuilder("key").BooleanMatchingSegment(segment.Key).Build();
            var evaluator = BasicEvaluator.WithStoredSegments(segment).WithBigSegments(bigSegments);

            var result = evaluator.Evaluate(flag, baseUser, EventFactory.Default);

            Assert.Equal(LdValue.Of(true), result.Result.Value);
            Assert.Equal(BigSegmentsStatus.Healthy, result.Result.Reason.BigSegmentsStatus);
        }
        public void UnmatchedByExcludeRegardlessOfRule()
        {
            var clause = ClauseBuilder.ShouldMatchUser(baseUser);
            var rule   = new SegmentRule(new List <Clause> {
                clause
            }, 0, null);
            var segment = new SegmentBuilder("segmentkey").Unbounded(true).Generation(2)
                          .Rules(rule)
                          .Build();
            var bigSegments = new MockBigSegmentProvider();

            bigSegments.Membership[baseUser.Key] = MockMembership.New().Exclude(segment);
            var flag      = new FeatureFlagBuilder("key").BooleanMatchingSegment(segment.Key).Build();
            var evaluator = BasicEvaluator.WithStoredSegments(segment).WithBigSegments(bigSegments);

            var result = evaluator.Evaluate(flag, baseUser, EventFactory.Default);

            Assert.Equal(LdValue.Of(false), result.Result.Value);
            Assert.Equal(BigSegmentsStatus.Healthy, result.Result.Reason.BigSegmentsStatus);
        }