ldclient-rb 5.4.3 → 5.5.0

data/spec/file_data_source_spec.rb

@@ -219,7 +219,7 @@ EOF
   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, update_processor_factory: factory)
+    config = LaunchDarkly::Config.new(send_events: false, data_source: factory)
     client = LaunchDarkly::LDClient.new('sdkKey', config)
 
     begin
@@ -233,7 +233,7 @@ EOF
   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, update_processor_factory: factory)
+    config = LaunchDarkly::Config.new(send_events: false, data_source: factory)
     client = LaunchDarkly::LDClient.new('sdkKey', config)
 
     begin

data/spec/http_util.rb

@@ -0,0 +1,103 @@
+require "webrick"
+require "webrick/httpproxy"
+require "webrick/https"
+
+class StubHTTPServer
+  attr_reader :requests
+
+  @@next_port = 50000
+
+  def initialize
+    @port = StubHTTPServer.next_port
+    begin
+      base_opts = {
+        BindAddress: '127.0.0.1',
+        Port: @port,
+        AccessLog: [],
+        Logger: NullLogger.new,
+        RequestCallback: method(:record_request)
+      }
+      @server = create_server(@port, base_opts)
+    rescue Errno::EADDRINUSE
+      @port = StubHTTPServer.next_port
+      retry
+    end
+    @requests = []
+  end
+
+  def self.next_port
+    p = @@next_port
+    @@next_port = (p + 1 < 60000) ? p + 1 : 50000
+    p
+  end
+
+  def create_server(port, base_opts)
+    WEBrick::HTTPServer.new(base_opts)
+  end
+
+  def start
+    Thread.new { @server.start }
+  end
+
+  def stop
+    @server.shutdown
+  end
+
+  def base_uri
+    URI("http://127.0.0.1:#{@port}")
+  end
+
+  def setup_response(uri_path, &action)
+    @server.mount_proc(uri_path, action)
+  end
+
+  def setup_ok_response(uri_path, body, content_type=nil, headers={})
+    setup_response(uri_path) do |req, res|
+      res.status = 200
+      res.content_type = content_type if !content_type.nil?
+      res.body = body
+      headers.each { |n, v| res[n] = v }
+    end
+  end
+
+  def record_request(req, res)
+    @requests.push(req)
+  end
+end
+
+class StubProxyServer < StubHTTPServer
+  attr_reader :request_count
+  attr_accessor :connect_status
+
+  def initialize
+    super
+    @request_count = 0
+  end
+
+  def create_server(port, base_opts)
+    WEBrick::HTTPProxyServer.new(base_opts.merge({
+      ProxyContentHandler: proc do |req,res|
+        if !@connect_status.nil?
+          res.status = @connect_status
+        end
+        @request_count += 1
+      end
+    }))
+  end
+end
+
+class NullLogger
+  def method_missing(*)
+    self
+  end
+end
+
+def with_server(server = nil)
+  server = StubHTTPServer.new if server.nil?
+  begin
+    server.start
+    yield server
+  ensure
+    server.stop
+  end
+end

data/spec/in_memory_feature_store_spec.rb

@@ -1,7 +1,7 @@
 require "feature_store_spec_base"
 require "spec_helper"
 
-def create_in_memory_store()
+def create_in_memory_store(opts = {})
   LaunchDarkly::InMemoryFeatureStore.new
 end
 

data/spec/integrations/consul_feature_store_spec.rb

@@ -0,0 +1,41 @@
+require "feature_store_spec_base"
+require "diplomat"
+require "spec_helper"
+
+
+$my_prefix = 'testprefix'
+$null_log = ::Logger.new($stdout)
+$null_log.level = ::Logger::FATAL
+
+$consul_base_opts = {
+  prefix: $my_prefix,
+  logger: $null_log
+}
+
+def create_consul_store(opts = {})
+  LaunchDarkly::Integrations::Consul::new_feature_store(
+    $consul_base_opts.merge(opts).merge({ expiration: 60 }))
+end
+
+def create_consul_store_uncached(opts = {})
+  LaunchDarkly::Integrations::Consul::new_feature_store(
+    $consul_base_opts.merge(opts).merge({ expiration: 0 }))
+end
+
+def clear_all_data
+  Diplomat::Kv.delete($my_prefix + '/', recurse: true)
+end
+
+
+describe "Consul feature store" do
+  
+  # These tests will all fail if there isn't a local Consul instance running.
+  
+  context "with local cache" do
+    include_examples "feature_store", method(:create_consul_store), method(:clear_all_data)
+  end
+
+  context "without local cache" do
+    include_examples "feature_store", method(:create_consul_store_uncached), method(:clear_all_data)
+  end
+end

