launchdarkly-server-sdk 6.1.1 → 6.4.0

data/spec/polling_spec.rb

@@ -1,120 +0,0 @@
-require "spec_helper"
-require 'ostruct'
-
-describe LaunchDarkly::PollingProcessor do
-  subject { LaunchDarkly::PollingProcessor }
-  let(:requestor) { double() }
-
-  def with_processor(store)
-    config = LaunchDarkly::Config.new(feature_store: store, logger: $null_log)
-    processor = subject.new(config, requestor)
-    begin
-      yield processor
-    ensure
-      processor.stop
-    end
-  end
-
-  describe 'successful request' do
-    flag = { key: 'flagkey', version: 1 }
-    segment = { key: 'segkey', version: 1 }
-    all_data = {
-      LaunchDarkly::FEATURES => {
-        flagkey: flag
-      },
-      LaunchDarkly::SEGMENTS => {
-        segkey: segment
-      }
-    }
-
-    it 'puts feature data in store' do
-      allow(requestor).to receive(:request_all_data).and_return(all_data)
-      store = LaunchDarkly::InMemoryFeatureStore.new
-      with_processor(store) do |processor|
-        ready = processor.start
-        ready.wait
-        expect(store.get(LaunchDarkly::FEATURES, "flagkey")).to eq(flag)
-        expect(store.get(LaunchDarkly::SEGMENTS, "segkey")).to eq(segment)
-      end
-    end
-
-    it 'sets initialized to true' do
-      allow(requestor).to receive(:request_all_data).and_return(all_data)
-      store = LaunchDarkly::InMemoryFeatureStore.new
-      with_processor(store) do |processor|
-        ready = processor.start
-        ready.wait
-        expect(processor.initialized?).to be true
-        expect(store.initialized?).to be true
-      end
-    end
-  end
-
-  describe 'connection error' do
-    it 'does not cause immediate failure, does not set initialized' do
-      allow(requestor).to receive(:request_all_data).and_raise(StandardError.new("test error"))
-      store = LaunchDarkly::InMemoryFeatureStore.new
-      with_processor(store) do |processor|
-        ready = processor.start
-        finished = ready.wait(0.2)
-        expect(finished).to be false
-        expect(processor.initialized?).to be false
-        expect(store.initialized?).to be false
-      end
-    end
-  end
-
-  describe 'HTTP errors' do
-    def verify_unrecoverable_http_error(status)
-      allow(requestor).to receive(:request_all_data).and_raise(LaunchDarkly::UnexpectedResponseError.new(status))
-      with_processor(LaunchDarkly::InMemoryFeatureStore.new) do |processor|
-        ready = processor.start
-        finished = ready.wait(0.2)
-        expect(finished).to be true
-        expect(processor.initialized?).to be false
-      end
-    end
-
-    def verify_recoverable_http_error(status)
-      allow(requestor).to receive(:request_all_data).and_raise(LaunchDarkly::UnexpectedResponseError.new(status))
-      with_processor(LaunchDarkly::InMemoryFeatureStore.new) do |processor|
-        ready = processor.start
-        finished = ready.wait(0.2)
-        expect(finished).to be false
-        expect(processor.initialized?).to be false
-      end
-    end
-
-    it 'stops immediately for error 401' do
-      verify_unrecoverable_http_error(401)
-    end
-
-    it 'stops immediately for error 403' do
-      verify_unrecoverable_http_error(403)
-    end
-
-    it 'does not stop immediately for error 408' do
-      verify_recoverable_http_error(408)
-    end
-
-    it 'does not stop immediately for error 429' do
-      verify_recoverable_http_error(429)
-    end
-
-    it 'does not stop immediately for error 503' do
-      verify_recoverable_http_error(503)
-    end
-  end
-
-  describe 'stop' do
-    it 'stops promptly rather than continuing to wait for poll interval' do
-      with_processor(LaunchDarkly::InMemoryFeatureStore.new) do |processor|
-        sleep(1)  # somewhat arbitrary, but should ensure that it has started polling
-        start_time = Time.now
-        processor.stop
-        end_time = Time.now
-        expect(end_time - start_time).to be <(LaunchDarkly::Config.default_poll_interval - 5)
-      end
-    end
-  end
-end

