prefab-cloud-ruby 0.24.5 → 1.0.0

data/test/test_client.rb

@@ -3,34 +3,54 @@
 require 'test_helper'
 
 class TestClient < Minitest::Test
-  def setup
-    @client = new_client
-  end
+  LOCAL_ONLY = Prefab::Options::DATASOURCES::LOCAL_ONLY
+
+  PROJECT_ENV_ID = 1
+  KEY = 'the-key'
+  DEFAULT_VALUE = 'default_value'
+  DESIRED_VALUE = 'desired_value'
+
+  IRRELEVANT = 'this should never show up'
+
+  DEFAULT_VALUE_CONFIG = PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
+  DESIRED_VALUE_CONFIG = PrefabProto::ConfigValue.new(string: DESIRED_VALUE)
+
+  TRUE_CONFIG = PrefabProto::ConfigValue.new(bool: true)
+  FALSE_CONFIG = PrefabProto::ConfigValue.new(bool: false)
+
+  DEFAULT_ROW = PrefabProto::ConfigRow.new(
+    values: [
+      PrefabProto::ConditionalValue.new(value: DEFAULT_VALUE_CONFIG)
+    ]
+  )
 
   def test_get
     _, err = capture_io do
-      assert_equal 'default', @client.get('does.not.exist', 'default')
-      assert_equal 'test sample value', @client.get('sample')
-      assert_equal 123, @client.get('sample_int')
+      client = new_client
+      assert_equal 'default', client.get('does.not.exist', 'default')
+      assert_equal 'test sample value', client.get('sample')
+      assert_equal 123, client.get('sample_int')
     end
     assert_equal '', err
   end
 
   def test_get_with_default
+    client = new_client
     # A `false` value is not replaced with the default
-    assert_equal false, @client.get('false_value', 'red')
+    assert_equal false, client.get('false_value', 'red')
 
     # A falsy value is not replaced with the default
-    assert_equal 0, @client.get('zero_value', 'red')
+    assert_equal 0, client.get('zero_value', 'red')
 
     # A missing value returns the default
-    assert_equal 'buckets', @client.get('missing_value', 'buckets')
+    assert_equal 'buckets', client.get('missing_value', 'buckets')
   end
 
   def test_get_with_missing_default
+    client = new_client
     # it raises by default
     err = assert_raises(Prefab::Errors::MissingDefaultError) do
-      assert_nil @client.get('missing_value')
+      assert_nil client.get('missing_value')
     end
 
     assert_match(/No value found for key/, err.message)
@@ -42,53 +62,87 @@ class TestClient < Minitest::Test
   end
 
   def test_enabled
-    assert_equal false, @client.enabled?('does_not_exist')
-    assert_equal true, @client.enabled?('enabled_flag')
-    assert_equal false, @client.enabled?('disabled_flag')
-    assert_equal false, @client.enabled?('flag_with_a_value')
+    client = new_client
+    assert_equal false, client.enabled?('does_not_exist')
+    assert_equal true, client.enabled?('enabled_flag')
+    assert_equal false, client.enabled?('disabled_flag')
+    assert_equal false, client.enabled?('flag_with_a_value')
   end
 
   def test_ff_enabled_with_user_key_match
-    assert_equal_context_and_jit(false, :enabled?, 'user_key_match', { user: { key: 'jimmy' } })
-    assert_equal_context_and_jit(true, :enabled?, 'user_key_match', { user: { key: 'abc123' } })
-    assert_equal_context_and_jit(true, :enabled?, 'user_key_match', { user: { key: 'xyz987' } })
+    client = new_client
+
+    ctx = { user: { key: 'jimmy' } }
+    assert_equal false, client.enabled?('user_key_match', ctx)
+    assert_equal false, Prefab::Context.with_context(ctx) { client.enabled?('user_key_match') }
+
+    ctx = { user: { key: 'abc123' } }
+    assert_equal true, client.enabled?('user_key_match', ctx)
+    assert_equal true, Prefab::Context.with_context(ctx) { client.enabled?('user_key_match') }
+
+    ctx = { user: { key: 'xyz987' } }
+    assert_equal true, client.enabled?('user_key_match', ctx)
+    assert_equal true, Prefab::Context.with_context(ctx) { client.enabled?('user_key_match') }
   end
 
+  # NOTE: these are all `false` because we're doing a enabled? on a FF with string variants
+  # see test_ff_get_with_context for the raw value tests
   def test_ff_enabled_with_context
