prefab-cloud-ruby 0.24.5 → 1.0.0

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_integration.rb

@@ -25,11 +25,13 @@ class TestIntegration < Minitest::Test
               assert_match(/#{it.expected[:message]}/, err.message)
             when :nil
               assert_nil it.test_client.send(it.func, *it.input)
-            when :feature_flag
-              flag, context = *it.input
-              assert_equal it.expected[:value], it.test_client.send(it.func, flag, context)
             when :simple_equality
-              assert_equal it.expected[:value], it.test_client.send(it.func, *it.input)
+              if it.func == :enabled?
+                flag, _default, context = *it.input
+                assert_equal it.expected[:value], it.test_client.send(it.func, flag, context)
+              else
+                assert_equal it.expected[:value], it.test_client.send(it.func, *it.input)
+              end
             when :log_level
               assert_equal it.expected[:value].to_sym, it.test_client.send(it.func, *it.input)
             else

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_log_path_aggregator.rb

@@ -8,7 +8,8 @@ class TestLogPathAggregator < Minitest::Test
   SLEEP_TIME = 0.01
 
   def test_push
-    aggregator = Prefab::LogPathAggregator.new(client: new_client, max_paths: 2, sync_interval: 1000)
+    client = new_client
+    aggregator = Prefab::LogPathAggregator.new(client: client, max_paths: 2, sync_interval: 1000)
 
     aggregator.push('test.test_log_path_aggregator.test_push.1', ::Logger::INFO)
     aggregator.push('test.test_log_path_aggregator.test_push.2', ::Logger::DEBUG)
@@ -18,6 +19,8 @@ class TestLogPathAggregator < Minitest::Test
     # we've reached the limit, so no more
     aggregator.push('test.test_log_path_aggregator.test_push.3', ::Logger::INFO)
     assert_equal 2, aggregator.data.size
+
+    assert_only_expected_logs
   end
 
   def test_sync
@@ -42,6 +45,11 @@ class TestLogPathAggregator < Minitest::Test
           namespace: 'this.is.a.namespace'
         )
       ]], requests
+
+      assert_logged [
+        'WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client No success loading checkpoints',
+        'ERROR 2023-08-09 15:18:12 -0400: test.test_log_path_aggregator.test_sync here is a message'
+      ]
     end
   end
 

data/test/test_logger.rb

@@ -19,6 +19,7 @@ class TestLogger < Minitest::Test
   )
 
   def setup
+    super
     Prefab::LoggerClient.send(:public, :get_path)
     Prefab::LoggerClient.send(:public, :get_loc_path)
     Prefab::LoggerClient.send(:public, :level_of)
@@ -65,20 +66,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

@@ -36,9 +36,40 @@ class TestOptions < Minitest::Test
     assert_equal 0, options.collect_max_paths
   end
 
-  def test_collect_max_paths_with_collect_logs_false
+  def test_collect_max_paths_with_collect_logger_counts_false
     options = Prefab::Options.new(collect_max_paths: 100,
-                                  collect_logs: false)
+                                  collect_logger_counts: false)
     assert_equal 0, options.collect_max_paths
   end
+
+  def test_collect_max_evaluation_summaries
+    assert_equal 100_000, Prefab::Options.new.collect_max_evaluation_summaries
+    assert_equal 0, Prefab::Options.new(collect_evaluation_summaries: false).collect_max_evaluation_summaries
+    assert_equal 3,
+                 Prefab::Options.new(collect_max_evaluation_summaries: 3).collect_max_evaluation_summaries
+  end
+
+  def test_context_upload_mode_periodic
+    options = Prefab::Options.new(context_upload_mode: :periodic_example, context_max_size: 100)
+    assert_equal 100, options.collect_max_example_contexts
+
+    options = Prefab::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_example_contexts
+  end
+
+  def test_context_upload_mode_shape_only
+    options = Prefab::Options.new(context_upload_mode: :shape_only, context_max_size: 100)
+    assert_equal 100, options.collect_max_shapes
+
+    options = Prefab::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_shapes
+  end
+
+  def test_context_upload_mode_none
+    options = Prefab::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_example_contexts
+
+    options = Prefab::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_shapes
+  end
 end