prefab-cloud-ruby 0.24.4 → 0.24.6

data/test/test_evaluation_summary_aggregator.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestEvaluationSummaryAggregator < Minitest::Test
+  EFFECTIVELY_NEVER = 99_999 # we sync manually
+
+  EXAMPLE_VALUE_1 = PrefabProto::ConfigValue.new(bool: true)
+  EXAMPLE_VALUE_2 = PrefabProto::ConfigValue.new(bool: false)
+
+  EXAMPLE_COUNTER = {
+    config_id: 1,
+    selected_index: 2,
+    config_row_index: 3,
+    conditional_value_index: 4,
+    weighted_value_index: 5,
+    seleced_value: EXAMPLE_VALUE_1
+  }.freeze
+
+  def test_increments_counts
+    aggregator = Prefab::EvaluationSummaryAggregator.new(client: MockBaseClient.new, max_keys: 10,
+                                                         sync_interval: EFFECTIVELY_NEVER)
+
+    aggregator.record(config_key: 'foo', config_type: 'bar', counter: EXAMPLE_COUNTER)
+
+    assert_equal 1, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+
+    2.times { aggregator.record(config_key: 'foo', config_type: 'bar', counter: EXAMPLE_COUNTER) }
+    assert_equal 3, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+
+    another_counter = EXAMPLE_COUNTER.merge(selected_index: EXAMPLE_COUNTER[:selected_index] + 1)
+
+    aggregator.record(config_key: 'foo', config_type: 'bar', counter: another_counter)
+    assert_equal 3, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+    assert_equal 1, aggregator.data[%w[foo bar]][another_counter]
+  end
+
+  def test_prepare_data
+    aggregator = Prefab::EvaluationSummaryAggregator.new(client: MockBaseClient.new, max_keys: 10,
+                                                         sync_interval: EFFECTIVELY_NEVER)
+
+    expected = {
+      ['config-1', :CONFIG] => {
+        { config_id: 1, selected_index: 2, config_row_index: 3, conditional_value_index: 4,
+          weighted_value_index: 5, selected_value: EXAMPLE_VALUE_1 } => 3,
+        { config_id: 1, selected_index: 3, config_row_index: 7, conditional_value_index: 8,
+          weighted_value_index: 10, selected_value: EXAMPLE_VALUE_2 } => 1
+      },
+      ['config-2', :FEATURE_FLAG] => {
+        { config_id: 2, selected_index: 3, config_row_index: 5, conditional_value_index: 7,
+          weighted_value_index: 6, selected_value: EXAMPLE_VALUE_1 } => 9
+      }
+    }
+
+    add_example_data(aggregator)
+    assert_equal expected, aggregator.prepare_data
+    assert aggregator.data.empty?
+  end
+
+  def test_sync
+    awhile_ago = Time.now - 60
+    now = Time.now
+
+    client = MockBaseClient.new
+
+    aggregator = nil
+
+    Timecop.freeze(awhile_ago) do
+      # start the aggregator in the past
+      aggregator = Prefab::EvaluationSummaryAggregator.new(client: client, max_keys: 10,
+                                                           sync_interval: EFFECTIVELY_NEVER)
+    end
+
+    add_example_data(aggregator)
+
+    expected_post = PrefabProto::TelemetryEvents.new(
+      instance_hash: client.instance_hash,
+      events: [
+        PrefabProto::TelemetryEvent.new(
+          summaries:
+
+      PrefabProto::ConfigEvaluationSummaries.new(
+        start: awhile_ago.to_i * 1000,
+        end: now.to_i * 1000,
+        summaries: [
+          PrefabProto::ConfigEvaluationSummary.new(
+            key: 'config-1',
+            type: :CONFIG,
+            counters: [
+              PrefabProto::ConfigEvaluationCounter.new(
+                config_id: 1,
+                selected_index: 2,
+                config_row_index: 3,
+                conditional_value_index: 4,
+                weighted_value_index: 5,
+                selected_value: EXAMPLE_VALUE_1,
+                count: 3
+              ),
+              PrefabProto::ConfigEvaluationCounter.new(
+                config_id: 1,
+                selected_index: 3,
+                config_row_index: 7,
+                conditional_value_index: 8,
+                weighted_value_index: 10,
+                selected_value: EXAMPLE_VALUE_2,
+                count: 1
+              )
+            ]
+          ),
+          PrefabProto::ConfigEvaluationSummary.new(
+            key: 'config-2',
+            type: :FEATURE_FLAG,
+            counters: [
+              PrefabProto::ConfigEvaluationCounter.new(
+                config_id: 2,
+                selected_index: 3,
+                config_row_index: 5,
+                conditional_value_index: 7,
+                weighted_value_index: 6,
+                selected_value: EXAMPLE_VALUE_1,
+                count: 9
+              )
+            ]
+          )
+        ]
+      )
+        )
+      ]
+    )
+
+    requests = wait_for_post_requests(client) do
+      Timecop.freeze(now) do
+        aggregator.sync
+      end
+    end
+
+    assert_equal [[
+      '/api/v1/telemetry',
+      expected_post
+    ]], requests
+  end
+
+  private
+
+  def add_example_data(aggregator)
+    data = {
+      ['config-1', :CONFIG] => {
+        { config_id: 1, selected_index: 2, config_row_index: 3, conditional_value_index: 4,
+          weighted_value_index: 5, selected_value: EXAMPLE_VALUE_1 } => 3,
+        { config_id: 1, selected_index: 3, config_row_index: 7, conditional_value_index: 8,
+          weighted_value_index: 10, selected_value: EXAMPLE_VALUE_2 } => 1
+      },
+      ['config-2', :FEATURE_FLAG] => {
+        { config_id: 2, selected_index: 3, config_row_index: 5, conditional_value_index: 7,
+          weighted_value_index: 6, selected_value: EXAMPLE_VALUE_1 } => 9
+      }
+    }
+
+    aggregator.instance_variable_set('@data', data)
+  end
+end