data/spec/redis_feature_store_spec.rb

@@ -1,121 +0,0 @@
-require "feature_store_spec_base"
-require "connection_pool"
-require "json"
-require "redis"
-require "spec_helper"
-
-
-$my_prefix = 'testprefix'
-
-$base_opts = {
-  prefix: $my_prefix,
-  logger: $null_log
-}
-
-def create_redis_store(opts = {})
-  LaunchDarkly::RedisFeatureStore.new($base_opts.merge(opts).merge({ expiration: 60 }))
-end
-
-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
-
-
-describe LaunchDarkly::RedisFeatureStore do
-  subject { LaunchDarkly::RedisFeatureStore }
-  
-  break if ENV['LD_SKIP_DATABASE_TESTS'] == '1'
-
-  # 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), method(:clear_all_data)
-  end
-
-  context "real Redis without local cache" do
-    include_examples "feature_store", method(:create_redis_store_uncached), method(:clear_all_data)
-  end
-
-  def make_concurrent_modifier_test_hook(other_client, flag, start_version, end_version)
-    test_hook = Object.new
-    version_counter = start_version
-    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
-        other_client.hset(base_key, key, new_flag.to_json)
-        version_counter = version_counter + 1
-      end
-    }.at_least(:once)
-    test_hook
-  end
-
-  it "handles upsert race condition against external client with lower version" do
-    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
-      store.init(LaunchDarkly::FEATURES => { flag[:key] => flag })
-
-      my_ver = { key: "foo", version: 10 }
-      store.upsert(LaunchDarkly::FEATURES, my_ver)
-      result = store.get(LaunchDarkly::FEATURES, flag[:key])
-      expect(result[:version]).to eq 10
-    ensure
-      other_client.close
-    end
-  end
-
-  it "handles upsert race condition against external client with higher version" do
-    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
-      store.init(LaunchDarkly::FEATURES => { flag[:key] => flag })
-
-      my_ver = { key: "foo", version: 2 }
-      store.upsert(LaunchDarkly::FEATURES, my_ver)
-      result = store.get(LaunchDarkly::FEATURES, flag[:key])
-      expect(result[:version]).to eq 3
-    ensure
-      other_client.close
-    end
-  end
-
-  it "shuts down a custom Redis pool by default" do
-    unowned_pool = ConnectionPool.new(size: 1, timeout: 1) { Redis.new({ url: "redis://localhost:6379" }) }
-    store = create_redis_store({ pool: unowned_pool })
-
-    begin
-      store.init(LaunchDarkly::FEATURES => { })
-      store.stop
-
-      expect { unowned_pool.with {} }.to raise_error(ConnectionPool::PoolShuttingDownError)
-    ensure
-      unowned_pool.shutdown { |conn| conn.close }
-    end
-  end
-
-  it "doesn't shut down a custom Redis pool if pool_shutdown_on_close = false" do
-    unowned_pool = ConnectionPool.new(size: 1, timeout: 1) { Redis.new({ url: "redis://localhost:6379" }) }
-    store = create_redis_store({ pool: unowned_pool, pool_shutdown_on_close: false })
-
-    begin
-      store.init(LaunchDarkly::FEATURES => { })
-      store.stop
-
-      expect { unowned_pool.with {} }.not_to raise_error(ConnectionPool::PoolShuttingDownError)
-    ensure
-      unowned_pool.shutdown { |conn| conn.close }
-    end
-  end
-end

data/spec/requestor_spec.rb

