launchdarkly-server-sdk 6.2.1 → 6.2.5

data/spec/http_util.rb

@@ -1,132 +0,0 @@
-require "webrick"
-require "webrick/httpproxy"
-require "webrick/https"
-
-class StubHTTPServer
-  attr_reader :requests, :port
-
-  @@next_port = 50000
-
-  def initialize
-    @port = StubHTTPServer.next_port
-    begin
-      base_opts = {
-        BindAddress: '127.0.0.1',
-        Port: @port,
-        AccessLog: [],
-        Logger: NullLogger.new,
-        RequestCallback: method(:record_request)
-      }
-      @server = create_server(@port, base_opts)
-    rescue Errno::EADDRINUSE
-      @port = StubHTTPServer.next_port
-      retry
-    end
-    @requests = []
-    @requests_queue = Queue.new
-  end
-
-  def self.next_port
-    p = @@next_port
-    @@next_port = (p + 1 < 60000) ? p + 1 : 50000
-    p
-  end
-
-  def create_server(port, base_opts)
-    WEBrick::HTTPServer.new(base_opts)
-  end
-
-  def start
-    Thread.new { @server.start }
-  end
-
-  def stop
-    @server.shutdown
-  end
-
-  def base_uri
-    URI("http://127.0.0.1:#{@port}")
-  end
-
-  def setup_response(uri_path, &action)
-    @server.mount_proc(uri_path, action)
-  end
-
-  def setup_status_response(uri_path, status, headers={})
-    setup_response(uri_path) do |req, res|
-      res.status = status
-      headers.each { |n, v| res[n] = v }
-    end
-  end
-
-  def setup_ok_response(uri_path, body, content_type=nil, headers={})
-    setup_response(uri_path) do |req, res|
-      res.status = 200
-      res.content_type = content_type if !content_type.nil?
-      res.body = body
-      headers.each { |n, v| res[n] = v }
-    end
-  end
-
-  def record_request(req, res)
-    @requests.push(req)
-    @requests_queue << [req, req.body]
-  end
-
-  def await_request
-    r = @requests_queue.pop
-    r[0]
-  end
-
-  def await_request_with_body
-    r = @requests_queue.pop
-    return r[0], r[1]
-  end
-end
-
-class StubProxyServer < StubHTTPServer
-  attr_reader :request_count
-  attr_accessor :connect_status
-
-  def initialize
-    super
-    @request_count = 0
-  end
-
-  def create_server(port, base_opts)
-    WEBrick::HTTPProxyServer.new(base_opts.merge({
-      ProxyContentHandler: proc do |req,res|
-        if !@connect_status.nil?
-          res.status = @connect_status
-        end
-        @request_count += 1
-      end
-    }))
-  end
-end
-
-class NullLogger
-  def method_missing(*)
-    self
-  end
-end
-
-def with_server(server = nil)
-  server = StubHTTPServer.new if server.nil?
-  begin
-    server.start
-    yield server
-  ensure
-    server.stop
-  end
-end
-
-class SocketFactoryFromHash
-  def initialize(ports = {})
-    @ports = ports
-  end
-
-  def open(uri, timeout)
-    TCPSocket.new 'localhost', @ports[uri]
-  end
-end

data/spec/impl/evaluator_bucketing_spec.rb

