quonfig 0.0.6 → 0.0.9

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_evaluation_summaries_aggregator.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestEvaluationSummariesAggregator < Minitest::Test
+  def make_aggregator(max_keys: 100)
+    Quonfig::Telemetry::EvaluationSummariesAggregator.new(max_keys: max_keys)
+  end
+
+  def record_eval(agg, overrides = {})
+    defaults = {
+      config_id: 'c1',
+      config_key: 'my-test-key',
+      config_type: 'config',
+      conditional_value_index: 0,
+      weighted_value_index: nil,
+      selected_value: 'hello',
+      reason: 1
+    }
+    agg.record(**defaults.merge(overrides))
+  end
+
+  def test_record_dedupes_identical_evaluations_into_one_counter
+    agg = make_aggregator
+
+    record_eval(agg)
+    record_eval(agg)
+    record_eval(agg)
+
+    event = agg.drain_event
+    refute_nil event
+    summaries = event['summaries']['summaries']
+    assert_equal 1, summaries.size
+
+    counters = summaries[0]['counters']
+    assert_equal 1, counters.size
+    assert_equal 3, counters[0]['count']
+  end
+
+  def test_record_creates_separate_counters_for_different_rule_indexes
+    agg = make_aggregator
+
+    record_eval(agg, conditional_value_index: 0)
+    record_eval(agg, conditional_value_index: 1)
+    record_eval(agg, conditional_value_index: 1)
+
+    summaries = agg.drain_event['summaries']['summaries']
+    assert_equal 1, summaries.size
+
+    counters = summaries[0]['counters']
+    assert_equal 2, counters.size
+
+    by_idx = counters.each_with_object({}) { |c, h| h[c['conditionalValueIndex']] = c['count'] }
+    assert_equal 1, by_idx[0]
+    assert_equal 2, by_idx[1]
+  end
+
+  def test_record_groups_by_config_key_and_type
+    agg = make_aggregator
+
+    record_eval(agg, config_key: 'alpha', config_type: 'config')
+    record_eval(agg, config_key: 'alpha', config_type: 'config')
+    record_eval(agg, config_key: 'beta',  config_type: 'feature_flag')
+
+    summaries = agg.drain_event['summaries']['summaries']
+    assert_equal 2, summaries.size
+
+    by_key = summaries.each_with_object({}) { |s, h| h[s['key']] = s }
+    assert_equal 'config',        by_key['alpha']['type']
+    assert_equal 'feature_flag',  by_key['beta']['type']
+    assert_equal 2, by_key['alpha']['counters'][0]['count']
+    assert_equal 1, by_key['beta']['counters'][0]['count']
+  end
+
+  def test_drain_event_nil_when_empty
+    agg = make_aggregator
+    assert_nil agg.drain_event
+  end
+
+  def test_drain_clears_state
+    agg = make_aggregator
+    record_eval(agg)
+
+    refute_nil agg.drain_event
+    assert_nil agg.drain_event, 'second drain with no new records should be nil'
+  end
+
+  def test_drain_event_wire_shape
+    agg = make_aggregator
+
+    record_eval(agg,
+                config_id: 'cid-42',
+                config_key: 'my-test-key',
+                config_type: 'config',
+                conditional_value_index: 1,
+                weighted_value_index: nil,
+                selected_value: 'my-test-value',
+                reason: 2)
+
+    event = agg.drain_event
+    refute_nil event
+    assert event.key?('summaries'), 'top-level event key is summaries'
+
+    inner = event['summaries']
+    assert_kind_of Integer, inner['start']
+    assert_kind_of Integer, inner['end']
+    assert inner['end'] >= inner['start']
+
+    summary = inner['summaries'][0]
+    assert_equal 'my-test-key', summary['key']
+    assert_equal 'config',      summary['type']
+
+    counter = summary['counters'][0]
+    assert_equal 'cid-42',         counter['configId']
+    assert_equal 1,                counter['conditionalValueIndex']
+    assert_equal 0,                counter['configRowIndex']
+    assert_equal 1,                counter['count']
+    assert_equal 2,                counter['reason']
+    assert_equal({ 'string' => 'my-test-value' }, counter['selectedValue'])
+    refute counter.key?('weightedValueIndex'),
+           'weightedValueIndex omitted when nil'
+  end
+
+  def test_selected_value_wrapper_keys_match_prefab_shape
+    agg = make_aggregator
+
+    record_eval(agg, selected_value: true,      conditional_value_index: 0)
+    record_eval(agg, selected_value: 3,         conditional_value_index: 1)
+    record_eval(agg, selected_value: 1.5,       conditional_value_index: 2)
+    record_eval(agg, selected_value: 'hi',      conditional_value_index: 3)
+    record_eval(agg, selected_value: %w[a b],   conditional_value_index: 4)
+
+    counters = agg.drain_event['summaries']['summaries'][0]['counters']
+    by_idx = counters.each_with_object({}) { |c, h| h[c['conditionalValueIndex']] = c['selectedValue'] }
+
+    assert_equal({ 'bool'       => true },  by_idx[0])
+    assert_equal({ 'int'        => 3 },     by_idx[1])
+    assert_equal({ 'double'     => 1.5 },   by_idx[2])
+    assert_equal({ 'string'     => 'hi' },  by_idx[3])
+    assert_equal({ 'stringList' => %w[a b] }, by_idx[4])
+  end
+
+  def test_weighted_value_index_included_when_present
+    agg = make_aggregator
+
+    record_eval(agg, weighted_value_index: 2, reason: 3)
+
+    counter = agg.drain_event['summaries']['summaries'][0]['counters'][0]
+    assert_equal 2, counter['weightedValueIndex']
+    assert_equal 3, counter['reason']
+  end
+
+  def test_log_level_evaluations_are_excluded
+    agg = make_aggregator
+
+    record_eval(agg, config_type: 'log_level')
+
+    assert_nil agg.drain_event
+  end
+
+  def test_record_caps_at_max_keys
+    agg = make_aggregator(max_keys: 2)
+
+    record_eval(agg, config_key: 'a')
+    record_eval(agg, config_key: 'b')
+    record_eval(agg, config_key: 'c') # dropped — at cap
+
+    summaries = agg.drain_event['summaries']['summaries']
+    keys = summaries.map { |s| s['key'] }.sort
+    assert_equal %w[a b], keys
+  end
+
+  def test_noop_when_max_keys_zero
+    agg = make_aggregator(max_keys: 0)
+
+    record_eval(agg)
+
+    assert_nil agg.drain_event
+  end
+end