@@ -1,196 +0,0 @@
-require "http_util"
-require "spec_helper"
-
-$sdk_key = "secret"
-
-describe LaunchDarkly::Requestor do
-  def with_requestor(base_uri, opts = {})
-    r = LaunchDarkly::Requestor.new($sdk_key, LaunchDarkly::Config.new({ base_uri: base_uri }.merge(opts)))
-    begin
-      yield r
-    ensure
-      r.stop
-    end
-  end
-
-  describe "request_all_flags" do
-    it "uses expected URI and headers" do
-      with_server do |server|
-        with_requestor(server.base_uri.to_s) do |requestor|
-          server.setup_ok_response("/", "{}")
-          requestor.request_all_data()
-          expect(server.requests.count).to eq 1
-          expect(server.requests[0].unparsed_uri).to eq "/sdk/latest-all"
-          expect(server.requests[0].header).to include({
-            "authorization" => [ $sdk_key ],
-            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ]
-          })
-        end
-      end
-    end
-
-    it "parses response" do
-      expected_data = { flags: { x: { key: "x" } } }
-      with_server do |server|
-        with_requestor(server.base_uri.to_s) do |requestor|
-          server.setup_ok_response("/", expected_data.to_json)
-          data = requestor.request_all_data()
-          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data)
-        end
-      end
-    end
-
-    it "sends etag from previous response" do
-      etag = "xyz"
-      with_server do |server|
-        with_requestor(server.base_uri.to_s) do |requestor|
-          server.setup_response("/") do |req, res|
-            res.status = 200
-            res.body = "{}"
-            res["ETag"] = etag
-          end
-          requestor.request_all_data()
-          expect(server.requests.count).to eq 1
-
-          requestor.request_all_data()
-          expect(server.requests.count).to eq 2
-          expect(server.requests[1].header).to include({ "if-none-match" => [ etag ] })
-        end
-      end
-    end
-
-    it "sends wrapper header if configured" do
-      with_server do |server|
-        with_requestor(server.base_uri.to_s, { wrapper_name: 'MyWrapper', wrapper_version: '1.0' }) do |requestor|
-          server.setup_ok_response("/", "{}")
-          requestor.request_all_data()
-          expect(server.requests.count).to eq 1
-          expect(server.requests[0].header).to include({
-            "x-launchdarkly-wrapper" => [ "MyWrapper/1.0" ]
-          })
-        end
-      end
-    end
-    
-    it "can reuse cached data" do
-      etag = "xyz"
-      expected_data = { flags: { x: { key: "x" } } }
-      with_server do |server|
-        with_requestor(server.base_uri.to_s) do |requestor|
-          server.setup_response("/") do |req, res|
-            res.status = 200
-            res.body = expected_data.to_json
-            res["ETag"] = etag
-          end
-          requestor.request_all_data()
-          expect(server.requests.count).to eq 1
-
-          server.setup_response("/") do |req, res|
-            res.status = 304
-          end
-          data = requestor.request_all_data()
-          expect(server.requests.count).to eq 2
-          expect(server.requests[1].header).to include({ "if-none-match" => [ etag ] })
-          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data)
-        end
-      end
-    end
-
-    it "replaces cached data with new data" do
-      etag1 = "abc"
-      etag2 = "xyz"
-      expected_data1 = { flags: { x: { key: "x" } } }
-      expected_data2 = { flags: { y: { key: "y" } } }
-      with_server do |server|
-        with_requestor(server.base_uri.to_s) do |requestor|
-          server.setup_response("/") do |req, res|
-            res.status = 200
-            res.body = expected_data1.to_json
-            res["ETag"] = etag1
-          end
-          data = requestor.request_all_data()
-          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data1)
-          expect(server.requests.count).to eq 1
-
-          server.setup_response("/") do |req, res|
-            res.status = 304
-          end
-          data = requestor.request_all_data()
-          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data1)
-          expect(server.requests.count).to eq 2
-          expect(server.requests[1].header).to include({ "if-none-match" => [ etag1 ] })
-
-          server.setup_response("/") do |req, res|
-            res.status = 200
-            res.body = expected_data2.to_json
-            res["ETag"] = etag2
-          end
-          data = requestor.request_all_data()
-          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data2)
-          expect(server.requests.count).to eq 3
-          expect(server.requests[2].header).to include({ "if-none-match" => [ etag1 ] })
-
-          server.setup_response("/") do |req, res|
-            res.status = 304
-          end
-          data = requestor.request_all_data()
-          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data2)
-          expect(server.requests.count).to eq 4
-          expect(server.requests[3].header).to include({ "if-none-match" => [ etag2 ] })
-        end
-      end
-    end
-
-    it "uses UTF-8 encoding by default" do
-      content = '{"flags": {"flagkey": {"key": "flagkey", "variations": ["blue", "grėeń"]}}}'
-      with_server do |server|
-        server.setup_ok_response("/sdk/latest-all", content, "application/json")
-        with_requestor(server.base_uri.to_s) do |requestor|
-          data = requestor.request_all_data
-          expect(data).to eq(LaunchDarkly::Impl::Model.make_all_store_data(JSON.parse(content, symbolize_names: true)))
-        end
-      end
-    end
-
-    it "detects other encodings from Content-Type" do
-      content = '{"flags": {"flagkey": {"key": "flagkey", "variations": ["proszę", "dziękuję"]}}}'
-      with_server do |server|
-        server.setup_ok_response("/sdk/latest-all", content.encode(Encoding::ISO_8859_2),
-          "text/plain; charset=ISO-8859-2")
-        with_requestor(server.base_uri.to_s) do |requestor|
-          data = requestor.request_all_data
-          expect(data).to eq(LaunchDarkly::Impl::Model.make_all_store_data(JSON.parse(content, symbolize_names: true)))
-        end
-      end
-    end
-
-    it "throws exception for error status" do
-      with_server do |server|
-        with_requestor(server.base_uri.to_s) do |requestor|
-          server.setup_response("/") do |req, res|
-            res.status = 400
-          end
-          expect { requestor.request_all_data() }.to raise_error(LaunchDarkly::UnexpectedResponseError)
-        end
-      end
-    end
-
-    it "can use a proxy server" do
-      expected_data = { flags: { flagkey: { key: "flagkey" } } }
-      with_server do |server|
-        server.setup_ok_response("/sdk/latest-all", expected_data.to_json, "application/json", { "etag" => "x" })
-        with_server(StubProxyServer.new) do |proxy|
-          begin
-            ENV["http_proxy"] = proxy.base_uri.to_s
-            with_requestor(server.base_uri.to_s) do |requestor|
-              data = requestor.request_all_data
-              expect(data).to eq(LaunchDarkly::Impl::Model.make_all_store_data(expected_data))
-            end
-          ensure
-            ENV["http_proxy"] = nil
-          end
-        end
-      end
-    end
-  end
-end

