ldclient-rb 5.4.3 → 5.5.0

data/spec/ldclient_spec.rb

@@ -7,8 +7,8 @@ describe LaunchDarkly::LDClient do
   let(:offline_client) do
     subject.new("secret", offline_config)
   end
-  let(:update_processor) { LaunchDarkly::NullUpdateProcessor.new }
-  let(:config) { LaunchDarkly::Config.new({send_events: false, update_processor: update_processor}) }
+  let(:null_data) { LaunchDarkly::NullUpdateProcessor.new }
+  let(:config) { LaunchDarkly::Config.new({send_events: false, data_source: null_data}) }
   let(:client) do
     subject.new("secret", config)
   end
@@ -357,7 +357,7 @@ describe LaunchDarkly::LDClient do
   end
 
   describe 'with send_events: false' do
-    let(:config) { LaunchDarkly::Config.new({offline: true, send_events: false, update_processor: update_processor}) }
+    let(:config) { LaunchDarkly::Config.new({offline: true, send_events: false, data_source: null_data}) }
     let(:client) { subject.new("secret", config) }
 
     it "uses a NullEventProcessor" do
@@ -367,7 +367,7 @@ describe LaunchDarkly::LDClient do
   end
 
   describe 'with send_events: true' do
-    let(:config_with_events) { LaunchDarkly::Config.new({offline: false, send_events: true, update_processor: update_processor}) }
+    let(:config_with_events) { LaunchDarkly::Config.new({offline: false, send_events: true, data_source: null_data}) }
     let(:client_with_events) { subject.new("secret", config_with_events) }
 
     it "does not use a NullEventProcessor" do
@@ -375,4 +375,83 @@ describe LaunchDarkly::LDClient do
       expect(ep).not_to be_a(LaunchDarkly::NullEventProcessor)
     end
   end
+
+  describe "feature store data ordering" do
+    let(:dependency_ordering_test_data) {
+      {
+        LaunchDarkly::FEATURES => {
+          a: { key: "a", prerequisites: [ { key: "b" }, { key: "c" } ] },
+          b: { key: "b", prerequisites: [ { key: "c" }, { key: "e" } ] },
+          c: { key: "c" },
+          d: { key: "d" },
+          e: { key: "e" },
+          f: { key: "f" }
+        },
+        LaunchDarkly::SEGMENTS => {
+          o: { key: "o" }
+        }
+      }
+    }
+
+    class FakeFeatureStore
+      attr_reader :received_data
+
+      def init(all_data)
+        @received_data = all_data
+      end
+    end
+
+    class FakeUpdateProcessor
+      def initialize(store, data)
+        @store = store
+        @data = data
+      end
+
+      def start
+        @store.init(@data)
+        ev = Concurrent::Event.new
+        ev.set
+        ev
+      end
+
+      def stop
+      end
+
+      def initialized?
+        true
+      end
+    end
+
+    it "passes data set to feature store in correct order on init" do
+      store = FakeFeatureStore.new
+      data_source_factory = lambda { |sdk_key, config| FakeUpdateProcessor.new(config.feature_store,
+        dependency_ordering_test_data) }
+      config = LaunchDarkly::Config.new(send_events: false, feature_store: store, data_source: data_source_factory)
+      client = subject.new("secret", config)
+
+      data = store.received_data
+      expect(data).not_to be_nil
+      expect(data.count).to eq(2)
+      
+      # Segments should always come first
+      expect(data.keys[0]).to be(LaunchDarkly::SEGMENTS)
+      expect(data.values[0].count).to eq(dependency_ordering_test_data[LaunchDarkly::SEGMENTS].count)
+
+      # Features should be ordered so that a flag always appears after its prerequisites, if any
+      expect(data.keys[1]).to be(LaunchDarkly::FEATURES)
+      flags_map = data.values[1]
+      flags_list = flags_map.values
+      expect(flags_list.count).to eq(dependency_ordering_test_data[LaunchDarkly::FEATURES].count)
+      flags_list.each_with_index do |item, item_index|
+        (item[:prerequisites] || []).each do |prereq|
+          prereq = flags_map[prereq[:key].to_sym]
+          prereq_index = flags_list.index(prereq)
+          if prereq_index > item_index
+            all_keys = (flags_list.map { |f| f[:key] }).join(", ")
+            raise "#{item[:key]} depends on #{prereq[:key]}, but #{item[:key]} was listed first; keys in order are [#{all_keys}]"
+          end
+        end
+      end
+    end
+  end
 end