-    assert_equal_context_and_jit(false, :enabled?, 'just_my_domain', user: { domain: 'gmail.com' })
-    assert_equal_context_and_jit(false, :enabled?, 'just_my_domain', user: { domain: 'prefab.cloud' })
-    assert_equal_context_and_jit(false, :enabled?, 'just_my_domain', user: { domain: 'example.com' })
+    client = new_client
+
+    ctx = { user: { domain: 'gmail.com' } }
+    assert_equal false, client.enabled?('just_my_domain', ctx)
+    assert_equal false, Prefab::Context.with_context(ctx) { client.enabled?('just_my_domain') }
+
+    ctx = { user: { domain: 'prefab.cloud' } }
+    assert_equal false, client.enabled?('just_my_domain', ctx)
+    assert_equal false, Prefab::Context.with_context(ctx) { client.enabled?('just_my_domain') }
+
+    ctx = { user: { domain: 'example.com' } }
+    assert_equal false, client.enabled?('just_my_domain', ctx)
+    assert_equal false, Prefab::Context.with_context(ctx) { client.enabled?('just_my_domain') }
   end
 
   def test_ff_get_with_context
-    assert_nil @client.get('just_my_domain', 'abc123', user: { domain: 'gmail.com' })
-    assert_equal 'DEFAULT', @client.get('just_my_domain', 'abc123', { user: { domain: 'gmail.com' } }, 'DEFAULT')
+    client = new_client
 
-    assert_equal_context_and_jit('new-version', :get, 'just_my_domain', { user: { domain: 'prefab.cloud' } })
-    assert_equal_context_and_jit('new-version', :get, 'just_my_domain', { user: { domain: 'example.com' } })
+    ctx = { user: { domain: 'gmail.com' } }
+    assert_equal 'DEFAULT', client.get('just_my_domain', 'DEFAULT', ctx)
+    assert_equal 'DEFAULT', Prefab::Context.with_context(ctx) { client.get('just_my_domain', 'DEFAULT') }
+
+    ctx = { user: { domain: 'prefab.cloud' } }
+    assert_equal 'new-version', client.get('just_my_domain', 'DEFAULT', ctx)
+    assert_equal 'new-version', Prefab::Context.with_context(ctx) { client.get('just_my_domain', 'DEFAULT') }
+
+    ctx = { user: { domain: 'example.com' } }
+    assert_equal 'new-version', client.get('just_my_domain', 'DEFAULT', ctx)
+    assert_equal 'new-version', Prefab::Context.with_context(ctx) { client.get('just_my_domain', 'DEFAULT') }
   end
 
   def test_deprecated_no_dot_notation_ff_enabled_with_jit_context
+    client = new_client
     # with no lookup key
-    assert_equal false, @client.enabled?('deprecated_no_dot_notation', { domain: 'gmail.com' })
-    assert_equal true, @client.enabled?('deprecated_no_dot_notation', { domain: 'prefab.cloud' })
-    assert_equal true, @client.enabled?('deprecated_no_dot_notation', { domain: 'example.com' })
+    assert_equal false, client.enabled?('deprecated_no_dot_notation', { domain: 'gmail.com' })
+    assert_equal true, client.enabled?('deprecated_no_dot_notation', { domain: 'prefab.cloud' })
+    assert_equal true, client.enabled?('deprecated_no_dot_notation', { domain: 'example.com' })
 
-    # with a lookup key
-    assert_equal false, @client.enabled?('deprecated_no_dot_notation', 'some-lookup-key', { domain: 'gmail.com' })
-    assert_equal true, @client.enabled?('deprecated_no_dot_notation', 'some-lookup-key', { domain: 'prefab.cloud' })
-    assert_equal true, @client.enabled?('deprecated_no_dot_notation', 'some-lookup-key', { domain: 'example.com' })
+    assert_stderr [
+      "[DEPRECATION] Prefab contexts should be a hash with a key of the context name and a value of a hash.",
+      "[DEPRECATION] Prefab contexts should be a hash with a key of the context name and a value of a hash.",
+      "[DEPRECATION] Prefab contexts should be a hash with a key of the context name and a value of a hash."
+    ]
   end
 
   def test_getting_feature_flag_value
-    assert_equal false, @client.enabled?('flag_with_a_value')
-    assert_equal 'all-features', @client.get('flag_with_a_value')
+    client = new_client
+    assert_equal false, client.enabled?('flag_with_a_value')
+    assert_equal 'all-features', client.get('flag_with_a_value')
   end
 
   def test_initialization_with_an_options_object
     options_hash = {
       namespace: 'test-namespace',
-      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+      prefab_datasources: LOCAL_ONLY
     }
 
     options = Prefab::Options.new(options_hash)
