launchdarkly-server-sdk 5.5.7

data/spec/ldclient_spec.rb

@@ -0,0 +1,471 @@
+require "spec_helper"
+
+
+describe LaunchDarkly::LDClient do
+  subject { LaunchDarkly::LDClient }
+  let(:offline_config) { LaunchDarkly::Config.new({offline: true}) }
+  let(:offline_client) do
+    subject.new("secret", offline_config)
+  end
+  let(:null_data) { LaunchDarkly::NullUpdateProcessor.new }
+  let(:logger) { double().as_null_object }
+  let(:config) { LaunchDarkly::Config.new({ send_events: false, data_source: null_data, logger: logger }) }
+  let(:client) do
+    subject.new("secret", config)
+  end
+  let(:feature) do
+    data = File.read(File.join("spec", "fixtures", "feature.json"))
+    JSON.parse(data, symbolize_names: true)
+  end
+  let(:user) do
+    {
+      key: "user@test.com",
+      custom: {
+          groups: [ "microsoft", "google" ]
+      }
+    }
+  end
+  let(:user_without_key) do
+    { name: "Keyless Joe" }
+  end
+
+  def event_processor
+    client.instance_variable_get(:@event_processor)
+  end
+
+  describe '#variation' do
+    feature_with_value = { key: "key", on: false, offVariation: 0, variations: ["value"], version: 100,
+      trackEvents: true, debugEventsUntilDate: 1000 }
+
+    it "returns the default value if the client is offline" do
+      result = offline_client.variation("doesntmatter", user, "default")
+      expect(result).to eq "default"
+    end
+
+    it "returns the default value for an unknown feature" do
+      expect(client.variation("badkey", user, "default")).to eq "default"
+    end
+
+    it "queues a feature request event for an unknown feature" do
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature", key: "badkey", user: user, value: "default", default: "default"
+      ))
+      client.variation("badkey", user, "default")
+    end
+
+    it "returns the value for an existing feature" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(client.variation("key", user, "default")).to eq "value"
+    end
+
+    it "returns the default value if a feature evaluates to nil" do
+      empty_feature = { key: "key", on: false, offVariation: nil }
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, empty_feature)
+      expect(client.variation("key", user, "default")).to eq "default"
+    end
+
+    it "queues a feature request event for an existing feature" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature",
+        key: "key",
+        version: 100,
+        user: user,
+        variation: 0,
+        value: "value",
+        default: "default",
+        trackEvents: true,
+        debugEventsUntilDate: 1000
+      ))
+      client.variation("key", user, "default")
+    end
+
+    it "queues a feature event for an existing feature when user is nil" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature",
+        key: "key",
+        version: 100,
+        user: nil,
+        variation: nil,
+        value: "default",
+        default: "default",
+        trackEvents: true,
+        debugEventsUntilDate: 1000
+      ))
+      client.variation("key", nil, "default")
+    end
+
+    it "queues a feature event for an existing feature when user key is nil" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      bad_user = { name: "Bob" }
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature",
+        key: "key",
+        version: 100,
+        user: bad_user,
+        variation: nil,
+        value: "default",
+        default: "default",
+        trackEvents: true,
+        debugEventsUntilDate: 1000
+      ))
+      client.variation("key", bad_user, "default")
+    end
+  end
+
+  describe '#variation_detail' do
+    feature_with_value = { key: "key", on: false, offVariation: 0, variations: ["value"], version: 100,
+      trackEvents: true, debugEventsUntilDate: 1000 }
+
+    it "returns the default value if the client is offline" do
+      result = offline_client.variation_detail("doesntmatter", user, "default")
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'ERROR', errorKind: 'CLIENT_NOT_READY' })
+      expect(result).to eq expected
+    end
+
+    it "returns the default value for an unknown feature" do
+      result = client.variation_detail("badkey", user, "default")
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'ERROR', errorKind: 'FLAG_NOT_FOUND'})
+      expect(result).to eq expected
+    end
+
+    it "queues a feature request event for an unknown feature" do
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature", key: "badkey", user: user, value: "default", default: "default",
+        reason: { kind: 'ERROR', errorKind: 'FLAG_NOT_FOUND' }
+      ))
+      client.variation_detail("badkey", user, "default")
+    end
+
+    it "returns a value for an existing feature" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      result = client.variation_detail("key", user, "default")
+      expected = LaunchDarkly::EvaluationDetail.new("value", 0, { kind: 'OFF' })
+      expect(result).to eq expected
+    end
+
+    it "returns the default value if a feature evaluates to nil" do
+      empty_feature = { key: "key", on: false, offVariation: nil }
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, empty_feature)
+      result = client.variation_detail("key", user, "default")
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'OFF' })
+      expect(result).to eq expected
+      expect(result.default_value?).to be true
+    end
+
+    it "queues a feature request event for an existing feature" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature",
+        key: "key",
+        version: 100,
+        user: user,
+        variation: 0,
+        value: "value",
+        default: "default",
+        trackEvents: true,
+        debugEventsUntilDate: 1000,
+        reason: { kind: "OFF" }
+      ))
+      client.variation_detail("key", user, "default")
+    end
+  end
+
+  describe '#all_flags' do
+    let(:flag1) { { key: "key1", offVariation: 0, variations: [ 'value1' ] } }
+    let(:flag2) { { key: "key2", offVariation: 0, variations: [ 'value2' ] } }
+
+    it "returns flag values" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })
+
+      result = client.all_flags({ key: 'userkey' })
+      expect(result).to eq({ 'key1' => 'value1', 'key2' => 'value2' })
+    end
+
+    it "returns empty map for nil user" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })
+
+      result = client.all_flags(nil)
+      expect(result).to eq({})
+    end
+
+    it "returns empty map for nil user key" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })
+
+      result = client.all_flags({})
+      expect(result).to eq({})
+    end
+
+    it "returns empty map if offline" do
+      offline_config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })
+
+      result = offline_client.all_flags(nil)
+      expect(result).to eq({})
+    end
+  end
+
+  describe '#all_flags_state' do
+    let(:flag1) { { key: "key1", version: 100, offVariation: 0, variations: [ 'value1' ], trackEvents: false } }
+    let(:flag2) { { key: "key2", version: 200, offVariation: 1, variations: [ 'x', 'value2' ], trackEvents: true, debugEventsUntilDate: 1000 } }
+
+    it "returns flags state" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })
+
+      state = client.all_flags_state({ key: 'userkey' })
+      expect(state.valid?).to be true
+
+      values = state.values_map
+      expect(values).to eq({ 'key1' => 'value1', 'key2' => 'value2' })
+      
+      result = state.as_json
+      expect(result).to eq({
+        'key1' => 'value1',
+        'key2' => 'value2',
+        '$flagsState' => {
+          'key1' => {
+            :variation => 0,
+            :version => 100
+          },
+          'key2' => {
+            :variation => 1,
+            :version => 200,
+            :trackEvents => true,
+            :debugEventsUntilDate => 1000
+          }
+        },
+        '$valid' => true
+      })
+    end
+
+    it "can be filtered for only client-side flags" do
+      flag1 = { key: "server-side-1", offVariation: 0, variations: [ 'a' ], clientSide: false }
+      flag2 = { key: "server-side-2", offVariation: 0, variations: [ 'b' ], clientSide: false }
+      flag3 = { key: "client-side-1", offVariation: 0, variations: [ 'value1' ], clientSide: true }
+      flag4 = { key: "client-side-2", offVariation: 0, variations: [ 'value2' ], clientSide: true }
+      config.feature_store.init({ LaunchDarkly::FEATURES => {
+        flag1[:key] => flag1, flag2[:key] => flag2, flag3[:key] => flag3, flag4[:key] => flag4
+      }})
+
+      state = client.all_flags_state({ key: 'userkey' }, client_side_only: true)
+      expect(state.valid?).to be true
+
+      values = state.values_map
+      expect(values).to eq({ 'client-side-1' => 'value1', 'client-side-2' => 'value2' })
+    end
+
+    it "can omit details for untracked flags" do
+      future_time = (Time.now.to_f * 1000).to_i + 100000
+      flag1 = { key: "key1", version: 100, offVariation: 0, variations: [ 'value1' ], trackEvents: false }
+      flag2 = { key: "key2", version: 200, offVariation: 1, variations: [ 'x', 'value2' ], trackEvents: true }
+      flag3 = { key: "key3", version: 300, offVariation: 1, variations: [ 'x', 'value3' ], debugEventsUntilDate: future_time }
+
+      config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2, 'key3' => flag3 } })
+
+      state = client.all_flags_state({ key: 'userkey' }, { details_only_for_tracked_flags: true })
+      expect(state.valid?).to be true
+
+      values = state.values_map
+      expect(values).to eq({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3' })
+      
+      result = state.as_json
+      expect(result).to eq({
+        'key1' => 'value1',
+        'key2' => 'value2',
+        'key3' => 'value3',
+        '$flagsState' => {
+          'key1' => {
+            :variation => 0
+          },
+          'key2' => {
+            :variation => 1,
+            :version => 200,
+            :trackEvents => true
+          },
+          'key3' => {
+            :variation => 1,
+            :version => 300,
+            :debugEventsUntilDate => future_time
+          }
+        },
+        '$valid' => true
+      })
+    end
+
+    it "returns empty state for nil user" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })
+
+      state = client.all_flags_state(nil)
+      expect(state.valid?).to be false
+      expect(state.values_map).to eq({})
+    end
+
+    it "returns empty state for nil user key" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })
+
+      state = client.all_flags_state({})
+      expect(state.valid?).to be false
+      expect(state.values_map).to eq({})
+    end
+
+    it "returns empty state if offline" do
+      offline_config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })
+
+      state = offline_client.all_flags_state({ key: 'userkey' })
+      expect(state.valid?).to be false
+      expect(state.values_map).to eq({})
+    end
+  end
+
+  describe '#secure_mode_hash' do
+    it "will return the expected value for a known message and secret" do
+      result = client.secure_mode_hash({key: :Message})
+      expect(result).to eq "aa747c502a898200f9e4fa21bac68136f886a0e27aec70ba06daf2e2a5cb5597"
+    end
+  end
+
+  describe '#track' do 
+    it "queues up an custom event" do
+      expect(event_processor).to receive(:add_event).with(hash_including(kind: "custom", key: "custom_event_name", user: user, data: 42))
+      client.track("custom_event_name", user, 42)
+    end
+
+    it "does not send an event, and logs a warning, if user is nil" do
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:warn)
+      client.track("custom_event_name", nil, nil)
+    end
+
+    it "does not send an event, and logs a warning, if user key is nil" do
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:warn)
+      client.track("custom_event_name", user_without_key, nil)
+    end
+  end
+
+  describe '#identify' do 
+    it "queues up an identify event" do
+      expect(event_processor).to receive(:add_event).with(hash_including(kind: "identify", key: user[:key], user: user))
+      client.identify(user)
+    end
+
+    it "does not send an event, and logs a warning, if user is nil" do
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:warn)
+      client.identify(nil)
+    end
+
+    it "does not send an event, and logs a warning, if user key is nil" do
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:warn)
+      client.identify(user_without_key)
+    end
+  end
+
+  describe 'with send_events: false' do
+    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
+      ep = client.instance_variable_get(:@event_processor)
+      expect(ep).to be_a(LaunchDarkly::NullEventProcessor)
+    end
+  end
+
+  describe 'with send_events: true' do
+    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
+      ep = client_with_events.instance_variable_get(:@event_processor)
+      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