data/test/test_example_contexts_aggregator.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestExampleContextsAggregator < Minitest::Test
+  def test_record_dedupes_within_window
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 2)
+
+    context = Quonfig::Context.new(
+      'user' => { 'key' => 'abc' },
+      'device' => { 'key' => 'def', 'mobile' => true }
+    )
+
+    aggregator.record(context)
+    assert_equal 1, aggregator.data.size
+
+    # Same grouped key → skipped.
+    aggregator.record(context)
+    assert_equal 1, aggregator.data.size
+
+    new_context = Quonfig::Context.new(
+      'user' => { 'key' => 'ghi', 'admin' => true },
+      'team' => { 'key' => '999' }
+    )
+
+    aggregator.record(new_context)
+    assert_equal 2, aggregator.data.size
+
+    # At max_contexts — next record is dropped.
+    aggregator.record(Quonfig::Context.new('user' => { 'key' => 'new' }))
+    assert_equal 2, aggregator.data.size
+  end
+
+  def test_record_drops_contexts_without_a_key_property
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+
+    # Anonymous contexts (no `key` / `trackingId`) produce an empty
+    # grouped_key under the sdk-node-aligned shape. The aggregator drops
+    # them so we don't ship rows the backend can't dedupe.
+    aggregator.record(Quonfig::Context.new('user' => { 'name' => 'no-key' }))
+    aggregator.record(Quonfig::Context.new('user' => { 'name' => 'still-no-key' }))
+    assert_equal 0, aggregator.data.size
+  end
+
+  def test_record_with_expiry_allows_re_recording_after_window
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+
+    context = Quonfig::Context.new(
+      'user' => { 'key' => 'abc' },
+      'device' => { 'key' => 'def', 'mobile' => true }
+    )
+
+    aggregator.record(context)
+    assert_equal 1, aggregator.data.size
+
+    Timecop.travel(Time.now + (60 * 60) - 1) do
+      aggregator.record(context)
+      assert_equal 1, aggregator.data.size
+    end
+
+    Timecop.travel(Time.now + (60 * 60) + 1) do
+      aggregator.record(context)
+      assert_equal 2, aggregator.data.size
+    end
+  end
+
+  def test_drain_event_emits_api_telemetry_wire_shape
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+
+    aggregator.record(
+      Quonfig::Context.new(
+        'user' => { 'key' => 'abc' },
+        'device' => { 'key' => 'def', 'mobile' => true }
+      )
+    )
+    aggregator.record(
+      Quonfig::Context.new('user' => { 'key' => 'kev', 'name' => 'kevin', 'age' => 48.5 })
+    )
+
+    event = aggregator.drain_event
+
+    refute_nil event
+    assert event.key?('exampleContexts')
+    examples = event['exampleContexts']['examples']
+    assert_equal 2, examples.size
+
+    first = examples[0]
+    assert_kind_of Integer, first['timestamp']
+    assert first['timestamp'] > 0
+
+    contexts_list = first['contextSet']['contexts']
+    user_ctx = contexts_list.find { |c| c['type'] == 'user' }
+    device_ctx = contexts_list.find { |c| c['type'] == 'device' }
+
+    refute_nil user_ctx
+    refute_nil device_ctx
+    assert_equal 'abc', user_ctx['values']['key']
+    assert_equal true, device_ctx['values']['mobile']
+
+    second = examples[1]
+    user_ctx = second['contextSet']['contexts'].find { |c| c['type'] == 'user' }
+    assert_equal 'kev', user_ctx['values']['key']
+    assert_equal 'kevin', user_ctx['values']['name']
+    assert_in_delta 48.5, user_ctx['values']['age']
+  end
+
+  def test_drain_event_nil_when_empty
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+    assert_nil aggregator.drain_event
+  end
+
+  def test_drain_clears_data
+    aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10)
+    aggregator.record(Quonfig::Context.new('user' => { 'key' => 'abc' }))
+    aggregator.drain_event
+    assert_equal 0, aggregator.data.size
+  end
+end

data/test/test_http_connection.rb

@@ -23,7 +23,7 @@ module Quonfig
 
     def test_x_quonfig_sdk_version_header
       conn = HttpConnection.new(URI, SDK_KEY).connection
-      assert_equal 'ruby-0.1.0', conn.headers['X-Quonfig-SDK-Version']
+      assert_equal "ruby-#{Quonfig::VERSION}", conn.headers['X-Quonfig-SDK-Version']
     end
 
     def test_no_protobuf_content_type

data/test/test_resolver.rb

@@ -134,11 +134,158 @@ class TestResolverTrio < Minitest::Test
     assert_equal DEFAULT_VALUE, result.unwrapped_value
   end
 
-  def test_resolver_get_returns_nil_for_missing_key
+  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)
 
-    assert_nil resolver.get('nope', Quonfig::Context.new({}))
+    # 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