quonfig 0.0.9 → 0.0.11

data/test/test_internal_logger.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestInternalLogger < Minitest::Test
-
-  def teardown
-    # using_quonfig_log_filter! mutates the shared @@instances list — restore
-    # the default :warn level so it doesn't bleed into other tests' $logs.
-    Quonfig::InternalLogger.class_variable_get(:@@instances).each do |logger|
-      logger.level = :warn
-    end
-    super
-  end
-
-  def test_levels
-    logger_a = Quonfig::InternalLogger.new(A)
-    logger_b = Quonfig::InternalLogger.new(B)
-
-    assert_equal :warn, logger_a.level
-    assert_equal :warn, logger_b.level
-
-    Quonfig::InternalLogger.using_quonfig_log_filter!
-    assert_equal :trace, logger_a.level
-    assert_equal :trace, logger_b.level
-  end
-
-end
-
-class A
-end
-
-class B
-end

data/test/test_options.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestOptions < Minitest::Test
-  API_KEY = 'abcdefg'
-
-  def test_api_urls_override_env_var
-    assert_equal Quonfig::Options::DEFAULT_API_URLS, Quonfig::Options.new.api_urls
-
-    # blank doesn't take effect
-    with_env('QUONFIG_API_URLS', '') do
-      assert_equal Quonfig::Options::DEFAULT_API_URLS, Quonfig::Options.new.api_urls
-    end
-
-    # non-blank does take effect
-    with_env('QUONFIG_API_URLS', 'https://override.example.com') do
-      assert_equal ["https://override.example.com"], Quonfig::Options.new.api_urls
-    end
-  end
-
-  def test_default_api_urls_point_to_quonfig
-    assert_equal [
-      'https://primary.quonfig.com',
-    ], Quonfig::Options::DEFAULT_API_URLS
-  end
-
-  def test_overriding_api_urls
-    assert_equal Quonfig::Options::DEFAULT_API_URLS, Quonfig::Options.new.api_urls
-
-    # a plain string ends up wrapped in an array
-    api_url = 'https://example.com'
-    assert_equal [api_url], Quonfig::Options.new(api_urls: api_url).api_urls
-
-    api_urls = ['https://example.com', 'https://example2.com']
-    assert_equal api_urls, Quonfig::Options.new(api_urls: api_urls).api_urls
-  end
-
-  def test_derive_stream_url_prepends_stream_to_hostname
-    assert_equal 'https://stream.primary.quonfig.com',
-                 Quonfig::Options.derive_stream_url('https://primary.quonfig.com')
-  end
-
-  def test_derive_stream_url_preserves_port
-    assert_equal 'http://stream.localhost:6550',
-                 Quonfig::Options.derive_stream_url('http://localhost:6550')
-  end
-
-  def test_derive_stream_url_preserves_scheme_and_path
-    assert_equal 'http://stream.api.example.com/base',
-                 Quonfig::Options.derive_stream_url('http://api.example.com/base')
-  end
-
-  def test_derive_stream_url_with_eu_subdomain
-    assert_equal 'https://stream.primary.eu.quonfig.com',
-                 Quonfig::Options.derive_stream_url('https://primary.eu.quonfig.com')
-  end
-
-  def test_works_with_named_arguments
-    assert_equal API_KEY, Quonfig::Options.new(sdk_key: API_KEY).sdk_key
-  end
-
-  def test_works_with_hash
-    assert_equal API_KEY, Quonfig::Options.new({ sdk_key: API_KEY }).sdk_key
-  end
-
-  def test_sdk_key_reads_from_quonfig_backend_sdk_key
-    with_env('QUONFIG_BACKEND_SDK_KEY', 'env-key') do
-      assert_equal 'env-key', Quonfig::Options.new.sdk_key
-    end
-  end
-
-  def test_environment_reads_from_quonfig_environment
-    with_env('QUONFIG_ENVIRONMENT', 'staging') do
-      assert_equal 'staging', Quonfig::Options.new.environment
-    end
-  end
-
-  def test_environment_explicit_overrides_env_var
-    with_env('QUONFIG_ENVIRONMENT', 'staging') do
-      assert_equal 'production', Quonfig::Options.new(environment: 'production').environment
-    end
-  end
-
-  def test_enable_sse_defaults_true
-    assert_equal true, Quonfig::Options.new.enable_sse
-    assert_equal false, Quonfig::Options.new(enable_sse: false).enable_sse
-  end
-
-  def test_enable_polling_defaults_true
-    assert_equal true, Quonfig::Options.new.enable_polling
-    assert_equal false, Quonfig::Options.new(enable_polling: false).enable_polling
-  end
-
-  def test_datadir_reads_from_quonfig_dir_env
-    with_env('QUONFIG_DIR', '/tmp/some/workspace') do
-      assert_equal '/tmp/some/workspace', Quonfig::Options.new.datadir
-    end
-  end
-
-  def test_datadir_explicit_overrides_env_var
-    with_env('QUONFIG_DIR', '/tmp/env/workspace') do
-      assert_equal '/tmp/explicit', Quonfig::Options.new(datadir: '/tmp/explicit').datadir
-    end
-  end
-
-  def test_datadir_predicate
-    assert_equal false, Quonfig::Options.new.datadir?
-    assert_equal true, Quonfig::Options.new(datadir: '/tmp/ws').datadir?
-  end
-
-  def test_local_only_uses_datadir_presence
-    refute Quonfig::Options.new.local_only?
-    assert Quonfig::Options.new(datadir: '/tmp/ws').local_only?
-  end
-
-  def test_collect_max_paths
-    assert_equal 1000, Quonfig::Options.new.collect_max_paths
-    assert_equal 100, Quonfig::Options.new(collect_max_paths: 100).collect_max_paths
-  end
-
-  def test_collect_max_evaluation_summaries
-    assert_equal 100_000, Quonfig::Options.new.collect_max_evaluation_summaries
-    assert_equal 0, Quonfig::Options.new(collect_evaluation_summaries: false).collect_max_evaluation_summaries
-    assert_equal 3,
-                 Quonfig::Options.new(collect_max_evaluation_summaries: 3).collect_max_evaluation_summaries
-  end
-
-  def test_context_upload_mode_periodic
-    options = Quonfig::Options.new(context_upload_mode: :periodic_example, context_max_size: 100)
-    assert_equal 100, options.collect_max_example_contexts
-
-    options = Quonfig::Options.new(context_upload_mode: :none)
-    assert_equal 0, options.collect_max_example_contexts
-  end
-
-  def test_context_upload_mode_shapes_only
-    options = Quonfig::Options.new(context_upload_mode: :shapes_only, context_max_size: 100)
-    assert_equal 100, options.collect_max_shapes
-
-    options = Quonfig::Options.new(context_upload_mode: :none)
-    assert_equal 0, options.collect_max_shapes
-  end
-
-  def test_context_upload_mode_none
-    options = Quonfig::Options.new(context_upload_mode: :none)
-    assert_equal 0, options.collect_max_example_contexts
-
-    options = Quonfig::Options.new(context_upload_mode: :none)
-    assert_equal 0, options.collect_max_shapes
-  end
-
-  def test_telemetry_destination_reads_env_first
-    with_env('QUONFIG_TELEMETRY_URL', 'https://custom-telemetry.example.com') do
-      assert_equal 'https://custom-telemetry.example.com', Quonfig::Options.new.telemetry_destination
-    end
-  end
-
-  def test_telemetry_destination_derives_from_default_sources
-    assert_equal 'https://telemetry.quonfig.com', Quonfig::Options.new.telemetry_destination
-  end
-
-  def test_telemetry_destination_derives_from_custom_quonfig_api_urls
-    options = Quonfig::Options.new(api_urls: ['https://primary.eu.quonfig.com'])
-    assert_equal 'https://telemetry.eu.quonfig.com', options.telemetry_destination
-  end
-end

