ldclient-rb 2.5.0 → 3.0.0

data/spec/segment_store_spec_base.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+RSpec.shared_examples "segment_store" do |create_store_method|
+
+  let(:segment0) {
+    {
+      key: "test-segment",
+      version: 11,
+      salt: "718ea30a918a4eba8734b57ab1a93227",
+      rules: []
+    }
+  }
+  let(:key0) { segment0[:key].to_sym }
+
+  let!(:store) do
+    s = create_store_method.call()
+    s.init({ key0 => segment0 })
+    s
+  end
+
+  def new_version_plus(f, deltaVersion, attrs = {})
+    f1 = f.clone
+    f1[:version] = f[:version] + deltaVersion
+    f1.update(attrs)
+    f1
+  end
+
+
+  it "is initialized" do
+    expect(store.initialized?).to eq true
+  end
+
+  it "can get existing feature with symbol key" do
+    expect(store.get(key0)).to eq segment0
+  end
+
+  it "can get existing feature with string key" do
+    expect(store.get(key0.to_s)).to eq segment0
+  end
+
+  it "gets nil for nonexisting feature" do
+    expect(store.get('nope')).to be_nil
+  end
+
+  it "can get all features" do
+    feature1 = segment0.clone
+    feature1[:key] = "test-feature-flag1"
+    feature1[:version] = 5
+    feature1[:on] = false
+    store.upsert(:"test-feature-flag1", feature1)
+    expect(store.all).to eq ({ key0 => segment0, :"test-feature-flag1" => feature1 })
+  end
+
+  it "can add new feature" do
+    feature1 = segment0.clone
+    feature1[:key] = "test-feature-flag1"
+    feature1[:version] = 5
+    feature1[:on] = false
+    store.upsert(:"test-feature-flag1", feature1)
+    expect(store.get(:"test-feature-flag1")).to eq feature1
+  end
+
+  it "can update feature with newer version" do
+    f1 = new_version_plus(segment0, 1, { on: !segment0[:on] })
+    store.upsert(key0, f1)
+    expect(store.get(key0)).to eq f1
+  end
+
+  it "cannot update feature with same version" do
+    f1 = new_version_plus(segment0, 0, { on: !segment0[:on] })
+    store.upsert(key0, f1)
+    expect(store.get(key0)).to eq segment0
+  end
+
+  it "cannot update feature with older version" do
+    f1 = new_version_plus(segment0, -1, { on: !segment0[:on] })
+    store.upsert(key0, f1)
+    expect(store.get(key0)).to eq segment0
+  end
+
+  it "can delete feature with newer version" do
+    store.delete(key0, segment0[:version] + 1)
+    expect(store.get(key0)).to be_nil
+  end
+
+  it "cannot delete feature with same version" do
+    store.delete(key0, segment0[:version])
+    expect(store.get(key0)).to eq segment0
+  end
+
+  it "cannot delete feature with older version" do
+    store.delete(key0, segment0[:version] - 1)
+    expect(store.get(key0)).to eq segment0
+  end
+end

data/spec/stream_spec.rb

@@ -3,20 +3,23 @@ require 'ostruct'
 
 describe LaunchDarkly::InMemoryFeatureStore do
   subject { LaunchDarkly::InMemoryFeatureStore }
+
+  include LaunchDarkly
+  
   let(:store) { subject.new }
   let(:key) { :asdf }
-  let(:feature) { { value: "qwer", version: 0 } }
+  let(:feature) { { key: "asdf", value: "qwer", version: 0 } }
 
   describe '#all' do
     it "will get all keys" do
-      store.upsert(key, feature)
-      data = store.all
+      store.upsert(LaunchDarkly::FEATURES, feature)
+      data = store.all(LaunchDarkly::FEATURES)
       expect(data).to eq(key => feature)
     end
     it "will not get deleted keys" do
-      store.upsert(key, feature)
-      store.delete(key, 1)
-      data = store.all
+      store.upsert(LaunchDarkly::FEATURES, feature)
+      store.delete(LaunchDarkly::FEATURES, key, 1)
+      data = store.all(LaunchDarkly::FEATURES)
       expect(data).to eq({})
     end
   end
@@ -37,21 +40,33 @@ describe LaunchDarkly::StreamProcessor do
   let(:processor) { subject.new("sdk_key", config, requestor) }
 
   describe '#process_message' do
-    let(:put_message) { OpenStruct.new({data: '{"key": {"value": "asdf"}}'}) }
-    let(:patch_message) { OpenStruct.new({data: '{"path": "akey", "data": {"value": "asdf", "version": 1}}'}) }
-    let(:delete_message) { OpenStruct.new({data: '{"path": "akey", "version": 2}'}) }
+    let(:put_message) { OpenStruct.new({data: '{"data":{"flags":{"asdf": {"key": "asdf"}},"segments":{"segkey": {"key": "segkey"}}}}'}) }
+    let(:patch_flag_message) { OpenStruct.new({data: '{"path": "/flags/key", "data": {"key": "asdf", "version": 1}}'}) }
+    let(:patch_seg_message) { OpenStruct.new({data: '{"path": "/segments/key", "data": {"key": "asdf", "version": 1}}'}) }
+    let(:delete_flag_message) { OpenStruct.new({data: '{"path": "/flags/key", "version": 2}'}) }
+    let(:delete_seg_message) { OpenStruct.new({data: '{"path": "/segments/key", "version": 2}'}) }
     it "will accept PUT methods" do
       processor.send(:process_message, put_message, LaunchDarkly::PUT)