@@ -1,216 +0,0 @@
-require "spec_helper"
-
-describe LaunchDarkly::Impl::EvaluatorBucketing do
-  subject { LaunchDarkly::Impl::EvaluatorBucketing }
-
-  describe "bucket_user" do
-    describe "seed exists" do
-      let(:seed) { 61 }
-      it "returns the expected bucket values for seed" do
-        user = { key: "userKeyA" }
-        bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
-        expect(bucket).to be_within(0.0000001).of(0.09801207);
-
-        user = { key: "userKeyB" }
-        bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
-        expect(bucket).to be_within(0.0000001).of(0.14483777);
-
-        user = { key: "userKeyC" }
-        bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
-        expect(bucket).to be_within(0.0000001).of(0.9242641);
-      end
-
-      it "returns the same bucket regardless of hashKey and salt" do
-        user = { key: "userKeyA" }
-        bucket1 = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
-        bucket2 = subject.bucket_user(user, "hashKey1", "key", "saltyB", seed)
-        bucket3 = subject.bucket_user(user, "hashKey2", "key", "saltyC", seed)
-        expect(bucket1).to eq(bucket2)
-        expect(bucket2).to eq(bucket3)
-      end
-
-      it "returns a different bucket if the seed is not the same" do
-        user = { key: "userKeyA" }
-        bucket1 = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
-        bucket2 = subject.bucket_user(user, "hashKey1", "key", "saltyB", seed+1)
-        expect(bucket1).to_not eq(bucket2)
-      end
-
-      it "returns a different bucket if the user is not the same" do
-        user1 = { key: "userKeyA" }
-        user2 = { key: "userKeyB" }
-        bucket1 = subject.bucket_user(user1, "hashKey", "key", "saltyA", seed)
-        bucket2 = subject.bucket_user(user2, "hashKey1", "key", "saltyB", seed)
-        expect(bucket1).to_not eq(bucket2)
-      end
-    end
-
-    it "gets expected bucket values for specific keys" do
-      user = { key: "userKeyA" }
-      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", nil)
-      expect(bucket).to be_within(0.0000001).of(0.42157587);
-
-      user = { key: "userKeyB" }
-      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", nil)
-      expect(bucket).to be_within(0.0000001).of(0.6708485);
-
-      user = { key: "userKeyC" }
-      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", nil)
-      expect(bucket).to be_within(0.0000001).of(0.10343106);
-    end
-
-    it "can bucket by int value (equivalent to string)" do
-      user = {
-        key: "userkey",
-        custom: {
-          stringAttr: "33333",
-          intAttr: 33333
-        }
-      }
-      stringResult = subject.bucket_user(user, "hashKey", "stringAttr", "saltyA", nil)
-      intResult = subject.bucket_user(user, "hashKey", "intAttr", "saltyA", nil)
-
-      expect(intResult).to be_within(0.0000001).of(0.54771423)
-      expect(intResult).to eq(stringResult)
-    end
-
-    it "cannot bucket by float value" do
-      user = {
-        key: "userkey",
-        custom: {
-          floatAttr: 33.5
-        }
-      }
-      result = subject.bucket_user(user, "hashKey", "floatAttr", "saltyA", nil)
-      expect(result).to eq(0.0)
-    end
-
-
-    it "cannot bucket by bool value" do
-      user = {
-        key: "userkey",
-        custom: {
-          boolAttr: true
-        }
-      }
-      result = subject.bucket_user(user, "hashKey", "boolAttr", "saltyA", nil)
-      expect(result).to eq(0.0)
-    end
-  end
-
-  describe "variation_index_for_user" do
-    context "rollout is not an experiment" do
-      it "matches bucket" do
-        user = { key: "userkey" }
-        flag_key = "flagkey"
-        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
-        bucket_value = (subject.bucket_user(user, flag_key, "key", salt, nil) * 100000).truncate()
-        expect(bucket_value).to be > 0
-        expect(bucket_value).to be < 100000
-
-        bad_variation_a = 0
-        matched_variation = 1
-        bad_variation_b = 2
-        rule = {
-          rollout: {
-            variations: [
-              { variation: bad_variation_a, weight: bucket_value }, # end of bucket range is not inclusive, so it will *not* match the target value
-              { variation: matched_variation, weight: 1 }, # size of this bucket is 1, so it only matches that specific value
-              { variation: bad_variation_b, weight: 100000 - (bucket_value + 1) }
-            ]
-          }
-        }
-        flag = { key: flag_key, salt: salt }
-
-        result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user)
-        expect(result_variation).to be matched_variation
-        expect(inExperiment).to be(false)
-      end
-
-      it "uses last bucket if bucket value is equal to total weight" do
-        user = { key: "userkey" }
-        flag_key = "flagkey"
-        salt = "salt"
-
-        bucket_value = (subject.bucket_user(user, flag_key, "key", salt, nil) * 100000).truncate()
-
-        # We'll construct a list of variations that stops right at the target bucket value
-        rule = {
-          rollout: {
-            variations: [
-              { variation: 0, weight: bucket_value }
-            ]
-          }
-        }
-        flag = { key: flag_key, salt: salt }
-
-        result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user)
-        expect(result_variation).to be 0
-        expect(inExperiment).to be(false)
-      end
-    end
-  end
-
-  context "rollout is an experiment" do
-    it "returns whether user is in the experiment or not" do
-      user1 = { key: "userKeyA" }
-      user2 = { key: "userKeyB" }
-      user3 = { key: "userKeyC" }
-      flag_key = "flagkey"
-      salt = "salt"
-      seed = 61
-
-    
-      rule = {
-        rollout: {
-          seed: seed,
-          kind: 'experiment',
-          variations: [
-            { variation: 0, weight: 10000, untracked: false },
-            { variation: 2, weight: 20000, untracked: false },
-            { variation: 0, weight: 70000 , untracked: true }
-          ]
-        }
-      }
-      flag = { key: flag_key, salt: salt }
-
-      result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user1)
-      expect(result_variation).to be(0)
-      expect(inExperiment).to be(true)
-      result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user2)
-      expect(result_variation).to be(2)
-      expect(inExperiment).to be(true)
-      result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user3)
-      expect(result_variation).to be(0)
-      expect(inExperiment).to be(false)
-    end
-
-    it "uses last bucket if bucket value is equal to total weight" do
-      user = { key: "userkey" }
-      flag_key = "flagkey"
-      salt = "salt"
-      seed = 61
-
-      bucket_value = (subject.bucket_user(user, flag_key, "key", salt, seed) * 100000).truncate()
-
-      # We'll construct a list of variations that stops right at the target bucket value
-      rule = {
-        rollout: {
-          seed: seed,
-          kind: 'experiment',
-          variations: [
-            { variation: 0, weight: bucket_value, untracked: false }
-          ]
-        }
-      }
-      flag = { key: flag_key, salt: salt }
-
-      result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user)
-      expect(result_variation).to be 0
-      expect(inExperiment).to be(true)
-    end
-  end
-end

