launchdarkly-server-sdk 6.2.4 → 6.2.5

data/spec/feature_store_spec_base.rb

@@ -1,213 +0,0 @@
-require "spec_helper"
-
-shared_examples "feature_store" do |create_store_method, clear_data_method|
-
-  # Rather than testing with feature flag or segment data, we'll use this fake data kind
-  # to make it clear that feature stores need to be able to handle arbitrary data.
-  let(:things_kind) { { namespace: "things" } }
-
-  let(:key1) { "thing1" }
-  let(:thing1) {
-    {
-      key: key1,
-      name: "Thing 1",
-      version: 11,
-      deleted: false
-    }
-  }
-  let(:unused_key) { "no" }
-
-  let(:create_store) { create_store_method } # just to avoid a scope issue
-  let(:clear_data) { clear_data_method }
-
-  def with_store(opts = {})
-    s = create_store.call(opts)
-    begin
-      yield s
-    ensure
-      s.stop
-    end
-  end
-
-  def with_inited_store(things)
-    things_hash = {}
-    things.each { |thing| things_hash[thing[:key].to_sym] = thing }
-
-    with_store do |s|
-      s.init({ things_kind => things_hash })
-      yield s
-    end
-  end
-
-  def new_version_plus(f, deltaVersion, attrs = {})
-    f.clone.merge({ version: f[:version] + deltaVersion }).merge(attrs)
-  end
-
-  before(:each) do
-    clear_data.call if !clear_data.nil?
-  end
-
-  # This block of tests is only run if the clear_data method is defined, meaning that this is a persistent store
-  # that operates on a database that can be shared with other store instances (as opposed to the in-memory store,
-  # which has its own private storage).
-  if !clear_data_method.nil?
-    it "is not initialized by default" do
-      with_store do |store|
-        expect(store.initialized?).to eq false
-      end
-    end
-
-    it "can detect if another instance has initialized the store" do
-      with_store do |store1|
-        store1.init({})
-        with_store do |store2|
-          expect(store2.initialized?).to eq true
-        end
-      end
-    end
-
-    it "can read data written by another instance" do
-      with_store do |store1|
-        store1.init({ things_kind => { key1.to_sym => thing1 } })
-        with_store do |store2|
-          expect(store2.get(things_kind, key1)).to eq thing1
-        end
-      end
-    end
-
-    it "is independent from other stores with different prefixes" do
-      with_store({ prefix: "a" }) do |store_a|
-        store_a.init({ things_kind => { key1.to_sym => thing1 } })
-        with_store({ prefix: "b" }) do |store_b|
-          store_b.init({ things_kind => {} })
-        end
-        with_store({ prefix: "b" }) do |store_b1|  # this ensures we're not just reading cached data
-          expect(store_b1.get(things_kind, key1)).to be_nil
-          expect(store_a.get(things_kind, key1)).to eq thing1
-        end
-      end
-    end
-  end
-
-  it "is initialized after calling init" do
-    with_inited_store([]) do |store|
-      expect(store.initialized?).to eq true
-    end
-  end
-
-  it "can get existing item with symbol key" do
-    with_inited_store([ thing1 ]) do |store|
-      expect(store.get(things_kind, key1.to_sym)).to eq thing1
-    end
-  end
-
-  it "can get existing item with string key" do
-    with_inited_store([ thing1 ]) do |store|
-      expect(store.get(things_kind, key1.to_s)).to eq thing1
-    end
-  end
-
-  it "gets nil for nonexisting item" do
-    with_inited_store([ thing1 ]) do |store|
-      expect(store.get(things_kind, unused_key)).to be_nil
-    end
-  end
-
-  it "returns nil for deleted item" do
-    deleted_thing = thing1.clone.merge({ deleted: true })
-    with_inited_store([ deleted_thing ]) do |store|
-      expect(store.get(things_kind, key1)).to be_nil
-    end
-  end
-
-  it "can get all items" do
-    key2 = "thing2"
-    thing2 = {
-      key: key2,
-      name: "Thing 2",
-      version: 22,
-      deleted: false
-    }
-    with_inited_store([ thing1, thing2 ]) do |store|
-      expect(store.all(things_kind)).to eq ({ key1.to_sym => thing1, key2.to_sym => thing2 })
-    end
-  end
-
-  it "filters out deleted items when getting all" do
-    key2 = "thing2"
-    thing2 = {
-      key: key2,
-      name: "Thing 2",
-      version: 22,
-      deleted: true
-    }
-    with_inited_store([ thing1, thing2 ]) do |store|
-      expect(store.all(things_kind)).to eq ({ key1.to_sym => thing1 })
-    end
-  end
-
-  it "can add new item" do
-    with_inited_store([]) do |store|
-      store.upsert(things_kind, thing1)
-      expect(store.get(things_kind, key1)).to eq thing1
-    end
-  end
-
-  it "can update item with newer version" do
-    with_inited_store([ thing1 ]) do |store|
-      thing1_mod = new_version_plus(thing1, 1, { name: thing1[:name] + ' updated' })
-      store.upsert(things_kind, thing1_mod)
-      expect(store.get(things_kind, key1)).to eq thing1_mod
-    end
-  end
-
-  it "cannot update item with same version" do
-    with_inited_store([ thing1 ]) do |store|
-      thing1_mod = thing1.clone.merge({ name: thing1[:name] + ' updated' })
-      store.upsert(things_kind, thing1_mod)
-      expect(store.get(things_kind, key1)).to eq thing1
-    end
-  end
-
-  it "cannot update feature with older version" do
-    with_inited_store([ thing1 ]) do |store|
-      thing1_mod = new_version_plus(thing1, -1, { name: thing1[:name] + ' updated' })
-      store.upsert(things_kind, thing1_mod)
-      expect(store.get(things_kind, key1)).to eq thing1
-    end
-  end
-
-  it "can delete item with newer version" do
-    with_inited_store([ thing1 ]) do |store|
-      store.delete(things_kind, key1, thing1[:version] + 1)
-      expect(store.get(things_kind, key1)).to be_nil
-    end
-  end
-
-  it "cannot delete item with same version" do
-    with_inited_store([ thing1 ]) do |store|
-      store.delete(things_kind, key1, thing1[:version])
-      expect(store.get(things_kind, key1)).to eq thing1
-    end
-  end
-
-  it "cannot delete item with older version" do
-    with_inited_store([ thing1 ]) do |store|
-      store.delete(things_kind, key1, thing1[:version] - 1)
-      expect(store.get(things_kind, key1)).to eq thing1
-    end
-  end
-
-  it "stores Unicode data correctly" do
-    flag = {
-      key: "my-fancy-flag",
-      name: "Tęst Feåtūre Flæg😺",
-      version: 1,
-      deleted: false
-    }
-    with_inited_store([]) do |store|
-      store.upsert(LaunchDarkly::FEATURES, flag)
-      expect(store.get(LaunchDarkly::FEATURES, flag[:key])).to eq flag
-    end
-  end
-end