@@ -101,7 +155,7 @@ class TestClient < Minitest::Test
   def test_initialization_with_a_hash
     options_hash = {
       namespace: 'test-namespace',
-      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+      prefab_datasources: LOCAL_ONLY
     }
 
     client = Prefab::Client.new(options_hash)
@@ -109,13 +163,273 @@ class TestClient < Minitest::Test
     assert_equal client.namespace, 'test-namespace'
   end
 
-  private
+  def test_evaluation_summary_aggregator
+    fake_api_key = '123-development-yourapikey-SDK'
+
+    # it is nil by default
+    assert_nil new_client(api_key: fake_api_key).evaluation_summary_aggregator
+
+    # it is nil when local_only even if collect_max_evaluation_summaries is true
+    assert_nil new_client(prefab_datasources: LOCAL_ONLY,
+                                  collect_evaluation_summaries: true, ).evaluation_summary_aggregator
+
+    # it is nil when collect_max_evaluation_summaries is false
+    assert_nil new_client(api_key: fake_api_key,
+                                  prefab_datasources: :all,
+                                  collect_evaluation_summaries: false).evaluation_summary_aggregator
+
+    # it is not nil when collect_max_evaluation_summaries is true and the datasource is not local_only
+    assert_equal Prefab::EvaluationSummaryAggregator,
+                 new_client(api_key: fake_api_key,
+                            prefab_datasources: :all,
+                            collect_evaluation_summaries: true).evaluation_summary_aggregator.class
+
+    assert_logged [
+      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client No success loading checkpoints"
+    ]
+  end
+
+  def test_get_with_basic_value
+    config = basic_value_config
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID, collect_evaluation_summaries: true,
+                        context_upload_mode: :periodic_example, allow_telemetry_in_local_mode: true)
+
+    assert_equal DESIRED_VALUE, client.get(config.key, IRRELEVANT, 'user' => { 'key' => 99 })
+
+    assert_summary client, {
+      [KEY, :CONFIG] => {
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: DESIRED_VALUE_CONFIG,
+          conditional_value_index: 0,
+          weighted_value_index: nil,
+          selected_index: nil
+        } => 1
+      }
+    }
+
+    assert_example_contexts client, [Prefab::Context.new({ user: { 'key' => 99 } })]
+  end
+
+  def test_get_with_basic_value_with_context
+    config = basic_value_config
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID, collect_evaluation_summaries: true,
+                        context_upload_mode: :periodic_example, allow_telemetry_in_local_mode: true)
+
+    client.with_context('user' => { 'key' => 99 }) do
+      assert_equal DESIRED_VALUE, client.get(config.key)
+    end
+
+    assert_summary client, {
+      [KEY, :CONFIG] => {
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: DESIRED_VALUE_CONFIG,
+          conditional_value_index: 0,
+          weighted_value_index: nil,
+          selected_index: nil
+        } => 1
+      }
+    }
+
+    assert_example_contexts client, [Prefab::Context.new({ user: { 'key' => 99 } })]
+  end
+
+  def test_get_with_weighted_values
+    config = PrefabProto::Config.new(
+      id: 123,
+      key: KEY,
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 98], ['def', 1],
+                                                                                    ['ghi', 1]]))
+            )
+          ]
+        )
+      ]
+    )
 
-  def assert_equal_context_and_jit(expected, method, key, context)
-    assert_equal expected, @client.send(method, key, context)
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID, collect_evaluation_summaries: true,
+                       context_upload_mode: :periodic_example, allow_telemetry_in_local_mode: true)
 
-    Prefab::Context.with_context(context) do
-      assert_equal expected, @client.send(method, key)
+    2.times do
+      assert_equal 'abc', client.get(config.key, IRRELEVANT, 'user' => { 'key' => '1' })
     end