data/test/test_rate_limit_cache.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'timecop'
-
-class RateLimitCacheTest < Minitest::Test
-  def test_set_and_fresh
-    cache = Quonfig::RateLimitCache.new(5)
-    cache.set('key')
-    assert cache.fresh?('key')
-  end
-
-  def test_fresh_with_no_set
-    cache = Quonfig::RateLimitCache.new(5)
-    refute cache.fresh?('key')
-  end
-
-  def test_get_after_expiration
-    cache = Quonfig::RateLimitCache.new(5)
-
-    Timecop.freeze(Time.now - 6) do
-      cache.set('key')
-      assert cache.fresh?('key')
-    end
-
-    refute cache.fresh?('key')
-
-    # but the data is still there
-    assert cache.data.get('key')
-  end
-
-  def test_prune
-    cache = Quonfig::RateLimitCache.new(5)
-
-    Timecop.freeze(Time.now - 6) do
-      cache.set('key')
-      assert cache.fresh?('key')
-    end
-
-    cache.prune
-
-    refute cache.fresh?('key')
-  end
-end

data/test/test_reason.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'quonfig/reason'
-
-# Tests Quonfig::Reason in isolation — uses plain Structs so the test does not
-# depend on PrefabProto (which is not loaded by the current bootstrap).
-class TestReason < Minitest::Test
-  FakeCriterion = Struct.new(:operator)
-  FakeConditionalValue = Struct.new(:criteria)
-  FakeRow = Struct.new(:values, :project_env_id)
-  FakeConfig = Struct.new(:rows)
-
-  ALWAYS_TRUE = FakeCriterion.new(:ALWAYS_TRUE)
-  PROP_MATCH = FakeCriterion.new(:PROP_IS_ONE_OF)
-
-  DEFAULT_CV = FakeConditionalValue.new([])
-  ALWAYS_TRUE_CV = FakeConditionalValue.new([ALWAYS_TRUE])
-  RULE_CV = FakeConditionalValue.new([PROP_MATCH])
-
-  def default_only_config
-    FakeConfig.new([FakeRow.new([DEFAULT_CV], 0)])
-  end
-
-  def targeted_config
-    FakeConfig.new([
-      FakeRow.new([DEFAULT_CV], 0),
-      FakeRow.new([RULE_CV, ALWAYS_TRUE_CV], 1)
-    ])
-  end
-
-  def test_default_for_default_only_config
-    reason = Quonfig::Reason.compute(
-      config: default_only_config,
-      conditional_value: DEFAULT_CV
-    )
-    assert_equal :DEFAULT, reason
-  end
-
-  def test_rule_match_when_targeting_rule_matched
-    reason = Quonfig::Reason.compute(
-      config: targeted_config,
-      conditional_value: RULE_CV
-    )
-    assert_equal :RULE_MATCH, reason
-  end
-
-  def test_rule_match_when_falling_back_to_always_true_in_targeted_config
-    reason = Quonfig::Reason.compute(
-      config: targeted_config,
-      conditional_value: ALWAYS_TRUE_CV
-    )
-    assert_equal :RULE_MATCH, reason
-  end
-
-  def test_split_when_weighted_value_index_positive
-    reason = Quonfig::Reason.compute(
-      config: default_only_config,
-      conditional_value: DEFAULT_CV,
-      weighted_value_index: 2
-    )
-    assert_equal :SPLIT, reason
-  end
-
-  def test_weighted_value_index_zero_is_not_split
-    reason = Quonfig::Reason.compute(
-      config: default_only_config,
-      conditional_value: DEFAULT_CV,
-      weighted_value_index: 0
-    )
-    assert_equal :DEFAULT, reason
-  end
-
-  def test_default_when_only_always_true_criteria_and_no_targeting_rules
-    config = FakeConfig.new([FakeRow.new([ALWAYS_TRUE_CV], 0)])
-    reason = Quonfig::Reason.compute(config: config, conditional_value: ALWAYS_TRUE_CV)
-    assert_equal :DEFAULT, reason
-  end
-end

