quonfig 0.0.8 → 0.0.10

data/test/integration/test_dev_overrides.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+#
+# AUTO-GENERATED from integration-test-data/tests/eval/dev_overrides.yaml.
+# Regenerate with:
+#   cd integration-test-data/generators && npm run generate -- --target=ruby
+# Source: integration-test-data/generators/src/targets/ruby.ts
+# Do NOT edit by hand — changes will be overwritten.
+
+require 'test_helper'
+require 'integration/test_helpers'
+
+class TestDevOverrides < Minitest::Test
+  def setup
+    @store = IntegrationTestHelpers.build_store("dev_overrides")
+  end
+
+  # override fires when quonfig-user.email matches
+  def test_override_fires_when_quonfig_user_email_matches
+    resolver = IntegrationTestHelpers.build_resolver(@store)
+    IntegrationTestHelpers.assert_enabled(resolver, "feature-flag.dev-override", {"quonfig-user" => {"email" => "bob@foo.com"}}, true)
+  end
+
+  # override does not fire when attribute absent (prod simulation)
+  def test_override_does_not_fire_when_attribute_absent_prod_simulation
+    resolver = IntegrationTestHelpers.build_resolver(@store)
+    IntegrationTestHelpers.assert_enabled(resolver, "feature-flag.dev-override", {"user" => {"email" => "bob@foo.com"}}, false)
+  end
+
+  # override matches any email in IS_ONE_OF list
+  def test_override_matches_any_email_in_is_one_of_list
+    resolver = IntegrationTestHelpers.build_resolver(@store)
+    IntegrationTestHelpers.assert_enabled(resolver, "feature-flag.dev-override.multi-email", {"quonfig-user" => {"email" => "alice@foo.com"}}, true)
+  end
+
+  # override beats customer rule by priority
+  def test_override_beats_customer_rule_by_priority
+    resolver = IntegrationTestHelpers.build_resolver(@store)
+    IntegrationTestHelpers.assert_enabled(resolver, "feature-flag.dev-override.priority", {"quonfig-user" => {"email" => "bob@foo.com"}, "user" => {"country" => "DE"}}, true)
+  end
+end

data/test/integration/test_helpers.rb

@@ -290,6 +290,13 @@ module IntegrationTestHelpers
   # so eval-summary cases can resolve real values for each key.
   class << self
     attr_accessor :last_store
+    # Side-channel populated by record_one_eval whenever we redact a
+    # confidential value before recording it on the aggregator. Keyed by
+    # config_key → { unwrapped:, value_type: }. evaluation_summary_post
+    # consults it so the YAML's `value` / `value_type` fields can still
+    # assert the runtime resolved value while `selected_value` carries
+    # the wire-redacted form.
+    attr_accessor :last_unwrapped_overrides
   end
 
   # Construct an aggregator. +kind+ is one of :context_shape,
@@ -465,6 +472,7 @@ module IntegrationTestHelpers
     ctx = contexts.is_a?(Quonfig::Context) ? contexts : Quonfig::Context.new(contexts || {})
     empty_ctx = Quonfig::Context.new({})
 
+    self.last_unwrapped_overrides = {}
     Array(keys).each { |key| record_one_eval(aggregator, resolver, store, key, ctx) }
     Array(keys_no_ctx).each { |key| record_one_eval(aggregator, resolver, store, key, empty_ctx) }
   end
@@ -482,13 +490,28 @@ module IntegrationTestHelpers
       end
     return if result.nil?
 
+    # Confidential / decryptWith values must never appear in plaintext on
+    # the wire. EvalResult#reportable_value, when populated, is the
+    # `*****<md5>`-redacted substitute the resolver computed pre-decryption.
+    # When we substitute, stash the runtime unwrapped value so the
+    # post-projection can still assert YAML's `value` / `value_type` against
+    # the resolved plaintext (the YAML treats `value` as the runtime view
+    # and `selected_value` as the wire view).
+    selected_for_telemetry = result.unwrapped_value
+    if result.reportable_value
+      selected_for_telemetry = result.reportable_value
+      (self.last_unwrapped_overrides ||= {})[key] = {
+        unwrapped: result.unwrapped_value,
+        value_type: result.value_type
+      }
+    end
     aggregator.record(
       config_id: (cfg[:id] || cfg['id']).to_s,
       config_key: key,
       config_type: (cfg[:type] || cfg['type']).to_s,
       conditional_value_index: result.rule_index,
       weighted_value_index: result.weighted_value_index,
-      selected_value: result.unwrapped_value,
+      selected_value: selected_for_telemetry,
       reason: result.wire_reason
     )
   end