data/test/test_example_contexts_aggregator.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestExampleContextsAggregator < Minitest::Test
+  EFFECTIVELY_NEVER = 99_999 # we sync manually
+
+  def test_record
+    aggregator = Prefab::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 2,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Prefab::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+
+    aggregator.record(context)
+    assert_equal [context], aggregator.data
+
+    # This doesn't get updated because we already have a context for this user/device
+    aggregator.record(context)
+    assert_equal [context], aggregator.data
+
+    new_context = Prefab::Context.new(
+      user: { key: 'ghi', admin: true },
+      team: { key: '999' }
+    )
+
+    aggregator.record(new_context)
+    assert_equal [context, new_context], aggregator.data
+
+    # this doesn't get recorded because we're at max_contexts
+    aggregator.record(Prefab::Context.new(user: { key: 'new' }))
+    assert_equal [context, new_context], aggregator.data
+  end
+
+  def test_prepare_data
+    aggregator = Prefab::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Prefab::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+
+    aggregator.record(context)
+
+    assert_equal [context], aggregator.prepare_data
+    assert aggregator.data.empty?
+  end
+
+  def test_record_with_expiry
+    aggregator = Prefab::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Prefab::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+
+    aggregator.record(context)
+
+    assert_equal [context], aggregator.data
+
+    Timecop.travel(Time.now + (60 * 60) - 1) do
+      aggregator.record(context)
+
+      # This doesn't get updated because we already have a context for this user/device in the timeframe
+      assert_equal [context], aggregator.data
+    end
+
+    Timecop.travel(Time.now + ((60 * 60) + 1)) do
+      # this is new because we've passed the expiry
+      aggregator.record(context)
+
+      assert_equal [context, context], aggregator.data
+    end
+  end
+
+  def test_sync
+    now = Time.now
+
+    client = MockBaseClient.new
+
+    aggregator = Prefab::ExampleContextsAggregator.new(client: client, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Prefab::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+    aggregator.record(context)
+
+    # This is the same as above so we shouldn't get anything new
+    aggregator.record(context)
+
+    aggregator.record(
+      Prefab::Context.new(
+        user: { key: 'ghi' },
+        device: { key: 'jkl', mobile: false }
+      )
+    )
+
+    aggregator.record(Prefab::Context.new(user: { key: 'kev', name: 'kevin', age: 48.5 }))
+
+    assert_equal 3, aggregator.cache.data.size
+
+    expected_post = PrefabProto::TelemetryEvents.new(
+      instance_hash: client.instance_hash,
+      events: [
+        PrefabProto::TelemetryEvent.new(
+          example_contexts: PrefabProto::ExampleContexts.new(
+            examples: [
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'abc')
+                      }
+                    ),
+                    PrefabProto::Context.new(
+                      type: 'device',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'def'),
+                        'mobile' => PrefabProto::ConfigValue.new(bool: true)
+                      }
+                    )
+                  ]
+                )
+              ),
+
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'ghi')
+                      }
+                    ),
+                    PrefabProto::Context.new(
+                      type: 'device',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'jkl'),
+                        'mobile' => PrefabProto::ConfigValue.new(bool: false)
+                      }
+                    )
+                  ]
+                )
+              ),
+
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'kev'),
+                        'name' => PrefabProto::ConfigValue.new(string: 'kevin'),
+                        'age' => PrefabProto::ConfigValue.new(double: 48.5)
+                      }
+                    )
+                  ]
+                )
+              )
+            ]
+          )
+        )
+      ]
+    )
+
+    requests = wait_for_post_requests(client) do
+      Timecop.freeze(now + (60 * 60) - 1) do
+        aggregator.sync
+      end
+    end
+
+    assert_equal [[
+      '/api/v1/telemetry',
+      expected_post
+    ]], requests
+
+    # this hasn't changed because not enough time has passed
+    assert_equal 3, aggregator.cache.data.size
+
+    # a sync past the expiry should clear the cache
+    Timecop.freeze(now + (60 * 60) + 1) do
+      # we need a new piece of data for the sync to happen
+      aggregator.record(Prefab::Context.new(user: { key: 'bozo', name: 'Bozo', age: 99 }))
+
+      requests = wait_for_post_requests(client) do
+        aggregator.sync
+      end
+    end
+
+    expected_post = PrefabProto::TelemetryEvents.new(
+      instance_hash: client.instance_hash,
+      events: [
+        PrefabProto::TelemetryEvent.new(
+          example_contexts: PrefabProto::ExampleContexts.new(
+            examples: [
+              PrefabProto::ExampleContext.new(
+                timestamp: (now.utc.to_i + (60 * 60) + 1) * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'bozo'),
+                        'name' => PrefabProto::ConfigValue.new(string: 'Bozo'),
+                        'age' => PrefabProto::ConfigValue.new(int: 99)
+                      }
+                    )
+                  ]
+                )
+              )
+            ]
+          )
+        )
+      ]
+    )
+
+    assert_equal [[
+      '/api/v1/telemetry',
+      expected_post
+    ]], requests
+
+    # The last sync should have cleared the cache of everything except the latest context
+    assert_equal 1, aggregator.cache.data.size
+    assert_equal ['user:bozo'], aggregator.cache.data.keys
+  end
+end