data/spec/redis_feature_store_spec.rb

@@ -9,13 +9,22 @@ $my_prefix = 'testprefix'
 $null_log = ::Logger.new($stdout)
 $null_log.level = ::Logger::FATAL
 
+$base_opts = {
+  prefix: $my_prefix,
+  logger: $null_log
+}
 
-def create_redis_store()
-  LaunchDarkly::RedisFeatureStore.new(prefix: $my_prefix, logger: $null_log, expiration: 60)
+def create_redis_store(opts = {})
+  LaunchDarkly::RedisFeatureStore.new($base_opts.merge(opts).merge({ expiration: 60 }))
 end
 
-def create_redis_store_uncached()
-  LaunchDarkly::RedisFeatureStore.new(prefix: $my_prefix, logger: $null_log, expiration: 0)
+def create_redis_store_uncached(opts = {})
+  LaunchDarkly::RedisFeatureStore.new($base_opts.merge(opts).merge({ expiration: 0 }))
+end
+
+def clear_all_data
+  client = Redis.new
+  client.flushdb
 end
 
 
@@ -25,16 +34,17 @@ describe LaunchDarkly::RedisFeatureStore do
   # These tests will all fail if there isn't a Redis instance running on the default port.
   
   context "real Redis with local cache" do
-    include_examples "feature_store", method(:create_redis_store)
+    include_examples "feature_store", method(:create_redis_store), method(:clear_all_data)
   end
 
   context "real Redis without local cache" do
-    include_examples "feature_store", method(:create_redis_store_uncached)
+    include_examples "feature_store", method(:create_redis_store_uncached), method(:clear_all_data)
   end
 
-  def add_concurrent_modifier(store, other_client, flag, start_version, end_version)
+  def make_concurrent_modifier_test_hook(other_client, flag, start_version, end_version)
+    test_hook = Object.new
     version_counter = start_version
