launchdarkly-server-sdk 6.2.1 → 6.2.5

data/spec/impl/model/serialization_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-module LaunchDarkly
-  module Impl
-    module Model
-      describe "model serialization" do
-        it "serializes flag" do
-          flag = { key: "flagkey", version: 1 }
-          json = Model.serialize(FEATURES, flag)
-          expect(JSON.parse(json, symbolize_names: true)).to eq flag
-        end
-
-        it "serializes segment" do
-          segment = { key: "segkey", version: 1 }
-          json = Model.serialize(SEGMENTS, segment)
-          expect(JSON.parse(json, symbolize_names: true)).to eq segment
-        end
-
-        it "serializes arbitrary data kind" do
-          thing = { key: "thingkey", name: "me" }
-          json = Model.serialize({ name: "things" }, thing)
-          expect(JSON.parse(json, symbolize_names: true)).to eq thing
-        end
-
-        it "deserializes flag with no rules or prerequisites" do
-          flag_in = { key: "flagkey", version: 1 }
-          json = Model.serialize(FEATURES, flag_in)
-          flag_out = Model.deserialize(FEATURES, json)
-          expect(flag_out).to eq flag_in
-        end
-
-        it "deserializes segment" do
-          segment_in = { key: "segkey", version: 1 }
-          json = Model.serialize(SEGMENTS, segment_in)
-          segment_out = Model.deserialize(SEGMENTS, json)
-          expect(segment_out).to eq segment_in
-        end
-      end
-    end
-  end
-end

data/spec/in_memory_feature_store_spec.rb

@@ -1,12 +0,0 @@
-require "feature_store_spec_base"
-require "spec_helper"
-
-def create_in_memory_store(opts = {})
-  LaunchDarkly::InMemoryFeatureStore.new
-end
-
-describe LaunchDarkly::InMemoryFeatureStore do
-  subject { LaunchDarkly::InMemoryFeatureStore }
-  
-  include_examples "feature_store", method(:create_in_memory_store)
-end

data/spec/integrations/consul_feature_store_spec.rb

@@ -1,40 +0,0 @@
-require "feature_store_spec_base"
-require "diplomat"
-require "spec_helper"
-
-
-$my_prefix = 'testprefix'
-
-$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
-  break if ENV['LD_SKIP_DATABASE_TESTS'] == '1'
-  
-  # 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

@@ -1,103 +0,0 @@
-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'
-
-$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
-  break if ENV['LD_SKIP_DATABASE_TESTS'] == '1'
-
-  # 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

@@ -1,276 +0,0 @@
-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

data/spec/launchdarkly-server-sdk_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-require "bundler"
-
-describe LaunchDarkly do
-  it "can be automatically loaded by Bundler.require" do
-    ldclient_loaded =
-      Bundler.with_unbundled_env do
-        Kernel.system("ruby", "./spec/launchdarkly-server-sdk_spec_autoloadtest.rb")
-      end
-
-    expect(ldclient_loaded).to be true
-  end
-end

data/spec/launchdarkly-server-sdk_spec_autoloadtest.rb

@@ -1,9 +0,0 @@
-require "bundler/setup"
-require "bundler/inline"
-
-gemfile do
-  gem "launchdarkly-server-sdk", path: "."
-end
-
-Bundler.require(:development)
-abort unless $LOADED_FEATURES.any? { |file| file =~ /ldclient-rb\.rb/ }

data/spec/ldclient_end_to_end_spec.rb