data/spec/impl/evaluator_clause_spec.rb

@@ -1,55 +0,0 @@
-require "spec_helper"
-require "impl/evaluator_spec_base"
-
-module LaunchDarkly
-  module Impl
-    describe "Evaluator (clauses)", :evaluator_spec_base => true do
-      subject { Evaluator }
-
-      it "can match built-in attribute" do
-        user = { key: 'x', name: 'Bob' }
-        clause = { attribute: 'name', op: 'in', values: ['Bob'] }
-        flag = boolean_flag_with_clauses([clause])
-        expect(basic_evaluator.evaluate(flag, user, factory).detail.value).to be true
-      end
-
-      it "can match custom attribute" do
-        user = { key: 'x', name: 'Bob', custom: { legs: 4 } }
-        clause = { attribute: 'legs', op: 'in', values: [4] }
-        flag = boolean_flag_with_clauses([clause])
-        expect(basic_evaluator.evaluate(flag, user, factory).detail.value).to be true
-      end
-
-      it "returns false for missing attribute" do
-        user = { key: 'x', name: 'Bob' }
-        clause = { attribute: 'legs', op: 'in', values: [4] }
-        flag = boolean_flag_with_clauses([clause])
-        expect(basic_evaluator.evaluate(flag, user, factory).detail.value).to be false
-      end
-
-      it "returns false for unknown operator" do
-        user = { key: 'x', name: 'Bob' }
-        clause = { attribute: 'name', op: 'unknown', values: [4] }
-        flag = boolean_flag_with_clauses([clause])
-        expect(basic_evaluator.evaluate(flag, user, factory).detail.value).to be false
-      end
-
-      it "does not stop evaluating rules after clause with unknown operator" do
-        user = { key: 'x', name: 'Bob' }
-        clause0 = { attribute: 'name', op: 'unknown', values: [4] }
-        rule0 = { clauses: [ clause0 ], variation: 1 }
-        clause1 = { attribute: 'name', op: 'in', values: ['Bob'] }
-        rule1 = { clauses: [ clause1 ], variation: 1 }
-        flag = boolean_flag_with_rules([rule0, rule1])
-        expect(basic_evaluator.evaluate(flag, user, factory).detail.value).to be true
-      end
-
-      it "can be negated" do
-        user = { key: 'x', name: 'Bob' }
-        clause = { attribute: 'name', op: 'in', values: ['Bob'], negate: true }
-        flag = boolean_flag_with_clauses([clause])
-        expect(basic_evaluator.evaluate(flag, user, factory).detail.value).to be false
-      end
-    end
-  end
-end

