quonfig 0.0.10 → 0.0.12

data/test/test_evaluation_summaries_aggregator.rb

@@ -1,180 +0,0 @@
-# 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_evaluator.rb

@@ -1,285 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# qfg-dk6.10: operator-level tests for Quonfig::Evaluator against the JSON
-# Criterion shape (propertyName / operator / valueToMatch). Mirrors sdk-node's
-# evaluator behaviour — the node suite is the authoritative spec.
-#
-# The Evaluator consumes configs in the shape produced by
-# IntegrationTestHelpers.to_config_response / Quonfig::Datadir.to_config_response:
-#   {
-#     id:, key:, type:, value_type:,
-#     send_to_client_sdk:, default: { 'rules' => [...] }, environment: {...}
-#   }
-# Rules/criteria inside stay as plain JSON hashes (string keys), matching what
-# lands on disk in integration-test-data.
-class TestEvaluator < Minitest::Test
-  def build_config(rules, key: 'my.key', value_type: 'string', environment: nil)
-    {
-      id: 'id-1',
-      key: key,
-      type: 'config',
-      value_type: value_type,
-      send_to_client_sdk: false,
-      default: { 'rules' => rules },
-      environment: environment
-    }
-  end
-
-  def evaluate(config, context_hash = {}, extra_configs: {})
-    store = Quonfig::ConfigStore.new
-    store.set(config[:key], config)
-    extra_configs.each { |k, v| store.set(k, v) }
-    evaluator = Quonfig::Evaluator.new(store)
-    resolver = Quonfig::Resolver.new(store, evaluator)
-    resolver.get(config[:key], Quonfig::Context.new(context_hash))
-  end
-
-  def value_match_rule(criteria, value_type, value)
-    {
-      'criteria' => criteria,
-      'value' => { 'type' => value_type, 'value' => value }
-    }
-  end
-
-  # ------ ALWAYS_TRUE ------
-
-  def test_always_true
-    cfg = build_config([
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'hit')
-    ])
-    assert_equal 'hit', evaluate(cfg).unwrapped_value
-  end
-
-  # ------ PROP_IS_ONE_OF / PROP_IS_NOT_ONE_OF ------
-
-  def test_prop_is_one_of_matches
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_IS_ONE_OF',
-           'valueToMatch' => { 'type' => 'string_list', 'value' => %w[a@b.com c@d.com] } }],
-        'string', 'match'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'nope')
-    ])
-    assert_equal 'match', evaluate(cfg, { user: { email: 'a@b.com' } }).unwrapped_value
-    assert_equal 'nope', evaluate(cfg, { user: { email: 'z@z.com' } }).unwrapped_value
-  end
-
-  def test_prop_is_not_one_of_inverse
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_IS_NOT_ONE_OF',
-           'valueToMatch' => { 'type' => 'string_list', 'value' => %w[a@b.com] } }],
-        'string', 'match'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'nope')
-    ])
-    # Missing context => NOT_ONE_OF is true (sdk-node parity)
-    assert_equal 'match', evaluate(cfg, {}).unwrapped_value
-    assert_equal 'nope', evaluate(cfg, { user: { email: 'a@b.com' } }).unwrapped_value
-    assert_equal 'match', evaluate(cfg, { user: { email: 'z@z.com' } }).unwrapped_value
-  end
-
-  # ------ PROP_STARTS_WITH / ENDS_WITH / CONTAINS ------
-
-  def test_starts_with
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_STARTS_WITH_ONE_OF',
-           'valueToMatch' => { 'type' => 'string_list', 'value' => %w[admin- root-] } }],
-        'string', 'yes'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-    ])
-    assert_equal 'yes', evaluate(cfg, { user: { email: 'admin-bob' } }).unwrapped_value
-    assert_equal 'no', evaluate(cfg, { user: { email: 'bob' } }).unwrapped_value
-  end
-
-  def test_ends_with
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_ENDS_WITH_ONE_OF',
-           'valueToMatch' => { 'type' => 'string_list', 'value' => ['@prefab.cloud'] } }],
-        'string', 'yes'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-    ])
-    assert_equal 'yes', evaluate(cfg, { user: { email: 'b@prefab.cloud' } }).unwrapped_value
-    assert_equal 'no', evaluate(cfg, { user: { email: 'b@other.com' } }).unwrapped_value
-  end
-
-  def test_contains
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_CONTAINS_ONE_OF',
-           'valueToMatch' => { 'type' => 'string_list', 'value' => ['admin'] } }],
-        'string', 'yes'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-    ])
-    assert_equal 'yes', evaluate(cfg, { user: { email: 'admin@x.com' } }).unwrapped_value
-    assert_equal 'no', evaluate(cfg, { user: { email: 'b@x.com' } }).unwrapped_value
-  end
-
-  # ------ PROP_MATCHES / DOES_NOT_MATCH ------
-
-  def test_prop_matches
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_MATCHES',
-           'valueToMatch' => { 'type' => 'string', 'value' => '^admin' } }],
-        'string', 'yes'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-    ])
-    assert_equal 'yes', evaluate(cfg, { user: { email: 'admin-foo' } }).unwrapped_value
-    assert_equal 'no', evaluate(cfg, { user: { email: 'foo' } }).unwrapped_value
-  end
-
-  # ------ HIERARCHICAL_MATCH ------
-
-  def test_hierarchical_match
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'team.path', 'operator' => 'HIERARCHICAL_MATCH',
-           'valueToMatch' => { 'type' => 'string', 'value' => 'orgs/a' } }],
-        'string', 'yes'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-    ])
-    assert_equal 'yes', evaluate(cfg, { team: { path: 'orgs/a/team1' } }).unwrapped_value
-    assert_equal 'no',  evaluate(cfg, { team: { path: 'orgs/b/team1' } }).unwrapped_value
-  end
-
-  # ------ IN_INT_RANGE ------
-
-  def test_in_int_range
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.age', 'operator' => 'IN_INT_RANGE',
-           'valueToMatch' => { 'type' => 'int_range', 'value' => { 'start' => 18, 'end' => 30 } } }],
-        'string', 'yes'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-    ])
-    assert_equal 'yes', evaluate(cfg, { user: { age: 20 } }).unwrapped_value
-    assert_equal 'no',  evaluate(cfg, { user: { age: 30 } }).unwrapped_value  # end exclusive
-    assert_equal 'yes', evaluate(cfg, { user: { age: 18 } }).unwrapped_value  # start inclusive
-  end
-
-  # ------ NUMERIC COMPARISONS ------
-
-  def test_prop_greater_than_lt_etc
-    %w[PROP_GREATER_THAN PROP_GREATER_THAN_OR_EQUAL PROP_LESS_THAN PROP_LESS_THAN_OR_EQUAL].each do |op|
-      cfg = build_config([
-        value_match_rule(
-          [{ 'propertyName' => 'user.age', 'operator' => op,
-             'valueToMatch' => { 'type' => 'int', 'value' => 10 } }],
-          'string', 'yes'
-        ),
-        value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-      ])
-      expected = case op
-                 when 'PROP_GREATER_THAN' then { 9 => 'no', 10 => 'no', 11 => 'yes' }
-                 when 'PROP_GREATER_THAN_OR_EQUAL' then { 9 => 'no', 10 => 'yes', 11 => 'yes' }
-                 when 'PROP_LESS_THAN' then { 9 => 'yes', 10 => 'no', 11 => 'no' }
-                 when 'PROP_LESS_THAN_OR_EQUAL' then { 9 => 'yes', 10 => 'yes', 11 => 'no' }
-                 end
-      expected.each do |age, want|
-        assert_equal want, evaluate(cfg, { user: { age: age } }).unwrapped_value,
-                     "op=#{op} age=#{age}"
-      end
-    end
-  end
-
-  # ------ DATE COMPARISONS (BEFORE / AFTER) ------
-
-  def test_prop_before_after
-    cfg_before = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.created_at', 'operator' => 'PROP_BEFORE',
-           'valueToMatch' => { 'type' => 'string', 'value' => '2025-01-01T00:00:00Z' } }],
-        'string', 'yes'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-    ])
-    assert_equal 'yes', evaluate(cfg_before, { user: { created_at: '2024-06-01T00:00:00Z' } }).unwrapped_value
-    assert_equal 'no',  evaluate(cfg_before, { user: { created_at: '2025-06-01T00:00:00Z' } }).unwrapped_value
-  end
-
-  # ------ SEMVER COMPARISONS ------
-
-  def test_semver_eq_gt_lt
-    [
-      ['PROP_SEMVER_EQUAL',        '1.2.3', '1.2.3', 'yes'],
-      ['PROP_SEMVER_EQUAL',        '1.2.4', '1.2.3', 'no'],
-      ['PROP_SEMVER_GREATER_THAN', '1.2.4', '1.2.3', 'yes'],
-      ['PROP_SEMVER_GREATER_THAN', '1.2.3', '1.2.4', 'no'],
-      ['PROP_SEMVER_LESS_THAN',    '1.2.2', '1.2.3', 'yes'],
-      ['PROP_SEMVER_LESS_THAN',    '1.2.4', '1.2.3', 'no']
-    ].each do |op, context_ver, match_ver, want|
-      cfg = build_config([
-        value_match_rule(
-          [{ 'propertyName' => 'app.version', 'operator' => op,
-             'valueToMatch' => { 'type' => 'string', 'value' => match_ver } }],
-          'string', 'yes'
-        ),
-        value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
-      ])
-      assert_equal want, evaluate(cfg, { app: { version: context_ver } }).unwrapped_value,
-                   "op=#{op} ctx=#{context_ver} match=#{match_ver}"
-    end
-  end
-
-  # ------ IN_SEG / NOT_IN_SEG ------
-
-  def test_in_seg_resolves_via_store
-    segment = build_config([
-      value_match_rule(
-        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_IS_ONE_OF',
-           'valueToMatch' => { 'type' => 'string_list', 'value' => ['ok@x.com'] } }],
-        'bool', true
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'bool', false)
-    ], key: 'seg.key', value_type: 'bool')
-
-    cfg = build_config([
-      value_match_rule(
-        [{ 'propertyName' => '', 'operator' => 'IN_SEG',
-           'valueToMatch' => { 'type' => 'string', 'value' => 'seg.key' } }],
-        'string', 'in'
-      ),
-      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'out')
-    ])
-
-    extra = { 'seg.key' => segment }
-    assert_equal 'in',  evaluate(cfg, { user: { email: 'ok@x.com' } }, extra_configs: extra).unwrapped_value
-    assert_equal 'out', evaluate(cfg, { user: { email: 'no@x.com' } }, extra_configs: extra).unwrapped_value
-  end
-
-  # ------ ENVIRONMENT-SPECIFIC RULES ------
-
-  def test_environment_rules_precede_default
-    env_rule = value_match_rule(
-      [{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'from-env'
-    )
-    default_rule = value_match_rule(
-      [{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'from-default'
-    )
-    cfg = build_config(
-      [default_rule],
-      environment: { 'id' => 'Production', 'rules' => [env_rule] }
-    )
-    # default evaluator has no envID set, so falls back to default rules
-    assert_equal 'from-default', evaluate(cfg).unwrapped_value
-
-    store = Quonfig::ConfigStore.new
-    store.set(cfg[:key], cfg)
-    evaluator = Quonfig::Evaluator.new(store, env_id: 'Production')
-    resolver = Quonfig::Resolver.new(store, evaluator)
-    result = resolver.get(cfg[:key], Quonfig::Context.new({}))
-    assert_equal 'from-env', result.unwrapped_value
-  end
-end

data/test/test_example_contexts_aggregator.rb

@@ -1,119 +0,0 @@
-# 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_exponential_backoff.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestExponentialBackoff < Minitest::Test
-  def test_backoff
-    backoff = Quonfig::ExponentialBackoff.new(max_delay: 120)
-
-    assert_equal 2, backoff.call
-    assert_equal 4, backoff.call
-    assert_equal 8, backoff.call
-    assert_equal 16, backoff.call
-    assert_equal 32, backoff.call
-    assert_equal 64, backoff.call
-    assert_equal 120, backoff.call
-    assert_equal 120, backoff.call
-  end
-
-  def test_backoff_with_15x_multiplier_matches_quonfig_spec
-    # Spec: initial 8s, multiplier 1.5, max 600s (matches sdk-node reporter.ts)
-    backoff = Quonfig::ExponentialBackoff.new(
-      initial_delay: 8, max_delay: 600, multiplier: 1.5
-    )
-
-    assert_equal 8, backoff.call
-    assert_equal 12.0, backoff.call
-    assert_equal 18.0, backoff.call
-    assert_equal 27.0, backoff.call
-    assert_equal 40.5, backoff.call
-    assert_equal 60.75, backoff.call
-  end
-
-  def test_periodic_sync_default_matches_quonfig_spec
-    mod = Class.new { include Quonfig::PeriodicSync }.new
-    interval = mod.send(:calculate_sync_interval, nil)
-
-    # Spec: initial 8s, multiplier 1.5, max 600s
-    assert_equal 8, interval.call
-    assert_equal 12.0, interval.call
-    assert_equal 18.0, interval.call
-    assert_equal 27.0, interval.call
-    assert_equal 40.5, interval.call
-  end
-end