+
+    3.times do
+      assert_equal 'def', client.get(config.key, IRRELEVANT, 'user' => { 'key' => '12' })
+    end
+
+    assert_equal 'ghi',
+                 client.get(config.key, IRRELEVANT, 'user' => { 'key' => '4', admin: true })
+
+    assert_summary client, {
+      [KEY, :CONFIG] => {
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'abc'),
+          conditional_value_index: 0,
+          weighted_value_index: 0,
+          selected_index: nil
+        } => 2,
+
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'def'),
+          conditional_value_index: 0,
+          weighted_value_index: 1,
+          selected_index: nil
+        } => 3,
+
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'ghi'),
+          conditional_value_index: 0,
+          weighted_value_index: 2,
+          selected_index: nil
+        } => 1
+      }
+    }
+
+    assert_example_contexts client, [
+      Prefab::Context.new(user: { 'key' => '1' }),
+      Prefab::Context.new(user: { 'key' => '12' }),
+      Prefab::Context.new(user: { 'key' => '4', admin: true })
+    ]
+  end
+
+  def test_in_seg
+    segment_key = 'segment_key'
+
+    segment_config = PrefabProto::Config.new(
+      config_type: PrefabProto::ConfigType::SEGMENT,
+      key: segment_key,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: TRUE_CONFIG,
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                  value_to_match: string_list(['hotmail.com', 'gmail.com']),
+                  property_name: 'user.email'
+                )
+              ]
+            ),
+            PrefabProto::ConditionalValue.new(value: FALSE_CONFIG)
+          ]
+        )
+      ]
+    )
+
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: segment_key)
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: [config, segment_config], project_env_id: PROJECT_ENV_ID,
+                        collect_evaluation_summaries: true, context_upload_mode: :periodic_example, allow_telemetry_in_local_mode: true)
+
+    assert_equal DEFAULT_VALUE, client.get(config.key)
+    assert_equal DEFAULT_VALUE,
+                 client.get(config.key, IRRELEVANT, user: { key: 'abc', email: 'example@prefab.cloud' })
+    assert_equal DESIRED_VALUE, client.get(config.key, IRRELEVANT, user: { key: 'def', email: 'example@hotmail.com' })
+
+    assert_summary client, {
+      [segment_key, :SEGMENT] => {
+        { config_id: 0, config_row_index: 0, conditional_value_index: 1, selected_value: FALSE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 2,
+        { config_id: 0, config_row_index: 0, conditional_value_index: 0, selected_value: TRUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 1
+      },
+      [KEY, :NOT_SET_CONFIG_TYPE] => {
+        { config_id: 0, config_row_index: 0, conditional_value_index: 0, selected_value: DEFAULT_VALUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 2,
+        { config_id: 0, config_row_index: 1, conditional_value_index: 0, selected_value: DESIRED_VALUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 1
+      }
+    }
+
+    assert_example_contexts client, [
+      Prefab::Context.new(user: { key: 'abc', email: 'example@prefab.cloud' }),
+      Prefab::Context.new(user: { key: 'def', email: 'example@hotmail.com' })
+    ]
+  end
+
+  def test_get_log_level
+    config = PrefabProto::Config.new(
+      id: 999,
+      key: 'log-level',
+      config_type: PrefabProto::ConfigType::LOG_LEVEL,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: PrefabProto::ConfigValue.new(log_level: PrefabProto::LogLevel::DEBUG)
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID,
+                        collect_evaluation_summaries: true, allow_telemetry_in_local_mode: true)
+
+    assert_equal :DEBUG, client.get(config.key, IRRELEVANT)
+
+    # nothing is summarized for log levels
+    assert_summary client, {}
+  end
+
+  private
+
+  def basic_value_config
+    PrefabProto::Config.new(
+      id: 123,
+      key: KEY,
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
   end
 end

data/test/test_config_client.rb

@@ -4,6 +4,7 @@ require 'test_helper'
 
 class TestConfigClient < Minitest::Test
   def setup
+    super
     options = Prefab::Options.new(
       prefab_config_override_dir: 'none',
       prefab_config_classpath_dir: 'test',

data/test/test_config_loader.rb

@@ -4,6 +4,7 @@ require 'test_helper'
 
 class TestConfigLoader < Minitest::Test
   def setup
+    super
     options = Prefab::Options.new(
       prefab_config_override_dir: 'none',
       prefab_config_classpath_dir: 'test',

data/test/test_config_resolver.rb

@@ -22,6 +22,10 @@ class TestConfigResolver < Minitest::Test
     ]
   )
 
+  class MockConfigLoader
+    def calc_config; end
+  end
+
   def test_resolution
     @loader = MockConfigLoader.new
 
@@ -117,31 +121,30 @@ class TestConfigResolver < Minitest::Test
 
     @loader.stub :calc_config, loaded_values do
       @resolverA = resolver_for_namespace('', @loader, project_env_id: PRODUCTION_ENV_ID)
-      assert_equal_context_and_jit DEFAULT_VALUE, @resolverA, 'key', {}, :string
+      assert_equal_context_and_jit DEFAULT_VALUE, @resolverA, 'key', {}
 
       ## below here in the test env
       @resolverA = resolver_for_namespace('', @loader)
-      assert_equal_context_and_jit 'value_none', @resolverA, 'key', {}, :string
+      assert_equal_context_and_jit 'value_none', @resolverA, 'key', {}
 
       @resolverA = resolver_for_namespace('projectA', @loader)
-      assert_equal_context_and_jit 'valueA', @resolverA, 'key', {}, :string
+      assert_equal_context_and_jit 'valueA', @resolverA, 'key', {}
 
       @resolverB = resolver_for_namespace('projectB', @loader)
-      assert_equal_context_and_jit 'valueB', @resolverB, 'key', {}, :string
+      assert_equal_context_and_jit 'valueB', @resolverB, 'key', {}
 
       @resolverBX = resolver_for_namespace('projectB.subprojectX', @loader)
-      assert_equal_context_and_jit 'projectB.subprojectX', @resolverBX, 'key', {}, :string
+      assert_equal_context_and_jit 'projectB.subprojectX', @resolverBX, 'key', {}
 
       @resolverBX = resolver_for_namespace('projectB.subprojectX', @loader)
-      assert_equal_context_and_jit 'valueB2', @resolverBX, 'key2', {}, :string
+      assert_equal_context_and_jit 'valueB2', @resolverBX, 'key2', {}
 
       @resolverUndefinedSubProject = resolver_for_namespace('projectB.subprojectX.subsubQ',
                                                             @loader)
-      assert_equal_context_and_jit 'projectB.subprojectX', @resolverUndefinedSubProject, 'key',
-                                   {}, :string
+      assert_equal_context_and_jit 'projectB.subprojectX', @resolverUndefinedSubProject, 'key', {}
 
       @resolverBX = resolver_for_namespace('projectC', @loader)
-      assert_equal_context_and_jit 'value_none', @resolverBX, 'key', {}, :string
+      assert_equal_context_and_jit 'value_none', @resolverBX, 'key', {}
 
       assert_nil @resolverBX.get('key_that_doesnt_exist', nil)
 
@@ -244,9 +247,9 @@ class TestConfigResolver < Minitest::Test
       resolver.project_env_id = PRODUCTION_ENV_ID
 
       assert_equal_context_and_jit DEFAULT_VALUE, resolver, CONFIG_KEY,
-                                   { user: { email: 'test@something-else.com' } }, :string
+                                   { user: { email: 'test@something-else.com' } }
       assert_equal_context_and_jit IN_SEGMENT_VALUE, resolver, CONFIG_KEY,
-                                   { user: { email: 'test@hotmail.com' } }, :string
+                                   { user: { email: 'test@hotmail.com' } }
     end
   end
 
@@ -312,10 +315,8 @@ class TestConfigResolver < Minitest::Test
       options = Prefab::Options.new
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
 
-      assert_equal_context_and_jit IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@hotmail.com' } },
-                                   :string
-      assert_equal_context_and_jit NOT_IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@something-else.com' } },
-                                   :string
+      assert_equal_context_and_jit IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@hotmail.com' } }
+      assert_equal_context_and_jit NOT_IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@something-else.com' } }
     end
   end
 
@@ -356,9 +357,9 @@ class TestConfigResolver < Minitest::Test
       resolver.project_env_id = TEST_ENV_ID
 
       Prefab::Context.with_context({ user: { email: 'test@example.com' } }) do
-        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY).string
-        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'freebie' } }).string
-        assert_equal DESIRED_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'pro' } }).string
+        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY).unwrapped_value
+        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'freebie' } }).unwrapped_value
+        assert_equal DESIRED_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'pro' } }).unwrapped_value
       end
     end
   end
