prefab-cloud-ruby 0.23.8 → 0.24.0

data/lib/prefab/resolved_config_presenter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Prefab
+  class ResolvedConfigPresenter
+    class ConfigRow
+      include Comparable
+
+      attr_reader :key, :value, :match, :source
+
+      def initialize(key, value, match, source)
+        @key = key
+        @value = value
+        @match = match
+        @source = source
+      end
+
+      def <=>(other)
+        inspect <=> other.inspect
+      end
+
+      def inspect
+        [@key, @value, @match, @source].inspect
+      end
+    end
+
+    def initialize(resolver, lock, local_store)
+      @resolver = resolver
+      @lock = lock
+      @local_store = local_store
+    end
+
+    def each(&block)
+      to_h.each(&block)
+    end
+
+    def to_h
+      hash = {}
+
+      Prefab::Context.with_context({}) do
+        @lock.with_read_lock do
+          @local_store.keys.sort.each do |k|
+            v = @local_store[k]
+
+            if v.nil?
+              hash[k] = ConfigRow.new(k, nil, nil, nil)
+            else
+              config = @resolver.evaluate(v[:config])
+              value = Prefab::ConfigValueUnwrapper.unwrap(config, k, {})
+              hash[k] = ConfigRow.new(k, value, v[:match], v[:source])
+            end
+          end
+        end
+      end
+
+      hash
+    end
+
+    def to_s
+      str = "\n"
+
+      Prefab::Context.with_context({}) do
+        @lock.with_read_lock do
+          @local_store.keys.sort.each do |k|
+            v = @local_store[k]
+            elements = [k.slice(0..49).ljust(50)]
+            if v.nil?
+              elements << 'tombstone'
+            else
+              config = @resolver.evaluate(v[:config], {})
+              value = Prefab::ConfigValueUnwrapper.unwrap(config, k, {})
+              elements << value.to_s.slice(0..34).ljust(35)
+              elements << value.class.to_s.slice(0..6).ljust(7)
+              elements << "Match: #{v[:match]}".slice(0..29).ljust(30)
+              elements << "Source: #{v[:source]}"
+            end
+            str += elements.join(' | ') << "\n"
+          end
+        end
+      end
+
+      str
+    end
+  end
+end

data/lib/prefab/weighted_value_resolver.rb

@@ -4,14 +4,14 @@ module Prefab
   class WeightedValueResolver
     MAX_32_FLOAT = 4_294_967_294.0
 
-    def initialize(weights, config_key, lookup_key)
+    def initialize(weights, config_key, context_hash_value)
       @weights = weights
       @config_key = config_key
-      @lookup_key = lookup_key
+      @context_hash_value = context_hash_value
     end
 
     def resolve
-      percent = @lookup_key ? user_percent : rand
+      percent = @context_hash_value ? user_percent : rand
 
       index = variant_index(percent)
 
@@ -19,7 +19,7 @@ module Prefab
     end
 
     def user_percent
-      to_hash = "#{@config_key}#{@lookup_key}"
+      to_hash = "#{@config_key}#{@context_hash_value}"
       int_value = Murmur3.murmur3_32(to_hash)
       int_value / MAX_32_FLOAT
     end

data/lib/prefab-cloud-ruby.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+module Prefab
+  NO_DEFAULT_PROVIDED = :no_default_provided
+end
+
 require 'concurrent/atomics'
 require 'concurrent'
 require 'faraday'
@@ -21,8 +25,10 @@ require 'prefab/criteria_evaluator'
 require 'prefab/config_loader'
 require 'prefab/local_config_parser'
 require 'prefab/yaml_config_parser'
+require 'prefab/resolved_config_presenter'
 require 'prefab/config_resolver'
 require 'prefab/http_connection'
+require 'prefab/context'
 require 'prefab/client'
 require 'prefab/config_client'
 require 'prefab/feature_flag_client'

data/prefab-cloud-ruby.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: prefab-cloud-ruby 0.23.8 ruby lib
+# stub: prefab-cloud-ruby 0.24.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.23.8"
+  s.version = "0.24.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Jeff Dwyer".freeze]
-  s.date = "2023-04-21"
+  s.date = "2023-04-26"
   s.description = "Feature Flags, Live Config, and Dynamic Log Levels as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [
