prefab-cloud-ruby 0.24.2 → 0.24.4

data/test/test_evaluated_configs_aggregator.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestEvaluatedConfigsAggregator < Minitest::Test
+  MAX_WAIT = 2
+  SLEEP_TIME = 0.01
+
+  def test_push
+    aggregator = Prefab::EvaluatedConfigsAggregator.new(client: new_client, max_configs: 2, sync_interval: 1000)
+
+    aggregator.push([])
+    aggregator.push([])
+
+    assert_equal 2, aggregator.data.size
+
+    # we've reached the limit, so no more
+    aggregator.push([])
+    assert_equal 2, aggregator.data.size
+  end
+
+  def test_coerce_to_proto
+    aggregator = Prefab::EvaluatedConfigsAggregator.new(client: new_client, max_configs: 2, sync_interval: 2)
+
+    Timecop.freeze do
+      coerced = aggregator.coerce_to_proto([
+                                             CONFIG_1,
+                                             DESIRED_VALUE,
+                                             Prefab::Context.new(CONTEXT)
+                                           ])
+
+      assert_equal PrefabProto::EvaluatedConfig.new(
+        key: CONFIG_1.key,
+        config_version: CONFIG_1.id,
+        result: DESIRED_VALUE,
+        context: PrefabProto::ContextSet.new(
+          contexts: [
+            PrefabProto::Context.new(
+              type: "user",
+              values: {
+                "id" => PrefabProto::ConfigValue.new(int: 1),
+                "email_suffix" => PrefabProto::ConfigValue.new(string: "hotmail.com")
+              }
+            ),
+            PrefabProto::Context.new(
+              type: "team",
+              values: {
+                "id" => PrefabProto::ConfigValue.new(int: 2),
+                "name" => PrefabProto::ConfigValue.new(string: "team-name")
+              }
+            ),
+            PrefabProto::Context.new(
+              type: "prefab",
+              values: {
+                "current-time" => PrefabProto::ConfigValue.new(int: Prefab::TimeHelpers.now_in_ms),
+              }
+            ),
+          ]
+        ),
+        timestamp: Prefab::TimeHelpers.now_in_ms
+      ), coerced
+    end
+  end
+
+  def test_sync
+    client = new_client(namespace: 'this.is.a.namespace')
+
+    inject_config(client, CONFIG_1)
+    inject_config(client, CONFIG_2)
+    inject_project_env_id(client, PROJECT_ENV_ID)
+
+    client.get CONFIG_1.key, 'default', CONTEXT
+    client.get CONFIG_1.key, 'default', { user: { email_suffix: "example.com" }, device: { mobile: true } }
+    client.get CONFIG_2.key, 'default', CONTEXT
+
+    # logger items are not reported
+    client.get "#{Prefab::ConfigClient::LOGGING_KEY_PREFIX}something", 'default', CONTEXT
+    client.get "#{Prefab::LoggerClient::BASE_KEY}", 'default', CONTEXT
+
+    requests = wait_for_post_requests(client) do
+      client.evaluated_configs_aggregator.send(:sync)
+    end
+
+    assert_equal [[
+      '/api/v1/evaluated-configs',
+      PrefabProto::EvaluatedConfigs.new(
+        configs: [
+          PrefabProto::EvaluatedConfig.new(
+            key: CONFIG_1.key,
+            config_version: CONFIG_1.id,
+            result: DESIRED_VALUE,
+            context: PrefabProto::ContextSet.new(
+              contexts: [
+                PrefabProto::Context.new(
+                  type: "user",
+                  values: {
+                    "id" => PrefabProto::ConfigValue.new(int: 1),
+                    "email_suffix" => PrefabProto::ConfigValue.new(string: "hotmail.com")
+                  }
+                ),
+                PrefabProto::Context.new(
+                  type: "team",
+                  values: {
+                    "id" => PrefabProto::ConfigValue.new(int: 2),
+                    "name" => PrefabProto::ConfigValue.new(string: "team-name")
+                  }
+                ),
+                PrefabProto::Context.new(
+                  type: "prefab",
+                  values: {
+                    "current-time" => PrefabProto::ConfigValue.new(int: Prefab::TimeHelpers.now_in_ms),
+                    "namespace" => PrefabProto::ConfigValue.new(string: "this.is.a.namespace"),
+                  }
+                ),
+              ]
+            ),
+            timestamp: Prefab::TimeHelpers.now_in_ms
+          ),
+          PrefabProto::EvaluatedConfig.new(
+            key: CONFIG_1.key,
+            config_version: CONFIG_1.id,
+            result: DEFAULT_VALUE,
+            context: PrefabProto::ContextSet.new(
+              contexts: [
+                PrefabProto::Context.new(
+                  type: "user",
+                  values: {
+                    "email_suffix" => PrefabProto::ConfigValue.new(string: "example.com")
+                  }
+                ),
+                PrefabProto::Context.new(
+                  type: "device",
+                  values: {
+                    "mobile" => PrefabProto::ConfigValue.new(bool: true),
+                  }
+                ),
+                PrefabProto::Context.new(
+                  type: "prefab",
+                  values: {
+                    "current-time" => PrefabProto::ConfigValue.new(int: Prefab::TimeHelpers.now_in_ms),
+                    "namespace" => PrefabProto::ConfigValue.new(string: "this.is.a.namespace"),
+                  }
+                )
+
+              ]
+            ),
+            timestamp: Prefab::TimeHelpers.now_in_ms
+          ),
+
+          PrefabProto::EvaluatedConfig.new(
+            key: CONFIG_2.key,
+            config_version: CONFIG_2.id,
+            result: DEFAULT_VALUE,
+            context: PrefabProto::ContextSet.new(
+              contexts: [
+                PrefabProto::Context.new(
+                  type: "user",
+                  values: {
+                    "id" => PrefabProto::ConfigValue.new(int: 1),
+                    "email_suffix" => PrefabProto::ConfigValue.new(string: "hotmail.com")
+                  }
+                ),
+                PrefabProto::Context.new(
+                  type: "team",
+                  values: {
+                    "id" => PrefabProto::ConfigValue.new(int: 2),
+                    "name" => PrefabProto::ConfigValue.new(string: "team-name")
+                  }
+                ),
+                PrefabProto::Context.new(
+                  type: "prefab",
+                  values: {
+                    "current-time" => PrefabProto::ConfigValue.new(int: Prefab::TimeHelpers.now_in_ms),
+                    "namespace" => PrefabProto::ConfigValue.new(string: "this.is.a.namespace"),
+                  }
+                )
+              ]
+            ),
+            timestamp: Prefab::TimeHelpers.now_in_ms
+          )
+
+        ]
+      )
+    ]], requests
+  end
+
+  private
+
+  def new_client(overrides = {})
+    super(**{
+      prefab_datasources: Prefab::Options::DATASOURCES::ALL,
+      initialization_timeout_sec: 0,
+      on_init_failure: Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN,
+      api_key: '123-development-yourapikey-SDK',
+      collect_sync_interval: 1000, # we'll trigger sync manually in our test
+      collect_evaluations: true
+    }.merge(overrides))
+  end
+
+  DEFAULT_VALUE = PrefabProto::ConfigValue.new(string: '❌')
+
+  DESIRED_VALUE = PrefabProto::ConfigValue.new(string: "✅")
+
+  DEFAULT_ROW = PrefabProto::ConfigRow.new(
+    values: [
+      PrefabProto::ConditionalValue.new(
+        value: DEFAULT_VALUE
+      )
+    ]
+  )
+
+  PROJECT_ENV_ID = 1
+
+  CONFIG_1 = PrefabProto::Config.new(
+    id: 1,
+    key: "key.1",
+    rows: [
+      PrefabProto::ConfigRow.new(
+        project_env_id: PROJECT_ENV_ID,
+        values: [
+          PrefabProto::ConditionalValue.new(
+            criteria: [
+              PrefabProto::Criterion.new(
+                operator: PrefabProto::Criterion::CriterionOperator::PROP_IS_ONE_OF,
+                value_to_match: string_list(['hotmail.com', 'gmail.com']),
+                property_name: 'user.email_suffix'
+              )
+            ],
+            value: DESIRED_VALUE
+          )
+        ]
+      ),
+      DEFAULT_ROW
+    ]
+  )
+
+  CONFIG_2 = PrefabProto::Config.new(
+    id: 2,
+    key: "key.2",
+    rows: [DEFAULT_ROW,]
+  )
+
+  CONTEXT = {
+    user: {
+      id: 1,
+      email_suffix: 'hotmail.com'
+    },
+    team: {
+      id: 2,
+      name: 'team-name'
+    }
+  }
+end

