prefab-cloud-ruby 0 → 0.0.1

data/test/test_config_client.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestConfigClient < Minitest::Test
-  def setup
-    super
-    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,
-      x_use_local_cache: true,
-    )
-
-    @config_client = Prefab::ConfigClient.new(MockBaseClient.new(options), 10)
-  end
-
-  def test_load
-    assert_equal 'test sample value', @config_client.get('sample')
-    assert_equal 123, @config_client.get('sample_int')
-    assert_equal 12.12, @config_client.get('sample_double')
-    assert_equal true, @config_client.get('sample_bool')
-    assert_equal :ERROR, @config_client.get('log-level.app')
-  end
-
-  def test_initialization_timeout_error
-    options = Prefab::Options.new(
-      api_key: '123-ENV-KEY-SDK',
-      initialization_timeout_sec: 0.01,
-      logdev: StringIO.new
-    )
-
-    err = assert_raises(Prefab::Errors::InitializationTimeoutError) do
-      Prefab::Client.new(options).config_client.get('anything')
-    end
-
-    assert_match(/couldn't initialize in 0.01 second timeout/, err.message)
-  end
-
-  def test_prefab_envs_is_forgiving
-    assert_equal ['my_env'], Prefab::Options.new(
-      prefab_envs: 'my_env'
-    ).prefab_envs
-
-    assert_equal %w[my_env a_second_env], Prefab::Options.new(
-      prefab_envs: %w[my_env a_second_env]
-    ).prefab_envs
-  end
-
-  def test_prefab_envs_env_var
-    ENV['PREFAB_ENVS'] = 'one,two'
-    assert_equal %w[one two], Prefab::Options.new.prefab_envs
-  end
-
-  def test_invalid_api_key_error
-    options = Prefab::Options.new(
-      api_key: ''
-    )
-
-    err = assert_raises(Prefab::Errors::InvalidApiKeyError) do
-      Prefab::Client.new(options).config_client.get('anything')
-    end
-
-    assert_match(/No API key/, err.message)
-
-    options = Prefab::Options.new(
-      api_key: 'invalid'
-    )
-
-    err = assert_raises(Prefab::Errors::InvalidApiKeyError) do
-      Prefab::Client.new(options).config_client.get('anything')
-    end
-
-    assert_match(/format is invalid/, err.message)
-  end
-
-  def test_caching
-    @config_client.send(:cache_configs,
-                        PrefabProto::Configs.new(configs:
-                                                   [PrefabProto::Config.new(key: 'test', id: 1,
-                                                                            rows: [PrefabProto::ConfigRow.new(
-                                                                              values: [
-                                                                                PrefabProto::ConditionalValue.new(
-                                                                                  value: PrefabProto::ConfigValue.new(string: "test value")
-                                                                                )
-                                                                              ]
-                                                                            )])],
-                                                 config_service_pointer: PrefabProto::ConfigServicePointer.new(project_id: 3, project_env_id: 5)))
-    @config_client.send(:load_cache)
-    assert_equal "test value", @config_client.get("test")
-  end
-
-  def test_cache_path_respects_xdg
-    options = Prefab::Options.new(
-      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY,
-      x_use_local_cache: true,
-      api_key: "123-ENV-KEY-SDK",)
-
-    config_client = Prefab::ConfigClient.new(MockBaseClient.new(options), 10)
-    assert_equal "#{Dir.home}/.cache/prefab.cache.123.json", config_client.send(:cache_path)
-
-    with_env('XDG_CACHE_HOME', '/tmp') do
-      config_client = Prefab::ConfigClient.new(MockBaseClient.new(options), 10)
-      assert_equal "/tmp/prefab.cache.123.json", config_client.send(:cache_path)
-    end
-  end
-
-end

data/test/test_config_loader.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestConfigLoader < Minitest::Test
-  def setup
-    super
-    options = Prefab::Options.new(
-      prefab_config_override_dir: 'none',
-      prefab_config_classpath_dir: 'test',
-      prefab_envs: 'unit_tests'
-    )
-    @loader = Prefab::ConfigLoader.new(MockBaseClient.new(options))
-  end
-
-  def test_load
-    should_be :int, 123, 'sample_int'
-    should_be :string, 'test sample value', 'sample'
-    should_be :bool, true, 'sample_bool'
-    should_be :double, 12.12, 'sample_double'
-  end
-
-  def test_nested
-    should_be :string, 'nested value', 'nested.values.string'
-    should_be :string, 'top level', 'nested.values'
-    should_be :log_level, :ERROR, 'log-level.app'
-    should_be :log_level, :WARN, 'log-level.app.controller.hello'
-    should_be :log_level, :INFO, 'log-level.app.controller.hello.index'
-  end
-
-  def test_invalid_log_level
-    should_be :log_level, :NOT_SET_LOG_LEVEL, 'log-level.invalid'
-  end
-
-  def test_load_without_unit_test_env
-    options = Prefab::Options.new(
-      prefab_config_override_dir: 'none',
-      prefab_config_classpath_dir: 'test'
-      # no prefab_envs
-    )
-    @loader = Prefab::ConfigLoader.new(MockBaseClient.new(options))
-    should_be :string, 'default sample value', 'sample'
-    should_be :bool, true, 'sample_bool'
-  end
-
-  def test_highwater
-    assert_equal 0, @loader.highwater_mark
-    @loader.set(PrefabProto::Config.new(id: 1, key: 'sample_int', rows: [config_row(PrefabProto::ConfigValue.new(int: 456))]),
-                'test')
-    assert_equal 1, @loader.highwater_mark
-
-    @loader.set(PrefabProto::Config.new(id: 5, key: 'sample_int', rows: [config_row(PrefabProto::ConfigValue.new(int: 456))]),
-                'test')
-    assert_equal 5, @loader.highwater_mark
-    @loader.set(PrefabProto::Config.new(id: 2, key: 'sample_int', rows: [config_row(PrefabProto::ConfigValue.new(int: 456))]),
-                'test')
-    assert_equal 5, @loader.highwater_mark
-  end
-
-  def test_keeps_most_recent
-    assert_equal 0, @loader.highwater_mark
-    @loader.set(PrefabProto::Config.new(id: 1, key: 'sample_int', rows: [config_row(PrefabProto::ConfigValue.new(int: 1))]),
-                'test')
-    assert_equal 1, @loader.highwater_mark
-    should_be :int, 1, 'sample_int'
-
-    @loader.set(PrefabProto::Config.new(id: 4, key: 'sample_int', rows: [config_row(PrefabProto::ConfigValue.new(int: 4))]),
-                'test')
-    assert_equal 4, @loader.highwater_mark
-    should_be :int, 4, 'sample_int'
-
-    @loader.set(PrefabProto::Config.new(id: 2, key: 'sample_int', rows: [config_row(PrefabProto::ConfigValue.new(int: 2))]),
-                'test')
-    assert_equal 4, @loader.highwater_mark
-    should_be :int, 4, 'sample_int'
-  end
-
-  def test_api_precedence
-    should_be :int, 123, 'sample_int'
-
-    @loader.set(PrefabProto::Config.new(key: 'sample_int', rows: [config_row(PrefabProto::ConfigValue.new(int: 456))]), 'test')
-    should_be :int, 456, 'sample_int'
-  end
-
-  def test_api_deltas
-    val = PrefabProto::ConfigValue.new(int: 456)
-    config = PrefabProto::Config.new(key: 'sample_int', rows: [config_row(val)])
-    @loader.set(config, 'test')
-
-    configs = PrefabProto::Configs.new
-    configs.configs << config
-    assert_equal configs, @loader.get_api_deltas
-  end
-
-  def test_loading_tombstones_removes_entries
-    val = PrefabProto::ConfigValue.new(int: 456)
-    config = PrefabProto::Config.new(key: 'sample_int', rows: [config_row(val)], id: 2)
-    @loader.set(config, 'test')
-
-    config = PrefabProto::Config.new(key: 'sample_int', rows: [], id: 3)
-    @loader.set(config, 'test')
-
-    configs = PrefabProto::Configs.new
-    assert_equal configs, @loader.get_api_deltas
-  end
-
-  private
-
-  def should_be(type, value, key)
-    assert_equal type, @loader.calc_config[key][:config].rows[0].values[0].value.type
-    assert_equal value, @loader.calc_config[key][:config].rows[0].values[0].value.send(type)
-  end
-
-  def config_row(value)
-    PrefabProto::ConfigRow.new(values: [PrefabProto::ConditionalValue.new(value: value)])
-  end
-end

data/test/test_config_resolver.rb

@@ -1,430 +0,0 @@
-# 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