launchdarkly-server-sdk 5.5.7

data/spec/expiring_cache_spec.rb

@@ -0,0 +1,76 @@
+require 'timecop'
+
+describe LaunchDarkly::ExpiringCache do
+  subject { LaunchDarkly::ExpiringCache }
+
+  before(:each) do
+    Timecop.freeze(Time.now)
+  end
+
+  after(:each) do
+    Timecop.return
+  end
+  
+  it "evicts entries based on TTL" do
+    c = subject.new(3, 300)
+    c[:a] = 1
+    c[:b] = 2
+
+    Timecop.freeze(Time.now + 330)
+
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3
+  end
+
+  it "evicts entries based on max size" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to eq 2
+    expect(c[:c]).to eq 3
+  end
+
+  it "does not reset LRU on get" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:a]
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to eq 2
+    expect(c[:c]).to eq 3    
+  end
+
+  it "resets LRU on put" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:a] = 1
+    c[:c] = 3
+
+    expect(c[:a]).to eq 1
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3    
+  end
+
+  it "resets TTL on put" do
+    c = subject.new(3, 300)
+    c[:a] = 1
+    c[:b] = 2
+
+    Timecop.freeze(Time.now + 330)
+    c[:a] = 1
+    c[:c] = 3
+
+    expect(c[:a]).to eq 1
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3
+  end
+end

data/spec/feature_store_spec_base.rb

@@ -0,0 +1,213 @@
+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

@@ -0,0 +1,255 @@
+require "spec_helper"
+require "tempfile"
+
+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(:bad_file_path) { "no-such-file" }
+
+  before do
+    @config = LaunchDarkly::Config.new
+    @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 "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