@@ -1,157 +0,0 @@
-require "http_util"
-require "spec_helper"
-
-
-SDK_KEY = "sdk-key"
-
-USER = { key: 'userkey' }
-
-ALWAYS_TRUE_FLAG = { key: 'flagkey', version: 1, on: false, offVariation: 1, variations: [ false, true ] }
-DATA_WITH_ALWAYS_TRUE_FLAG = {
-  flags: { ALWAYS_TRUE_FLAG[:key  ].to_sym => ALWAYS_TRUE_FLAG },
-  segments: {}
-}
-PUT_EVENT_WITH_ALWAYS_TRUE_FLAG = "event: put\ndata:{\"data\":#{DATA_WITH_ALWAYS_TRUE_FLAG.to_json}}\n\n'"
-
-def with_client(config)
-  client = LaunchDarkly::LDClient.new(SDK_KEY, config)
-  begin
-    yield client
-  ensure
-    client.close
-  end
-end
-
-module LaunchDarkly
-  # Note that we can't do end-to-end tests in streaming mode until we have a test server that can do streaming
-  # responses, which is difficult in WEBrick.
-
-  describe "LDClient end-to-end" do
-    it "starts in polling mode" do
-      with_server do |poll_server|
-        poll_server.setup_ok_response("/sdk/latest-all", DATA_WITH_ALWAYS_TRUE_FLAG.to_json, "application/json")
-        
-        config = Config.new(
-          stream: false,
-          base_uri: poll_server.base_uri.to_s,
-          send_events: false,
-          logger: NullLogger.new
-        )
-        with_client(config) do |client|
-          expect(client.initialized?).to be true
-          expect(client.variation(ALWAYS_TRUE_FLAG[:key], USER, false)).to be true
-        end
-      end
-    end
-
-    it "fails in polling mode with 401 error" do
-      with_server do |poll_server|
-        poll_server.setup_status_response("/sdk/latest-all", 401)
-        
-        config = Config.new(
-          stream: false,
-          base_uri: poll_server.base_uri.to_s,
-          send_events: false,
-          logger: NullLogger.new
-        )
-        with_client(config) do |client|
-          expect(client.initialized?).to be false
-          expect(client.variation(ALWAYS_TRUE_FLAG[:key], USER, false)).to be false
-        end
-      end
-    end
-
-    it "sends event without diagnostics" do
-      with_server do |poll_server|
-        with_server do |events_server|
-          events_server.setup_ok_response("/bulk", "")
-          poll_server.setup_ok_response("/sdk/latest-all", '{"flags":{},"segments":{}}', "application/json")
-          
-          config = Config.new(
-            stream: false,
-            base_uri: poll_server.base_uri.to_s,
-            events_uri: events_server.base_uri.to_s,
-            diagnostic_opt_out: true,
-            logger: NullLogger.new
-          )
-          with_client(config) do |client|
-            client.identify(USER)
-            client.flush
-
-            req, body = events_server.await_request_with_body
-            expect(req.header['authorization']).to eq [ SDK_KEY ]
-            expect(req.header['connection']).to eq [ "Keep-Alive" ]
-            data = JSON.parse(body)
-            expect(data.length).to eq 1
-            expect(data[0]["kind"]).to eq "identify"
-          end
-        end
-      end
-    end
-
-    it "sends diagnostic event" do
-      with_server do |poll_server|
-        with_server do |events_server|
-          events_server.setup_ok_response("/bulk", "")
-          events_server.setup_ok_response("/diagnostic", "")
-          poll_server.setup_ok_response("/sdk/latest-all", '{"flags":{},"segments":{}}', "application/json")
-          
-          config = Config.new(
-            stream: false,
-            base_uri: poll_server.base_uri.to_s,
-            events_uri: events_server.base_uri.to_s,
-            logger: NullLogger.new
-          )
-          with_client(config) do |client|
-            user = { key: 'userkey' }
-            client.identify(user)
-            client.flush
-
-            req0, body0 = events_server.await_request_with_body
-            req1, body1 = events_server.await_request_with_body
-            req = req0.path == "/diagnostic" ? req0 : req1
-            body = req0.path == "/diagnostic" ? body0 : body1
-            expect(req.header['authorization']).to eq [ SDK_KEY ]
-            expect(req.header['connection']).to eq [ "Keep-Alive" ]
-            data = JSON.parse(body)
-            expect(data["kind"]).to eq "diagnostic-init"
-          end
-        end
-      end
-    end
-
-    it "can use socket factory" do
-      with_server do |poll_server|
-        with_server do |events_server|
-          events_server.setup_ok_response("/bulk", "")
-          poll_server.setup_ok_response("/sdk/latest-all", '{"flags":{},"segments":{}}', "application/json")
-          
-          config = Config.new(
-            stream: false,
-            base_uri: "http://polling.com",
-            events_uri: "http://events.com",
-            diagnostic_opt_out: true,
-            logger: NullLogger.new,
-            socket_factory: SocketFactoryFromHash.new({
-              "polling.com" => poll_server.port,
-              "events.com" => events_server.port  
-            })
-          )
-          with_client(config) do |client|
-            client.identify(USER)
-            client.flush
-
-            req, body = events_server.await_request_with_body
-            expect(req.header['authorization']).to eq [ SDK_KEY ]
-            expect(req.header['connection']).to eq [ "Keep-Alive" ]
-            data = JSON.parse(body)
-            expect(data.length).to eq 1
-            expect(data[0]["kind"]).to eq "identify"
-          end
-        end
-      end
-    end
-
-    # TODO: TLS tests with self-signed cert
-  end
-end