data/spec/integrations/dynamodb_feature_store_spec.rb

@@ -0,0 +1,104 @@
+require "feature_store_spec_base"
+require "aws-sdk-dynamodb"
+require "spec_helper"
+
+
+$table_name = 'LD_DYNAMODB_TEST_TABLE'
+$endpoint = 'http://localhost:8000'
+$my_prefix = 'testprefix'
+$null_log = ::Logger.new($stdout)
+$null_log.level = ::Logger::FATAL
+
+$dynamodb_opts = {
+  credentials: Aws::Credentials.new("key", "secret"),
+  region: "us-east-1",
+  endpoint: $endpoint
+}
+
+$ddb_base_opts = {
+  dynamodb_opts: $dynamodb_opts,
+  prefix: $my_prefix,
+  logger: $null_log
+}
+
+def create_dynamodb_store(opts = {})
+  LaunchDarkly::Integrations::DynamoDB::new_feature_store($table_name,
+    $ddb_base_opts.merge(opts).merge({ expiration: 60 }))
+end
+
+def create_dynamodb_store_uncached(opts = {})
+  LaunchDarkly::Integrations::DynamoDB::new_feature_store($table_name,
+    $ddb_base_opts.merge(opts).merge({ expiration: 0 }))
+end
+
+def clear_all_data
+  client = create_test_client
+  items_to_delete = []
+  req = {
+    table_name: $table_name,
+    projection_expression: '#namespace, #key',
+    expression_attribute_names: {
+      '#namespace' => 'namespace',
+      '#key' => 'key'
+    }
+  }
+  while true
+    resp = client.scan(req)
+    items_to_delete = items_to_delete + resp.items
+    break if resp.last_evaluated_key.nil? || resp.last_evaluated_key.length == 0
+    req.exclusive_start_key = resp.last_evaluated_key
+  end
+  requests = items_to_delete.map do |item|
+    { delete_request: { key: item } }
+  end
+  LaunchDarkly::Impl::Integrations::DynamoDB::DynamoDBUtil.batch_write_requests(client, $table_name, requests)
+end
+
+def create_table_if_necessary
+  client = create_test_client
+  begin
+    client.describe_table({ table_name: $table_name })
+    return  # no error, table exists
+  rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+    # fall through to code below - we'll create the table
+  end
+
+  req = {
+    table_name: $table_name,
+    key_schema: [
+      { attribute_name: "namespace", key_type: "HASH" },
+      { attribute_name: "key", key_type: "RANGE" }
+    ],
+    attribute_definitions: [
+      { attribute_name: "namespace", attribute_type: "S" },
+      { attribute_name: "key", attribute_type: "S" }
+    ],
+    provisioned_throughput: {
+      read_capacity_units: 1,
+      write_capacity_units: 1
+    }
+  }
+  client.create_table(req)
+
+  # When DynamoDB creates a table, it may not be ready to use immediately
+end
+
+def create_test_client
+  Aws::DynamoDB::Client.new($dynamodb_opts)
+end
+
+
+describe "DynamoDB feature store" do
+  
+  # These tests will all fail if there isn't a local DynamoDB instance running.
+  
+  create_table_if_necessary
+
+  context "with local cache" do
+    include_examples "feature_store", method(:create_dynamodb_store), method(:clear_all_data)
+  end
+
+  context "without local cache" do
+    include_examples "feature_store", method(:create_dynamodb_store_uncached), method(:clear_all_data)
+  end
+end

data/spec/integrations/store_wrapper_spec.rb