@@ -38,6 +38,7 @@ Gem::Specification.new do |s|
     "lib/prefab/config_loader.rb",
     "lib/prefab/config_resolver.rb",
     "lib/prefab/config_value_unwrapper.rb",
+    "lib/prefab/context.rb",
     "lib/prefab/criteria_evaluator.rb",
     "lib/prefab/error.rb",
     "lib/prefab/errors/initialization_timeout_error.rb",
@@ -54,6 +55,7 @@ Gem::Specification.new do |s|
     "lib/prefab/noop_cache.rb",
     "lib/prefab/noop_stats.rb",
     "lib/prefab/options.rb",
+    "lib/prefab/resolved_config_presenter.rb",
     "lib/prefab/sse_logger.rb",
     "lib/prefab/weighted_value_resolver.rb",
     "lib/prefab/yaml_config_parser.rb",
@@ -68,6 +70,7 @@ Gem::Specification.new do |s|
     "test/test_config_loader.rb",
     "test/test_config_resolver.rb",
     "test/test_config_value_unwrapper.rb",
+    "test/test_context.rb",
     "test/test_criteria_evaluator.rb",
     "test/test_exponential_backoff.rb",
     "test/test_feature_flag_client.rb",

data/test/.prefab.unit_tests.config.yaml

@@ -9,8 +9,9 @@ sample: test sample value
 enabled_flag: true
 disabled_flag: false
 flag_with_a_value: { "feature_flag": "true", value: "all-features" }
-in_lookup_key: { "feature_flag": "true", value: true, criterion: { operator: LOOKUP_KEY_IN, values: [ "abc123", "xyz987" ] } }
-just_my_domain: { "feature_flag": "true", value: "new-version", criterion: { operator: PROP_IS_ONE_OF, property: "domain", values: [ "prefab.cloud", "example.com" ] } }
+user_key_match: { "feature_flag": "true", value: true, criterion: { operator: PROP_IS_ONE_OF, values: [ "abc123", "xyz987" ], property: "user.key" } }
+just_my_domain: { "feature_flag": "true", value: "new-version", criterion: { operator: PROP_IS_ONE_OF, property: "user.domain", values: [ "prefab.cloud", "example.com" ] } }
+deprecated_no_dot_notation: { "feature_flag": "true", value: true, criterion: { operator: PROP_IS_ONE_OF, property: "domain", values: [ "prefab.cloud", "example.com" ] } }
 
 nested:
   values:

data/test/integration_test.rb

@@ -1,18 +1,14 @@
 # frozen_string_literal: true
 
 class IntegrationTest
-  attr_reader :func
-  attr_reader :input
-  attr_reader :expected
-  attr_reader :test_client
+  attr_reader :func, :input, :expected, :test_client
 
   def initialize(test_data)
     @client_overrides = parse_client_overrides(test_data['client_overrides'])
     @func = parse_function(test_data['function'])
     @input = parse_input(test_data['input'])
     @expected = parse_expected(test_data['expected'])
-    test_client = :"#{test_data['client']}"
-    @test_client = base_client.send(test_client)
+    @test_client = base_client
   end
 
   def test_type
@@ -40,7 +36,7 @@ class IntegrationTest
   def parse_function(function)
     case function
     when 'get_or_raise' then :get
-    when 'enabled' then :feature_is_on_for?
+    when 'enabled' then :enabled?
     else :"#{function}"
     end
   end
@@ -62,7 +58,7 @@ class IntegrationTest
   end
 
   def parse_ff_input(input)
-    [input['flag'], input['lookup_key'], input['properties'] || {}]
+    [input['flag'], input['context']]
   end
 
   def parse_expected(expected)

data/test/test_client.rb

@@ -44,32 +44,36 @@ class TestClient < Minitest::Test
     assert_equal false, @client.enabled?('flag_with_a_value')
   end
 