data/spec/file_data_source_spec.rb

@@ -1,283 +0,0 @@
-require "spec_helper"
-require "tempfile"
-
-# see does not allow Ruby objects in YAML" for the purpose of the following two things
-$created_bad_class = false
-class BadClassWeShouldNotInstantiate < Hash
-  def []=(key, value)
-    $created_bad_class = true
-  end
-end
-
-describe LaunchDarkly::FileDataSource do
-  let(:full_flag_1_key) { "flag1" }
-  let(:full_flag_1_value) { "on" }
-  let(:flag_value_1_key) { "flag2" }
-  let(:flag_value_1) { "value2" }
-  let(:all_flag_keys) { [ full_flag_1_key.to_sym, flag_value_1_key.to_sym ] }
-  let(:full_segment_1_key) { "seg1" }
-  let(:all_segment_keys) { [ full_segment_1_key.to_sym ] }
-
-  let(:flag_only_json) { <<-EOF
-  {
-    "flags": {
-      "flag1": {
-        "key": "flag1",
-        "on": true,
-        "fallthrough": {
-          "variation": 2
-        },
-        "variations": [ "fall", "off", "on" ]
-      }
-    }
-  }
-EOF
-  }
-
-  let(:segment_only_json) { <<-EOF
-  {
-    "segments": {
-      "seg1": {
-        "key": "seg1",
-        "include": ["user1"]
-      }
-    }
-  }
-EOF
-  }
-
-  let(:all_properties_json) { <<-EOF
-  {
-    "flags": {
-      "flag1": {
-        "key": "flag1",
-        "on": true,
-        "fallthrough": {
-          "variation": 2
-        },
-        "variations": [ "fall", "off", "on" ]
-      }
-    },
-    "flagValues": {
-      "flag2": "value2"
-    },
-    "segments": {
-      "seg1": {
-        "key": "seg1",
-        "include": ["user1"]
-      }
-    }
-  }
-EOF
-  }
-
-  let(:all_properties_yaml) { <<-EOF
----
-flags:
-  flag1:
-    key: flag1
-    "on": true
-flagValues:
-  flag2: value2
-segments:
-  seg1:
-    key: seg1
-    include: ["user1"]
-EOF
-  }
-
-  let(:unsafe_yaml) { <<-EOF
---- !ruby/hash:BadClassWeShouldNotInstantiate
-foo: bar
-EOF
-  }
-
-  let(:bad_file_path) { "no-such-file" }
-
-  before do
-    @config = LaunchDarkly::Config.new(logger: $null_log)
-    @store = @config.feature_store
-    @tmp_dir = Dir.mktmpdir
-  end
-
-  after do
-    FileUtils.rm_rf(@tmp_dir)
-  end
-
-  def make_temp_file(content)
-    # Note that we don't create our files in the default temp file directory, but rather in an empty directory
-    # that we made. That's because (depending on the platform) the temp file directory may contain huge numbers
-    # of files, which can make the file watcher perform poorly enough to break the tests.
-    file = Tempfile.new('flags', @tmp_dir)
-    IO.write(file, content)
-    file
-  end
-
-  def with_data_source(options)
-    factory = LaunchDarkly::FileDataSource.factory(options)
-    ds = factory.call('', @config)
-    begin
-      yield ds
-    ensure
-      ds.stop
-    end
-  end
-
-  it "doesn't load flags prior to start" do
-    file = make_temp_file('{"flagValues":{"key":"value"}}')
-    with_data_source({ paths: [ file.path ] }) do |ds|
-      expect(@store.initialized?).to eq(false)
-      expect(@store.all(LaunchDarkly::FEATURES)).to eq({})
-      expect(@store.all(LaunchDarkly::SEGMENTS)).to eq({})
-    end
-  end
-
-  it "loads flags on start - from JSON" do
-    file = make_temp_file(all_properties_json)
-    with_data_source({ paths: [ file.path ] }) do |ds|
-      ds.start
-      expect(@store.initialized?).to eq(true)
-      expect(@store.all(LaunchDarkly::FEATURES).keys).to eq(all_flag_keys)
-      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq(all_segment_keys)
-    end
-  end
-
-  it "loads flags on start - from YAML" do
-    file = make_temp_file(all_properties_yaml)
-    with_data_source({ paths: [ file.path ] }) do |ds|
-      ds.start
-      expect(@store.initialized?).to eq(true)
-      expect(@store.all(LaunchDarkly::FEATURES).keys).to eq(all_flag_keys)
-      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq(all_segment_keys)
-    end
-  end
-
-  it "does not allow Ruby objects in YAML" do
-    # This tests for the vulnerability described here: https://trailofbits.github.io/rubysec/yaml/index.html
-    # The file we're loading contains a hash with a custom Ruby class, BadClassWeShouldNotInstantiate (see top
-    # of file). If we're not loading in safe mode, it will create an instance of that class and call its []=
-    # method, which we've defined to set $created_bad_class to true. In safe mode, it refuses to parse this file.
-    file = make_temp_file(unsafe_yaml)
-    with_data_source({ paths: [file.path ] }) do |ds|
-      event = ds.start
-      expect(event.set?).to eq(true)
-      expect(ds.initialized?).to eq(false)
-      expect($created_bad_class).to eq(false)
-    end
-  end
-
-  it "sets start event and initialized on successful load" do
-    file = make_temp_file(all_properties_json)
-    with_data_source({ paths: [ file.path ] }) do |ds|
-      event = ds.start
-      expect(event.set?).to eq(true)
-      expect(ds.initialized?).to eq(true)
-    end
-  end
-
-  it "sets start event and does not set initialized on unsuccessful load" do
-    with_data_source({ paths: [ bad_file_path ] }) do |ds|
-      event = ds.start
-      expect(event.set?).to eq(true)
-      expect(ds.initialized?).to eq(false)
-    end
-  end
-
-  it "can load multiple files" do
-    file1 = make_temp_file(flag_only_json)
-    file2 = make_temp_file(segment_only_json)
-    with_data_source({ paths: [ file1.path, file2.path ] }) do |ds|
-      ds.start
-      expect(@store.initialized?).to eq(true)
-      expect(@store.all(LaunchDarkly::FEATURES).keys).to eq([ full_flag_1_key.to_sym ])
-      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq([ full_segment_1_key.to_sym ])
-    end
-  end
-
-  it "does not allow duplicate keys" do
-    file1 = make_temp_file(flag_only_json)
-    file2 = make_temp_file(flag_only_json)
-    with_data_source({ paths: [ file1.path, file2.path ] }) do |ds|
-      ds.start
-      expect(@store.initialized?).to eq(false)
-      expect(@store.all(LaunchDarkly::FEATURES).keys).to eq([])
-    end
-  end
-
-  it "does not reload modified file if auto-update is off" do
-    file = make_temp_file(flag_only_json)
-
-    with_data_source({ paths: [ file.path ] }) do |ds|
-      event = ds.start
-      expect(event.set?).to eq(true)
-      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq([])
-
-      IO.write(file, all_properties_json)
-      sleep(0.5)
-      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq([])
-    end
-  end
-
-  def test_auto_reload(options)
-    file = make_temp_file(flag_only_json)
-    options[:paths] = [ file.path ]
-
-    with_data_source(options) do |ds|
-      event = ds.start
-      expect(event.set?).to eq(true)
-      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq([])
-
-      sleep(1)
-      IO.write(file, all_properties_json)
-
-      max_time = 10
-      ok = wait_for_condition(10) { @store.all(LaunchDarkly::SEGMENTS).keys == all_segment_keys }
-      expect(ok).to eq(true), "Waited #{max_time}s after modifying file and it did not reload"
-    end
-  end
-
-  it "reloads modified file if auto-update is on" do
-    test_auto_reload({ auto_update: true })
-  end
-
-  it "reloads modified file in polling mode" do
-    test_auto_reload({ auto_update: true, force_polling: true, poll_interval: 0.1 })
-  end
-
-  it "evaluates simplified flag with client as expected" do
-    file = make_temp_file(all_properties_json)
-    factory = LaunchDarkly::FileDataSource.factory({ paths: file.path })
-    config = LaunchDarkly::Config.new(send_events: false, data_source: factory)
-    client = LaunchDarkly::LDClient.new('sdkKey', config)
-
-    begin
-      value = client.variation(flag_value_1_key, { key: 'user' }, '')
-      expect(value).to eq(flag_value_1)
-    ensure
-      client.close
-    end
-  end
-
-  it "evaluates full flag with client as expected" do
-    file = make_temp_file(all_properties_json)
-    factory = LaunchDarkly::FileDataSource.factory({ paths: file.path })
-    config = LaunchDarkly::Config.new(send_events: false, data_source: factory)
-    client = LaunchDarkly::LDClient.new('sdkKey', config)
-
-    begin
-      value = client.variation(full_flag_1_key, { key: 'user' }, '')
-      expect(value).to eq(full_flag_1_value)
-    ensure
-      client.close
-    end
-  end
-
-  def wait_for_condition(max_time)
-    deadline = Time.now + max_time
-    while Time.now < deadline
-      return true if yield
-      sleep(0.1)
-    end
-    false
-  end
-end