data/test/test_rename.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestRename < Minitest::Test
-  def test_quonfig_module_is_defined
-    assert defined?(Quonfig), 'Quonfig module must be defined after rename'
-  end
-
-  def test_reforge_module_is_gone
-    # NOTE: 'Reforge' intentionally not renamed — this test guards against the old constant leaking back in.
-    refute Object.const_defined?(:Reforge), 'Reforge constant must be removed after rename'
-  end
-
-  def test_quonfig_options_exists
-    assert defined?(Quonfig::Options), 'Quonfig::Options must be defined'
-  end
-
-  def test_quonfig_client_exists
-    assert defined?(Quonfig::Client), 'Quonfig::Client must be defined'
-  end
-
-  def test_quonfig_sdk_key_env_var
-    # NOTE: the REFORGE_/PREFAB_ keys below are intentionally spelled out in string literals
-    # so the bulk rename tool does not touch them — we are asserting that the NEW env var name
-    # is the one the SDK reads.
-    old_key_a = 'REFORGE_' + 'BACKEND_SDK_KEY'
-    old_key_b = 'PREFAB_' + 'API_KEY'
-    original = ENV.to_h.slice('QUONFIG_BACKEND_SDK_KEY', old_key_a, old_key_b)
-    ENV.delete(old_key_a)
-    ENV.delete(old_key_b)
-    ENV['QUONFIG_BACKEND_SDK_KEY'] = 'quonfig-test-key-123'
-    options = Quonfig::Options.new
-    assert_equal 'quonfig-test-key-123', options.sdk_key
-  ensure
-    ENV.delete('QUONFIG_BACKEND_SDK_KEY')
-    original&.each { |k, v| ENV[k] = v }
-  end
-
-  def test_gemspec_file_is_quonfig
-    root = File.expand_path('..', __dir__)
-    assert File.exist?(File.join(root, 'quonfig.gemspec')),
-           'quonfig.gemspec must exist at repo root'
-    refute File.exist?(File.join(root, 'sdk-reforge.gemspec')),
-           'sdk-reforge.gemspec must be removed'
-  end
-
-  def test_gemspec_name_is_quonfig
-    root = File.expand_path('..', __dir__)
-    spec = Gem::Specification.load(File.join(root, 'quonfig.gemspec'))
-    assert_equal 'quonfig', spec.name
-  end
-
-  def test_lib_entrypoint_renamed
-    root = File.expand_path('..', __dir__)
-    assert File.exist?(File.join(root, 'lib', 'quonfig.rb')),
-           'lib/quonfig.rb must exist'
-    assert Dir.exist?(File.join(root, 'lib', 'quonfig')),
-           'lib/quonfig/ directory must exist'
-    refute File.exist?(File.join(root, 'lib', 'sdk-reforge.rb')),
-           'lib/sdk-reforge.rb must be removed'
-    refute Dir.exist?(File.join(root, 'lib', 'reforge')),
-           'lib/reforge/ directory must be removed'
-  end
-end