data/spec/impl/evaluator_operators_spec.rb

@@ -1,141 +0,0 @@
-require "spec_helper"
-
-describe LaunchDarkly::Impl::EvaluatorOperators do
-  subject { LaunchDarkly::Impl::EvaluatorOperators }
-
-  describe "operators" do
-    dateStr1 = "2017-12-06T00:00:00.000-07:00"
-    dateStr2 = "2017-12-06T00:01:01.000-07:00"
-    dateMs1 = 10000000
-    dateMs2 = 10000001
-    invalidDate = "hey what's this?"
-
-    operatorTests = [
-      # numeric comparisons
-      [ :in,                 99,      99,      true ],
-      [ :in,                 99.0001, 99.0001, true ],
-      [ :in,                 99,      99.0001, false ],
-      [ :in,                 99.0001, 99,      false ],
-      [ :lessThan,           99,      99.0001, true ],
-      [ :lessThan,           99.0001, 99,      false ],
-      [ :lessThan,           99,      99,      false ],
-      [ :lessThanOrEqual,    99,      99.0001, true ],
-      [ :lessThanOrEqual,    99.0001, 99,      false ],
-      [ :lessThanOrEqual,    99,      99,      true ],
-      [ :greaterThan,        99.0001, 99,      true ],
-      [ :greaterThan,        99,      99.0001, false ],
-      [ :greaterThan,        99,      99,      false ],
-      [ :greaterThanOrEqual, 99.0001, 99,      true ],
-      [ :greaterThanOrEqual, 99,      99.0001, false ],
-      [ :greaterThanOrEqual, 99,      99,      true ],
-
-      # string comparisons
-      [ :in,         "x",   "x",   true ],
-      [ :in,         "x",   "xyz", false ],
-      [ :startsWith, "xyz", "x",   true ],
-      [ :startsWith, "x",   "xyz", false ],
-      [ :endsWith,   "xyz", "z",   true ],
-      [ :endsWith,   "z",   "xyz", false ],
-      [ :contains,   "xyz", "y",   true ],
-      [ :contains,   "y",   "xyz", false ],
-
-      # mixed strings and numbers
-      [ :in,                 "99", 99, false ],
-      [ :in,                  99, "99", false ],
-      [ :contains,           "99", 99, false ],
-      [ :startsWith,         "99", 99, false ],
-      [ :endsWith,           "99", 99, false ],
-      [ :lessThanOrEqual,    "99", 99, false ],
-      [ :lessThanOrEqual,    99, "99", false ],
-      [ :greaterThanOrEqual, "99", 99, false ],
-      [ :greaterThanOrEqual, 99, "99", false ],
-      
-      # regex
-      [ :matches, "hello world", "hello.*rld",     true ],
-      [ :matches, "hello world", "hello.*orl",     true ],
-      [ :matches, "hello world", "l+",             true ],
-      [ :matches, "hello world", "(world|planet)", true ],
-      [ :matches, "hello world", "aloha",          false ],
-      [ :matches, "hello world", "***not a regex", false ],
-
-      # dates
-      [ :before, dateStr1, dateStr2,    true ],
-      [ :before, dateMs1,  dateMs2,     true ],
-      [ :before, dateStr2, dateStr1,    false ],
-      [ :before, dateMs2,  dateMs1,     false ],
-      [ :before, dateStr1, dateStr1,    false ],
-      [ :before, dateMs1,  dateMs1,     false ],
-      [ :before, dateStr1, invalidDate, false ],
-      [ :after,  dateStr1, dateStr2,    false ],
-      [ :after,  dateMs1,  dateMs2,     false ],
-      [ :after,  dateStr2, dateStr1,    true ],
-      [ :after,  dateMs2,  dateMs1,     true ],
-      [ :after,  dateStr1, dateStr1,    false ],
-      [ :after,  dateMs1,  dateMs1,     false ],
-      [ :after,  dateStr1, invalidDate, false ],
-
-      # semver
-      [ :semVerEqual,       "2.0.1", "2.0.1", true ],
-      [ :semVerEqual,       "2.0",   "2.0.0", true ],
-      [ :semVerEqual,       "2-rc1", "2.0.0-rc1", true ],
-      [ :semVerEqual,       "2+build2", "2.0.0+build2", true ],
-      [ :semVerLessThan,    "2.0.0", "2.0.1", true ],
-      [ :semVerLessThan,    "2.0",   "2.0.1", true ],
-      [ :semVerLessThan,    "2.0.1", "2.0.0", false ],
-      [ :semVerLessThan,    "2.0.1", "2.0",   false ],
-      [ :semVerLessThan,    "2.0.0-rc", "2.0.0-rc.beta", true ],
-      [ :semVerGreaterThan, "2.0.1", "2.0.0", true ],
-      [ :semVerGreaterThan, "2.0.1", "2.0",   true ],
-      [ :semVerGreaterThan, "2.0.0", "2.0.1", false ],
-      [ :semVerGreaterThan, "2.0",   "2.0.1", false ],
-      [ :semVerGreaterThan, "2.0.0-rc.1", "2.0.0-rc.0", true ],
-      [ :semVerLessThan,    "2.0.1", "xbad%ver", false ],
-      [ :semVerGreaterThan, "2.0.1", "xbad%ver", false ]
-    ]
-
-    operatorTests.each do |params|
-      op = params[0]
-      value1 = params[1]
-      value2 = params[2]
-      shouldBe = params[3]
-      it "should return #{shouldBe} for #{value1} #{op} #{value2}" do
-        expect(subject::apply(op, value1, value2)).to be shouldBe
-      end
-    end
-  end
-
-  describe "user_value" do
-    [:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name, :anonymous, :some_custom_attr].each do |attr|
-      it "returns nil if property #{attr} is not defined" do
-        expect(subject::user_value({}, attr)).to be nil
-      end
-    end
-
-    [:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name].each do |attr|
-      it "gets string value of string property #{attr}" do
-        expect(subject::user_value({ attr => 'x' }, attr)).to eq 'x'
-      end
-
-      it "coerces non-string value of property #{attr} to string" do
-        expect(subject::user_value({ attr => 3 }, attr)).to eq '3'
-      end
-    end
-
-    it "gets boolean value of property anonymous" do
-      expect(subject::user_value({ anonymous: true }, :anonymous)).to be true
-      expect(subject::user_value({ anonymous: false }, :anonymous)).to be false
-    end
-
-    it "does not coerces non-boolean value of property anonymous" do
-      expect(subject::user_value({ anonymous: 3 }, :anonymous)).to eq 3
-    end
-
-    it "gets string value of custom property" do
-      expect(subject::user_value({ custom: { some_custom_attr: 'x' } }, :some_custom_attr)).to eq 'x'
-    end
-
-    it "gets non-string value of custom property" do
-      expect(subject::user_value({ custom: { some_custom_attr: 3 } }, :some_custom_attr)).to eq 3
-    end
-  end
-end