-    expect(store).to receive(:before_update_transaction) { |base_key, key|
+    expect(test_hook).to receive(:before_update_transaction) { |base_key, key|
       if version_counter <= end_version
         new_flag = flag.clone
         new_flag[:version] = version_counter
@@ -42,18 +52,18 @@ describe LaunchDarkly::RedisFeatureStore do
         version_counter = version_counter + 1
       end
     }.at_least(:once)
+    test_hook
   end
 
   it "handles upsert race condition against external client with lower version" do
-    store = create_redis_store
     other_client = Redis.new({ url: "redis://localhost:6379" })
+    flag = { key: "foo", version: 1 }
+    test_hook = make_concurrent_modifier_test_hook(other_client, flag, 2, 4)
+    store = create_redis_store({ test_hook: test_hook })
     
     begin
-      flag = { key: "foo", version: 1 }
       store.init(LaunchDarkly::FEATURES => { flag[:key] => flag })
 
-      add_concurrent_modifier(store, other_client, flag, 2, 4)
-
       my_ver = { key: "foo", version: 10 }
       store.upsert(LaunchDarkly::FEATURES, my_ver)
       result = store.get(LaunchDarkly::FEATURES, flag[:key])
@@ -64,15 +74,14 @@ describe LaunchDarkly::RedisFeatureStore do
   end
 
   it "handles upsert race condition against external client with higher version" do
-    store = create_redis_store
     other_client = Redis.new({ url: "redis://localhost:6379" })
+    flag = { key: "foo", version: 1 }
+    test_hook = make_concurrent_modifier_test_hook(other_client, flag, 3, 3)
+    store = create_redis_store({ test_hook: test_hook })
     
     begin
-      flag = { key: "foo", version: 1 }
       store.init(LaunchDarkly::FEATURES => { flag[:key] => flag })
 
-      add_concurrent_modifier(store, other_client, flag, 3, 3)
-
       my_ver = { key: "foo", version: 2 }
       store.upsert(LaunchDarkly::FEATURES, my_ver)
       result = store.get(LaunchDarkly::FEATURES, flag[:key])

data/spec/requestor_spec.rb

@@ -1,52 +1,58 @@
+require "http_util"
 require "spec_helper"
-require "faraday"
 
 describe LaunchDarkly::Requestor do
   describe ".request_all_flags" do
     describe "with a proxy" do
-      let(:requestor) {
-        LaunchDarkly::Requestor.new(
-          "key",
-          LaunchDarkly::Config.new({
-            :proxy => "http://proxy.com",
-            :base_uri => "http://ld.com"
-          })
-        )
-      }
       it "converts the proxy option" do
-        faraday = Faraday.new
-        requestor.instance_variable_set(:@client, faraday)
-        allow(faraday).to receive(:get) do |*args, &block|
-          req = double(Faraday::Request, :headers => {}, :options => Faraday::RequestOptions.new)
-          block.call(req)
-          expect(args).to eq ['http://ld.com/sdk/latest-all']
-          expect(req.options.proxy[:uri]).to eq URI("http://proxy.com")
-          double(body: '{"foo": "bar"}', status: 200, headers: {})
+        content = '{"flags": {"flagkey": {"key": "flagkey"}}}'
+        with_server do |server|
+          server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
+          with_server(StubProxyServer.new) do |proxy|
+            config = LaunchDarkly::Config.new(base_uri: server.base_uri.to_s, proxy: proxy.base_uri.to_s)
+            r = LaunchDarkly::Requestor.new("sdk-key", config)
+            result = r.request_all_data
+            expect(result).to eq(JSON.parse(content, symbolize_names: true))
+          end
         end
-
-        requestor.request_all_data()
       end
     end
     describe "without a proxy" do
-      let(:requestor) {
-        LaunchDarkly::Requestor.new(
-          "key",
-          LaunchDarkly::Config.new({
-            :base_uri => "http://ld.com"
-          })
-        )
-      }
-      it "converts the proxy option" do
-        faraday = Faraday.new
-        requestor.instance_variable_set(:@client, faraday)
-        allow(faraday).to receive(:get) do |*args, &block|
-          req = double(Faraday::Request, :headers => {}, :options => Faraday::RequestOptions.new)
-          block.call(req)
-          expect(args).to eq ['http://ld.com/sdk/latest-all']
-          expect(req.options.proxy).to eq nil
-          double(body: '{"foo": "bar"}', status: 200, headers: {})
+      it "sends headers" do
+        content = '{"flags": {}}'
+        sdk_key = 'sdk-key'
+        with_server do |server|
+          server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
+          r = LaunchDarkly::Requestor.new(sdk_key, LaunchDarkly::Config.new({ base_uri: server.base_uri.to_s }))
+          r.request_all_data
+          expect(server.requests.length).to eq 1
+          req = server.requests[0]
+          expect(req.header['authorization']).to eq [sdk_key]
+          expect(req.header['user-agent']).to eq ["RubyClient/" + LaunchDarkly::VERSION]
+        end
+      end
+
+      it "receives data" do
+        content = '{"flags": {"flagkey": {"key": "flagkey"}}}'
+        with_server do |server|
+          server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
+          r = LaunchDarkly::Requestor.new("sdk-key", LaunchDarkly::Config.new({ base_uri: server.base_uri.to_s }))
+          result = r.request_all_data
+          expect(result).to eq(JSON.parse(content, symbolize_names: true))
+        end
+      end
+
+      it "handles Unicode content" do
+        content = '{"flags": {"flagkey": {"key": "flagkey", "variations": ["blue", "grėeń"]}}}'
+        with_server do |server|
+          server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
+          # Note that the ETag header here is important because without it, the HTTP cache will not be used,
+          # and the cache is what required a fix to handle Unicode properly. See:
+          #   https://github.com/launchdarkly/ruby-client/issues/90
+          r = LaunchDarkly::Requestor.new("sdk-key", LaunchDarkly::Config.new({ base_uri: server.base_uri.to_s }))
+          result = r.request_all_data
+          expect(result).to eq(JSON.parse(content, symbolize_names: true))
         end
-        requestor.request_all_data()
       end
     end
   end

data/spec/stream_spec.rb

@@ -1,5 +1,5 @@
+require "ld-eventsource"
 require "spec_helper"
-require 'ostruct'
 
 describe LaunchDarkly::StreamProcessor do
   subject { LaunchDarkly::StreamProcessor }
@@ -8,52 +8,52 @@ describe LaunchDarkly::StreamProcessor do
   let(:processor) { subject.new("sdk_key", config, requestor) }
 
   describe '#process_message' do
-    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}'}) }
-    let(:indirect_patch_flag_message) { OpenStruct.new({data: "/flags/key"}) }
-    let(:indirect_patch_segment_message) { OpenStruct.new({data: "/segments/key"}) }
+    let(:put_message) { SSE::StreamEvent.new(:put, '{"data":{"flags":{"asdf": {"key": "asdf"}},"segments":{"segkey": {"key": "segkey"}}}}') }
+    let(:patch_flag_message) { SSE::StreamEvent.new(:patch, '{"path": "/flags/key", "data": {"key": "asdf", "version": 1}}') }
+    let(:patch_seg_message) { SSE::StreamEvent.new(:patch, '{"path": "/segments/key", "data": {"key": "asdf", "version": 1}}') }
+    let(:delete_flag_message) { SSE::StreamEvent.new(:delete, '{"path": "/flags/key", "version": 2}') }
+    let(:delete_seg_message) { SSE::StreamEvent.new(:delete, '{"path": "/segments/key", "version": 2}') }
+    let(:indirect_patch_flag_message) { SSE::StreamEvent.new(:'indirect/patch', "/flags/key") }
+    let(:indirect_patch_segment_message) { SSE::StreamEvent.new(:'indirect/patch', "/segments/key") }
 
     it "will accept PUT methods" do