@@ -0,0 +1,276 @@
+require "spec_helper"
+
+describe LaunchDarkly::Integrations::Util::CachingStoreWrapper do
+  subject { LaunchDarkly::Integrations::Util::CachingStoreWrapper }
+
+  THINGS = { namespace: "things" }
+
+  shared_examples "tests" do |cached|
+    opts = cached ? { expiration: 30 } : { expiration: 0 }
+
+    it "gets item" do
+      core = MockCore.new
+      wrapper = subject.new(core, opts)
+      key = "flag"
+      itemv1 = { key: key, version: 1 }
+      itemv2 = { key: key, version: 2 }
+
+      core.force_set(THINGS, itemv1)
+      expect(wrapper.get(THINGS, key)).to eq itemv1
+
+      core.force_set(THINGS, itemv2)
+      expect(wrapper.get(THINGS, key)).to eq (cached ? itemv1 : itemv2)  # if cached, we will not see the new underlying value yet
+    end
+
+    it "gets deleted item" do
+      core = MockCore.new
+      wrapper = subject.new(core, opts)
+      key = "flag"
+      itemv1 = { key: key, version: 1, deleted: true }
+      itemv2 = { key: key, version: 2, deleted: false }
+
+      core.force_set(THINGS, itemv1)
+      expect(wrapper.get(THINGS, key)).to eq nil  # item is filtered out because deleted is true
+
+      core.force_set(THINGS, itemv2)
+      expect(wrapper.get(THINGS, key)).to eq (cached ? nil : itemv2)  # if cached, we will not see the new underlying value yet
+    end
+
+    it "gets missing item" do
+      core = MockCore.new
+      wrapper = subject.new(core, opts)
+      key = "flag"
+      item = { key: key, version: 1 }
+
+      expect(wrapper.get(THINGS, key)).to eq nil
+
+      core.force_set(THINGS, item)
+      expect(wrapper.get(THINGS, key)).to eq (cached ? nil : item)  # the cache can retain a nil result
+    end
+
+    it "gets all items" do
+      core = MockCore.new
+      wrapper = subject.new(core, opts)
+      item1 = { key: "flag1", version: 1 }
+      item2 = { key: "flag2", version: 1 }
+
+      core.force_set(THINGS, item1)
+      core.force_set(THINGS, item2)
+      expect(wrapper.all(THINGS)).to eq({ item1[:key] => item1, item2[:key] => item2 })
+
+      core.force_remove(THINGS, item2[:key])
+      expect(wrapper.all(THINGS)).to eq (cached ?
+        { item1[:key] => item1, item2[:key] => item2 } :
+        { item1[:key] => item1 })
+    end
+
+    it "gets all items filtering out deleted items" do
+      core = MockCore.new
+      wrapper = subject.new(core, opts)
+      item1 = { key: "flag1", version: 1 }
+      item2 = { key: "flag2", version: 1, deleted: true }
+
+      core.force_set(THINGS, item1)
+      core.force_set(THINGS, item2)
+      expect(wrapper.all(THINGS)).to eq({ item1[:key] => item1 })
+    end
+
+    it "upserts item successfully" do
+      core = MockCore.new
+      wrapper = subject.new(core, opts)
+      key = "flag"
+      itemv1 = { key: key, version: 1 }
+      itemv2 = { key: key, version: 2 }
+
+      wrapper.upsert(THINGS, itemv1)
+      expect(core.data[THINGS][key]).to eq itemv1
+
+      wrapper.upsert(THINGS, itemv2)
+      expect(core.data[THINGS][key]).to eq itemv2
+
+      # if we have a cache, verify that the new item is now cached by writing a different value
+      # to the underlying data - Get should still return the cached item
+      if cached
+        itemv3 = { key: key, version: 3 }
+        core.force_set(THINGS, itemv3)
+      end
+
+      expect(wrapper.get(THINGS, key)).to eq itemv2
+    end
+
+    it "deletes item" do
+      core = MockCore.new
+      wrapper = subject.new(core, opts)
+      key = "flag"
+      itemv1 = { key: key, version: 1 }
+      itemv2 = { key: key, version: 2, deleted: true }
+      itemv3 = { key: key, version: 3 }
+
+      core.force_set(THINGS, itemv1)
+      expect(wrapper.get(THINGS, key)).to eq itemv1
+
+      wrapper.delete(THINGS, key, 2)
+      expect(core.data[THINGS][key]).to eq itemv2
+
+      core.force_set(THINGS, itemv3)  # make a change that bypasses the cache
+
+      expect(wrapper.get(THINGS, key)).to eq (cached ? nil : itemv3)
+    end
+  end
+
+  context "cached" do
+    include_examples "tests", true
+
+    cached_opts = { expiration: 30 }
+
+    it "get uses values from init" do
+      core = MockCore.new
+      wrapper = subject.new(core, cached_opts)
+      item1 = { key: "flag1", version: 1 }
+      item2 = { key: "flag2", version: 1 }
+
+      wrapper.init({ THINGS => { item1[:key] => item1, item2[:key] => item2 } })
+      core.force_remove(THINGS, item1[:key])
+
+      expect(wrapper.get(THINGS, item1[:key])).to eq item1
+    end
+
+    it "get all uses values from init" do
+      core = MockCore.new
+      wrapper = subject.new(core, cached_opts)
+      item1 = { key: "flag1", version: 1 }
+      item2 = { key: "flag2", version: 1 }
+
+      wrapper.init({ THINGS => { item1[:key] => item1, item2[:key] => item2 } })
+      core.force_remove(THINGS, item1[:key])
+
+      expect(wrapper.all(THINGS)).to eq ({ item1[:key] => item1, item2[:key] => item2 })
+    end
+
+    it "upsert doesn't update cache if unsuccessful" do
+      # This is for an upsert where the data in the store has a higher version. In an uncached
+      # store, this is just a no-op as far as the wrapper is concerned so there's nothing to
+      # test here. In a cached store, we need to verify that the cache has been refreshed
+      # using the data that was found in the store.
+      core = MockCore.new
+      wrapper = subject.new(core, cached_opts)
+      key = "flag"
+      itemv1 = { key: key, version: 1 }
+      itemv2 = { key: key, version: 2 }
+
+      wrapper.upsert(THINGS, itemv2)
+      expect(core.data[THINGS][key]).to eq itemv2
+
+      wrapper.upsert(THINGS, itemv1)
+      expect(core.data[THINGS][key]).to eq itemv2  # value in store remains the same
+
+      itemv3 = { key: key, version: 3 }
+      core.force_set(THINGS, itemv3)  # bypasses cache so we can verify that itemv2 is in the cache
+      expect(wrapper.get(THINGS, key)).to eq itemv2
+    end
+
+    it "initialized? can cache false result" do
+      core = MockCore.new
+      wrapper = subject.new(core, { expiration: 0.2 })  # use a shorter cache TTL for this test
+
+      expect(wrapper.initialized?).to eq false
+      expect(core.inited_query_count).to eq 1
+
+      core.inited = true
+      expect(wrapper.initialized?).to eq false
+      expect(core.inited_query_count).to eq 1
+
+      sleep(0.5)
+
+      expect(wrapper.initialized?).to eq true
+      expect(core.inited_query_count).to eq 2
+
+      # From this point on it should remain true and the method should not be called
+      expect(wrapper.initialized?).to eq true
+      expect(core.inited_query_count).to eq 2
+    end
+  end
+
+  context "uncached" do
+    include_examples "tests", false
+
+    uncached_opts = { expiration: 0 }
+
+    it "queries internal initialized state only if not already inited" do
+      core = MockCore.new
+      wrapper = subject.new(core, uncached_opts)
+
+      expect(wrapper.initialized?).to eq false
+      expect(core.inited_query_count).to eq 1
+
+      core.inited = true
+      expect(wrapper.initialized?).to eq true
+      expect(core.inited_query_count).to eq 2
+
+      core.inited = false
+      expect(wrapper.initialized?).to eq true
+      expect(core.inited_query_count).to eq 2
+    end
+
+    it "does not query internal initialized state if init has been called" do
+      core = MockCore.new
+      wrapper = subject.new(core, uncached_opts)
+
+      expect(wrapper.initialized?).to eq false
+      expect(core.inited_query_count).to eq 1
+
+      wrapper.init({})
+
+      expect(wrapper.initialized?).to eq true
+      expect(core.inited_query_count).to eq 1
+    end
+  end
+
+  class MockCore
+    def initialize
+      @data = {}
+      @inited = false
+      @inited_query_count = 0
+    end
+
+    attr_reader :data
+    attr_reader :inited_query_count
+    attr_accessor :inited
+
+    def force_set(kind, item)
+      @data[kind] = {} if !@data.has_key?(kind)
+      @data[kind][item[:key]] = item
+    end
+
+    def force_remove(kind, key)
+      @data[kind].delete(key) if @data.has_key?(kind)
+    end
+
+    def init_internal(all_data)
+      @data = all_data
+      @inited = true
+    end
+
+    def get_internal(kind, key)
+      items = @data[kind]
+      items.nil? ? nil : items[key]
+    end
+
+    def get_all_internal(kind)
+      @data[kind]
+    end
+
+    def upsert_internal(kind, item)
+      @data[kind] = {} if !@data.has_key?(kind)
+      old_item = @data[kind][item[:key]]
+      return old_item if !old_item.nil? && old_item[:version] >= item[:version]
+      @data[kind][item[:key]] = item
+      item
+    end
+
+    def initialized_internal?
+      @inited_query_count = @inited_query_count + 1
+      @inited
+    end
+  end
+end