data/spec/fixtures/feature.json

@@ -1,37 +0,0 @@
-{
-   "key":"test-feature-flag",
-   "version":11,
-   "on":true,
-   "prerequisites":[
-
-   ],
-   "salt":"718ea30a918a4eba8734b57ab1a93227",
-   "sel":"fe1244e5378c4f99976c9634e33667c6",
-   "targets":[
-      {
-         "values":[
-            "alice"
-         ],
-         "variation":0
-      },
-      {
-         "values":[
-            "bob"
-         ],
-         "variation":1
-      }
-   ],
-   "rules":[
-
-   ],
-   "fallthrough":{
-      "variation":0
-   },
-   "offVariation":1,
-   "variations":[
-      true,
-      false
-   ],
-   "trackEvents": true,
-   "deleted":false
-}

data/spec/fixtures/feature1.json

@@ -1,36 +0,0 @@
-{
-   "key":"test-feature-flag1",
-   "version":5,
-   "on":false,
-   "prerequisites":[
-
-   ],
-   "salt":"718ea30a918a4eba8734b57ab1a93227",
-   "sel":"fe1244e5378c4f99976c9634e33667c6",
-   "targets":[
-      {
-         "values":[
-            "alice"
-         ],
-         "variation":0
-      },
-      {
-         "values":[
-            "bob"
-         ],
-         "variation":1
-      }
-   ],
-   "rules":[
-
-   ],
-   "fallthrough":{
-      "variation":0
-   },
-   "offVariation":1,
-   "variations":[
-      true,
-      false
-   ],
-   "deleted":false
-}

