quonfig 0.0.10 → 0.0.12

data/test/test_telemetry_reporter.rb

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestTelemetryReporter < Minitest::Test
-  # Minimal stand-in for Quonfig::HttpConnection that records POSTs.
-  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
-
-  def make_options(telemetry_destination: 'https://telemetry.example.com',
-                   sdk_key: 'qf_sk_development_abc_deadbeef')
-    # Build minimal Options bypassing env-var lookups via explicit overrides.
-    Quonfig::Options.new(
-      sdk_key: sdk_key,
-      environment: 'development',
-      api_urls: ['https://primary.example.com'],
-      enable_sse: false,
-      enable_polling: false,
-      on_init_failure: Quonfig::Options::ON_INITIALIZATION_FAILURE::RETURN,
-      context_upload_mode: :periodic_example
-    ).tap do |opts|
-      opts.instance_variable_set(:@telemetry_destination, telemetry_destination)
-    end
-  end
-
-  def test_sync_posts_combined_events_in_api_telemetry_wire_shape
-    options = make_options
-    fake = FakeHttpConnection.new
-
-    shape_agg = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 100)
-    example_agg = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 100)
-
-    reporter = Quonfig::Telemetry::TelemetryReporter.new(
-      options: options,
-      instance_hash: 'fake-instance-hash',
-      context_shape_aggregator: shape_agg,
-      example_contexts_aggregator: example_agg,
-      http_connection: fake
-    )
-
-    ctx = Quonfig::Context.new('user' => { 'key' => 'abc', 'age' => 33 })
-    shape_agg.push(ctx)
-    example_agg.record(ctx)
-
-    reporter.sync
-
-    assert_equal 1, fake.posts.size
-    path, body = fake.posts.first
-    assert_equal '/api/v1/telemetry/', path
-
-    # Wire shape: TelemetryEventsSchema
-    assert_equal 'fake-instance-hash', body['instanceHash']
-    assert_kind_of Array, body['events']
-    assert_equal 2, body['events'].size
-
-    shape_event = body['events'].find { |e| e.key?('contextShapes') }
-    example_event = body['events'].find { |e| e.key?('exampleContexts') }
-
-    refute_nil shape_event
-    refute_nil example_event
-
-    # ContextShapesSchema: { shapes: [{ name, fieldTypes }] }
-    shapes = shape_event['contextShapes']['shapes']
-    assert_equal 1, shapes.size
-    assert_equal 'user', shapes[0]['name']
-    assert_equal({ 'key' => 2, 'age' => 1 }, shapes[0]['fieldTypes'])
-
-    # ExampleContextsSchema: { examples: [{ timestamp, contextSet: { contexts: [...] } }] }
-    examples = example_event['exampleContexts']['examples']
-    assert_equal 1, examples.size
-    assert_kind_of Integer, examples[0]['timestamp']
-    contexts_list = examples[0]['contextSet']['contexts']
-    assert_equal 'user', contexts_list[0]['type']
-    assert_equal 'abc', contexts_list[0]['values']['key']
-    assert_equal 33, contexts_list[0]['values']['age']
-  end
-
-  def test_sync_noop_when_aggregators_empty
-    fake = FakeHttpConnection.new
-    reporter = Quonfig::Telemetry::TelemetryReporter.new(
-      options: make_options,
-      instance_hash: 'h',
-      context_shape_aggregator: Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 10),
-      example_contexts_aggregator: Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 10),
-      http_connection: fake
-    )
-
-    reporter.sync
-    assert_equal 0, fake.posts.size
-  end
-
-  def test_enabled_requires_sdk_key_and_destination
-    options = make_options(sdk_key: '')
-    reporter = Quonfig::Telemetry::TelemetryReporter.new(
-      options: options,
-      instance_hash: 'h',
-      context_shape_aggregator: Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 10)
-    )
-    refute reporter.enabled?
-  end
-
-  def test_record_feeds_both_aggregators
-    fake = FakeHttpConnection.new
-    shape_agg = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 100)
-    example_agg = Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: 100)
-
-    reporter = Quonfig::Telemetry::TelemetryReporter.new(
-      options: make_options,
-      instance_hash: 'h',
-      context_shape_aggregator: shape_agg,
-      example_contexts_aggregator: example_agg,
-      http_connection: fake
-    )
-
-    reporter.record(Quonfig::Context.new('user' => { 'key' => 'zzz' }))
-
-    refute_nil shape_agg.drain_event
-    refute_nil example_agg.drain_event
-  end
-
-  def test_sync_posts_evaluation_summaries_event
-    fake = FakeHttpConnection.new
-    summaries_agg = Quonfig::Telemetry::EvaluationSummariesAggregator.new(max_keys: 100)
-
-    reporter = Quonfig::Telemetry::TelemetryReporter.new(
-      options: make_options,
-      instance_hash: 'h',
-      evaluation_summaries_aggregator: summaries_agg,
-      http_connection: fake
-    )
-
-    summaries_agg.record(
-      config_id: 'cid',
-      config_key: 'my-key',
-      config_type: 'config',
-      conditional_value_index: 0,
-      selected_value: 'v',
-      reason: 1
-    )
-
-    reporter.sync
-
-    assert_equal 1, fake.posts.size
-    _path, body = fake.posts.first
-
-    summaries_event = body['events'].find { |e| e.key?('summaries') }
-    refute_nil summaries_event, 'expected a summaries event in the payload'
-
-    inner = summaries_event['summaries']
-    assert_kind_of Array, inner['summaries']
-    counter = inner['summaries'][0]['counters'][0]
-    assert_equal 1, counter['count']
-    assert_equal 1, counter['reason']
-  end
-
-  def test_at_exit_final_drain_posts_pending_batch
-    fake = FakeHttpConnection.new
-    shape_agg = Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 100)
-
-    reporter = Quonfig::Telemetry::TelemetryReporter.new(
-      options: make_options,
-      instance_hash: 'h',
-      context_shape_aggregator: shape_agg,
-      http_connection: fake
-    )
-
-    # Simulate evaluations accumulating between sync cycles.
-    shape_agg.push(Quonfig::Context.new('user' => { 'key' => 'x' }))
-
-    # Simulate a Rails SIGTERM: process exits without Client#stop being
-    # called. The reporter's at_exit handler must flush the pending batch.
-    reporter.send(:final_drain_on_exit)
-
-    assert_equal 1, fake.posts.size
-    _path, body = fake.posts.first
-    refute_nil body['events'].find { |e| e.key?('contextShapes') }
-  end
-
-  def test_at_exit_handler_registered_on_start
-    # Guards against regressing the Kernel.at_exit hookup that catches
-    # Rails / Passenger worker SIGTERMs where Client#stop isn't called.
-    fake = FakeHttpConnection.new
-    reporter = Quonfig::Telemetry::TelemetryReporter.new(
-      options: make_options,
-      instance_hash: 'h',
-      context_shape_aggregator: Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: 10),
-      http_connection: fake,
-      sync_interval: 999 # avoid the background thread firing during the test
-    )
-
-    refute reporter.at_exit_registered?, 'not registered before start'
-    reporter.start
-    assert reporter.at_exit_registered?, 'registered after start'
-  ensure
-    reporter&.stop
-  end
-end

