launchdarkly-server-sdk 5.5.7

data/spec/newrelic_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe LaunchDarkly::LDNewRelic do
+  subject { LaunchDarkly::LDNewRelic }
+end

data/spec/polling_spec.rb

@@ -0,0 +1,120 @@
+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)
+    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 = {
+      flags: {
+        flagkey: flag
+      },
+      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

@@ -0,0 +1,95 @@
+require "feature_store_spec_base"
+require "json"
+require "redis"
+require "spec_helper"
+
+
+
+$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(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 }
+  
+  return 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
+end

data/spec/requestor_spec.rb

@@ -0,0 +1,214 @@
+require "http_util"
+require "spec_helper"
+
+$sdk_key = "secret"
+
+describe LaunchDarkly::Requestor do
+  def with_requestor(base_uri)
+    r = LaunchDarkly::Requestor.new($sdk_key, LaunchDarkly::Config.new(base_uri: base_uri))
+    yield r
+    r.stop
+  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 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 "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 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 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 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 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 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(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(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
+      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|
+          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(JSON.parse(content, symbolize_names: true))
+            end
+          ensure
+            ENV["http_proxy"] = nil
+          end
+        end
+      end
+    end
+  end
+
+  describe "request_flag" 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_flag("key")
+          expect(server.requests.count).to eq 1
+          expect(server.requests[0].unparsed_uri).to eq "/sdk/latest-flags/key"
+          expect(server.requests[0].header).to include({
+            "authorization" => [ $sdk_key ],
+            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ]
+          })
+        end
+      end
+    end
+  end
+
+  describe "request_segment" 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_segment("key")
+          expect(server.requests.count).to eq 1
+          expect(server.requests[0].unparsed_uri).to eq "/sdk/latest-segments/key"
+          expect(server.requests[0].header).to include({
+            "authorization" => [ $sdk_key ],
+            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ]
+          })
+        end
+      end
+    end
+  end
+end

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