@@ -400,9 +401,9 @@ class TestConfigResolver < Minitest::Test
       resolver.project_env_id = TEST_ENV_ID
 
       Prefab::Context.with_context({ user: { email: 'test@hotmail.com' }, team: { plan: 'pro' } }) do
-        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY).string
-        assert_equal DESIRED_VALUE, resolver.get(CONFIG_KEY, { user: { email: 'test@example.com' } }).string
-        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'freebie' } }).string
+        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY).unwrapped_value
+        assert_equal DESIRED_VALUE, resolver.get(CONFIG_KEY, { user: { email: 'test@example.com' } }).unwrapped_value
+        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'freebie' } }).unwrapped_value
       end
     end
   end
@@ -419,11 +420,11 @@ class TestConfigResolver < Minitest::Test
     resolver
   end
 
-  def assert_equal_context_and_jit(expected_value, resolver, key, properties, type)
-    assert_equal expected_value, resolver.get(key, properties).send(type)
+  def assert_equal_context_and_jit(expected_value, resolver, key, properties)
+    assert_equal expected_value, resolver.get(key, properties).unwrapped_value
 
     Prefab::Context.with_context(properties) do
-      assert_equal expected_value, resolver.get(key).send(type)
+      assert_equal expected_value, resolver.get(key).unwrapped_value
     end
   end
 end