-      expect(processor.instance_variable_get(:@store).get("key")).to eq(value: "asdf")
+      expect(config.feature_store.get(LaunchDarkly::FEATURES, "asdf")).to eq(key: "asdf")
+      expect(config.feature_store.get(LaunchDarkly::SEGMENTS, "segkey")).to eq(key: "segkey")
+    end
+    it "will accept PATCH methods for flags" do
+      processor.send(:process_message, patch_flag_message, LaunchDarkly::PATCH)
+      expect(config.feature_store.get(LaunchDarkly::FEATURES, "asdf")).to eq(key: "asdf", version: 1)
+    end
+    it "will accept PATCH methods for segments" do
+      processor.send(:process_message, patch_seg_message, LaunchDarkly::PATCH)
+      expect(config.feature_store.get(LaunchDarkly::SEGMENTS, "asdf")).to eq(key: "asdf", version: 1)
     end
-    it "will accept PATCH methods" do
-      processor.send(:process_message, patch_message, LaunchDarkly::PATCH)
-      expect(processor.instance_variable_get(:@store).get("key")).to eq(value: "asdf", version: 1)
+    it "will accept DELETE methods for flags" do
+      processor.send(:process_message, patch_flag_message, LaunchDarkly::PATCH)
+      processor.send(:process_message, delete_flag_message, LaunchDarkly::DELETE)
+      expect(config.feature_store.get(LaunchDarkly::FEATURES, "key")).to eq(nil)
     end
-    it "will accept DELETE methods" do
-      processor.send(:process_message, patch_message, LaunchDarkly::PATCH)
-      processor.send(:process_message, delete_message, LaunchDarkly::DELETE)
-      expect(processor.instance_variable_get(:@store).get("key")).to eq(nil)
+    it "will accept DELETE methods for segments" do
+      processor.send(:process_message, patch_seg_message, LaunchDarkly::PATCH)
+      processor.send(:process_message, delete_seg_message, LaunchDarkly::DELETE)
+      expect(config.feature_store.get(LaunchDarkly::SEGMENTS, "key")).to eq(nil)
     end
     it "will log a warning if the method is not recognized" do
       expect(processor.instance_variable_get(:@config).logger).to receive :warn

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ldclient-rb
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 3.0.0
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-13 00:00:00.000000000 Z
+date: 2018-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -323,12 +323,12 @@ files:
 - lib/ldclient-rb/evaluation.rb
 - lib/ldclient-rb/event_serializer.rb
 - lib/ldclient-rb/events.rb
-- lib/ldclient-rb/feature_store.rb
+- lib/ldclient-rb/in_memory_store.rb
 - lib/ldclient-rb/ldclient.rb
 - lib/ldclient-rb/memoized_value.rb
 - lib/ldclient-rb/newrelic.rb
 - lib/ldclient-rb/polling.rb
-- lib/ldclient-rb/redis_feature_store.rb
+- lib/ldclient-rb/redis_store.rb
 - lib/ldclient-rb/requestor.rb
 - lib/ldclient-rb/stream.rb
 - lib/ldclient-rb/version.rb
@@ -347,6 +347,7 @@ files:
 - spec/newrelic_spec.rb
 - spec/redis_feature_store_spec.rb
 - spec/requestor_spec.rb
+- spec/segment_store_spec_base.rb
 - spec/spec_helper.rb
 - spec/store_spec.rb
 - spec/stream_spec.rb
@@ -390,6 +391,7 @@ test_files:
 - spec/newrelic_spec.rb
 - spec/redis_feature_store_spec.rb
 - spec/requestor_spec.rb
+- spec/segment_store_spec_base.rb
 - spec/spec_helper.rb
 - spec/store_spec.rb
 - spec/stream_spec.rb

data/lib/ldclient-rb/feature_store.rb

@@ -1,63 +0,0 @@
-require "concurrent/atomics"
-
-module LaunchDarkly
-  class InMemoryFeatureStore
-    def initialize
-      @features = Hash.new
-      @lock = Concurrent::ReadWriteLock.new
-      @initialized = Concurrent::AtomicBoolean.new(false)
-    end
-
-    def get(key)
-      @lock.with_read_lock do
-        f = @features[key.to_sym]
-        (f.nil? || f[:deleted]) ? nil : f
-      end
-    end
-
-    def all
-      @lock.with_read_lock do
-        @features.select { |_k, f| not f[:deleted] }
-      end
-    end
-
-    def delete(key, version)
-      @lock.with_write_lock do
-        old = @features[key.to_sym]
-
-        if !old.nil? && old[:version] < version
-          old[:deleted] = true
-          old[:version] = version
-          @features[key.to_sym] = old
-        elsif old.nil?
-          @features[key.to_sym] = { deleted: true, version: version }
-        end
-      end
-    end
-
-    def init(fs)
-      @lock.with_write_lock do
-        @features.replace(fs)
-        @initialized.make_true
-      end
-    end
-
-    def upsert(key, feature)
-      @lock.with_write_lock do
-        old = @features[key.to_sym]
-
-        if old.nil? || old[:version] < feature[:version]
-          @features[key.to_sym] = feature
-        end
-      end
-    end
-
-    def initialized?
-      @initialized.value
-    end
-
-    def stop
-      # nothing to do
-    end
-  end
-end