-      processor.send(:process_message, put_message, LaunchDarkly::PUT)
+      processor.send(:process_message, put_message)
       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)
+      processor.send(:process_message, patch_flag_message)
       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)
+      processor.send(:process_message, patch_seg_message)
       expect(config.feature_store.get(LaunchDarkly::SEGMENTS, "asdf")).to eq(key: "asdf", version: 1)
     end
     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)
+      processor.send(:process_message, patch_flag_message)
+      processor.send(:process_message, delete_flag_message)
       expect(config.feature_store.get(LaunchDarkly::FEATURES, "key")).to eq(nil)
     end
     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)
+      processor.send(:process_message, patch_seg_message)
+      processor.send(:process_message, delete_seg_message)
       expect(config.feature_store.get(LaunchDarkly::SEGMENTS, "key")).to eq(nil)
     end
     it "will accept INDIRECT PATCH method for flags" do
       flag = { key: 'key', version: 1 }
       allow(requestor).to receive(:request_flag).with(flag[:key]).and_return(flag)
-      processor.send(:process_message, indirect_patch_flag_message, LaunchDarkly::INDIRECT_PATCH);
+      processor.send(:process_message, indirect_patch_flag_message);
       expect(config.feature_store.get(LaunchDarkly::FEATURES, flag[:key])).to eq(flag)
     end
     it "will accept INDIRECT PATCH method for segments" do
       segment = { key: 'key', version: 1 }
       allow(requestor).to receive(:request_segment).with(segment[:key]).and_return(segment)
-      processor.send(:process_message, indirect_patch_segment_message, LaunchDarkly::INDIRECT_PATCH);
+      processor.send(:process_message, indirect_patch_segment_message);
       expect(config.feature_store.get(LaunchDarkly::SEGMENTS, segment[:key])).to eq(segment)
     end
     it "will log a warning if the method is not recognized" do
       expect(processor.instance_variable_get(:@config).logger).to receive :warn
-      processor.send(:process_message, put_message, "get")
+      processor.send(:process_message, SSE::StreamEvent.new(type: :get, data: "", id: nil))
     end
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ldclient-rb
 version: !ruby/object:Gem::Version
-  version: 5.4.3
+  version: 5.5.0
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-11 00:00:00.000000000 Z
+date: 2019-01-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-dynamodb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: diplomat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -245,33 +273,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: http_tools
+  name: ld-eventsource
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.5
-- !ruby/object:Gem::Dependency
-  name: socketry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: '1.0'
 description: Official LaunchDarkly SDK for Ruby
 email:
 - team@launchdarkly.com