data/test/test_resolver.rb

@@ -1,291 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# Tests for the new public API trio introduced by qfg-dk6.9:
-#   store     = Quonfig::ConfigStore.new(configs_hash)
-#   evaluator = Quonfig::Evaluator.new(store)
-#   resolver  = Quonfig::Resolver.new(store, evaluator)
-#   result    = resolver.get('my.flag', context)
-#
-# Mirrors the sdk-node pattern so the integration test suite (qfg-dk6.22-24)
-# can construct these directly without a full Client.
-#
-# We deliberately do NOT use PrefabProto — the protobuf gem was dropped in
-# qfg-dk6.4 and JSON Criterion types land in qfg-dk6.5 / operators port in
-# qfg-dk6.10. These tests use minimal Struct doubles that satisfy the
-# duck-typed shape the current CriteriaEvaluator reads.
-class TestResolverTrio < Minitest::Test
-  CONFIG_KEY = 'my.flag'
-  DEFAULT_VALUE = 'default_value'
-
-  # qfg-dk6.10 — configs are now plain ConfigResponse-shaped hashes (symbol
-  # top-level keys + string keys inside rules/criteria). Matches what
-  # Quonfig::Datadir.to_config_response and
-  # IntegrationTestHelpers.to_config_response emit.
-  def make_default_config(key: CONFIG_KEY, value: DEFAULT_VALUE)
-    {
-      id: '1',
-      key: key,
-      type: 'config',
-      value_type: 'string',
-      send_to_client_sdk: false,
-      default: {
-        'rules' => [
-          {
-            'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
-            'value' => { 'type' => 'string', 'value' => value }
-          }
-        ]
-      },
-      environment: nil
-    }
-  end
-
-  def base_client
-    MockBaseClient.new(Quonfig::Options.new)
-  end
-
-  # ---- ConfigStore ------------------------------------------------------
-
-  def test_config_store_constructs_with_hash
-    cfg = make_default_config
-    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
-
-    assert_equal cfg, store.get(CONFIG_KEY)
-    assert_equal [CONFIG_KEY], store.keys
-  end
-
-  def test_config_store_constructs_empty
-    store = Quonfig::ConfigStore.new
-    assert_nil store.get('missing')
-    assert_empty store.keys
-  end
-
-  def test_config_store_set_and_get
-    store = Quonfig::ConfigStore.new
-    cfg = make_default_config
-    store.set(CONFIG_KEY, cfg)
-    assert_equal cfg, store.get(CONFIG_KEY)
-  end
-
-  def test_config_store_all_configs_returns_hash
-    cfg = make_default_config
-    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
-
-    all = store.all_configs
-    assert_kind_of Hash, all
-    assert_equal cfg, all[CONFIG_KEY]
-  end
-
-  def test_config_store_all_configs_is_a_copy
-    cfg = make_default_config
-    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
-    store.all_configs['mutated'] = :nope
-    assert_nil store.get('mutated')
-  end
-
-  def test_config_store_clear_empties_the_store
-    store = Quonfig::ConfigStore.new({ CONFIG_KEY => make_default_config })
-    store.clear
-    assert_nil store.get(CONFIG_KEY)
-    assert_empty store.keys
-  end
-
-  # ---- Evaluator --------------------------------------------------------
-
-  def test_evaluator_accepts_store
-    store = Quonfig::ConfigStore.new
-    Quonfig::Evaluator.new(store, base_client: base_client)
-  end
-
-  # ---- Resolver ---------------------------------------------------------
-
-  def test_resolver_raw_returns_config_from_store
-    cfg = make_default_config
-    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
-    evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
-    resolver = Quonfig::Resolver.new(store, evaluator)
-
-    assert_equal cfg, resolver.raw(CONFIG_KEY)
-  end
-
-  def test_resolver_raw_returns_nil_for_missing_key
-    store = Quonfig::ConfigStore.new
-    evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
-    resolver = Quonfig::Resolver.new(store, evaluator)
-
-    assert_nil resolver.raw('nope')
-  end
-
-  def test_resolver_get_returns_evaluation_for_default_row_with_empty_criteria
-    cfg = make_default_config
-    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
-    evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
-    resolver = Quonfig::Resolver.new(store, evaluator)
-
-    result = resolver.get(CONFIG_KEY, Quonfig::Context.new({}))
-
-    refute_nil result
-    assert_kind_of Quonfig::EvalResult, result
-    # The EvalResult exposes both the raw JSON value hash (#value) and the
-    # coerced Ruby value (#unwrapped_value). Prefer unwrapped_value for
-    # assertions — it mirrors what the real Client returns.
-    assert_equal DEFAULT_VALUE, result.unwrapped_value
-  end
-
-  def test_resolver_get_raises_missing_default_for_missing_key
-    store = Quonfig::ConfigStore.new
-    evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
-    resolver = Quonfig::Resolver.new(store, evaluator)
-
-    # Resolver.get raises Quonfig::Errors::MissingDefaultError when no
-    # config exists for the key (qfg-9x7 alignment with the shared YAML
-    # get_or_raise.yaml suite). Client.get catches this and folds it into
-    # the on_no_default policy / caller-supplied default.
-    assert_raises(Quonfig::Errors::MissingDefaultError) do
-      resolver.get('nope', Quonfig::Context.new({}))
-    end
-  end
-
-  # ---- ENV_VAR provided value resolution (qfg-08q) ---------------------
-
-  # Build a config whose value comes from a `provided` ENV_VAR lookup.
-  # value_type drives coercion of the env var string back to the SDK type
-  # (mirrors sdk-node/sdk-go behavior).
-  def make_provided_config(key:, value_type:, lookup:)
-    {
-      id: '1',
-      key: key,
-      type: 'config',
-      value_type: value_type,
-      send_to_client_sdk: false,
-      default: {
-        'rules' => [
-          {
-            'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
-            'value' => {
-              'type' => 'provided',
-              'value' => { 'source' => 'ENV_VAR', 'lookup' => lookup }
-            }
-          }
-        ]
-      },
-      environment: nil
-    }
-  end
-
-  def with_env(name, value)
-    original = ENV[name]
-    ENV[name] = value
-    yield
-  ensure
-    if original.nil?
-      ENV.delete(name)
-    else
-      ENV[name] = original
-    end
-  end
-
-  def build_resolver(cfg)
-    store = Quonfig::ConfigStore.new({ cfg[:key] => cfg })
-    evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
-    Quonfig::Resolver.new(store, evaluator)
-  end
-
-  def test_resolver_get_resolves_provided_env_var_as_string
-    cfg = make_provided_config(key: 'a.string', value_type: 'string', lookup: 'QFG_TEST_STRING')
-    resolver = build_resolver(cfg)
-
-    with_env('QFG_TEST_STRING', 'hello') do
-      result = resolver.get('a.string', Quonfig::Context.new({}))
-      assert_equal 'hello', result.unwrapped_value
-      assert_equal 'string', result.value_type
-    end
-  end
-
-  def test_resolver_get_resolves_provided_env_var_as_int
-    cfg = make_provided_config(key: 'a.number', value_type: 'int', lookup: 'QFG_TEST_INT')
-    resolver = build_resolver(cfg)
-
-    with_env('QFG_TEST_INT', '1234') do
-      result = resolver.get('a.number', Quonfig::Context.new({}))
-      assert_equal 1234, result.unwrapped_value
-      assert_equal 'int', result.value_type
-    end
-  end
-
-  def test_resolver_get_resolves_provided_env_var_as_double
-    cfg = make_provided_config(key: 'a.double', value_type: 'double', lookup: 'QFG_TEST_DOUBLE')
-    resolver = build_resolver(cfg)
-
-    with_env('QFG_TEST_DOUBLE', '3.14') do
-      result = resolver.get('a.double', Quonfig::Context.new({}))
-      assert_in_delta 3.14, result.unwrapped_value, 0.0001
-      assert_equal 'double', result.value_type
-    end
-  end
-
-  def test_resolver_get_resolves_provided_env_var_as_bool
-    cfg = make_provided_config(key: 'a.bool', value_type: 'bool', lookup: 'QFG_TEST_BOOL')
-    resolver = build_resolver(cfg)
-
-    with_env('QFG_TEST_BOOL', 'true') do
-      result = resolver.get('a.bool', Quonfig::Context.new({}))
-      assert_equal true, result.unwrapped_value
-      assert_equal 'bool', result.value_type
-    end
-
-    with_env('QFG_TEST_BOOL', 'no') do
-      result = resolver.get('a.bool', Quonfig::Context.new({}))
-      assert_equal false, result.unwrapped_value
-    end
-  end
-
-  def test_resolver_get_resolves_provided_env_var_as_string_list
-    cfg = make_provided_config(key: 'a.list', value_type: 'string_list', lookup: 'QFG_TEST_LIST')
-    resolver = build_resolver(cfg)
-
-    with_env('QFG_TEST_LIST', 'a, b ,c') do
-      result = resolver.get('a.list', Quonfig::Context.new({}))
-      assert_equal %w[a b c], result.unwrapped_value
-      assert_equal 'string_list', result.value_type
-    end
-  end
-
-  def test_resolver_get_raises_missing_env_var_error_when_unset
-    cfg = make_provided_config(key: 'a.missing', value_type: 'string', lookup: 'QFG_DEFINITELY_UNSET')
-    resolver = build_resolver(cfg)
-    ENV.delete('QFG_DEFINITELY_UNSET')
-
-    err = assert_raises(Quonfig::Errors::MissingEnvVarError) do
-      resolver.get('a.missing', Quonfig::Context.new({}))
-    end
-    assert_match(/QFG_DEFINITELY_UNSET/, err.message)
-    assert_match(/a\.missing/, err.message)
-  end
-
-  def test_resolver_get_raises_env_var_parse_error_on_bad_int
-    cfg = make_provided_config(key: 'a.number', value_type: 'int', lookup: 'QFG_TEST_BAD_INT')
-    resolver = build_resolver(cfg)
-
-    with_env('QFG_TEST_BAD_INT', 'not_a_number') do
-      err = assert_raises(Quonfig::Errors::EnvVarParseError) do
-        resolver.get('a.number', Quonfig::Context.new({}))
-      end
-      assert_match(/a\.number/, err.message)
-      assert_match(/not_a_number/, err.message)
-    end
-  end
-
-  def test_resolver_get_raises_env_var_parse_error_on_bad_double
-    cfg = make_provided_config(key: 'a.double', value_type: 'double', lookup: 'QFG_TEST_BAD_DOUBLE')
-    resolver = build_resolver(cfg)
-
-    with_env('QFG_TEST_BAD_DOUBLE', 'not_a_number') do
-      assert_raises(Quonfig::Errors::EnvVarParseError) do
-        resolver.get('a.double', Quonfig::Context.new({}))
-      end
-    end
-  end
-end