-  def test_ff_enabled_with_lookup_key
-    assert_equal false, @client.enabled?('in_lookup_key', 'jimmy')
-    assert_equal true, @client.enabled?('in_lookup_key', 'abc123')
-    assert_equal true, @client.enabled?('in_lookup_key', 'xyz987')
+  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' } })
   end
 
-  def test_ff_get_with_lookup_key
-    assert_nil @client.get('in_lookup_key', 'jimmy')
-    assert_equal 'DEFAULT', @client.get('in_lookup_key', 'jimmy', {}, 'DEFAULT')
-
-    assert_equal true, @client.get('in_lookup_key', 'abc123')
-    assert_equal true, @client.get('in_lookup_key', 'xyz987')
+  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' })
   end
 
-  def test_ff_enabled_with_attributes
-    assert_equal false, @client.enabled?('just_my_domain', 'abc123', { domain: 'gmail.com' })
-    assert_equal false, @client.enabled?('just_my_domain', 'abc123', { domain: 'prefab.cloud' })
-    assert_equal false, @client.enabled?('just_my_domain', 'abc123', { domain: 'example.com' })
+  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')
+
+    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' } })
   end
 
-  def test_ff_get_with_attributes
-    assert_nil @client.get('just_my_domain', 'abc123', { domain: 'gmail.com' })
-    assert_equal 'DEFAULT', @client.get('just_my_domain', 'abc123', { domain: 'gmail.com' }, 'DEFAULT')
+  def test_deprecated_no_dot_notation_ff_enabled_with_jit_context
+    # 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 'new-version', @client.get('just_my_domain', 'abc123', { domain: 'prefab.cloud' })
-    assert_equal 'new-version', @client.get('just_my_domain', 'abc123', { 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' })
   end
 
   def test_getting_feature_flag_value
@@ -103,14 +107,11 @@ class TestClient < Minitest::Test
 
   private
 
-  def new_client(overrides = {})
-    options = Prefab::Options.new(**{
-      prefab_config_override_dir: 'none',
-      prefab_config_classpath_dir: 'test',
-      prefab_envs: ['unit_tests'],
-      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
-    }.merge(overrides))
+  def assert_equal_context_and_jit(expected, method, key, context)
+    assert_equal expected, @client.send(method, key, context)
 
-    Prefab::Client.new(options)
+    Prefab::Context.with_context(context) do
+      assert_equal expected, @client.send(method, key)
+    end
   end
 end

data/test/test_config_resolver.rb

@@ -9,10 +9,19 @@ class TestConfigResolver < Minitest::Test
   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 = Prefab::ConfigRow.new(
+    values: [
+      Prefab::ConditionalValue.new(
+        value: Prefab::ConfigValue.new(string: DEFAULT_VALUE)
+      )
+    ]
+  )
+
   def test_resolution
     @loader = MockConfigLoader.new
 
@@ -20,13 +29,7 @@ class TestConfigResolver < Minitest::Test
       'key' => { config: Prefab::Config.new(
         key: 'key',
         rows: [
-          Prefab::ConfigRow.new(
-            values: [
-              Prefab::ConditionalValue.new(
-                value: Prefab::ConfigValue.new(string: 'value_no_env_default')
-              )
-            ]
-          ),
+          DEFAULT_ROW,
           Prefab::ConfigRow.new(
             project_env_id: TEST_ENV_ID,
             values: [
@@ -114,31 +117,49 @@ class TestConfigResolver < Minitest::Test
 
     @loader.stub :calc_config, loaded_values do
       @resolverA = resolver_for_namespace('', @loader, project_env_id: PRODUCTION_ENV_ID)
-      assert_equal 'value_no_env_default', @resolverA.get('key', nil).string
+      assert_equal_context_and_jit DEFAULT_VALUE, @resolverA, 'key', {}, :string
 
       ## below here in the test env
       @resolverA = resolver_for_namespace('', @loader)
-      assert_equal 'value_none', @resolverA.get('key', nil).string
+      assert_equal_context_and_jit 'value_none', @resolverA, 'key', {}, :string
 
       @resolverA = resolver_for_namespace('projectA', @loader)
-      assert_equal 'valueA', @resolverA.get('key', nil).string
+      assert_equal_context_and_jit 'valueA', @resolverA, 'key', {}, :string
 
       @resolverB = resolver_for_namespace('projectB', @loader)
-      assert_equal 'valueB', @resolverB.get('key', nil).string
+      assert_equal_context_and_jit 'valueB', @resolverB, 'key', {}, :string
 
       @resolverBX = resolver_for_namespace('projectB.subprojectX', @loader)
-      assert_equal 'projectB.subprojectX', @resolverBX.get('key', nil).string
+      assert_equal_context_and_jit 'projectB.subprojectX', @resolverBX, 'key', {}, :string
 
       @resolverBX = resolver_for_namespace('projectB.subprojectX', @loader)
-      assert_equal 'valueB2', @resolverBX.get('key2', nil).string
+      assert_equal_context_and_jit 'valueB2', @resolverBX, 'key2', {}, :string
 
-      @resolverUndefinedSubProject = resolver_for_namespace('projectB.subprojectX.subsubQ', @loader)
-      assert_equal 'projectB.subprojectX', @resolverUndefinedSubProject.get('key', nil).string
+      @resolverUndefinedSubProject = resolver_for_namespace('projectB.subprojectX.subsubQ',
+                                                            @loader)
+      assert_equal_context_and_jit 'projectB.subprojectX', @resolverUndefinedSubProject, 'key',
+                                   {}, :string
 
       @resolverBX = resolver_for_namespace('projectC', @loader)
-      assert_equal 'value_none', @resolverBX.get('key', nil).string
+      assert_equal_context_and_jit 'value_none', @resolverBX, 'key', {}, :string
 
       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
 
@@ -155,7 +176,7 @@ class TestConfigResolver < Minitest::Test
                 Prefab::Criterion.new(
                   operator: Prefab::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
                   value_to_match: string_list(['hotmail.com', 'gmail.com']),
-                  property_name: 'email'
+                  property_name: 'user.email'
                 )
               ]
             ),
@@ -222,8 +243,10 @@ class TestConfigResolver < Minitest::Test
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
       resolver.project_env_id = PRODUCTION_ENV_ID
 
-      assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, nil, { email: 'test@something-else.com' }).string
-      assert_equal IN_SEGMENT_VALUE, resolver.get(CONFIG_KEY, nil, { email: 'test@hotmail.com' }).string
+      assert_equal_context_and_jit DEFAULT_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' } }, :string
     end
   end
 
@@ -240,7 +263,7 @@ class TestConfigResolver < Minitest::Test
                 Prefab::Criterion.new(
                   operator: Prefab::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
                   value_to_match: string_list(['hotmail.com', 'gmail.com']),
-                  property_name: 'email'
+                  property_name: 'user.email'
                 )
               ]
             ),
@@ -289,77 +312,98 @@ class TestConfigResolver < Minitest::Test
       options = Prefab::Options.new
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
 
-      assert_equal IN_SEGMENT_VALUE, resolver.get(CONFIG_KEY, nil, { email: 'test@hotmail.com' }).string
-      assert_equal NOT_IN_SEGMENT_VALUE, resolver.get(CONFIG_KEY, nil, { email: 'test@something-else.com' }).string
+      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
     end
   end
 
-  def test_resolving_in_segment_with_lookup_key
-    segment_config = Prefab::Config.new(
-      config_type: Prefab::ConfigType::SEGMENT,
-      key: SEGMENT_KEY,
+  def test_jit_context_merges_with_existing_context
+    config = Prefab::Config.new(
+      key: CONFIG_KEY,
       rows: [
+        DEFAULT_ROW,
         Prefab::ConfigRow.new(
+          project_env_id: TEST_ENV_ID,
           values: [
             Prefab::ConditionalValue.new(
-              value: Prefab::ConfigValue.new(bool: true),
               criteria: [
                 Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::LOOKUP_KEY_IN,
-                  value_to_match: string_list(['user:1234', 'user:4567']),
-                  property_name: 'LOOKUP'
+                  operator: Prefab::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,
+                  value_to_match: string_list(%w[@example.com]),
+                  property_name: 'user.email'
                 )
-              ]
-            ),
-            Prefab::ConditionalValue.new(value: Prefab::ConfigValue.new(bool: false))
+              ],
+              value: Prefab::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).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
+      end
+    end
+  end
+
+  def test_jit_can_clobber_existing_context
     config = Prefab::Config.new(
       key: CONFIG_KEY,
       rows: [
+        DEFAULT_ROW,
         Prefab::ConfigRow.new(
+          project_env_id: TEST_ENV_ID,
           values: [
             Prefab::ConditionalValue.new(
               criteria: [
                 Prefab::Criterion.new(
-                  operator: Prefab::Criterion::CriterionOperator::IN_SEG,
-                  value_to_match: Prefab::ConfigValue.new(string: SEGMENT_KEY)
-                )
-              ],
-              value: Prefab::ConfigValue.new(string: IN_SEGMENT_VALUE)
-            ),
-            Prefab::ConditionalValue.new(
-              criteria: [
+                  operator: Prefab::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::NOT_IN_SEG,
-                  value_to_match: Prefab::ConfigValue.new(string: SEGMENT_KEY)
+                  operator: Prefab::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                  value_to_match: string_list(%w[@example.com]),
+                  property_name: 'user.email'
                 )
               ],
-              value: Prefab::ConfigValue.new(string: NOT_IN_SEGMENT_VALUE)
+              value: Prefab::ConfigValue.new(string: DESIRED_VALUE)
             )
           ]
         )
       ]
     )
 
-    loaded_values = {
-      SEGMENT_KEY => { config: segment_config },
-      CONFIG_KEY => { config: config }
-    }
-
     loader = MockConfigLoader.new
 
-    loader.stub :calc_config, loaded_values do
+    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
 
-      assert_equal IN_SEGMENT_VALUE, resolver.get(CONFIG_KEY, 'user:1234', {}).string
-      assert_equal IN_SEGMENT_VALUE, resolver.get(CONFIG_KEY, 'user:4567', {}).string
-      assert_equal NOT_IN_SEGMENT_VALUE, resolver.get(CONFIG_KEY, nil, {}).string
-      assert_equal NOT_IN_SEGMENT_VALUE, resolver.get(CONFIG_KEY, 'user:9999', {}).string
+      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
+      end
     end
   end
 
@@ -374,4 +418,12 @@ class TestConfigResolver < Minitest::Test
     resolver.update
     resolver
   end
+
+  def assert_equal_context_and_jit(expected_value, resolver, key, properties, type)
+    assert_equal expected_value, resolver.get(key, properties).send(type)
+
+    Prefab::Context.with_context(properties) do
+      assert_equal expected_value, resolver.get(key).send(type)
+    end
+  end
 end

data/test/test_config_value_unwrapper.rb

@@ -41,34 +41,34 @@ class TestConfigValueUnwrapper < Minitest::Test
   def test_unwrapping_weighted_values
     # single value
     config_value = Prefab::ConfigValue.new(weighted_values: weighted_values([['abc', 1]]))
+
     assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
 
     # multiple values, evenly distributed
     config_value = Prefab::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 1], ['ghi', 1]]))
-    assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:123'))
-    assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:456'))
-    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:789'))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:012'))
+    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]]))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:123'))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:456'))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:789'))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:012'))
-
-    assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:103'))
-    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, lookup_properties('user:119'))
+    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'))
+    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:012'))
+    assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:428'))
+    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:548'))
   end
 
   private
 
-  def weighted_values(values_and_weights)
+  def weighted_values(values_and_weights, hash_by_property_name: 'user.key')
     values = values_and_weights.map do |value, weight|
       weighted_value(value, weight)
     end
 
-    Prefab::WeightedValues.new(weighted_values: values)
+    Prefab::WeightedValues.new(weighted_values: values, hash_by_property_name: hash_by_property_name)
   end
 
   def weighted_value(string, weight)
@@ -77,7 +77,7 @@ class TestConfigValueUnwrapper < Minitest::Test
     )
   end
 
-  def lookup_properties(lookup_key)
-    { Prefab::CriteriaEvaluator::LOOKUP_KEY => lookup_key }
+  def context_with_key(key)
+    Prefab::Context.new(user: { key: key })
   end
 end