@@ -545,6 +568,7 @@ module IntegrationTestHelpers
 
   def self.evaluation_summary_post(event)
     summaries = event.dig('summaries', 'summaries') || []
+    overrides = last_unwrapped_overrides || {}
     rows = []
     summaries.each do |summary|
       type_label = TYPE_LABELS[summary['type'].to_s] || summary['type'].to_s.upcase
@@ -552,6 +576,15 @@ module IntegrationTestHelpers
       counters.each do |counter|
         selected = counter['selectedValue'] || {}
         unwrapped, value_type = unwrap_selected(selected)
+        # When the resolver redacted this key (confidential / decryptWith),
+        # selected_value carries the redacted form on the wire but YAML's
+        # `value` / `value_type` should still reflect the runtime resolved
+        # plaintext. Restore from the side channel populated in
+        # record_one_eval.
+        if (override = overrides[summary['key']])
+          unwrapped = override[:unwrapped]
+          value_type = override[:value_type] if override[:value_type]
+        end
         row = {
           'key' => summary['key'],
           'type' => type_label,

data/test/integration/test_telemetry.rb

@@ -153,4 +153,18 @@ class TestTelemetry < Minitest::Test
     IntegrationTestHelpers.feed_aggregator(aggregator, :context_shape, {}, contexts: {})
     IntegrationTestHelpers.assert_aggregator_post(aggregator, :context_shape, nil, endpoint: "/api/v1/context-shapes")
   end
+
+  # confidential plain string is redacted in selectedValue
+  def test_confidential_plain_string_is_redacted_in_selectedvalue
+    aggregator = IntegrationTestHelpers.build_aggregator(:evaluation_summary, {})
+    IntegrationTestHelpers.feed_aggregator(aggregator, :evaluation_summary, {"keys" => ["confidential.new.string"]}, contexts: {})
+    IntegrationTestHelpers.assert_aggregator_post(aggregator, :evaluation_summary, [{"key" => "confidential.new.string", "type" => "CONFIG", "value" => "hello.world", "value_type" => "string", "count" => 1, "reason" => 1, "selected_value" => {"string" => "*****18aa7"}, "summary" => {"config_row_index" => 0, "conditional_value_index" => 0}}], endpoint: "/api/v1/telemetry")
+  end
+
+  # confidential encrypted string is redacted using ciphertext hash
+  def test_confidential_encrypted_string_is_redacted_using_ciphertext_hash
+    aggregator = IntegrationTestHelpers.build_aggregator(:evaluation_summary, {})
+    IntegrationTestHelpers.feed_aggregator(aggregator, :evaluation_summary, {"keys" => ["a.secret.config"]}, contexts: {})
+    IntegrationTestHelpers.assert_aggregator_post(aggregator, :evaluation_summary, [{"key" => "a.secret.config", "type" => "CONFIG", "value" => "hello.world", "value_type" => "string", "count" => 1, "reason" => 1, "selected_value" => {"string" => "*****936c9"}, "summary" => {"config_row_index" => 0, "conditional_value_index" => 0}}], endpoint: "/api/v1/telemetry")
+  end
 end

data/test/test_client_telemetry.rb

@@ -129,4 +129,47 @@ class TestClientTelemetry < Minitest::Test
     client.get('does.not.exist', 'fallback')
     assert_nil summaries_agg.drain_event
   end
+
+  # Regression: client used to hardcode weighted_value_index: nil, so split
+  # variants never reported as REASON_SPLIT in telemetry.
+  def test_weighted_value_records_split_reason_and_index
+    weighted_config = {
+      'id' => 'cid-weighted',
+      'key' => 'feature-flag.weighted',
+      'type' => 'feature_flag',
+      'valueType' => 'string',
+      'sendToClientSdk' => false,
+      'default' => {
+        'rules' => [
+          {
+            'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
+            'value' => {
+              'type' => 'weighted_values',
+              'value' => {
+                'hashByPropertyName' => 'user.key',
+                'weightedValues' => [
+                  { 'value' => { 'type' => 'string', 'value' => 'control' }, 'weight' => 1 },
+                  { 'value' => { 'type' => 'string', 'value' => 'variant' }, 'weight' => 99 }
+                ]
+              }
+            }
+          }
+        ]
+      },
+      'environment' => nil
+    }
+
+    store = Quonfig::ConfigStore.new
+    store.set('feature-flag.weighted', weighted_config)
+
+    client, _reporter, summaries_agg, _conn = make_client_with_telemetry(store)
+    client.get('feature-flag.weighted', Quonfig::NO_DEFAULT_PROVIDED, 'user' => { 'key' => 'u1' })
+
+    counter = summaries_agg.drain_event['summaries']['summaries'][0]['counters'][0]
+    assert_equal Quonfig::EvalResult::REASON_SPLIT, counter['reason'],
+                 'weighted variant evaluation must report REASON_SPLIT (3)'
+    refute_nil counter['weightedValueIndex'],
+               'weighted variant evaluation must report a weightedValueIndex'
+    assert_kind_of Integer, counter['weightedValueIndex']
+  end
 end

data/test/test_details_getters.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# Coverage for the *_details getters on Quonfig::Client and Quonfig::BoundClient.
+# These return Quonfig::EvaluationDetails carrying an OpenFeature-aligned
+# +reason+ and (on the error path) error_code / error_message. They never raise.
+class TestDetailsGetters < Minitest::Test
+  Details = Quonfig::EvaluationDetails
+
+  INTEGRATION_FIXTURE_DIR = File.expand_path(
+    '../../integration-test-data/data/integration-tests', __dir__
+  )
+
+  # ---- Helpers --------------------------------------------------------
+
+  def fixture_client
+    skip "integration-test-data sibling missing at #{INTEGRATION_FIXTURE_DIR}" unless Dir.exist?(INTEGRATION_FIXTURE_DIR)
+
+    Quonfig::Client.new(
+      Quonfig::Options.new(
+        datadir: INTEGRATION_FIXTURE_DIR,
+        environment: 'Production',
+        enable_sse: false,
+        enable_polling: false
+      )
+    )
+  end
+
+  # An ALWAYS_TRUE-only config: no targeting rules anywhere -> STATIC.
+  def make_static_config(key:, value:, type:)
+    {
+      'id' => '1',
+      'key' => key,
+      'type' => 'config',
+      'valueType' => type,
+      'sendToClientSdk' => false,
+      'default' => {
+        'rules' => [
+          {
+            'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
+            'value' => { 'type' => type, 'value' => value }
+          }
+        ]
+      },
+      'environment' => nil
+    }
+  end
+
+  def static_client(key:, value:, type:)
+    store = Quonfig::ConfigStore.new
+    store.set(key, make_static_config(key: key, value: value, type: type))
+    Quonfig::Client.new(Quonfig::Options.new, store: store)
+  end
+
+  # ---- STATIC reason --------------------------------------------------
+
+  def test_get_bool_details_static_reason_for_always_true_only_config
+    client = static_client(key: 'plain', value: true, type: 'bool')
+    details = client.get_bool_details('plain')
+    assert_kind_of Details, details
+    assert_equal true, details.value
+    assert_equal Details::REASON_STATIC, details.reason
+    assert_nil details.error_code
+    assert_nil details.error_message
+  end
+
+  def test_get_string_details_static_reason
+    client = static_client(key: 'plain.s', value: 'hi', type: 'string')
+    details = client.get_string_details('plain.s')
+    assert_equal 'hi', details.value
+    assert_equal Details::REASON_STATIC, details.reason
+  end
+
+  def test_static_reason_via_integration_fixture_always_true
+    client = fixture_client
+    details = client.get_bool_details('always.true')
+    assert_equal true, details.value
+    assert_equal Details::REASON_STATIC, details.reason
+  ensure
+    client&.stop
+  end
+
+  # ---- TARGETING_MATCH reason ----------------------------------------
+
+  def test_targeting_match_reason_via_integration_fixture
+    client = fixture_client
+    details = client.get_bool_details('of.targeting', context: { 'user' => { 'plan' => 'pro' } })
+    assert_equal true, details.value
+    assert_equal Details::REASON_TARGETING_MATCH, details.reason
+  ensure
+    client&.stop
+  end
+
+  def test_targeting_match_falls_through_to_default_branch_still_targeting
+    # The of.targeting fixture has a property-match rule + an ALWAYS_TRUE
+    # fallback. Even when the fallback wins, the *config* has targeting rules,
+    # so wire_reason / of_reason returns TARGETING_MATCH.
+    client = fixture_client
+    details = client.get_bool_details('of.targeting', context: { 'user' => { 'plan' => 'free' } })
+    assert_equal false, details.value
+    assert_equal Details::REASON_TARGETING_MATCH, details.reason
+  ensure
+    client&.stop
+  end
+
+  # ---- SPLIT reason ---------------------------------------------------
+
+  def test_split_reason_via_integration_fixture
+    client = fixture_client
+    # Pick a deterministic targetingKey so the outcome is reproducible.
+    details = client.get_string_details('of.weighted', context: { 'user' => { 'id' => 'user-123' } })
+    assert_equal Details::REASON_SPLIT, details.reason
+    assert_includes %w[variant-a variant-b], details.value
+  ensure
+    client&.stop
+  end
+
+  # ---- DEFAULT reason -------------------------------------------------
+
+  def test_default_reason_when_no_rule_matches
+    # Config exists but no rule matches against the empty context.
+    config = {
+      'id' => '9',
+      'key' => 'no.match.here',
+      'type' => 'config',
+      'valueType' => 'string',
+      'sendToClientSdk' => false,
+      'default' => {
+        'rules' => [
+          {
+            'criteria' => [
+              {
+                'propertyName' => 'user.plan',
+                'operator' => 'PROP_IS_ONE_OF',
+                'valueToMatch' => { 'type' => 'string_list', 'value' => ['enterprise'] }
+              }
+            ],
+            'value' => { 'type' => 'string', 'value' => 'gold' }
+          }
+        ]
+      },
+      'environment' => nil
+    }
+    store = Quonfig::ConfigStore.new
+    store.set('no.match.here', config)
+    client = Quonfig::Client.new(Quonfig::Options.new, store: store)
+
+    details = client.get_string_details('no.match.here')
+    assert_nil details.value
+    assert_equal Details::REASON_DEFAULT, details.reason
+    assert_nil details.error_code
+  end
+
+  # ---- ERROR / FLAG_NOT_FOUND ----------------------------------------
+
+  def test_flag_not_found_returns_error_details
+    client = Quonfig::Client.new(Quonfig::Options.new, store: Quonfig::ConfigStore.new)
+    details = client.get_bool_details('does.not.exist')
+    assert_nil details.value
+    assert_equal Details::REASON_ERROR, details.reason
+    assert_equal Details::ERROR_FLAG_NOT_FOUND, details.error_code
+    refute_nil details.error_message
+  end
+
+  def test_flag_not_found_for_string_details
+    client = Quonfig::Client.new(Quonfig::Options.new, store: Quonfig::ConfigStore.new)
+    details = client.get_string_details('nope')
+    assert_equal Details::REASON_ERROR, details.reason
+    assert_equal Details::ERROR_FLAG_NOT_FOUND, details.error_code
+  end
+
+  # ---- ERROR / TYPE_MISMATCH -----------------------------------------
+
+  def test_type_mismatch_for_int_when_value_is_string
+    client = static_client(key: 'wrong.type', value: 'oops', type: 'string')
+    details = client.get_int_details('wrong.type')
+    assert_nil details.value
+    assert_equal Details::REASON_ERROR, details.reason
+    assert_equal Details::ERROR_TYPE_MISMATCH, details.error_code
+    refute_nil details.error_message
+  end
+
+  def test_type_mismatch_for_bool_when_value_is_string
+    client = static_client(key: 'bool.miss', value: 'true', type: 'string')
+    details = client.get_bool_details('bool.miss')
+    assert_equal Details::REASON_ERROR, details.reason
+    assert_equal Details::ERROR_TYPE_MISMATCH, details.error_code
+  end
+
+  def test_type_mismatch_for_string_list_when_value_is_string
+    client = static_client(key: 'list.miss', value: 'a,b', type: 'string')
+    details = client.get_string_list_details('list.miss')
+    assert_equal Details::REASON_ERROR, details.reason
+    assert_equal Details::ERROR_TYPE_MISMATCH, details.error_code
+  end
+
+  # ---- json passes through unchanged ---------------------------------
+
+  def test_get_json_details_returns_hash_with_static_reason
+    payload = { 'a' => 1, 'b' => [1, 2] }
+    client = static_client(key: 'shape', value: payload, type: 'json')
+    details = client.get_json_details('shape')
+    assert_equal payload, details.value
+    assert_equal Details::REASON_STATIC, details.reason
+  end
+
+  # ---- Float / Int success path -------------------------------------
+
+  def test_get_int_details_static_reason
+    client = static_client(key: 'i', value: 42, type: 'int')
+    details = client.get_int_details('i')
+    assert_equal 42, details.value
+    assert_equal Details::REASON_STATIC, details.reason
+  end
+
+  def test_get_float_details_static_reason
+    client = static_client(key: 'f', value: 3.14, type: 'double')
+    details = client.get_float_details('f')
+    assert_in_delta 3.14, details.value, 1e-9
+    assert_equal Details::REASON_STATIC, details.reason
+  end
+
+  def test_get_string_list_details_static_reason
+    client = static_client(key: 'sl', value: %w[a b], type: 'string_list')
+    details = client.get_string_list_details('sl')
+    assert_equal %w[a b], details.value
+    assert_equal Details::REASON_STATIC, details.reason
+  end
+
+  # ---- BoundClient mirror --------------------------------------------
+
+  def test_bound_client_get_bool_details_passes_context
+    client = fixture_client
+    bound = client.in_context('user' => { 'plan' => 'pro' })
+    details = bound.get_bool_details('of.targeting')
+    assert_equal true, details.value
+    assert_equal Details::REASON_TARGETING_MATCH, details.reason
+  ensure
+    client&.stop
+  end
+end

data/test/test_dev_context.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'json'
+require 'tmpdir'
+require 'fileutils'
+
+# qfg-pj0.5 — Dev-context injection. When enable_quonfig_user_context: true
+# (or env var QUONFIG_DEV_CONTEXT=true), the SDK reads ~/.quonfig/tokens.json
+# (written by `qfg login`) and merges {'quonfig-user' => {'email' => ...}}
+# into globalContext. Customer-supplied keys win on collision.
+#
+# Mirror of sdk-node qfg-pj0.3 / sdk-go qfg-pj0.4.
+class TestDevContext < Minitest::Test
+  def setup
+    super
+    @tmphome = Dir.mktmpdir('quonfig-dev-ctx-')
+    FileUtils.mkdir_p(File.join(@tmphome, '.quonfig'))
+    @old_home = ENV.fetch('HOME', nil)
+    ENV['HOME'] = @tmphome
+    ENV.delete('QUONFIG_DEV_CONTEXT')
+  end
+
+  def teardown
+    ENV['HOME'] = @old_home
+    ENV.delete('QUONFIG_DEV_CONTEXT')
+    FileUtils.remove_entry(@tmphome) if @tmphome && Dir.exist?(@tmphome)
+    super
+  end
+
+  def write_tokens(payload)
+    File.write(File.join(@tmphome, '.quonfig', 'tokens.json'), JSON.generate(payload))
+  end
+
+  def global_context_of(client)
+    client.instance_variable_get(:@global_context)
+  end
+
+  # 1. RED: injects quonfig-user.email when option enabled and file exists
+  def test_injects_quonfig_user_email_when_option_enabled
+    write_tokens(userEmail: 'bob@foo.com', accessToken: 'x', refreshToken: 'y', expiresAt: 0)
+
+    client = Quonfig::Client.new(
+      Quonfig::Options.new(enable_quonfig_user_context: true),
+      store: Quonfig::ConfigStore.new
+    )
+
+    assert_equal({ 'quonfig-user' => { 'email' => 'bob@foo.com' } }, global_context_of(client))
+  end
+
+  # 2. RED: no-op when option disabled and no env var
+  def test_no_op_when_option_disabled
+    write_tokens(userEmail: 'bob@foo.com')
+
+    client = Quonfig::Client.new(
+      Quonfig::Options.new(global_context: { user: { 'plan' => 'pro' } }),
+      store: Quonfig::ConfigStore.new
+    )
+
+    assert_equal({ user: { 'plan' => 'pro' } }, global_context_of(client))
+  end
+
+  # 3. RED: no-op when option enabled but file missing
+  def test_no_op_when_file_missing
+    # No tokens.json written.
+    client = Quonfig::Client.new(
+      Quonfig::Options.new(
+        enable_quonfig_user_context: true,
+        global_context: { user: { 'plan' => 'pro' } }
+      ),
+      store: Quonfig::ConfigStore.new
+    )
+
+    assert_equal({ user: { 'plan' => 'pro' } }, global_context_of(client))
+  end
+
+  # 4. RED: no-op when file unparseable; warning emitted; init succeeds
+  def test_no_op_when_file_unparseable
+    File.write(File.join(@tmphome, '.quonfig', 'tokens.json'), '{not valid json')
+
+    client = Quonfig::Client.new(
+      Quonfig::Options.new(enable_quonfig_user_context: true),
+      store: Quonfig::ConfigStore.new
+    )
+
+    assert_equal({}, global_context_of(client))
+    # The dev-context loader emits a warning to stderr that we want to verify.
+    assert_stderr(['quonfig'])
+  end
+
+  # 5. RED: customer-supplied quonfig-user keys win on collision
+  def test_customer_global_context_wins
+    write_tokens(userEmail: 'bob@foo.com')
+
+    client = Quonfig::Client.new(
+      Quonfig::Options.new(
+        enable_quonfig_user_context: true,
+        global_context: { 'quonfig-user' => { 'email' => 'override@x.com' } }
+      ),
+      store: Quonfig::ConfigStore.new
+    )
+
+    assert_equal({ 'quonfig-user' => { 'email' => 'override@x.com' } }, global_context_of(client))
+  end
+
+  # 6. RED: env var QUONFIG_DEV_CONTEXT=true enables when option absent
+  def test_env_var_enables_when_option_absent
+    write_tokens(userEmail: 'bob@foo.com')
+    ENV['QUONFIG_DEV_CONTEXT'] = 'true'
+
+    client = Quonfig::Client.new(
+      Quonfig::Options.new,
+      store: Quonfig::ConfigStore.new
+    )
+
+    assert_equal({ 'quonfig-user' => { 'email' => 'bob@foo.com' } }, global_context_of(client))
+  end
+
+  # 7. RED: integration — rule keyed on quonfig-user.email fires when injected
+  def test_attribute_reaches_eval_context
+    write_tokens(userEmail: 'bob@foo.com')
+
+    flag_config = {
+      'id' => 'cfg-flag',
+      'key' => 'my-flag',
+      'type' => 'feature_flag',
+      'valueType' => 'bool',
+      'sendToClientSdk' => false,
+      'default' => {
+        'rules' => [
+          { 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }], 'value' => { 'type' => 'bool', 'value' => false } }
+        ]
+      },
+      'environment' => {
+        'id' => 'Production',
+        'rules' => [
+          {
+            'criteria' => [{
+              'propertyName' => 'quonfig-user.email',
+              'operator' => 'PROP_IS_ONE_OF',
+              'valueToMatch' => { 'type' => 'string_list', 'value' => ['bob@foo.com'] }
+            }],
+            'value' => { 'type' => 'bool', 'value' => true }
+          },
+          { 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }], 'value' => { 'type' => 'bool', 'value' => false } }
+        ]
+      }
+    }
+
+    store = Quonfig::ConfigStore.new
+    store.set('my-flag', flag_config)
+
+    client = Quonfig::Client.new(
+      Quonfig::Options.new(
+        enable_quonfig_user_context: true,
+        environment: 'Production'
+      ),
+      store: store
+    )
+
+    assert_equal true, client.get_bool('my-flag')
+  end
+end

data/test/test_http_connection.rb

@@ -65,15 +65,17 @@ module Quonfig
       refute(Options::DEFAULT_API_URLS.any? { |s| s.include?('reforge.com') })
     end
 
-    def test_telemetry_destination_honors_quonfig_telemetry_url_env
-      with_env('QUONFIG_TELEMETRY_URL', 'https://override-telemetry.example.com') do
-        assert_equal 'https://override-telemetry.example.com',
+    def test_telemetry_destination_honors_quonfig_domain_env
+      with_env('QUONFIG_DOMAIN', 'quonfig-staging.com') do
+        assert_equal 'https://telemetry.quonfig-staging.com',
                      Options.new.telemetry_destination
       end
     end
 
     def test_telemetry_destination_default
-      assert_equal 'https://telemetry.quonfig.com', Options.new.telemetry_destination
+      with_env('QUONFIG_DOMAIN', nil) do
+        assert_equal 'https://telemetry.quonfig.com', Options.new.telemetry_destination
+      end
     end
   end
 end