@@ -305,7 +319,19 @@ files:
 - lib/ldclient-rb/expiring_cache.rb
 - lib/ldclient-rb/file_data_source.rb
 - lib/ldclient-rb/flags_state.rb
+- lib/ldclient-rb/impl.rb
+- lib/ldclient-rb/impl/integrations/consul_impl.rb
+- lib/ldclient-rb/impl/integrations/dynamodb_impl.rb
+- lib/ldclient-rb/impl/integrations/redis_impl.rb
+- lib/ldclient-rb/impl/store_client_wrapper.rb
+- lib/ldclient-rb/impl/store_data_set_sorter.rb
 - lib/ldclient-rb/in_memory_store.rb
+- lib/ldclient-rb/integrations.rb
+- lib/ldclient-rb/integrations/consul.rb
+- lib/ldclient-rb/integrations/dynamodb.rb
+- lib/ldclient-rb/integrations/redis.rb
+- lib/ldclient-rb/integrations/util/store_wrapper.rb
+- lib/ldclient-rb/interfaces.rb
 - lib/ldclient-rb/ldclient.rb
 - lib/ldclient-rb/memoized_value.rb
 - lib/ldclient-rb/newrelic.rb
@@ -318,11 +344,7 @@ files:
 - lib/ldclient-rb/user_filter.rb
 - lib/ldclient-rb/util.rb
 - lib/ldclient-rb/version.rb
-- lib/sse_client.rb
-- lib/sse_client/backoff.rb
-- lib/sse_client/sse_client.rb
-- lib/sse_client/sse_events.rb
-- lib/sse_client/streaming_http.rb
+- scripts/gendocs.sh
 - scripts/release.sh
 - spec/config_spec.rb
 - spec/evaluation_spec.rb
@@ -337,7 +359,11 @@ files:
 - spec/fixtures/sanitized_numeric_key_user.json
 - spec/fixtures/user.json
 - spec/flags_state_spec.rb
+- spec/http_util.rb
 - spec/in_memory_feature_store_spec.rb
+- spec/integrations/consul_feature_store_spec.rb
+- spec/integrations/dynamodb_feature_store_spec.rb
+- spec/integrations/store_wrapper_spec.rb
 - spec/ldclient_spec.rb
 - spec/newrelic_spec.rb
 - spec/polling_spec.rb
@@ -346,10 +372,6 @@ files:
 - spec/segment_store_spec_base.rb
 - spec/simple_lru_cache_spec.rb
 - spec/spec_helper.rb
-- spec/sse_client/sse_client_spec.rb
-- spec/sse_client/sse_events_spec.rb
-- spec/sse_client/sse_shared.rb
-- spec/sse_client/streaming_http_spec.rb
 - spec/store_spec.rb
 - spec/stream_spec.rb
 - spec/user_filter_spec.rb
@@ -357,7 +379,7 @@ files:
 - spec/version_spec.rb
 homepage: https://github.com/launchdarkly/ruby-client
 licenses:
-- Apache 2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -393,7 +415,11 @@ test_files:
 - spec/fixtures/sanitized_numeric_key_user.json
 - spec/fixtures/user.json
 - spec/flags_state_spec.rb
+- spec/http_util.rb
 - spec/in_memory_feature_store_spec.rb
+- spec/integrations/consul_feature_store_spec.rb
+- spec/integrations/dynamodb_feature_store_spec.rb
+- spec/integrations/store_wrapper_spec.rb
 - spec/ldclient_spec.rb
 - spec/newrelic_spec.rb
 - spec/polling_spec.rb
@@ -402,10 +428,6 @@ test_files:
 - spec/segment_store_spec_base.rb
 - spec/simple_lru_cache_spec.rb
 - spec/spec_helper.rb
-- spec/sse_client/sse_client_spec.rb
-- spec/sse_client/sse_events_spec.rb
-- spec/sse_client/sse_shared.rb
-- spec/sse_client/streaming_http_spec.rb
 - spec/store_spec.rb
 - spec/stream_spec.rb
 - spec/user_filter_spec.rb