data/test/test_helper.rb

@@ -7,137 +7,11 @@ Minitest::Reporters.use!
 
 require 'prefab-cloud-ruby'
 
-class MockBaseClient
-  STAGING_ENV_ID = 1
-  PRODUCTION_ENV_ID = 2
-  TEST_ENV_ID = 3
-  attr_reader :namespace
-  attr_reader :logger
-  attr_reader :config_client
-  attr_reader :options
-
-  def initialize(options = Prefab::Options.new)
-    @options = options
-    @namespace = namespace
-    @logger = Prefab::LoggerClient.new($stdout)
-    @config_client = MockConfigClient.new
-  end
-
-  def project_id
-    1
-  end
-
-  def log
-    @logger
-  end
-
-  def log_internal(level, message); end
-
-  def context_shape_aggregator; end
-
-  def evaluated_keys_aggregator; end
-
-  def evaluated_configs_aggregator; end
-
-  def config_value(key)
-    @config_values[key]
-  end
-end
-
-class MockConfigClient
-  def initialize(config_values = {})
-    @config_values = config_values
-  end
-
-  def get(key, default = nil)
-    @config_values.fetch(key, default)
-  end
-
-  def get_config(key)
-    PrefabProto::Config.new(value: @config_values[key], key: key)
-  end
-
-  def mock_this_config(key, config_value)
-    @config_values[key] = config_value
-  end
-end
-
-class MockConfigLoader
-  def calc_config; end
-end
-
-private
-
-def default_ff_rule(variant_idx)
-  [
-    Prefab::Rule.new(
-      criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
-      variant_weights: [
-        Prefab::VariantWeight.new(weight: 1000,
-                                  variant_idx: variant_idx)
-      ]
-    )
-  ]
-end
-
-def with_env(key, value, &block)
-  old_value = ENV[key]
-
-  ENV[key] = value
-  block.call
-ensure
-  ENV[key] = old_value
-end
-
-def new_client(overrides = {})
-  options = Prefab::Options.new(**{
-    prefab_config_override_dir: 'none',
-    prefab_config_classpath_dir: 'test',
-    prefab_envs: ['unit_tests'],
-    prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
-  }.merge(overrides))
-
-  Prefab::Client.new(options)
-end
-
-def string_list(values)
-  PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: values))
-end
-
-def inject_config(client, config)
-  resolver = client.config_client.instance_variable_get('@config_resolver')
-  store = resolver.instance_variable_get('@local_store')
-
-  store[config.key] = { config: config }
+Dir.glob(File.join(File.dirname(__FILE__), 'support', '**', '*.rb')).each do |file|
+  require file
 end
 
