quonfig 0.0.9 → 0.0.11

data/test/test_client_telemetry.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# Verifies that Quonfig::Client#get feeds every evaluation into the
-# telemetry reporter's evaluation_summaries aggregator.
-class TestClientTelemetry < Minitest::Test
-  CONFIG_KEY = 'my.flag'
-
-  class FakeHttpConnection
-    FakeResponse = Struct.new(:status)
-    attr_reader :posts
-    def initialize; @posts = []; end
-    def post(path, body); @posts << [path, body]; FakeResponse.new(200); end
-  end
-
-  # Plain ConfigResponse-shaped hash (matches Datadir.to_config_response).
-  def make_config(key:, value:, type: 'string', criteria: nil)
-    {
-      'id' => 'cid-abc',
-      'key' => key,
-      'type' => 'config',
-      'valueType' => type,
-      'sendToClientSdk' => false,
-      'default' => {
-        'rules' => [
-          {
-            'criteria' => criteria || [{ 'operator' => 'ALWAYS_TRUE' }],
-            'value' => { 'type' => type, 'value' => value }
-          }
-        ]
-      },
-      'environment' => nil
-    }
-  end
-
-  def make_client_with_telemetry(store)
-    client = Quonfig::Client.new(Quonfig::Options.new, store: store)
-
-    # The store-injection path skips initialize_telemetry by design (it's
-    # for test/bootstrap mode), so we attach the reporter + aggregators
-    # here explicitly to exercise the record path.
-    summaries_agg = Quonfig::Telemetry::EvaluationSummariesAggregator.new(max_keys: 100)
-    shape_agg = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 100)
-    example_agg = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 100)
-
-    options = Quonfig::Options.new(
-      sdk_key: 'qf_sk_dev_abc_deadbeef',
-      environment: 'development',
-      api_urls: ['https://primary.example.com'],
-      enable_sse: false,
-      enable_polling: false,
-      on_init_failure: Quonfig::Options::ON_INITIALIZATION_FAILURE::RETURN
-    ).tap { |o| o.instance_variable_set(:@telemetry_destination, 'https://t.example.com') }
-
-    fake_conn = FakeHttpConnection.new
-    reporter = Quonfig::Telemetry::TelemetryReporter.new(
-      options: options,
-      instance_hash: client.instance_hash,
-      context_shape_aggregator: shape_agg,
-      example_contexts_aggregator: example_agg,
-      evaluation_summaries_aggregator: summaries_agg,
-      http_connection: fake_conn
-    )
-    client.instance_variable_set(:@telemetry_reporter, reporter)
-
-    [client, reporter, summaries_agg, fake_conn]
-  end
-
-  def test_get_pushes_evaluation_into_summaries_aggregator
-    store = Quonfig::ConfigStore.new
-    store.set(CONFIG_KEY, make_config(key: CONFIG_KEY, value: 'hello'))
-
-    client, _reporter, summaries_agg, _conn = make_client_with_telemetry(store)
-    client.get(CONFIG_KEY, Quonfig::NO_DEFAULT_PROVIDED, 'user' => { 'key' => 'u1' })
-
-    event = summaries_agg.drain_event
-    refute_nil event, 'expected an evaluation_summaries event after Client#get'
-
-    summary = event['summaries']['summaries'][0]
-    assert_equal CONFIG_KEY, summary['key']
-    assert_equal 'config',   summary['type']
-
-    counter = summary['counters'][0]
-    assert_equal 'cid-abc',                 counter['configId']
-    assert_equal 0,                         counter['conditionalValueIndex']
-    assert_equal 1,                         counter['count']
-    assert_equal({ 'string' => 'hello' },   counter['selectedValue'])
-    # ALWAYS_TRUE on the only rule → STATIC (1)
-    assert_equal 1, counter['reason']
-  end
-
-  def test_get_with_targeting_rule_reports_targeting_match
-    store = Quonfig::ConfigStore.new
-    store.set(CONFIG_KEY, make_config(
-      key: CONFIG_KEY,
-      value: 'targeted',
-      criteria: [{
-        'operator' => 'PROP_IS_ONE_OF',
-        'propertyName' => 'user.tier',
-        'valueToMatch' => { 'type' => 'string_list', 'value' => ['pro'] }
-      }]
-    ))
-
-    client, _reporter, summaries_agg, _conn = make_client_with_telemetry(store)
-    client.get(CONFIG_KEY, 'fallback', 'user' => { 'key' => 'u1', 'tier' => 'pro' })
-
-    counter = summaries_agg.drain_event['summaries']['summaries'][0]['counters'][0]
-    # Config has a non-ALWAYS_TRUE rule → TARGETING_MATCH (2)
-    assert_equal 2, counter['reason']
-  end
-
-  def test_repeated_get_increments_count_not_new_counters
-    store = Quonfig::ConfigStore.new
-    store.set(CONFIG_KEY, make_config(key: CONFIG_KEY, value: 'hello'))
-
-    client, _reporter, summaries_agg, _conn = make_client_with_telemetry(store)
-    3.times { client.get(CONFIG_KEY, Quonfig::NO_DEFAULT_PROVIDED, 'user' => { 'key' => 'u1' }) }
-
-    counters = summaries_agg.drain_event['summaries']['summaries'][0]['counters']
-    assert_equal 1, counters.size, 'same evaluation should dedupe into one counter'
-    assert_equal 3, counters[0]['count']
-  end
-
-  def test_missing_key_does_not_record_evaluation
-    store = Quonfig::ConfigStore.new
-    client, _reporter, summaries_agg, _conn = make_client_with_telemetry(store)
-
-    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_config_loader.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'ostruct'
-require 'json'
-
-class TestConfigLoader < Minitest::Test
-  def setup
-    super
-    options = Quonfig::Options.new(
-      sdk_key: '1-test-sdk-key',
-      api_urls: ['https://primary.example.test']
-    )
-    @loader = Quonfig::ConfigLoader.new(MockBaseClient.new(options))
-  end
-
-  def test_fetch_200_populates_configs_and_stores_etag_then_304_is_a_noop
-    body = JSON.generate(
-      'configs' => [
-        { 'key' => 'my.flag', 'type' => 'config', 'valueType' => 'bool',
-          'default' => { 'rules' => [] } }
-      ],
-      'meta' => { 'version' => 'v1', 'environment' => 'production' }
-    )
-    ok_response = Faraday::Response.new(
-      status: 200, body: body,
-      response_headers: { 'ETag' => 'W/"etag-one"' }
-    )
-    not_modified = Faraday::Response.new(
-      status: 304, body: '', response_headers: {}
-    )
-
-    observed_headers = []
-
-    http_conn = Minitest::Mock.new
-    http_conn.expect(:get, ok_response) do |path, headers|
-      observed_headers << headers.dup
-      path == '/api/v2/configs' && !headers.key?('If-None-Match')
-    end
-    http_conn.expect(:get, not_modified) do |path, headers|
-      observed_headers << headers.dup
-      path == '/api/v2/configs' && headers['If-None-Match'] == 'W/"etag-one"'
-    end
-
-    Quonfig::HttpConnection.stub :new, ->(_uri, _key) { http_conn } do
-      assert_equal :updated, @loader.fetch!
-      assert_equal :not_modified, @loader.fetch!
-    end
-
-    assert_equal 'W/"etag-one"', @loader.etag
-    calc = @loader.calc_config
-    assert calc.key?('my.flag'), "expected 'my.flag' to be loaded"
-    assert_equal 'W/"etag-one"', observed_headers[1]['If-None-Match']
-    http_conn.verify
-  end
-
-  def test_set_and_rm_preserved
-    config = OpenStruct.new(key: 'x', rows: [1])
-    @loader.set(config, :test)
-    assert @loader.calc_config.key?('x')
-
-    @loader.rm('x')
-    refute @loader.calc_config.key?('x')
-  end
-
-  def test_no_highwater_mark_attribute
-    refute @loader.respond_to?(:highwater_mark),
-           'highwater_mark should be removed from ConfigLoader'
-  end
-end