data/test/test_evaluated_keys_aggregator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestEvaluatedKeysAggregator < Minitest::Test
+  MAX_WAIT = 2
+  SLEEP_TIME = 0.01
+
+  def test_push
+    aggregator = Prefab::EvaluatedKeysAggregator.new(client: new_client, max_keys: 2, sync_interval: 1000)
+
+    aggregator.push('key.1')
+    aggregator.push('key.2')
+
+    assert_equal 2, aggregator.data.size
+
+    # we've reached the limit, so no more
+    aggregator.push('key.3')
+    assert_equal 2, aggregator.data.size
+  end
+
+  def test_sync
+    client = new_client(namespace: 'this.is.a.namespace')
+
+    client.get 'key.1', 'default', {}
+    client.get 'key.1', 'default', {}
+    client.get 'key.2', 'default', {}
+
+    requests = wait_for_post_requests(client) do
+      client.evaluated_keys_aggregator.send(:sync)
+    end
+
+    assert_equal [[
+      '/api/v1/evaluated-keys',
+      PrefabProto::EvaluatedKeys.new(
+        keys: ['key.1', 'key.2'],
+        namespace: 'this.is.a.namespace'
+      )
+    ]], requests
+  end
+
+  private
+
+  def new_client(overrides = {})
+    super(**{
+      prefab_datasources: Prefab::Options::DATASOURCES::ALL,
+      initialization_timeout_sec: 0,
+      on_init_failure: Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN,
+      api_key: '123-development-yourapikey-SDK',
+      collect_sync_interval: 1000, # we'll trigger sync manually in our test
+      collect_keys: true
+    }.merge(overrides))
+  end
+end