data/spec/fixtures/user.json

@@ -1,9 +0,0 @@
-{
-    "key":"user@test.com",
-    "custom":{
-        "groups":[
-            "microsoft",
-            "google"
-        ]
-    }
-}

data/spec/flags_state_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-require "json"
-
-describe LaunchDarkly::FeatureFlagsState do
-  subject { LaunchDarkly::FeatureFlagsState }
-
-  it "can get flag value" do
-    state = subject.new(true)
-    flag = { key: 'key' }
-    state.add_flag(flag, 'value', 1)
-
-    expect(state.flag_value('key')).to eq 'value'
-  end
-
-  it "returns nil for unknown flag" do
-    state = subject.new(true)
-
-    expect(state.flag_value('key')).to be nil
-  end
-
-  it "can be converted to values map" do
-    state = subject.new(true)
-    flag1 = { key: 'key1' }
-    flag2 = { key: 'key2' }
-    state.add_flag(flag1, 'value1', 0)
-    state.add_flag(flag2, 'value2', 1)
-
-    expect(state.values_map).to eq({ 'key1' => 'value1', 'key2' => 'value2' })
-  end
-
-  it "can be converted to JSON structure" do
-    state = subject.new(true)
-    flag1 = { key: "key1", version: 100, offVariation: 0, variations: [ 'value1' ], trackEvents: false }
-    flag2 = { key: "key2", version: 200, offVariation: 1, variations: [ 'x', 'value2' ], trackEvents: true, debugEventsUntilDate: 1000 }
-    state.add_flag(flag1, 'value1', 0)
-    state.add_flag(flag2, 'value2', 1)
-    
-    result = state.as_json
-    expect(result).to eq({
-      'key1' => 'value1',
-      'key2' => 'value2',
-      '$flagsState' => {
-        'key1' => {
-          :variation => 0,
-          :version => 100
-        },
-        'key2' => {
-          :variation => 1,
-          :version => 200,
-          :trackEvents => true,
-          :debugEventsUntilDate => 1000
-        }
-      },
-      '$valid' => true
-    })
-  end
-
-  it "can be converted to JSON string" do
-    state = subject.new(true)
-    flag1 = { key: "key1", version: 100, offVariation: 0, variations: [ 'value1' ], trackEvents: false }
-    flag2 = { key: "key2", version: 200, offVariation: 1, variations: [ 'x', 'value2' ], trackEvents: true, debugEventsUntilDate: 1000 }
-    state.add_flag(flag1, 'value1', 0)
-    state.add_flag(flag2, 'value2', 1)
-    
-    object = state.as_json
-    str = state.to_json
-    expect(object.to_json).to eq(str)
-  end
-
-  it "uses our custom serializer with JSON.generate" do
-    state = subject.new(true)
-    flag1 = { key: "key1", version: 100, offVariation: 0, variations: [ 'value1' ], trackEvents: false }
-    flag2 = { key: "key2", version: 200, offVariation: 1, variations: [ 'x', 'value2' ], trackEvents: true, debugEventsUntilDate: 1000 }
-    state.add_flag(flag1, 'value1', 0)
-    state.add_flag(flag2, 'value2', 1)
-    
-    stringFromToJson = state.to_json
-    stringFromGenerate = JSON.generate(state)
-    expect(stringFromGenerate).to eq(stringFromToJson)
-  end
-end