data/test/test_context.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestContext < Minitest::Test
-  EXAMPLE_PROPERTIES = {
-    user: { key: 'some-user-key', name: 'Ted' },
-    team: { key: 'abc', plan: 'pro' }
-  }.freeze
-
-  def test_initialize_with_empty_context
-    context = Quonfig::Context.new({})
-    assert_empty context.contexts
-    assert context.blank?
-  end
-
-  def test_initialize_with_hash
-    context = Quonfig::Context.new(test: { foo: 'bar' })
-    assert_equal 1, context.contexts.size
-    assert_equal 'bar', context.get('test.foo')
-  end
-
-  def test_initialize_with_multiple_hashes
-    context = Quonfig::Context.new(test: { foo: 'bar' }, other: { foo: 'baz' })
-    assert_equal 2, context.contexts.size
-    assert_equal 'bar', context.get('test.foo')
-    assert_equal 'baz', context.get('other.foo')
-  end
-
-  def test_initialize_with_invalid_argument
-    assert_raises(ArgumentError) { Quonfig::Context.new([]) }
-  end
-
-  def test_setting
-    context = Quonfig::Context.new({})
-    context.set('user', { key: 'value' })
-    context.set(:other, { key: 'different', something: 'other' })
-
-    assert_equal(
-      stringify(user: { key: 'value' }, other: { key: 'different', something: 'other' }),
-      context.to_h
-    )
-  end
-
-  def test_getting
-    context = Quonfig::Context.new(EXAMPLE_PROPERTIES)
-    assert_equal('some-user-key', context.get('user.key'))
-    assert_equal('pro', context.get('team.plan'))
-  end
-
-  def test_dot_notation_getting
-    context = Quonfig::Context.new('user' => { 'key' => 'value' })
-    assert_equal('value', context.get('user.key'))
-  end
-
-  def test_dot_notation_getting_with_symbols
-    context = Quonfig::Context.new(user: { key: 'value' })
-    assert_equal('value', context.get('user.key'))
-  end
-
-  def test_get_returns_nil_for_missing_property
-    context = Quonfig::Context.new(user: { key: 'value' })
-    assert_nil context.get('user.missing')
-    assert_nil context.get('absent.key')
-  end
-
-  def test_clear
-    context = Quonfig::Context.new(EXAMPLE_PROPERTIES)
-    context.clear
-
-    assert_empty context.to_h
-    assert context.blank?
-  end
-
-  def test_to_h_stringifies_keys
-    context = Quonfig::Context.new(EXAMPLE_PROPERTIES)
-    assert_equal stringify(EXAMPLE_PROPERTIES), context.to_h
-  end
-
-  def test_legacy_flat_hash_shorthand_promotes_to_blank_named_context
-    # Pre-named-contexts callers passed a flat Hash. The constructor still
-    # accepts that shape and stuffs it under the empty-string named context.
-    context = Quonfig::Context.new('foo' => 'bar')
-    assert_equal 'bar', context.get('.foo')
-  end
-
-  def test_grouped_key_combines_named_contexts_by_key
-    context = Quonfig::Context.new(
-      user: { key: 'u1' },
-      team: { key: 't1' }
-    )
-
-    # Mirrors sdk-node groupedKey: just the key/trackingId values, sorted
-    # and pipe-joined. Contexts without a key/trackingId contribute
-    # nothing — so the example aggregator drops anonymous contexts.
-    assert_equal 't1|u1', context.grouped_key
-  end
-
-  def test_named_context_lookup_returns_namedcontext
-    context = Quonfig::Context.new(user: { key: 'u1', name: 'Ted' })
-    user = context.context('user')
-
-    assert_kind_of Quonfig::Context::NamedContext, user
-    assert_equal 'user', user.name
-    assert_equal({ 'key' => 'u1', 'name' => 'Ted' }, user.to_h)
-  end
-
-  def test_named_context_lookup_for_missing_returns_empty_namedcontext
-    context = Quonfig::Context.new(user: { key: 'u1' })
-    missing = context.context('absent')
-
-    assert_kind_of Quonfig::Context::NamedContext, missing
-    assert_equal 'absent', missing.name
-    assert_empty missing.to_h
-  end
-
-  def test_comparable
-    a = Quonfig::Context.new(user: { key: 'u1' })
-    b = Quonfig::Context.new(user: { key: 'u1' })
-    c = Quonfig::Context.new(user: { key: 'u2' })
-
-    assert_equal a, b
-    refute_equal a, c
-  end
-
-  private
-
-  def stringify(hash)
-    hash.map { |k, v| [k.to_s, stringify_keys(v)] }.to_h
-  end
-
-  def stringify_keys(value)
-    if value.is_a?(Hash)
-      value.transform_keys(&:to_s)
-    else
-      value
-    end
-  end
-end