-def inject_project_env_id(client, project_env_id)
-  resolver = client.config_client.instance_variable_get('@config_resolver')
-  resolver.project_env_id = project_env_id
-end
-
-def wait_for_post_requests(client)
-  max_wait = 2
-  sleep_time = 0.01
-
-  requests = []
-
-  client.define_singleton_method(:post) do |*params|
-    requests.push(params)
-
-    OpenStruct.new(status: 200)
-  end
-
-  yield
-
-  # let the flush thread run
-  wait_time = 0
-  while requests.empty?
-    wait_time += sleep_time
-    sleep sleep_time
-
-    raise "Waited #{max_wait} seconds for the flush thread to run, but it never did" if wait_time > max_wait
-  end
-
-  requests
+MiniTest::Test.class_eval do
+  include CommonHelpers
+  extend CommonHelpers
 end

data/test/test_local_config_parser.rb

@@ -34,7 +34,7 @@ class TestLocalConfigParser < Minitest::Test
     assert_equal 1, config.rows[0].values.size
 
     value_row = config.rows[0].values[0]
-    assert_equal 'all-features', Prefab::ConfigValueUnwrapper.unwrap(value_row.value, key, {})
+    assert_equal 'all-features', Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, key, {}).unwrap
   end
 
   def test_flag_in_user_key
@@ -53,7 +53,7 @@ class TestLocalConfigParser < Minitest::Test
     assert_equal 1, config.rows[0].values[0].criteria.size
 
     value_row = config.rows[0].values[0]
-    assert_equal true, Prefab::ConfigValueUnwrapper.unwrap(value_row.value, key, {})
+    assert_equal true, Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, key, {}).unwrap
 
     assert_equal 'user.key', value_row.criteria[0].property_name
     assert_equal :PROP_IS_ONE_OF, value_row.criteria[0].operator

data/test/test_logger.rb

@@ -65,20 +65,20 @@ class TestLogger < Minitest::Test
       assert_equal ::Logger::INFO,
                    @logger.level_of('app.models.user'), 'PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL is info'
 
-      @logger.set_config_client(MockConfigClient.new({}))
+      @logger.config_client = MockConfigClient.new({})
       assert_equal ::Logger::WARN,
                    @logger.level_of('app.models.user'), 'default is warn'
 
-      @logger.set_config_client(MockConfigClient.new('log-level.app' => :INFO))
+      @logger.config_client = MockConfigClient.new('log-level.app' => :INFO)
       assert_equal ::Logger::INFO,
                    @logger.level_of('app.models.user')
 
-      @logger.set_config_client(MockConfigClient.new('log-level.app' => :DEBUG))
+      @logger.config_client = MockConfigClient.new('log-level.app' => :DEBUG)
       assert_equal ::Logger::DEBUG,
                    @logger.level_of('app.models.user')
 
-      @logger.set_config_client(MockConfigClient.new('log-level.app' => :DEBUG,
-                                                     'log-level.app.models' => :ERROR))
+      @logger.config_client = MockConfigClient.new('log-level.app' => :DEBUG,
+                                                   'log-level.app.models' => :ERROR)
       assert_equal ::Logger::ERROR,
                    @logger.level_of('app.models.user'), 'test leveling'
     end

data/test/test_options.rb