data/spec/impl/evaluator_rule_spec.rb

@@ -1,128 +0,0 @@
-require "spec_helper"
-require "impl/evaluator_spec_base"
-
-module LaunchDarkly
-  module Impl
-    describe "Evaluator (rules)", :evaluator_spec_base => true do
-      subject { Evaluator }
-
-      it "matches user from rules" do
-        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: 1 }
-        flag = boolean_flag_with_rules([rule])
-        user = { key: 'userkey' }
-        detail = EvaluationDetail.new(true, 1, EvaluationReason::rule_match(0, 'ruleid'))
-        result = basic_evaluator.evaluate(flag, user, factory)
-        expect(result.detail).to eq(detail)
-        expect(result.events).to eq(nil)
-      end
-
-      it "reuses rule match reason instances if possible" do
-        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: 1 }
-        flag = boolean_flag_with_rules([rule])
-        Model.postprocess_item_after_deserializing!(FEATURES, flag)  # now there's a cached rule match reason
-        user = { key: 'userkey' }
-        detail = EvaluationDetail.new(true, 1, EvaluationReason::rule_match(0, 'ruleid'))
-        result1 = basic_evaluator.evaluate(flag, user, factory)
-        result2 = basic_evaluator.evaluate(flag, user, factory)
-        expect(result1.detail.reason.rule_id).to eq 'ruleid'
-        expect(result1.detail.reason).to be result2.detail.reason
-      end
-
-      it "returns an error if rule variation is too high" do
-        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: 999 }
-        flag = boolean_flag_with_rules([rule])
-        user = { key: 'userkey' }
-        detail = EvaluationDetail.new(nil, nil,
-          EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
-        result = basic_evaluator.evaluate(flag, user, factory)
-        expect(result.detail).to eq(detail)
-        expect(result.events).to eq(nil)
-      end
-
-      it "returns an error if rule variation is negative" do
-        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: -1 }
-        flag = boolean_flag_with_rules([rule])
-        user = { key: 'userkey' }
-        detail = EvaluationDetail.new(nil, nil,
-          EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
-        result = basic_evaluator.evaluate(flag, user, factory)
-        expect(result.detail).to eq(detail)
-        expect(result.events).to eq(nil)
-      end
-
-      it "returns an error if rule has neither variation nor rollout" do
-        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }] }
-        flag = boolean_flag_with_rules([rule])
-        user = { key: 'userkey' }
-        detail = EvaluationDetail.new(nil, nil,
-          EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
-        result = basic_evaluator.evaluate(flag, user, factory)
-        expect(result.detail).to eq(detail)
-        expect(result.events).to eq(nil)
-      end
-
-      it "returns an error if rule has a rollout with no variations" do
-        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
-          rollout: { variations: [] } }
-        flag = boolean_flag_with_rules([rule])
-        user = { key: 'userkey' }
-        detail = EvaluationDetail.new(nil, nil,
-          EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
-        result = basic_evaluator.evaluate(flag, user, factory)
-        expect(result.detail).to eq(detail)
-        expect(result.events).to eq(nil)
-      end
-
-      it "coerces user key to a string for evaluation" do
-        clause = { attribute: 'key', op: 'in', values: ['999'] }
-        flag = boolean_flag_with_clauses([clause])
-        user = { key: 999 }
-        result = basic_evaluator.evaluate(flag, user, factory)
-        expect(result.detail.value).to eq(true)
-      end
-
-      it "coerces secondary key to a string for evaluation" do
-        # We can't really verify that the rollout calculation works correctly, but we can at least
-        # make sure it doesn't error out if there's a non-string secondary value (ch35189)
-        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
-          rollout: { salt: '', variations: [ { weight: 100000, variation: 1 } ] } }
-        flag = boolean_flag_with_rules([rule])
-        user = { key: "userkey", secondary: 999 }
-        result = basic_evaluator.evaluate(flag, user, factory)
-        expect(result.detail.reason).to eq(EvaluationReason::rule_match(0, 'ruleid'))
-      end
-
-      describe "experiment rollout behavior" do
-        it "sets the in_experiment value if rollout kind is experiment " do
-          rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
-            rollout: { kind: 'experiment', variations: [ { weight: 100000, variation: 1, untracked: false } ] } }
-          flag = boolean_flag_with_rules([rule])
-          user = { key: "userkey", secondary: 999 }
-          result = basic_evaluator.evaluate(flag, user, factory)
-          expect(result.detail.reason.to_json).to include('"inExperiment":true')
-          expect(result.detail.reason.in_experiment).to eq(true)
-        end
-
-        it "does not set the in_experiment value if rollout kind is not experiment " do
-          rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
-            rollout: { kind: 'rollout', variations: [ { weight: 100000, variation: 1, untracked: false } ] } }
-          flag = boolean_flag_with_rules([rule])
-          user = { key: "userkey", secondary: 999 }
-          result = basic_evaluator.evaluate(flag, user, factory)
-          expect(result.detail.reason.to_json).to_not include('"inExperiment":true')
-          expect(result.detail.reason.in_experiment).to eq(nil)
-        end
-
-        it "does not set the in_experiment value if rollout kind is experiment and untracked is true" do
-          rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
-            rollout: { kind: 'experiment', variations: [ { weight: 100000, variation: 1, untracked: true } ] } }
-          flag = boolean_flag_with_rules([rule])
-          user = { key: "userkey", secondary: 999 }
-          result = basic_evaluator.evaluate(flag, user, factory)
-          expect(result.detail.reason.to_json).to_not include('"inExperiment":true')
-          expect(result.detail.reason.in_experiment).to eq(nil)
-        end
-      end
-    end
-  end
-end