prefab-cloud-ruby 0.24.3 → 0.24.4

data/test/test_config_resolver.rb

@@ -14,10 +14,10 @@ class TestConfigResolver < Minitest::Test
   WRONG_ENV_VALUE = 'wrong_env_value'
   NOT_IN_SEGMENT_VALUE = 'not_in_segment_value'
 
-  DEFAULT_ROW = Prefab::ConfigRow.new(
+  DEFAULT_ROW = PrefabProto::ConfigRow.new(
     values: [
-      Prefab::ConditionalValue.new(
-        value: Prefab::ConfigValue.new(string: DEFAULT_VALUE)
+      PrefabProto::ConditionalValue.new(
+        value: PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
       )
     ]
   )
@@ -26,88 +26,88 @@ class TestConfigResolver < Minitest::Test
     @loader = MockConfigLoader.new
 
     loaded_values = {
-      'key' => { config: Prefab::Config.new(
+      'key' => { config: PrefabProto::Config.new(
         key: 'key',
         rows: [
           DEFAULT_ROW,
-          Prefab::ConfigRow.new(
+          PrefabProto::ConfigRow.new(
             project_env_id: TEST_ENV_ID,
             values: [
-              Prefab::ConditionalValue.new(
+              PrefabProto::ConditionalValue.new(
                 criteria: [
-                  Prefab::Criterion.new(
-                    operator: Prefab::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
-                    value_to_match: Prefab::ConfigValue.new(string: 'projectB.subprojectX'),
+                  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: Prefab::ConfigValue.new(string: 'projectB.subprojectX')
+                value: PrefabProto::ConfigValue.new(string: 'projectB.subprojectX')
               ),
-              Prefab::ConditionalValue.new(
+              PrefabProto::ConditionalValue.new(
                 criteria: [
-                  Prefab::Criterion.new(
-                    operator: Prefab::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
-                    value_to_match: Prefab::ConfigValue.new(string: 'projectB.subprojectY'),
+                  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: Prefab::ConfigValue.new(string: 'projectB.subprojectY')
+                value: PrefabProto::ConfigValue.new(string: 'projectB.subprojectY')
               ),
-              Prefab::ConditionalValue.new(
+              PrefabProto::ConditionalValue.new(
                 criteria: [
-                  Prefab::Criterion.new(
-                    operator: Prefab::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
-                    value_to_match: Prefab::ConfigValue.new(string: 'projectA'),
+                  PrefabProto::Criterion.new(
+                    operator: PrefabProto::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
+                    value_to_match: PrefabProto::ConfigValue.new(string: 'projectA'),
                     property_name: Prefab::CriteriaEvaluator::NAMESPACE_KEY
                   )
                 ],
-                value: Prefab::ConfigValue.new(string: 'valueA')
+                value: PrefabProto::ConfigValue.new(string: 'valueA')
               ),
-              Prefab::ConditionalValue.new(
+              PrefabProto::ConditionalValue.new(
                 criteria: [
-                  Prefab::Criterion.new(
-                    operator: Prefab::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
-                    value_to_match: Prefab::ConfigValue.new(string: 'projectB'),
+                  PrefabProto::Criterion.new(
+                    operator: PrefabProto::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
+                    value_to_match: PrefabProto::ConfigValue.new(string: 'projectB'),
                     property_name: Prefab::CriteriaEvaluator::NAMESPACE_KEY
                   )
                 ],
-                value: Prefab::ConfigValue.new(string: 'valueB')
+                value: PrefabProto::ConfigValue.new(string: 'valueB')
               ),
-              Prefab::ConditionalValue.new(
+              PrefabProto::ConditionalValue.new(
                 criteria: [
-                  Prefab::Criterion.new(
-                    operator: Prefab::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
-                    value_to_match: Prefab::ConfigValue.new(string: 'projectB.subprojectX'),
+                  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: Prefab::ConfigValue.new(string: 'projectB.subprojectX')
+                value: PrefabProto::ConfigValue.new(string: 'projectB.subprojectX')
               ),
-              Prefab::ConditionalValue.new(
+              PrefabProto::ConditionalValue.new(
                 criteria: [
-                  Prefab::Criterion.new(
-                    operator: Prefab::Criterion::CriterionOperator::HIERARCHICAL_MATCH,
-                    value_to_match: Prefab::ConfigValue.new(string: 'projectB.subprojectY'),
+                  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: Prefab::ConfigValue.new(string: 'projectB.subprojectY')
+                value: PrefabProto::ConfigValue.new(string: 'projectB.subprojectY')
               ),
-              Prefab::ConditionalValue.new(
-                value: Prefab::ConfigValue.new(string: 'value_none')
+              PrefabProto::ConditionalValue.new(
+                value: PrefabProto::ConfigValue.new(string: 'value_none')
               )
             ]
           )
 
         ]
       ) },
-      'key2' => { config: Prefab::Config.new(
+      'key2' => { config: PrefabProto::Config.new(
         key: 'key2',
         rows: [
-          Prefab::ConfigRow.new(
+          PrefabProto::ConfigRow.new(
             values: [
-              Prefab::ConditionalValue.new(
-                value: Prefab::ConfigValue.new(string: 'valueB2')
+              PrefabProto::ConditionalValue.new(
+                value: PrefabProto::ConfigValue.new(string: 'valueB2')
               )
             ]
           )
@@ -164,67 +164,67 @@ class TestConfigResolver < Minitest::Test
   end
 
   def test_resolving_in_segment
-    segment_config = Prefab::Config.new(
-      config_type: Prefab::ConfigType::SEGMENT,
+    segment_config = PrefabProto::Config.new(
+      config_type: PrefabProto::ConfigType::SEGMENT,
       key: SEGMENT_KEY,
       rows: [
-        Prefab::ConfigRow.new(
+        PrefabProto::ConfigRow.new(
           values: [
-            Prefab::ConditionalValue.new(
-              value: Prefab::ConfigValue.new(bool: true),
+            PrefabProto::ConditionalValue.new(
+              value: PrefabProto::ConfigValue.new(bool: true),
               criteria: [
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                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'
                 )
               ]
             ),
-            Prefab::ConditionalValue.new(value: Prefab::ConfigValue.new(bool: false))
+            PrefabProto::ConditionalValue.new(value: PrefabProto::ConfigValue.new(bool: false))
           ]
         )
       ]
     )
 
-    config = Prefab::Config.new(
+    config = PrefabProto::Config.new(
       key: CONFIG_KEY,
       rows: [
         # wrong env
-        Prefab::ConfigRow.new(
+        PrefabProto::ConfigRow.new(
           project_env_id: TEST_ENV_ID,
           values: [
-            Prefab::ConditionalValue.new(
+            PrefabProto::ConditionalValue.new(
               criteria: [
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::IN_SEG,
-                  value_to_match: Prefab::ConfigValue.new(string: SEGMENT_KEY)
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: SEGMENT_KEY)
                 )
               ],
-              value: Prefab::ConfigValue.new(string: WRONG_ENV_VALUE)
+              value: PrefabProto::ConfigValue.new(string: WRONG_ENV_VALUE)
             ),
-            Prefab::ConditionalValue.new(
+            PrefabProto::ConditionalValue.new(
               criteria: [],
-              value: Prefab::ConfigValue.new(string: DEFAULT_VALUE)
+              value: PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
             )
           ]
         ),
 
         # correct env
-        Prefab::ConfigRow.new(
+        PrefabProto::ConfigRow.new(
           project_env_id: PRODUCTION_ENV_ID,
           values: [
-            Prefab::ConditionalValue.new(
+            PrefabProto::ConditionalValue.new(
               criteria: [
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::IN_SEG,
-                  value_to_match: Prefab::ConfigValue.new(string: SEGMENT_KEY)
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: SEGMENT_KEY)
                 )
               ],
-              value: Prefab::ConfigValue.new(string: IN_SEGMENT_VALUE)
+              value: PrefabProto::ConfigValue.new(string: IN_SEGMENT_VALUE)
             ),
-            Prefab::ConditionalValue.new(
+            PrefabProto::ConditionalValue.new(
               criteria: [],
-              value: Prefab::ConfigValue.new(string: DEFAULT_VALUE)
+              value: PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
             )
           ]
         )
@@ -251,50 +251,50 @@ class TestConfigResolver < Minitest::Test
   end
 
   def test_resolving_not_in_segment
-    segment_config = Prefab::Config.new(
-      config_type: Prefab::ConfigType::SEGMENT,
+    segment_config = PrefabProto::Config.new(
+      config_type: PrefabProto::ConfigType::SEGMENT,
       key: SEGMENT_KEY,
       rows: [
-        Prefab::ConfigRow.new(
+        PrefabProto::ConfigRow.new(
           values: [
-            Prefab::ConditionalValue.new(
-              value: Prefab::ConfigValue.new(bool: true),
+            PrefabProto::ConditionalValue.new(
+              value: PrefabProto::ConfigValue.new(bool: true),
               criteria: [
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                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'
                 )
               ]
             ),
-            Prefab::ConditionalValue.new(value: Prefab::ConfigValue.new(bool: false))
+            PrefabProto::ConditionalValue.new(value: PrefabProto::ConfigValue.new(bool: false))
           ]
         )
       ]
     )
 
-    config = Prefab::Config.new(
+    config = PrefabProto::Config.new(
       key: CONFIG_KEY,
       rows: [
-        Prefab::ConfigRow.new(
+        PrefabProto::ConfigRow.new(
           values: [
-            Prefab::ConditionalValue.new(
+            PrefabProto::ConditionalValue.new(
               criteria: [
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::IN_SEG,
-                  value_to_match: Prefab::ConfigValue.new(string: SEGMENT_KEY)
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: SEGMENT_KEY)
                 )
               ],
-              value: Prefab::ConfigValue.new(string: IN_SEGMENT_VALUE)
+              value: PrefabProto::ConfigValue.new(string: IN_SEGMENT_VALUE)
             ),
-            Prefab::ConditionalValue.new(
+            PrefabProto::ConditionalValue.new(
               criteria: [
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::NOT_IN_SEG,
-                  value_to_match: Prefab::ConfigValue.new(string: SEGMENT_KEY)
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::NOT_IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: SEGMENT_KEY)
                 )
               ],
-              value: Prefab::ConfigValue.new(string: NOT_IN_SEGMENT_VALUE)
+              value: PrefabProto::ConfigValue.new(string: NOT_IN_SEGMENT_VALUE)
             )
           ]
         )
@@ -320,28 +320,28 @@ class TestConfigResolver < Minitest::Test
   end
 
   def test_jit_context_merges_with_existing_context
-    config = Prefab::Config.new(
+    config = PrefabProto::Config.new(
       key: CONFIG_KEY,
       rows: [
         DEFAULT_ROW,
-        Prefab::ConfigRow.new(
+        PrefabProto::ConfigRow.new(
           project_env_id: TEST_ENV_ID,
           values: [
-            Prefab::ConditionalValue.new(
+            PrefabProto::ConditionalValue.new(
               criteria: [
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::PROP_IS_ONE_OF,
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_IS_ONE_OF,
                   value_to_match: string_list(%w[pro advanced]),
                   property_name: 'team.plan'
                 ),
 
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                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: Prefab::ConfigValue.new(string: DESIRED_VALUE)
+              value: PrefabProto::ConfigValue.new(string: DESIRED_VALUE)
             )
           ]
         )
@@ -364,28 +364,28 @@ class TestConfigResolver < Minitest::Test
   end
 
   def test_jit_can_clobber_existing_context
-    config = Prefab::Config.new(
+    config = PrefabProto::Config.new(
       key: CONFIG_KEY,
       rows: [
         DEFAULT_ROW,
-        Prefab::ConfigRow.new(
+        PrefabProto::ConfigRow.new(
           project_env_id: TEST_ENV_ID,
           values: [
-            Prefab::ConditionalValue.new(
+            PrefabProto::ConditionalValue.new(
               criteria: [
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::PROP_IS_ONE_OF,
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_IS_ONE_OF,
                   value_to_match: string_list(%w[pro advanced]),
                   property_name: 'team.plan'
                 ),
 
-                Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                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: Prefab::ConfigValue.new(string: DESIRED_VALUE)
+              value: PrefabProto::ConfigValue.new(string: DESIRED_VALUE)
             )
           ]
         )

data/test/test_config_value_unwrapper.rb

@@ -7,53 +7,53 @@ class TestConfigValueUnwrapper < Minitest::Test
   EMPTY_CONTEXT = Prefab::Context.new()
 
   def test_unwrapping_int
-    config_value = Prefab::ConfigValue.new(int: 123)
+    config_value = PrefabProto::ConfigValue.new(int: 123)
     assert_equal 123, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_string
-    config_value = Prefab::ConfigValue.new(string: 'abc')
+    config_value = PrefabProto::ConfigValue.new(string: 'abc')
     assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_double
-    config_value = Prefab::ConfigValue.new(double: 1.23)
+    config_value = PrefabProto::ConfigValue.new(double: 1.23)
     assert_equal 1.23, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_bool
-    config_value = Prefab::ConfigValue.new(bool: true)
+    config_value = PrefabProto::ConfigValue.new(bool: true)
     assert_equal true, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
 
-    config_value = Prefab::ConfigValue.new(bool: false)
+    config_value = PrefabProto::ConfigValue.new(bool: false)
     assert_equal false, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_log_level
-    config_value = Prefab::ConfigValue.new(log_level: :INFO)
+    config_value = PrefabProto::ConfigValue.new(log_level: :INFO)
     assert_equal :INFO, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_string_list
-    config_value = Prefab::ConfigValue.new(string_list: Prefab::StringList.new(values: %w[a b c]))
+    config_value = PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: %w[a b c]))
     assert_equal %w[a b c], Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_weighted_values
     # single value
-    config_value = Prefab::ConfigValue.new(weighted_values: weighted_values([['abc', 1]]))
+    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1]]))
 
     assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
 
     # multiple values, evenly distributed
-    config_value = Prefab::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 1], ['ghi', 1]]))
+    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 1], ['ghi', 1]]))
     assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:000'))
     assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:456'))
     assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:789'))
     assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:888'))
 
     # multiple values, unevenly distributed
-    config_value = Prefab::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 99], ['ghi', 1]]))
+    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 99], ['ghi', 1]]))
     assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:123'))
     assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:456'))
     assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:789'))
@@ -69,12 +69,12 @@ class TestConfigValueUnwrapper < Minitest::Test
       weighted_value(value, weight)
     end
 
-    Prefab::WeightedValues.new(weighted_values: values, hash_by_property_name: hash_by_property_name)
+    PrefabProto::WeightedValues.new(weighted_values: values, hash_by_property_name: hash_by_property_name)
   end
 
   def weighted_value(string, weight)
-    Prefab::WeightedValue.new(
-      value: Prefab::ConfigValue.new(string: string), weight: weight
+    PrefabProto::WeightedValue.new(
+      value: PrefabProto::ConfigValue.new(string: string), weight: weight
     )
   end
 

data/test/test_context.rb

@@ -132,6 +132,48 @@ class TestContext < Minitest::Test
     assert_empty context.to_h
   end
 
+  def test_to_proto
+    namespace = "my.namespace"
+
+    contexts = Prefab::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")
+          }
+        ),
+
+        PrefabProto::Context.new(
+          type: "prefab",
+          values: {
+            'current-time' => PrefabProto::ConfigValue.new(int: Prefab::TimeHelpers.now_in_ms),
+            'namespace' => PrefabProto::ConfigValue.new(string: namespace)
+          }
+        )
+      ]
+    ), contexts.to_proto(namespace)
+  end
+
   private
 
   def stringify(hash)

data/test/test_context_shape.rb

@@ -0,0 +1,51 @@
+# 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 = Prefab::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]
+
+    supported = PrefabProto::ConfigValue.descriptor.entries.reject do |entry|
+      unsupported.include?(entry.name.to_sym)
+    end.map(&:number)
+
+    mapped = Prefab::ContextShape::MAPPING.values.uniq
+
+    unless mapped == supported
+      raise "ContextShape MAPPING needs update: #{mapped} != #{supported}"
+    end
+  end
+end