@@ -41,4 +41,12 @@ class TestOptions < Minitest::Test
                                   collect_logs: false)
     assert_equal 0, options.collect_max_paths
   end
+
+  def test_collect_max_evaluation_summaries
+    assert_equal 0, Prefab::Options.new.collect_max_evaluation_summaries
+    assert_equal 100_000, Prefab::Options.new(collect_evaluation_summaries: true).collect_max_evaluation_summaries
+    assert_equal 3,
+                 Prefab::Options.new(collect_evaluation_summaries: true,
+                                     collect_max_evaluation_summaries: 3).collect_max_evaluation_summaries
+  end
 end

data/test/test_rate_limit_cache.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class RateLimitCacheTest < Minitest::Test
+  def test_set_and_fresh
+    cache = Prefab::RateLimitCache.new(5)
+    cache.set('key')
+    assert cache.fresh?('key')
+  end
+
+  def test_fresh_with_no_set
+    cache = Prefab::RateLimitCache.new(5)
+    refute cache.fresh?('key')
+  end
+
+  def test_get_after_expiration
+    cache = Prefab::RateLimitCache.new(5)
+
+    Timecop.freeze(Time.now - 6) do
+      cache.set('key')
+      assert cache.fresh?('key')
+    end
+
+    refute cache.fresh?('key')
+
+    # but the data is still there
+    assert cache.data.get('key')
+  end
+
+  def test_prune
+    cache = Prefab::RateLimitCache.new(5)
+
+    Timecop.freeze(Time.now - 6) do
+      cache.set('key')
+      assert cache.fresh?('key')
+    end
+
+    cache.prune
+
+    refute cache.fresh?('key')
+  end
+end

data/test/test_weighted_value_resolver.rb

@@ -8,30 +8,36 @@ class TestWeightedValueResolver < Minitest::Test
   def test_resolving_single_value
     values = weighted_values([['abc', 1]])
     resolver = Prefab::WeightedValueResolver.new(values, KEY, nil)
-    assert_equal 'abc', resolver.resolve.value.string
+    assert_equal 'abc', resolver.resolve[0].value.string
+    assert_equal 0, resolver.resolve[1]
   end
 
   def test_resolving_multiple_values_evenly_distributed
     values = weighted_values([['abc', 1], ['def', 1]])
 
     resolver = Prefab::WeightedValueResolver.new(values, KEY, 'user:001')
-    assert_equal 'abc', resolver.resolve.value.string
+    assert_equal 'abc', resolver.resolve[0].value.string
+    assert_equal 0, resolver.resolve[1]
 
     resolver = Prefab::WeightedValueResolver.new(values, KEY, 'user:456')
-    assert_equal 'def', resolver.resolve.value.string
+    assert_equal 'def', resolver.resolve[0].value.string
+    assert_equal 1, resolver.resolve[1]
   end
 
   def test_resolving_multiple_values_unevenly_distributed
     values = weighted_values([['abc', 1], ['def', 98], ['ghi', 1]])
 
     resolver = Prefab::WeightedValueResolver.new(values, KEY, 'user:456')
-    assert_equal 'def', resolver.resolve.value.string
+    assert_equal 'def', resolver.resolve[0].value.string
+    assert_equal 1, resolver.resolve[1]
 
     resolver = Prefab::WeightedValueResolver.new(values, KEY, 'user:103')
-    assert_equal 'ghi', resolver.resolve.value.string
+    assert_equal 'ghi', resolver.resolve[0].value.string
+    assert_equal 2, resolver.resolve[1]
 
     resolver = Prefab::WeightedValueResolver.new(values, KEY, 'user:119')
-    assert_equal 'abc', resolver.resolve.value.string
+    assert_equal 'abc', resolver.resolve[0].value.string
+    assert_equal 0, resolver.resolve[1]
   end
 
   def test_resolving_multiple_values_with_simulation
@@ -39,7 +45,7 @@ class TestWeightedValueResolver < Minitest::Test
     results = {}
 
     10_000.times do |i|
-      result = Prefab::WeightedValueResolver.new(values, KEY, "user:#{i}").resolve.value.string
+      result = Prefab::WeightedValueResolver.new(values, KEY, "user:#{i}").resolve[0].value.string
       results[result] ||= 0
       results[result] += 1
     end