prefab-cloud-ruby 0

data/test/test_config_resolver.rb

@@ -0,0 +1,430 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestConfigResolver < Minitest::Test
+  STAGING_ENV_ID = 1
+  PRODUCTION_ENV_ID = 2
+  TEST_ENV_ID = 3
+  SEGMENT_KEY = 'segment_key'
+  CONFIG_KEY = 'config_key'
+  DEFAULT_VALUE = 'default_value'
+  DESIRED_VALUE = 'desired_value'
+  IN_SEGMENT_VALUE = 'in_segment_value'
+  WRONG_ENV_VALUE = 'wrong_env_value'
+  NOT_IN_SEGMENT_VALUE = 'not_in_segment_value'
+
+  DEFAULT_ROW = PrefabProto::ConfigRow.new(
+    values: [
+      PrefabProto::ConditionalValue.new(
+        value: PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
+      )
+    ]
+  )
+
+  class MockConfigLoader
+    def calc_config; end
+  end
+
+  def test_resolution
+    @loader = MockConfigLoader.new
+
+    loaded_values = {
+      'key' => { config: PrefabProto::Config.new(
+        key: 'key',
+        rows: [
+          DEFAULT_ROW,
+          PrefabProto::ConfigRow.new(
+            project_env_id: TEST_ENV_ID,
+            values: [
+              PrefabProto::ConditionalValue.new(
+                criteria: [
+                  PrefabProto::Criterion.new(
+                    operator: PrefabProto::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
+                    value_to_match: PrefabProto::ConfigValue.new(string: 'projectB.subprojectX'),
+                    property_name: Prefab::CriteriaEvaluator::NAMESPACE_KEY
+                  )
+                ],
+                value: PrefabProto::ConfigValue.new(string: 'projectB.subprojectX')
+              ),
+              PrefabProto::ConditionalValue.new(
+                criteria: [
+                  PrefabProto::Criterion.new(
+                    operator: PrefabProto::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
+                    value_to_match: PrefabProto::ConfigValue.new(string: 'projectB.subprojectY'),
+                    property_name: Prefab::CriteriaEvaluator::NAMESPACE_KEY
+                  )
+                ],
+                value: PrefabProto::ConfigValue.new(string: 'projectB.subprojectY')
+              ),
+              PrefabProto::ConditionalValue.new(
+                criteria: [
+                  PrefabProto::Criterion.new(
+                    operator: PrefabProto::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
+                    value_to_match: PrefabProto::ConfigValue.new(string: 'projectA'),
+                    property_name: Prefab::CriteriaEvaluator::NAMESPACE_KEY
+                  )
+                ],
+                value: PrefabProto::ConfigValue.new(string: 'valueA')
+              ),
+              PrefabProto::ConditionalValue.new(
+                criteria: [
+                  PrefabProto::Criterion.new(
+                    operator: PrefabProto::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
+                    value_to_match: PrefabProto::ConfigValue.new(string: 'projectB'),
+                    property_name: Prefab::CriteriaEvaluator::NAMESPACE_KEY
+                  )
+                ],
+                value: PrefabProto::ConfigValue.new(string: 'valueB')
+              ),
+              PrefabProto::ConditionalValue.new(
+                criteria: [
+                  PrefabProto::Criterion.new(
+                    operator: PrefabProto::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
+                    value_to_match: PrefabProto::ConfigValue.new(string: 'projectB.subprojectX'),
+                    property_name: Prefab::CriteriaEvaluator::NAMESPACE_KEY
+                  )
+                ],
+                value: PrefabProto::ConfigValue.new(string: 'projectB.subprojectX')
+              ),
+              PrefabProto::ConditionalValue.new(
+                criteria: [
+                  PrefabProto::Criterion.new(
+                    operator: PrefabProto::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
+                    value_to_match: PrefabProto::ConfigValue.new(string: 'projectB.subprojectY'),
+                    property_name: Prefab::CriteriaEvaluator::NAMESPACE_KEY
+                  )
+                ],
+                value: PrefabProto::ConfigValue.new(string: 'projectB.subprojectY')
+              ),
+              PrefabProto::ConditionalValue.new(
+                value: PrefabProto::ConfigValue.new(string: 'value_none')
+              )
+            ]
+          )
+
+        ]
+      ) },
+      'key2' => { config: PrefabProto::Config.new(
+        key: 'key2',
+        rows: [
+          PrefabProto::ConfigRow.new(
+            values: [
+              PrefabProto::ConditionalValue.new(
+                value: PrefabProto::ConfigValue.new(string: 'valueB2')
+              )
+            ]
+          )
+        ]
+      ) }
+    }
+
+    @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', {}
+
+      ## below here in the test env
+      @resolverA = resolver_for_namespace('', @loader)
+      assert_equal_context_and_jit 'value_none', @resolverA, 'key', {}
+
+      @resolverA = resolver_for_namespace('projectA', @loader)
+      assert_equal_context_and_jit 'valueA', @resolverA, 'key', {}
+
+      @resolverB = resolver_for_namespace('projectB', @loader)
+      assert_equal_context_and_jit 'valueB', @resolverB, 'key', {}
+
+      @resolverBX = resolver_for_namespace('projectB.subprojectX', @loader)
+      assert_equal_context_and_jit 'projectB.subprojectX', @resolverBX, 'key', {}
+
+      @resolverBX = resolver_for_namespace('projectB.subprojectX', @loader)
+      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', {}
+
+      @resolverBX = resolver_for_namespace('projectC', @loader)
+      assert_equal_context_and_jit 'value_none', @resolverBX, 'key', {}
+
+      assert_nil @resolverBX.get('key_that_doesnt_exist', nil)
+
+      assert_equal @resolverBX.to_s.strip.split("\n").map(&:strip), [
+        'key                                                | value_none                          | String  | Match:                         | Source:',
+        'key2                                               | valueB2                             | String  | Match:                         | Source:'
+      ]
+
+      assert_equal @resolverBX.presenter.to_h, {
+        'key' => Prefab::ResolvedConfigPresenter::ConfigRow.new('key', 'value_none', nil, nil),
+        'key2' => Prefab::ResolvedConfigPresenter::ConfigRow.new('key2', 'valueB2', nil, nil)
+      }
+
+      resolved_lines = []
+      @resolverBX.presenter.each do |key, row|
+        resolved_lines << [key, row.value]
+      end
+      assert_equal resolved_lines, [%w[key value_none], %w[key2 valueB2]]
+    end
+  end
+
+  def test_resolving_in_segment
+    segment_config = PrefabProto::Config.new(
+      config_type: PrefabProto::ConfigType::SEGMENT,
+      key: SEGMENT_KEY,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: PrefabProto::ConfigValue.new(bool: true),
+              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: PrefabProto::ConfigValue.new(bool: false))
+          ]
+        )
+      ]
+    )
+
+    config = PrefabProto::Config.new(
+      key: CONFIG_KEY,
+      rows: [
+        # wrong env
+        PrefabProto::ConfigRow.new(
+          project_env_id: TEST_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: PrefabProto::ConfigValue.new(string: WRONG_ENV_VALUE)
+            ),
+            PrefabProto::ConditionalValue.new(
+              criteria: [],
+              value: PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
+            )
+          ]
+        ),
+
+        # correct env
+        PrefabProto::ConfigRow.new(
+          project_env_id: PRODUCTION_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: PrefabProto::ConfigValue.new(string: IN_SEGMENT_VALUE)
+            ),
+            PrefabProto::ConditionalValue.new(
+              criteria: [],
+              value: PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
+            )
+          ]
+        )
+      ]
+    )
+
+    loaded_values = {
+      SEGMENT_KEY => { config: segment_config },
+      CONFIG_KEY => { config: config }
+    }
+
+    loader = MockConfigLoader.new
+
+    loader.stub :calc_config, loaded_values do
+      options = Prefab::Options.new
+      resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
+      resolver.project_env_id = PRODUCTION_ENV_ID
+
+      assert_equal_context_and_jit DEFAULT_VALUE, resolver, CONFIG_KEY,
+                                   { user: { email: 'test@something-else.com' } }
+      assert_equal_context_and_jit IN_SEGMENT_VALUE, resolver, CONFIG_KEY,
+                                   { user: { email: 'test@hotmail.com' } }
+    end
+  end
+
+  def test_resolving_not_in_segment
+    segment_config = PrefabProto::Config.new(
+      config_type: PrefabProto::ConfigType::SEGMENT,
+      key: SEGMENT_KEY,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: PrefabProto::ConfigValue.new(bool: true),
+              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: PrefabProto::ConfigValue.new(bool: false))
+          ]
+        )
+      ]
+    )
+
+    config = PrefabProto::Config.new(
+      key: CONFIG_KEY,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: SEGMENT_KEY)
+                )
+              ],
+              value: PrefabProto::ConfigValue.new(string: IN_SEGMENT_VALUE)
+            ),
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::NOT_IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: SEGMENT_KEY)
+                )
+              ],
+              value: PrefabProto::ConfigValue.new(string: NOT_IN_SEGMENT_VALUE)
+            )
+          ]
+        )
+      ]
+    )
+
+    loaded_values = {
+      SEGMENT_KEY => { config: segment_config },
+      CONFIG_KEY => { config: config }
+    }
+
+    loader = MockConfigLoader.new
+
+    loader.stub :calc_config, loaded_values do
+      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' } }
+      assert_equal_context_and_jit NOT_IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@something-else.com' } }
+    end
+  end
+
+  def test_jit_context_merges_with_existing_context
+    config = PrefabProto::Config.new(
+      key: CONFIG_KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: TEST_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_IS_ONE_OF,
+                  value_to_match: string_list(%w[pro advanced]),
+                  property_name: 'team.plan'
+                ),
+
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                  value_to_match: string_list(%w[@example.com]),
+                  property_name: 'user.email'
+                )
+              ],
+              value: PrefabProto::ConfigValue.new(string: DESIRED_VALUE)
+            )
+          ]
+        )
+      ]
+    )
+
+    loader = MockConfigLoader.new
+
+    loader.stub :calc_config, { CONFIG_KEY => { config: config } } do
+      options = Prefab::Options.new
+      resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
+      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).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
+
+  def test_jit_can_clobber_existing_context
+    config = PrefabProto::Config.new(
+      key: CONFIG_KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: TEST_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_IS_ONE_OF,
+                  value_to_match: string_list(%w[pro advanced]),
+                  property_name: 'team.plan'
+                ),
+
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                  value_to_match: string_list(%w[@example.com]),
+                  property_name: 'user.email'
+                )
+              ],
+              value: PrefabProto::ConfigValue.new(string: DESIRED_VALUE)
+            )
+          ]
+        )
+      ]
+    )
+
+    loader = MockConfigLoader.new
+
+    loader.stub :calc_config, { CONFIG_KEY => { config: config } } do
+      options = Prefab::Options.new
+      resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
+      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).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
+
+  private
+
+  def resolver_for_namespace(namespace, loader, project_env_id: TEST_ENV_ID)
+    options = Prefab::Options.new(
+      namespace: namespace
+    )
+    resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
+    resolver.project_env_id = project_env_id
+    resolver.update
+    resolver
+  end
+
+  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).unwrapped_value
+    end
+  end
+end