data/test/test_helper.rb

@@ -33,6 +33,12 @@ class MockBaseClient
 
   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
@@ -48,7 +54,7 @@ class MockConfigClient
   end
 
   def get_config(key)
-    Prefab::Config.new(value: @config_values[key], key: key)
+    PrefabProto::Config.new(value: @config_values[key], key: key)
   end
 
   def mock_this_config(key, config_value)
@@ -95,7 +101,7 @@ def new_client(overrides = {})
 end
 
 def string_list(values)
-  Prefab::ConfigValue.new(string_list: Prefab::StringList.new(values: values))
+  PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: values))
 end
 
 def inject_config(client, config)
@@ -109,3 +115,29 @@ 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
+end

data/test/test_log_path_aggregator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestLogPathAggregator < Minitest::Test
+  MAX_WAIT = 2
+  SLEEP_TIME = 0.01
+
+  def test_push
+    aggregator = Prefab::LogPathAggregator.new(client: new_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)
+
+    assert_equal 2, aggregator.data.size
+
+    # 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
+  end
+
+  def test_sync
+    Timecop.freeze do
+      client = new_client(namespace: 'this.is.a.namespace')
+
+      2.times { client.log.info('here is a message') }
+      3.times { client.log.error('here is a message') }
+
+      requests = wait_for_post_requests(client) do
+        client.log_path_aggregator.send(:sync)
+      end
+
+      assert_equal [[
+        '/api/v1/known-loggers',
+        PrefabProto::Loggers.new(
+          loggers: [PrefabProto::Logger.new(logger_name: 'test.test_log_path_aggregator.test_sync',
+                                            infos: 2, errors: 3)],
+          start_at: Prefab::TimeHelpers.now_in_ms,
+          end_at: Prefab::TimeHelpers.now_in_ms,
+          instance_hash: client.instance_hash,
+          namespace: 'this.is.a.namespace'
+        )
+      ]], requests
+    end
+  end
+
+  private
+
+  def new_client(overrides = {})
+    super(**{
+      prefab_datasources: Prefab::Options::DATASOURCES::ALL,
+      api_key: '123-development-yourapikey-SDK',
+      collect_sync_interval: 1000 # we'll trigger sync manually in our test
+    }.merge(overrides))
+  end
+end