data/test/test_context_shape.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestContextShape < Minitest::Test
-  class Email; end
-
-  def test_field_type_number
-    [
-      [1, 1],
-      [99_999_999_999_999_999_999_999_999_999_999_999_999_999_999, 1],
-      [-99_999_999_999_999_999_999_999_999_999_999_999_999_999_999, 1],
-
-      ['a', 2],
-      ['99999999999999999999999999999999999999999999', 2],
-
-      [1.0, 4],
-      [99_999_999_999_999_999_999_999_999_999_999_999_999_999_999.0, 4],
-      [-99_999_999_999_999_999_999_999_999_999_999_999_999_999_999.0, 4],
-
-      [true, 5],
-      [false, 5],
-
-      [[], 10],
-      [[1, 2, 3], 10],
-      [%w[a b c], 10],
-
-      # Unknown / custom types fall back to "string" (2).
-      [Email.new, 2]
-    ].each do |value, expected|
-      actual = Quonfig::Telemetry::ContextShape.field_type_number(value)
-
-      refute_nil actual, "Expected a value for input: #{value.inspect}"
-      assert_equal expected, actual, "Expected #{expected} for #{value.inspect}"
-    end
-  end
-end

data/test/test_context_shape_aggregator.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestContextShapeAggregator < Minitest::Test
-  CONTEXT_1 = Quonfig::Context.new(
-    'user' => {
-      'name' => 'user-name',
-      'email' => 'user.email',
-      'age' => 42.5
-    },
-    'subscription' => {
-      'plan' => 'advanced',
-      'free' => false
-    }
-  ).freeze
-
-  CONTEXT_2 = Quonfig::Context.new(
-    'user' => {
-      'name' => 'other-user-name',
-      'dob' => '2020-01-01'
-    },
-    'device' => {
-      'name' => 'device-name',
-      'os' => 'os-name',
-      'version' => 3
-    }
-  ).freeze
-
-  CONTEXT_3 = Quonfig::Context.new(
-    'subscription' => {
-      'plan' => 'pro',
-      'trial' => true
-    }
-  ).freeze
-
-  def test_push_respects_max_shapes
-    aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 9)
-
-    aggregator.push(CONTEXT_1)
-    aggregator.push(CONTEXT_2)
-    assert_equal 9, aggregator.data.size
-
-    # At the limit — further shapes get dropped.
-    aggregator.push(CONTEXT_3)
-    assert_equal 9, aggregator.data.size
-
-    tuples = aggregator.data.to_a
-    assert_includes tuples, ['user', 'name', 2]
-    assert_includes tuples, ['user', 'email', 2]
-    assert_includes tuples, ['user', 'age', 4]
-    assert_includes tuples, ['subscription', 'plan', 2]
-    assert_includes tuples, ['subscription', 'free', 5]
-    assert_includes tuples, ['device', 'name', 2]
-    assert_includes tuples, ['device', 'os', 2]
-    assert_includes tuples, ['device', 'version', 1]
-  end
-
-  def test_prepare_data_folds_tuples_and_clears
-    aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 1000)
-
-    aggregator.push(CONTEXT_1)
-    aggregator.push(CONTEXT_2)
-    aggregator.push(CONTEXT_3)
-
-    data = aggregator.prepare_data
-
-    assert_equal %w[user subscription device].sort, data.keys.sort
-
-    assert_equal(
-      { 'name' => 2, 'email' => 2, 'dob' => 2, 'age' => 4 },
-      data['user']
-    )
-
-    assert_equal(
-      { 'plan' => 2, 'trial' => 5, 'free' => 5 },
-      data['subscription']
-    )
-
-    assert_equal(
-      { 'name' => 2, 'os' => 2, 'version' => 1 },
-      data['device']
-    )
-
-    assert_equal [], aggregator.data.to_a
-  end
-
-  def test_drain_event_emits_api_telemetry_wire_shape
-    aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 1000)
-    aggregator.push(Quonfig::Context.new('user' => { 'key' => 'abc', 'age' => 42 }))
-
-    event = aggregator.drain_event
-
-    refute_nil event
-    assert event.key?('contextShapes')
-    shapes = event['contextShapes']['shapes']
-    assert_equal 1, shapes.size
-    assert_equal 'user', shapes[0]['name']
-    assert_equal({ 'key' => 2, 'age' => 1 }, shapes[0]['fieldTypes'])
-  end
-
-  def test_drain_event_nil_when_empty
-    aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 1000)
-    assert_nil aggregator.drain_event
-  end
-
-  def test_push_dedupes_identical_shapes
-    aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 1000)
-
-    aggregator.push(Quonfig::Context.new('user' => { 'key' => 'a', 'age' => 1 }))
-    aggregator.push(Quonfig::Context.new('user' => { 'key' => 'b', 'age' => 2 }))
-
-    # Same (name, key, type) tuples should have been deduped by the Set.
-    assert_equal 2, aggregator.data.size
-  end
-
-  def test_accepts_plain_hash_context
-    aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 1000)
-
-    aggregator.push('user' => { 'key' => 'abc', 'is_admin' => true })
-
-    event = aggregator.drain_event
-    refute_nil event
-    assert_equal({ 'key' => 2, 'is_admin' => 5 }, event['contextShapes']['shapes'][0]['fieldTypes'])
-  end
-end