sdk-reforge 1.9.0

data/test/test_config_value_unwrapper.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestConfigValueUnwrapper < Minitest::Test
+  CONFIG = PrefabProto::Config.new(
+    key: 'config_key'
+  )
+  EMPTY_CONTEXT = Reforge::Context.new()
+  DECRYPTION_KEY_NAME = "decryption.key"
+  DECRYPTION_KEY_VALUE = Reforge::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_duration
+    duration = PrefabProto::IsoDuration.new(definition: "PT1.5S")
+    config_value = PrefabProto::ConfigValue.new(duration: duration)
+    assert_equal 1.5, unwrap(config_value, CONFIG, EMPTY_CONTEXT).in_seconds
+    assert_equal 0.025, unwrap(config_value, CONFIG, EMPTY_CONTEXT).in_minutes
+    assert_in_delta 0.00041667, unwrap(config_value, CONFIG, EMPTY_CONTEXT).in_hours, 0.00001
+
+    duration = PrefabProto::IsoDuration.new(definition: "P4DT12H30M5S")
+    config_value = PrefabProto::ConfigValue.new(duration: duration)
+    assert_in_delta 0.6458, unwrap(config_value, CONFIG, EMPTY_CONTEXT).in_weeks, 0.0001
+    assert_in_delta 4.521, unwrap(config_value, CONFIG, EMPTY_CONTEXT).in_days, 0.001
+    assert_in_delta 108.5, unwrap(config_value, CONFIG, EMPTY_CONTEXT).in_hours, 0.1
+    assert_in_delta 6510.083, unwrap(config_value, CONFIG, EMPTY_CONTEXT).in_minutes, 0.001
+    assert_equal 390605 ,unwrap(config_value, CONFIG, EMPTY_CONTEXT).in_seconds
+  end
+
+  def test_unwrapping_json    
+    json = PrefabProto::Json.new(json: '{"a": 1, "b": "c"}')
+    config_value = PrefabProto::ConfigValue.new(json: json)
+    assert_equal({"a" => 1, "b" => "c"}, unwrap(config_value, CONFIG, EMPTY_CONTEXT))    
+  end
+  
+  def test_unwrapping_json_with_symbolize_json_names_true
+    @mock_resolver = MockResolver.new(symbolize_json_names: true)
+    json = PrefabProto::Json.new(json: '{"a": 1, "b": "c"}')
+    config_value = PrefabProto::ConfigValue.new(json: json)
+    assert_equal({:a => 1, :b => "c"}, unwrap(config_value, CONFIG, EMPTY_CONTEXT))
+
+    json = PrefabProto::Json.new(json: '{"foo": { "bar": "baz"}, "cow": "moo"}')
+    config_value = PrefabProto::ConfigValue.new(json: json)
+    assert_equal({:foo=>{:bar=>"baz"}, :cow=>"moo"}, unwrap(config_value, CONFIG, EMPTY_CONTEXT))
+
+    json = PrefabProto::Json.new(json: '[{"foo": { "bar": "baz"}}, {"cow": "moo"}]')
+    config_value = PrefabProto::ConfigValue.new(json: json)
+    assert_equal([{:foo=>{:bar=>"baz"}}, {:cow=>"moo"}], 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 Reforge::Errors::EnvVarParseError do
+        unwrap(config_value, config_of(PrefabProto::Config::ValueType::INT), EMPTY_CONTEXT)
+      end
+    end
+  end
+
+  def test_coerce
+    assert_equal "string", Reforge::ConfigValueUnwrapper.coerce_into_type("string", CONFIG, "ENV")
+    assert_equal 42, Reforge::ConfigValueUnwrapper.coerce_into_type("42", CONFIG, "ENV")
+    assert_equal false, Reforge::ConfigValueUnwrapper.coerce_into_type("false", CONFIG, "ENV")
+    assert_equal 42.42, Reforge::ConfigValueUnwrapper.coerce_into_type("42.42", CONFIG, "ENV")
+    assert_equal ["a","b"], Reforge::ConfigValueUnwrapper.coerce_into_type("['a','b']", CONFIG, "ENV")
+
+    assert_equal "string", Reforge::ConfigValueUnwrapper.coerce_into_type("string", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal "42", Reforge::ConfigValueUnwrapper.coerce_into_type("42", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal "42.42", Reforge::ConfigValueUnwrapper.coerce_into_type("42.42", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal 42, Reforge::ConfigValueUnwrapper.coerce_into_type("42", config_of(PrefabProto::Config::ValueType::INT),"ENV")
+    assert_equal false, Reforge::ConfigValueUnwrapper.coerce_into_type("false", config_of(PrefabProto::Config::ValueType::BOOL),"ENV")
+    assert_equal 42.42, Reforge::ConfigValueUnwrapper.coerce_into_type("42.42", config_of(PrefabProto::Config::ValueType::DOUBLE),"ENV")
+    assert_equal ["a","b"], Reforge::ConfigValueUnwrapper.coerce_into_type("['a','b']", config_of(PrefabProto::Config::ValueType::STRING_LIST),"ENV")
+
+    assert_raises Reforge::Errors::EnvVarParseError do
+      Reforge::ConfigValueUnwrapper.coerce_into_type("not an int", config_of(PrefabProto::Config::ValueType::INT), "ENV")
+    end
+    assert_raises Reforge::Errors::EnvVarParseError do
+      Reforge::ConfigValueUnwrapper.coerce_into_type("not bool", config_of(PrefabProto::Config::ValueType::BOOL), "ENV")
+    end
+    assert_raises Reforge::Errors::EnvVarParseError do
+      Reforge::ConfigValueUnwrapper.coerce_into_type("not a double", config_of(PrefabProto::Config::ValueType::DOUBLE), "ENV")
+    end
+    assert_raises Reforge::Errors::EnvVarParseError do
+      Reforge::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(Reforge::Errors::MissingEnvVarError) do
+      unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    end
+  end
+
+  def test_unwrapping_encrypted_values_decrypts
+    clear_text = "very secret stuff"
+    encrypted = Reforge::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? Reforge::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? Reforge::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? Reforge::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)
+    Reforge::Context.new(user: { key: key })
+  end
+
+  def unwrap(config_value, config_key, context)
+    Reforge::ConfigValueUnwrapper.deepest_value(config_value, config_key, context, @mock_resolver).unwrap
+  end
+
+  def reportable_value(config_value, config_key, context)
+    Reforge::ConfigValueUnwrapper.deepest_value(config_value, config_key, context, @mock_resolver).reportable_value
+  end
+
+  class MockResolver
+
+    def initialize(symbolize_json_names: false)
+      @symbolize_json_names = symbolize_json_names
+    end
+
+    def symbolize_json_names?
+      @symbolize_json_names
+    end
+
+    def get(key)
+      if DECRYPTION_KEY_NAME == key
+        Reforge::Evaluation.new(config: PrefabProto::Config.new(key: key),
+                               value: PrefabProto::ConfigValue.new(string: DECRYPTION_KEY_VALUE),
+                                value_index: 0,
+                                config_row_index: 0,
+                                context: Reforge::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 = Reforge::ConfigValueWrapper.wrap(42)
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal 42, result.int
+  end
+
+  def test_wrap_float
+    result = Reforge::ConfigValueWrapper.wrap(3.14)
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal 3.14, result.double
+  end
+
+  def test_wrap_boolean_true
+    result = Reforge::ConfigValueWrapper.wrap(true)
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal true, result.bool
+  end
+
+  def test_wrap_boolean_false
+    result = Reforge::ConfigValueWrapper.wrap(false)
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal false, result.bool
+  end
+
+  def test_wrap_array
+    result = Reforge::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 = Reforge::ConfigValueWrapper.wrap('hello')
+    assert_instance_of PrefabProto::ConfigValue, result
+    assert_equal 'hello', result.string
+  end
+end

data/test/test_context.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestContext < Minitest::Test
+  EXAMPLE_PROPERTIES = { user: { key: 'some-user-key', name: 'Ted' }, team: { key: 'abc', plan: 'pro' } }.freeze
+
+  def setup
+    super
+    Reforge::Context.current = nil
+  end
+
+  def test_initialize_with_empty_context
+    context = Reforge::Context.new({})
+    assert_empty context.contexts
+  end
+
+  def test_initialize_with_hash
+    context = Reforge::Context.new(test: { foo: 'bar' })
+    assert_equal 1, context.contexts.size
+    assert_equal 'bar', context.get("test.foo")
+  end
+
+  def test_initialize_with_multiple_hashes
+    context = Reforge::Context.new(test: { foo: 'bar' }, other: { foo: 'baz' })
+    assert_equal 2, context.contexts.size
+    assert_equal 'bar', context.get("test.foo")
+    assert_equal 'baz', context.get("other.foo")
+  end
+
+  def test_initialize_with_invalid_argument
+    assert_raises(ArgumentError) { Reforge::Context.new([]) }
+  end
+
+  def test_current
+    context = Reforge::Context.current
+    assert_instance_of Reforge::Context, context
+    assert_empty context.to_h
+  end
+
+  def test_current_set
+    context = Reforge::Context.new(EXAMPLE_PROPERTIES)
+    Reforge::Context.current = context.to_h
+    assert_instance_of Reforge::Context, context
+    assert_equal stringify(EXAMPLE_PROPERTIES), context.to_h
+  end
+
+  def test_with_context
+    Reforge::Context.with_context(EXAMPLE_PROPERTIES) do
+      context = Reforge::Context.current
+      assert_equal(stringify(EXAMPLE_PROPERTIES), context.to_h)
+      assert_equal('some-user-key', context.get('user.key'))
+    end
+  end
+
+  def test_with_context_nesting
+    Reforge::Context.with_context(EXAMPLE_PROPERTIES) do
+      Reforge::Context.with_context({ user: { key: 'abc', other: 'different' } }) do
+        context = Reforge::Context.current
+        assert_equal({ 'user' => { 'key' => 'abc', 'other' => 'different' } }, context.to_h)
+      end
+
+      context = Reforge::Context.current
+      assert_equal(stringify(EXAMPLE_PROPERTIES), context.to_h)
+    end
+  end
+
+  def test_with_context_merge_nesting
+    Reforge::Context.with_context(EXAMPLE_PROPERTIES) do
+      Reforge::Context.with_merged_context({ user: { key: 'hij', other: 'different' } }) do
+        context = Reforge::Context.current
+        assert_nil context.get('user.name')
+        assert_equal context.get('user.key'), 'hij'
+        assert_equal context.get('user.other'), 'different'
+
+        assert_equal context.get('team.key'), 'abc'
+        assert_equal context.get('team.plan'), 'pro'
+      end
+
+      context = Reforge::Context.current
+      assert_equal(stringify(EXAMPLE_PROPERTIES), context.to_h)
+    end
+  end
+
+  def test_setting
+    context = Reforge::Context.new({})
+    context.set('user', { key: 'value' })
+    context.set(:other, { key: 'different', something: 'other' })
+    assert_equal(stringify({ user: { key: 'value' }, other: { key: 'different', something: 'other' } }), context.to_h)
+  end
+
+  def test_getting
+    context = Reforge::Context.new(EXAMPLE_PROPERTIES)
+    assert_equal('some-user-key', context.get('user.key'))
+    assert_equal('pro', context.get('team.plan'))
+  end
+
+  def test_dot_notation_getting
+    context = Reforge::Context.new({ 'user' => { 'key' => 'value' } })
+    assert_equal('value', context.get('user.key'))
+  end
+
+  def test_dot_notation_getting_with_symbols
+    context = Reforge::Context.new({ user: { key: 'value' } })
+    assert_equal('value', context.get('user.key'))
+  end
+
+  def test_clear
+    context = Reforge::Context.new(EXAMPLE_PROPERTIES)
+    context.clear
+
+    assert_empty context.to_h
+  end
+
+  def test_to_proto
+    namespace = "my.namespace"
+
+    contexts = Reforge::Context.new({
+                                     user: {
+                                       id: 1,
+                                       email: 'user-email'
+                                     },
+                                     team: {
+                                       id: 2,
+                                       name: 'team-name'
+                                     }
+                                   })
+
+    assert_equal PrefabProto::ContextSet.new(
+      contexts: [
+        PrefabProto::Context.new(
+          type: "user",
+          values: {
+            "id" => PrefabProto::ConfigValue.new(int: 1),
+            "email" => PrefabProto::ConfigValue.new(string: "user-email")
+          }
+        ),
+        PrefabProto::Context.new(
+          type: "team",
+          values: {
+            "id" => PrefabProto::ConfigValue.new(int: 2),
+            "name" => PrefabProto::ConfigValue.new(string: "team-name")
+          }
+        )
+      ]
+    ), contexts.to_proto(namespace)
+  end
+
+  def test_to_proto_with_parent
+    global_context = { cpu: { count: 4, speed: '2.4GHz' }, clock: { timezone: 'UTC' }, magic: { key: "global-key" } }
+    default_context = { 'prefab-api-key' => { 'user-id' => 123 } }
+
+    Reforge::Context.global_context = global_context
+    Reforge::Context.default_context = default_context
+
+    Reforge::Context.current = {
+      user: { id: 2, email: 'parent-email' },
+      magic: { key: 'parent-key', rabbits: 3 },
+      clock: { timezone: 'PST' }
+    }
+
+    contexts = Reforge::Context.join(hash: {
+                                      user: {
+                                        id: 1,
+                                        email: 'user-email'
+                                      },
+                                      team: {
+                                        id: 2,
+                                        name: 'team-name'
+                                      }
+                                    }, id: :jit, parent: Reforge::Context.current)
+
+    expected = PrefabProto::ContextSet.new(
+      contexts: [
+        # Via global
+        PrefabProto::Context.new(
+          type: "cpu",
+          values: {
+            "count" => PrefabProto::ConfigValue.new(int: 4),
+            "speed" => PrefabProto::ConfigValue.new(string: "2.4GHz")
+          }
+        ),
+        # Via default
+        PrefabProto::Context.new(
+          type: "clock",
+          values: {
+            "timezone" => PrefabProto::ConfigValue.new(string: 'PST'),
+          }
+        ),
+        # via current
+        PrefabProto::Context.new(
+          type: "magic",
+          values: {
+            "key" => PrefabProto::ConfigValue.new(string: 'parent-key'),
+            "rabbits" => PrefabProto::ConfigValue.new(int: 3)
+          }
+        ),
+        # via default
+        PrefabProto::Context.new(
+          type: "prefab-api-key",
+          values: {
+            "user-id" => PrefabProto::ConfigValue.new(int: 123)
+          }
+        ),
+        # via jit
+        PrefabProto::Context.new(
+          type: "user",
+          values: {
+            "id" => PrefabProto::ConfigValue.new(int: 1),
+            "email" => PrefabProto::ConfigValue.new(string: "user-email")
+          }
+        ),
+        # via jit
+        PrefabProto::Context.new(
+          type: "team",
+          values: {
+            "id" => PrefabProto::ConfigValue.new(int: 2),
+            "name" => PrefabProto::ConfigValue.new(string: "team-name")
+          }
+        ),
+      ]
+    )
+
+    actual = contexts.to_proto("")
+
+    assert_equal expected, actual
+  end
+
+  def test_parent_lookup
+    global_context = { cpu: { count: 4, speed: '2.4GHz' }, clock: { timezone: 'UTC' } }
+    default_context = { 'prefab-api-key' => { 'user-id' => 123 } }
+    local_context = { clock: { timezone: 'PST' }, user: { name: 'Ted', email: 'ted@example.com' } }
+    jit_context = { user: { name: 'Frank' } }
+
+    Reforge::Context.global_context = global_context
+    Reforge::Context.default_context = default_context
+    Reforge::Context.current = local_context
+
+    context = Reforge::Context.join(parent: Reforge::Context.current, hash: jit_context, id: :jit)
+
+    # This digs all the way to the global context
+    assert_equal 4, context.get('cpu.count')
+    assert_equal '2.4GHz', context.get('cpu.speed')
+
+    # This digs to the default context
+    assert_equal 123, context.get('prefab-api-key.user-id')
+
+    # This digs to the local context
+    assert_equal 'PST', context.get('clock.timezone')
+
+    # This uses the jit context
+    assert_equal 'Frank', context.get('user.name')
+
+    # This is nil in the jit context because `user` was clobbered
+    assert_nil context.get('user.email')
+  end
+
+  private
+
+  def stringify(hash)
+    hash.map { |k, v| [k.to_s, stringify_keys(v)] }.to_h
+  end
+
+  def stringify_keys(value)
+    if value.is_a?(Hash)
+      value.transform_keys(&:to_s)
+    else
+      value
+    end
+  end
+end

data/test/test_context_shape.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestContextShape < Minitest::Test
+  class Email; end
+
+  def test_field_type_number
+    [
+      [1, 1],
+      [99999999999999999999999999999999999999999999, 1],
+      [-99999999999999999999999999999999999999999999, 1],
+
+      ['a', 2],
+      ['99999999999999999999999999999999999999999999', 2],
+
+      [1.0, 4],
+      [99999999999999999999999999999999999999999999.0, 4],
+      [-99999999999999999999999999999999999999999999.0, 4],
+
+      [true, 5],
+      [false, 5],
+
+      [[], 10],
+      [[1, 2, 3], 10],
+      [['a', 'b', 'c'], 10],
+
+      [Email.new, 2],
+    ].each do |value, expected|
+      actual = Reforge::ContextShape.field_type_number(value)
+
+      refute_nil actual, "Expected a value for input: #{value}"
+      assert_equal expected, actual, "Expected #{expected} for #{value}"
+    end
+  end
+
+  # If this test fails, it means that we've added a new type to the ConfigValue
+  def test_mapping_is_exhaustive
+    unsupported = [:bytes, :limit_definition, :log_level, :weighted_values, :int_range, :provided, :duration, :json, :schema]
+    type_fields = PrefabProto::ConfigValue.descriptor.lookup_oneof("type").entries
+    supported = type_fields.entries.reject do |entry|
+      unsupported.include?(entry.name.to_sym)
+    end.map(&:number)
+    mapped = Reforge::ContextShape::MAPPING.values.uniq
+
+    unless mapped == supported
+      raise "ContextShape MAPPING needs update: #{mapped} != #{supported}"
+    end
+  end
+end