data/test/test_typed_getters.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# Typed getters (get_string / get_int / get_bool / get_string_list /
-# get_duration / get_json) on Quonfig::Client. Each verifies both the happy
-# path against an injected ConfigStore and the type-mismatch error path.
-class TestTypedGetters < Minitest::Test
-  KEY = 'my.key'
-
-  def make_config(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 client_with_value(value:, type:)
-    store = Quonfig::ConfigStore.new
-    store.set(KEY, make_config(value: value, type: type))
-    Quonfig::Client.new(Quonfig::Options.new, store: store)
-  end
-
-  # ---- get_string -------------------------------------------------------
-
-  def test_get_string_returns_string
-    assert_equal 'hello', client_with_value(value: 'hello', type: 'string').get_string(KEY)
-  end
-
-  def test_get_string_raises_on_non_string
-    assert_raises(Quonfig::Errors::TypeMismatchError) do
-      client_with_value(value: 42, type: 'int').get_string(KEY)
-    end
-  end
-
-  def test_get_string_default_when_missing
-    client = Quonfig::Client.new(Quonfig::Options.new, store: Quonfig::ConfigStore.new)
-    assert_equal 'fallback', client.get_string('nope', default: 'fallback')
-  end
-
-  # ---- get_int ----------------------------------------------------------
-
-  def test_get_int_returns_integer
-    assert_equal 42, client_with_value(value: 42, type: 'int').get_int(KEY)
-  end
-
-  def test_get_int_raises_on_string
-    assert_raises(Quonfig::Errors::TypeMismatchError) do
-      client_with_value(value: 'oops', type: 'string').get_int(KEY)
-    end
-  end
-
-  # ---- get_float --------------------------------------------------------
-
-  def test_get_float_returns_float
-    assert_in_delta 3.14, client_with_value(value: 3.14, type: 'double').get_float(KEY), 0.0001
-  end
-
-  def test_get_float_raises_on_non_float
-    assert_raises(Quonfig::Errors::TypeMismatchError) do
-      client_with_value(value: 'oops', type: 'string').get_float(KEY)
-    end
-  end
-
-  # ---- get_bool ---------------------------------------------------------
-
-  def test_get_bool_returns_true
-    assert_equal true, client_with_value(value: true, type: 'bool').get_bool(KEY)
-  end
-
-  def test_get_bool_returns_false
-    assert_equal false, client_with_value(value: false, type: 'bool').get_bool(KEY)
-  end
-
-  def test_get_bool_raises_on_string
-    assert_raises(Quonfig::Errors::TypeMismatchError) do
-      client_with_value(value: 'true', type: 'string').get_bool(KEY)
-    end
-  end
-
-  # ---- get_string_list --------------------------------------------------
-
-  def test_get_string_list_returns_array_of_strings
-    assert_equal %w[a b c], client_with_value(value: %w[a b c], type: 'string_list').get_string_list(KEY)
-  end
-
-  def test_get_string_list_raises_on_non_array
-    assert_raises(Quonfig::Errors::TypeMismatchError) do
-      client_with_value(value: 'a,b,c', type: 'string').get_string_list(KEY)
-    end
-  end
-
-  # ---- get_duration -----------------------------------------------------
-
-  def test_get_duration_returns_milliseconds_for_iso_string
-    # ISO-8601 PT1S -> 1 second -> 1000 ms.
-    client = client_with_value(value: 'PT1S', type: 'duration')
-    assert_equal 1000, client.get_duration(KEY)
-  end
-
-  def test_get_duration_passes_through_numeric
-    client = client_with_value(value: 5000, type: 'int')
-    assert_equal 5000, client.get_duration(KEY)
-  end
-
-  # ---- get_json ---------------------------------------------------------
-
-  def test_get_json_returns_hash_unchanged
-    payload = { 'a' => 1, 'b' => [1, 2, 3] }
-    client = client_with_value(value: payload, type: 'json')
-    assert_equal payload, client.get_json(KEY)
-  end
-
-  def test_get_json_returns_array_unchanged
-    payload = [1, 2, 3]
-    client = client_with_value(value: payload, type: 'json')
-    assert_equal payload, client.get_json(KEY)
-  end
-end

data/test/test_types.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-require 'json'
-require 'quonfig/types'
-
-class TestTypes < Minitest::Test
-  def test_value_holds_type_and_value
-    v = Quonfig::Value.new(type: 'double', value: '9.95')
-    assert_equal 'double', v.type
-    assert_equal '9.95', v.value
-    assert_nil v.confidential
-    assert_nil v.decrypt_with
-  end
-
-  def test_criterion_fields_accept_nil
-    c = Quonfig::Criterion.new(operator: 'ALWAYS_TRUE')
-    assert_equal 'ALWAYS_TRUE', c.operator
-    assert_nil c.property_name
-    assert_nil c.value_to_match
-  end
-
-  def test_rule_wires_criteria_and_value
-    value = Quonfig::Value.new(type: 'double', value: '9.95')
-    criterion = Quonfig::Criterion.new(operator: 'ALWAYS_TRUE')
-    rule = Quonfig::Rule.new(criteria: [criterion], value: value)
-    assert_equal [criterion], rule.criteria
-    assert_same value, rule.value
-  end
-
-  def test_rule_set_holds_rules_array
-    rs = Quonfig::RuleSet.new(rules: [])
-    assert_equal [], rs.rules
-  end
-
-  def test_environment_holds_id_and_rules
-    env = Quonfig::Environment.new(id: 'env-1', rules: [])
-    assert_equal 'env-1', env.id
-    assert_equal [], env.rules
-  end
-
-  def test_meta_optional_workspace_id
-    meta = Quonfig::Meta.new(version: '1', environment: 'production')
-    assert_nil meta.workspace_id
-  end
-
-  def test_weighted_value_and_weighted_values_data
-    wv = Quonfig::WeightedValue.new(weight: 100, value: Quonfig::Value.new(type: 'bool', value: true))
-    assert_equal 100, wv.weight
-    wvd = Quonfig::WeightedValuesData.new(weighted_values: [wv])
-    assert_equal [wv], wvd.weighted_values
-    assert_nil wvd.hash_by_property_name
-  end
-
-  def test_schema_data
-    sd = Quonfig::SchemaData.new(schema_type: 'zod', schema: 'z.string()')
-    assert_equal 'zod', sd.schema_type
-    assert_equal 'z.string()', sd.schema
-  end
-
-  def test_provided_data
-    pd = Quonfig::ProvidedData.new(source: 'ENV_VAR', lookup: 'DATABASE_URL')
-    assert_equal 'ENV_VAR', pd.source
-    assert_equal 'DATABASE_URL', pd.lookup
-  end
-
-  def test_config_response_from_integration_fixture
-    path = File.expand_path(
-      '../../integration-test-data/data/integration-tests/configs/my-double-key.json',
-      __dir__
-    )
-    skip "integration-test-data not present at #{path}" unless File.exist?(path)
-
-    raw = JSON.parse(File.read(path))
-    default_rules = raw.fetch('default').fetch('rules').map do |rule|
-      criteria = rule.fetch('criteria').map do |c|
-        Quonfig::Criterion.new(
-          property_name: c['propertyName'],
-          operator: c.fetch('operator'),
-          value_to_match: c['valueToMatch']
-        )
-      end
-      value = rule.fetch('value')
-      Quonfig::Rule.new(
-        criteria: criteria,
-        value: Quonfig::Value.new(type: value['type'], value: value['value'])
-      )
-    end
-
-    response = Quonfig::ConfigResponse.new(
-      id: raw.fetch('id'),
-      key: raw.fetch('key'),
-      type: raw.fetch('type'),
-      value_type: raw.fetch('valueType'),
-      send_to_client_sdk: raw.fetch('sendToClientSdk'),
-      default: Quonfig::RuleSet.new(rules: default_rules)
-    )
-
-    assert_equal 'my-double-key', response.key
-    assert_equal 'config', response.type
-    assert_equal 'double', response.value_type
-    refute response.send_to_client_sdk
-    assert_nil response.environment
-    assert_equal 1, response.default.rules.length
-
-    rule = response.default.rules.first
-    assert_equal 'ALWAYS_TRUE', rule.criteria.first.operator
-    assert_equal 'double', rule.value.type
-    assert_equal '9.95', rule.value.value
-  end
-
-  def test_config_envelope_carries_configs_and_meta
-    meta = Quonfig::Meta.new(version: '1', environment: 'production')
-    envelope = Quonfig::ConfigEnvelope.new(configs: [], meta: meta)
-    assert_equal [], envelope.configs
-    assert_same meta, envelope.meta
-  end
-
-  def test_workspace_config_document_fields
-    doc = Quonfig::WorkspaceConfigDocument.new(
-      id: 'id-1',
-      key: 'feature.x',
-      type: 'feature_flag',
-      value_type: 'bool',
-      send_to_client_sdk: true,
-      default: Quonfig::RuleSet.new(rules: []),
-      environments: []
-    )
-    assert_equal 'feature.x', doc.key
-    assert_equal 'feature_flag', doc.type
-    assert_equal 'bool', doc.value_type
-    assert doc.send_to_client_sdk
-    assert_equal [], doc.environments
-  end
-
-  def test_workspace_environment_fields
-    we = Quonfig::WorkspaceEnvironment.new(id: 'env-1', rules: [])
-    assert_equal 'env-1', we.id
-    assert_equal [], we.rules
-  end
-end

data/test/test_weighted_value_resolver.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestWeightedValueResolver < Minitest::Test
-  KEY = 'config_key'
-
-  def test_resolving_single_value
-    values = weighted_values([['abc', 1]])
-    resolver = Quonfig::WeightedValueResolver.new(values, KEY, nil)
-    assert_equal 'abc', resolver.resolve[0][:value]
-    assert_equal 0, resolver.resolve[1]
-  end
-
-  def test_resolving_multiple_values_evenly_distributed
-    values = weighted_values([['abc', 1], ['def', 1]])
-
-    resolver = Quonfig::WeightedValueResolver.new(values, KEY, 'user:001')
-    assert_equal 'abc', resolver.resolve[0][:value]
-    assert_equal 0, resolver.resolve[1]
-
-    resolver = Quonfig::WeightedValueResolver.new(values, KEY, 'user:456')
-    assert_equal 'def', resolver.resolve[0][:value]
-    assert_equal 1, resolver.resolve[1]
-  end
-
-  def test_resolving_multiple_values_unevenly_distributed
-    values = weighted_values([['abc', 1], ['def', 98], ['ghi', 1]])
-
-    resolver = Quonfig::WeightedValueResolver.new(values, KEY, 'user:456')
-    assert_equal 'def', resolver.resolve[0][:value]
-    assert_equal 1, resolver.resolve[1]
-
-    resolver = Quonfig::WeightedValueResolver.new(values, KEY, 'user:103')
-    assert_equal 'ghi', resolver.resolve[0][:value]
-    assert_equal 2, resolver.resolve[1]
-
-    resolver = Quonfig::WeightedValueResolver.new(values, KEY, 'user:119')
-    assert_equal 'abc', resolver.resolve[0][:value]
-    assert_equal 0, resolver.resolve[1]
-  end
-
-  def test_resolving_multiple_values_with_simulation
-    values = weighted_values([['abc', 1], ['def', 98], ['ghi', 1]])
-    results = {}
-
-    10_000.times do |i|
-      result = Quonfig::WeightedValueResolver.new(values, KEY, "user:#{i}").resolve[0][:value]
-      results[result] ||= 0
-      results[result] += 1
-    end
-
-    assert_in_delta 100, results['abc'], 20
-    assert_in_delta 9800, results['def'], 50
-    assert_in_delta 100, results['ghi'], 20
-  end
-
-  def test_string_keyed_weighted_value_hashes
-    # JSON.parse without symbolize_names yields string keys; the resolver must
-    # accept that shape too.
-    values = [
-      { 'value' => 'abc', 'weight' => 1 },
-      { 'value' => 'def', 'weight' => 1 }
-    ]
-    resolver = Quonfig::WeightedValueResolver.new(values, KEY, 'user:456')
-    assert_equal 'def', resolver.resolve[0]['value']
-    assert_equal 1, resolver.resolve[1]
-  end
-
-  def test_all_zero_weights_returns_last_variant
-    values = weighted_values([['abc', 0], ['def', 0], ['ghi', 0]])
-    resolver = Quonfig::WeightedValueResolver.new(values, KEY, 'user:001')
-    assert_equal 'ghi', resolver.resolve[0][:value]
-    assert_equal 2, resolver.resolve[1]
-  end
-
-  private
-
-  def weighted_values(values_and_weights)
-    values_and_weights.map do |value, weight|
-      { value: value, weight: weight }
-    end
-  end
-end