data/test/test_config_value_unwrapper.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestConfigValueUnwrapper < Minitest::Test
+  CONFIG = PrefabProto::Config.new(
+    key: 'config_key'
+  )
+  EMPTY_CONTEXT = Prefab::Context.new()
+  DECRYPTION_KEY_NAME = "decryption.key"
+  DECRYPTION_KEY_VALUE = Prefab::Encryption.generate_new_hex_key
+
+  def setup
+    super
+    @mock_resolver = MockResolver.new
+  end
+
+  def test_unwrapping_int
+    config_value = PrefabProto::ConfigValue.new(int: 123)
+    assert_equal 123, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+  end
+
+  def test_unwrapping_string
+    config_value = PrefabProto::ConfigValue.new(string: 'abc')
+    assert_equal 'abc', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    assert_equal 'abc', reportable_value(config_value, CONFIG, EMPTY_CONTEXT)
+  end
+
+  def test_unwrapping_double
+    config_value = PrefabProto::ConfigValue.new(double: 1.23)
+    assert_equal 1.23, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+  end
+
+  def test_unwrapping_bool
+    config_value = PrefabProto::ConfigValue.new(bool: true)
+    assert_equal true, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+
+    config_value = PrefabProto::ConfigValue.new(bool: false)
+    assert_equal false, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+  end
+
+  def test_unwrapping_log_level
+    config_value = PrefabProto::ConfigValue.new(log_level: :INFO)
+    assert_equal :INFO, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+  end
+
+  def test_unwrapping_string_list
+    config_value = PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: %w[a b c]))
+    assert_equal %w[a b c], unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+  end
+
+  def test_unwrapping_weighted_values
+    # single value
+    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1]]))
+
+    assert_equal 'abc', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+
+    # multiple values, evenly distributed
+    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 1], ['ghi', 1]]))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:000'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:456'))
+    assert_equal 'abc', unwrap(config_value, CONFIG, context_with_key('user:789'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:888'))
+
+    # multiple values, unevenly distributed
+    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 99], ['ghi', 1]]))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:123'))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:456'))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:789'))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:012'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:428'))
+    assert_equal 'abc', unwrap(config_value, CONFIG, context_with_key('user:548'))
+  end
+
+  def test_unwrapping_provided_values
+    with_env('ENV_VAR_NAME', 'unit test value')do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "ENV_VAR_NAME"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value)
+      assert_equal 'unit test value', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    end
+  end
+
+  def test_unwrapping_provided_values_of_type_string_list
+    with_env('ENV_VAR_NAME', '["bob","cary"]')do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "ENV_VAR_NAME"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value)
+      assert_equal ["bob", "cary"], unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    end
+  end
+
+  def test_unwrapping_provided_values_coerces_to_int
+    with_env('ENV_VAR_NAME', '42')do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "ENV_VAR_NAME"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value)
+      assert_equal 42,  unwrap(config_value, config_of(PrefabProto::Config::ValueType::INT), EMPTY_CONTEXT)
+    end
+  end
+
+  def test_unwrapping_provided_values_when_value_type_mismatch
+    with_env('ENV_VAR_NAME', 'not an int')do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "ENV_VAR_NAME"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value)
+
+      assert_raises Prefab::Errors::EnvVarParseError do
+        unwrap(config_value, config_of(PrefabProto::Config::ValueType::INT), EMPTY_CONTEXT)
+      end
+    end
+  end
+
+  def test_coerce
+    assert_equal "string", Prefab::ConfigValueUnwrapper.coerce_into_type("string", CONFIG, "ENV")
+    assert_equal 42, Prefab::ConfigValueUnwrapper.coerce_into_type("42", CONFIG, "ENV")
+    assert_equal false, Prefab::ConfigValueUnwrapper.coerce_into_type("false", CONFIG, "ENV")
+    assert_equal 42.42, Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", CONFIG, "ENV")
+    assert_equal ["a","b"], Prefab::ConfigValueUnwrapper.coerce_into_type("['a','b']", CONFIG, "ENV")
+
+    assert_equal "string", Prefab::ConfigValueUnwrapper.coerce_into_type("string", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal "42", Prefab::ConfigValueUnwrapper.coerce_into_type("42", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal "42.42", Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal 42, Prefab::ConfigValueUnwrapper.coerce_into_type("42", config_of(PrefabProto::Config::ValueType::INT),"ENV")
+    assert_equal false, Prefab::ConfigValueUnwrapper.coerce_into_type("false", config_of(PrefabProto::Config::ValueType::BOOL),"ENV")
+    assert_equal 42.42, Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", config_of(PrefabProto::Config::ValueType::DOUBLE),"ENV")
+    assert_equal ["a","b"], Prefab::ConfigValueUnwrapper.coerce_into_type("['a','b']", config_of(PrefabProto::Config::ValueType::STRING_LIST),"ENV")
+
+    assert_raises Prefab::Errors::EnvVarParseError do
+      Prefab::ConfigValueUnwrapper.coerce_into_type("not an int", config_of(PrefabProto::Config::ValueType::INT), "ENV")
+    end
+    assert_raises Prefab::Errors::EnvVarParseError do
+      Prefab::ConfigValueUnwrapper.coerce_into_type("not bool", config_of(PrefabProto::Config::ValueType::BOOL), "ENV")
+    end
+    assert_raises Prefab::Errors::EnvVarParseError do
+      Prefab::ConfigValueUnwrapper.coerce_into_type("not a double", config_of(PrefabProto::Config::ValueType::DOUBLE), "ENV")
+    end
+    assert_raises Prefab::Errors::EnvVarParseError do
+      Prefab::ConfigValueUnwrapper.coerce_into_type("not a list", config_of(PrefabProto::Config::ValueType::STRING_LIST), "ENV")
+    end
+  end
+
+  def test_unwrapping_provided_values_with_missing_env_var
+    value = PrefabProto::Provided.new(
+      source: :ENV_VAR,
+      lookup: "NON_EXISTENT_ENV_VAR_NAME"
+    )
+    config_value = PrefabProto::ConfigValue.new(provided: value)
+    assert_raises(Prefab::Errors::MissingEnvVarError) do
+      unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    end
+  end
+
+  def test_unwrapping_encrypted_values_decrypts
+    clear_text = "very secret stuff"
+    encrypted = Prefab::Encryption.new(DECRYPTION_KEY_VALUE).encrypt(clear_text)
+    config_value = PrefabProto::ConfigValue.new(string: encrypted, decrypt_with: "decryption.key")
+    assert_equal clear_text, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    assert reportable_value(config_value, CONFIG, EMPTY_CONTEXT).start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+  end
+
+  def test_confidential
+    config_value = PrefabProto::ConfigValue.new(confidential: true, string: "something confidential")
+    assert reportable_value(config_value, CONFIG, EMPTY_CONTEXT).start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+  end
+
+  def test_unwrap_confiential_provided
+    with_env('PAAS_PASSWORD', "the password")do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "PAAS_PASSWORD"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value, confidential: true)
+      assert_equal "the password", unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+      assert reportable_value(config_value, CONFIG, EMPTY_CONTEXT).start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+    end
+  end
+
+  private
+
+  def config_of(value_type)
+    PrefabProto::Config.new(
+      key: 'config-key',
+      value_type: value_type
+    )
+  end
+
+  def context_with_key(key)
+    Prefab::Context.new(user: { key: key })
+  end
+
+  def unwrap(config_value, config_key, context)
+    Prefab::ConfigValueUnwrapper.deepest_value(config_value, config_key, context, @mock_resolver).unwrap
+  end
+
+  def reportable_value(config_value, config_key, context)
+    Prefab::ConfigValueUnwrapper.deepest_value(config_value, config_key, context, @mock_resolver).reportable_value
+  end
+
+  class MockResolver
+    def get(key)
+      if DECRYPTION_KEY_NAME == key
+        Prefab::Evaluation.new(config: PrefabProto::Config.new(key: key),
+                               value: PrefabProto::ConfigValue.new(string: DECRYPTION_KEY_VALUE),
+                                value_index: 0,
+                                config_row_index: 0,
+                                context: Prefab::Context.new,
+                                resolver: self
+        )
+
+      else
+        raise "unexpected key"
+      end
+    end
+  end
+end

data/test/test_config_value_wrapper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestConfigValueWrapper < Minitest::Test
+  def test_wrap_integer
+    result = Prefab::ConfigValueWrapper.wrap(42)
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal 42, result.int
+  end
+
+  def test_wrap_float
+    result = Prefab::ConfigValueWrapper.wrap(3.14)
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal 3.14, result.double
+  end
+
+  def test_wrap_boolean_true
+    result = Prefab::ConfigValueWrapper.wrap(true)
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal true, result.bool
+  end
+
+  def test_wrap_boolean_false
+    result = Prefab::ConfigValueWrapper.wrap(false)
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal false, result.bool
+  end
+
+  def test_wrap_array
+    result = Prefab::ConfigValueWrapper.wrap(['one', 'two', 'three'])
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_instance_of PrefabProto::StringList, result.string_list
+    assert_equal ['one', 'two', 'three'], result.string_list.values
+  end
+
+  def test_wrap_string
+    result = Prefab::ConfigValueWrapper.wrap('hello')
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal 'hello', result.string
+  end
+end