data/spec/segment_store_spec_base.rb

@@ -1,95 +0,0 @@
-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/simple_lru_cache_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-describe LaunchDarkly::SimpleLRUCacheSet do
-  subject { LaunchDarkly::SimpleLRUCacheSet }
-
-  it "retains values up to capacity" do
-    lru = subject.new(3)
-    expect(lru.add("a")).to be false
-    expect(lru.add("b")).to be false
-    expect(lru.add("c")).to be false
-    expect(lru.add("a")).to be true
-    expect(lru.add("b")).to be true
-    expect(lru.add("c")).to be true
-  end
-
-  it "discards oldest value on overflow" do
-    lru = subject.new(2)
-    expect(lru.add("a")).to be false
-    expect(lru.add("b")).to be false
-    expect(lru.add("a")).to be true
-    expect(lru.add("c")).to be false  # b is discarded as oldest
-    expect(lru.add("b")).to be false
-  end
-end

data/spec/spec_helper.rb

@@ -1,9 +0,0 @@
-require "ldclient-rb"
-
-$null_log = ::Logger.new($stdout)
-$null_log.level = ::Logger::FATAL
-
-RSpec.configure do |config|
-  config.before(:each) do
-  end
-end

data/spec/store_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-
-describe LaunchDarkly::ThreadSafeMemoryStore do
-  subject { LaunchDarkly::ThreadSafeMemoryStore }
-  let(:store) { subject.new }
-  it "can read and write" do
-    store.write("key", "value")
-    expect(store.read("key")).to eq "value"
-  end
-end

data/spec/stream_spec.rb

@@ -1,45 +0,0 @@
-require "ld-eventsource"
-require "spec_helper"
-
-describe LaunchDarkly::StreamProcessor do
-  subject { LaunchDarkly::StreamProcessor }
-  let(:config) { LaunchDarkly::Config.new }
-  let(:processor) { subject.new("sdk_key", config) }
-
-  describe '#process_message' do
-    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}') }
-
-    it "will accept PUT methods" do
-      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)
-      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)
-      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)
-      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)
-      processor.send(:process_message, delete_seg_message)
-      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
-      processor.send(:process_message, SSE::StreamEvent.new(type: :get, data: "", id: nil))
-    end
-  end
-end
-