quonfig 0.0.2

data/test/test_options.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestOptions < Minitest::Test
+  API_KEY = 'abcdefg'
+
+  def test_api_urls_override_env_var
+    assert_equal Quonfig::Options::DEFAULT_API_URLS, Quonfig::Options.new.api_urls
+
+    # blank doesn't take effect
+    with_env('QUONFIG_API_URLS', '') do
+      assert_equal Quonfig::Options::DEFAULT_API_URLS, Quonfig::Options.new.api_urls
+    end
+
+    # non-blank does take effect
+    with_env('QUONFIG_API_URLS', 'https://override.example.com') do
+      assert_equal ["https://override.example.com"], Quonfig::Options.new.api_urls
+    end
+  end
+
+  def test_default_api_urls_point_to_quonfig
+    assert_equal [
+      'https://primary.quonfig.com',
+    ], Quonfig::Options::DEFAULT_API_URLS
+  end
+
+  def test_overriding_api_urls
+    assert_equal Quonfig::Options::DEFAULT_API_URLS, Quonfig::Options.new.api_urls
+
+    # a plain string ends up wrapped in an array
+    api_url = 'https://example.com'
+    assert_equal [api_url], Quonfig::Options.new(api_urls: api_url).api_urls
+
+    api_urls = ['https://example.com', 'https://example2.com']
+    assert_equal api_urls, Quonfig::Options.new(api_urls: api_urls).api_urls
+  end
+
+  def test_derive_stream_url_prepends_stream_to_hostname
+    assert_equal 'https://stream.primary.quonfig.com',
+                 Quonfig::Options.derive_stream_url('https://primary.quonfig.com')
+  end
+
+  def test_derive_stream_url_preserves_port
+    assert_equal 'http://stream.localhost:6550',
+                 Quonfig::Options.derive_stream_url('http://localhost:6550')
+  end
+
+  def test_derive_stream_url_preserves_scheme_and_path
+    assert_equal 'http://stream.api.example.com/base',
+                 Quonfig::Options.derive_stream_url('http://api.example.com/base')
+  end
+
+  def test_derive_stream_url_with_eu_subdomain
+    assert_equal 'https://stream.primary.eu.quonfig.com',
+                 Quonfig::Options.derive_stream_url('https://primary.eu.quonfig.com')
+  end
+
+  def test_works_with_named_arguments
+    assert_equal API_KEY, Quonfig::Options.new(sdk_key: API_KEY).sdk_key
+  end
+
+  def test_works_with_hash
+    assert_equal API_KEY, Quonfig::Options.new({ sdk_key: API_KEY }).sdk_key
+  end
+
+  def test_sdk_key_reads_from_quonfig_backend_sdk_key
+    with_env('QUONFIG_BACKEND_SDK_KEY', 'env-key') do
+      assert_equal 'env-key', Quonfig::Options.new.sdk_key
+    end
+  end
+
+  def test_environment_reads_from_quonfig_environment
+    with_env('QUONFIG_ENVIRONMENT', 'staging') do
+      assert_equal 'staging', Quonfig::Options.new.environment
+    end
+  end
+
+  def test_environment_explicit_overrides_env_var
+    with_env('QUONFIG_ENVIRONMENT', 'staging') do
+      assert_equal 'production', Quonfig::Options.new(environment: 'production').environment
+    end
+  end
+
+  def test_enable_sse_defaults_true
+    assert_equal true, Quonfig::Options.new.enable_sse
+    assert_equal false, Quonfig::Options.new(enable_sse: false).enable_sse
+  end
+
+  def test_enable_polling_defaults_true
+    assert_equal true, Quonfig::Options.new.enable_polling
+    assert_equal false, Quonfig::Options.new(enable_polling: false).enable_polling
+  end
+
+  def test_datadir_reads_from_quonfig_dir_env
+    with_env('QUONFIG_DIR', '/tmp/some/workspace') do
+      assert_equal '/tmp/some/workspace', Quonfig::Options.new.datadir
+    end
+  end
+
+  def test_datadir_explicit_overrides_env_var
+    with_env('QUONFIG_DIR', '/tmp/env/workspace') do
+      assert_equal '/tmp/explicit', Quonfig::Options.new(datadir: '/tmp/explicit').datadir
+    end
+  end
+
+  def test_datadir_predicate
+    assert_equal false, Quonfig::Options.new.datadir?
+    assert_equal true, Quonfig::Options.new(datadir: '/tmp/ws').datadir?
+  end
+
+  def test_local_only_uses_datadir_presence
+    refute Quonfig::Options.new.local_only?
+    assert Quonfig::Options.new(datadir: '/tmp/ws').local_only?
+  end
+
+  def test_collect_max_paths
+    assert_equal 1000, Quonfig::Options.new.collect_max_paths
+    assert_equal 100, Quonfig::Options.new(collect_max_paths: 100).collect_max_paths
+  end
+
+  def test_collect_max_evaluation_summaries
+    assert_equal 100_000, Quonfig::Options.new.collect_max_evaluation_summaries
+    assert_equal 0, Quonfig::Options.new(collect_evaluation_summaries: false).collect_max_evaluation_summaries
+    assert_equal 3,
+                 Quonfig::Options.new(collect_max_evaluation_summaries: 3).collect_max_evaluation_summaries
+  end
+
+  def test_context_upload_mode_periodic
+    options = Quonfig::Options.new(context_upload_mode: :periodic_example, context_max_size: 100)
+    assert_equal 100, options.collect_max_example_contexts
+
+    options = Quonfig::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_example_contexts
+  end
+
+  def test_context_upload_mode_shapes_only
+    options = Quonfig::Options.new(context_upload_mode: :shapes_only, context_max_size: 100)
+    assert_equal 100, options.collect_max_shapes
+
+    options = Quonfig::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_shapes
+  end
+
+  def test_context_upload_mode_none
+    options = Quonfig::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_example_contexts
+
+    options = Quonfig::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_shapes
+  end
+
+  def test_telemetry_destination_reads_env_first
+    with_env('QUONFIG_TELEMETRY_URL', 'https://custom-telemetry.example.com') do
+      assert_equal 'https://custom-telemetry.example.com', Quonfig::Options.new.telemetry_destination
+    end
+  end
+
+  def test_telemetry_destination_derives_from_default_sources
+    assert_equal 'https://telemetry.quonfig.com', Quonfig::Options.new.telemetry_destination
+  end
+
+  def test_telemetry_destination_derives_from_custom_quonfig_api_urls
+    options = Quonfig::Options.new(api_urls: ['https://primary.eu.quonfig.com'])
+    assert_equal 'https://telemetry.eu.quonfig.com', options.telemetry_destination
+  end
+end

data/test/test_rate_limit_cache.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class RateLimitCacheTest < Minitest::Test
+  def test_set_and_fresh
+    cache = Quonfig::RateLimitCache.new(5)
+    cache.set('key')
+    assert cache.fresh?('key')
+  end
+
+  def test_fresh_with_no_set
+    cache = Quonfig::RateLimitCache.new(5)
+    refute cache.fresh?('key')
+  end
+
+  def test_get_after_expiration
+    cache = Quonfig::RateLimitCache.new(5)
+
+    Timecop.freeze(Time.now - 6) do
+      cache.set('key')
+      assert cache.fresh?('key')
+    end
+
+    refute cache.fresh?('key')
+
+    # but the data is still there
+    assert cache.data.get('key')
+  end
+
+  def test_prune
+    cache = Quonfig::RateLimitCache.new(5)
+
+    Timecop.freeze(Time.now - 6) do
+      cache.set('key')
+      assert cache.fresh?('key')
+    end
+
+    cache.prune
+
+    refute cache.fresh?('key')
+  end
+end

data/test/test_reason.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'quonfig/reason'
+
+# Tests Quonfig::Reason in isolation — uses plain Structs so the test does not
+# depend on PrefabProto (which is not loaded by the current bootstrap).
+class TestReason < Minitest::Test
+  FakeCriterion = Struct.new(:operator)
+  FakeConditionalValue = Struct.new(:criteria)
+  FakeRow = Struct.new(:values, :project_env_id)
+  FakeConfig = Struct.new(:rows)
+
+  ALWAYS_TRUE = FakeCriterion.new(:ALWAYS_TRUE)
+  PROP_MATCH = FakeCriterion.new(:PROP_IS_ONE_OF)
+
+  DEFAULT_CV = FakeConditionalValue.new([])
+  ALWAYS_TRUE_CV = FakeConditionalValue.new([ALWAYS_TRUE])
+  RULE_CV = FakeConditionalValue.new([PROP_MATCH])
+
+  def default_only_config
+    FakeConfig.new([FakeRow.new([DEFAULT_CV], 0)])
+  end
+
+  def targeted_config
+    FakeConfig.new([
+      FakeRow.new([DEFAULT_CV], 0),
+      FakeRow.new([RULE_CV, ALWAYS_TRUE_CV], 1)
+    ])
+  end
+
+  def test_default_for_default_only_config
+    reason = Quonfig::Reason.compute(
+      config: default_only_config,
+      conditional_value: DEFAULT_CV
+    )
+    assert_equal :DEFAULT, reason
+  end
+
+  def test_rule_match_when_targeting_rule_matched
+    reason = Quonfig::Reason.compute(
+      config: targeted_config,
+      conditional_value: RULE_CV
+    )
+    assert_equal :RULE_MATCH, reason
+  end
+
+  def test_rule_match_when_falling_back_to_always_true_in_targeted_config
+    reason = Quonfig::Reason.compute(
+      config: targeted_config,
+      conditional_value: ALWAYS_TRUE_CV
+    )
+    assert_equal :RULE_MATCH, reason
+  end
+
+  def test_split_when_weighted_value_index_positive
+    reason = Quonfig::Reason.compute(
+      config: default_only_config,
+      conditional_value: DEFAULT_CV,
+      weighted_value_index: 2
+    )
+    assert_equal :SPLIT, reason
+  end
+
+  def test_weighted_value_index_zero_is_not_split
+    reason = Quonfig::Reason.compute(
+      config: default_only_config,
+      conditional_value: DEFAULT_CV,
+      weighted_value_index: 0
+    )
+    assert_equal :DEFAULT, reason
+  end
+
+  def test_default_when_only_always_true_criteria_and_no_targeting_rules
+    config = FakeConfig.new([FakeRow.new([ALWAYS_TRUE_CV], 0)])
+    reason = Quonfig::Reason.compute(config: config, conditional_value: ALWAYS_TRUE_CV)
+    assert_equal :DEFAULT, reason
+  end
+end

data/test/test_rename.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestRename < Minitest::Test
+  def test_quonfig_module_is_defined
+    assert defined?(Quonfig), 'Quonfig module must be defined after rename'
+  end
+
+  def test_reforge_module_is_gone
+    # NOTE: 'Reforge' intentionally not renamed — this test guards against the old constant leaking back in.
+    refute Object.const_defined?(:Reforge), 'Reforge constant must be removed after rename'
+  end
+
+  def test_quonfig_options_exists
+    assert defined?(Quonfig::Options), 'Quonfig::Options must be defined'
+  end
+
+  def test_quonfig_client_exists
+    assert defined?(Quonfig::Client), 'Quonfig::Client must be defined'
+  end
+
+  def test_quonfig_sdk_key_env_var
+    # NOTE: the REFORGE_/PREFAB_ keys below are intentionally spelled out in string literals
+    # so the bulk rename tool does not touch them — we are asserting that the NEW env var name
+    # is the one the SDK reads.
+    old_key_a = 'REFORGE_' + 'BACKEND_SDK_KEY'
+    old_key_b = 'PREFAB_' + 'API_KEY'
+    original = ENV.to_h.slice('QUONFIG_BACKEND_SDK_KEY', old_key_a, old_key_b)
+    ENV.delete(old_key_a)
+    ENV.delete(old_key_b)
+    ENV['QUONFIG_BACKEND_SDK_KEY'] = 'quonfig-test-key-123'
+    options = Quonfig::Options.new
+    assert_equal 'quonfig-test-key-123', options.sdk_key
+  ensure
+    ENV.delete('QUONFIG_BACKEND_SDK_KEY')
+    original&.each { |k, v| ENV[k] = v }
+  end
+
+  def test_gemspec_file_is_quonfig
+    root = File.expand_path('..', __dir__)
+    assert File.exist?(File.join(root, 'quonfig.gemspec')),
+           'quonfig.gemspec must exist at repo root'
+    refute File.exist?(File.join(root, 'sdk-reforge.gemspec')),
+           'sdk-reforge.gemspec must be removed'
+  end
+
+  def test_gemspec_name_is_quonfig
+    root = File.expand_path('..', __dir__)
+    spec = Gem::Specification.load(File.join(root, 'quonfig.gemspec'))
+    assert_equal 'quonfig', spec.name
+  end
+
+  def test_lib_entrypoint_renamed
+    root = File.expand_path('..', __dir__)
+    assert File.exist?(File.join(root, 'lib', 'quonfig.rb')),
+           'lib/quonfig.rb must exist'
+    assert Dir.exist?(File.join(root, 'lib', 'quonfig')),
+           'lib/quonfig/ directory must exist'
+    refute File.exist?(File.join(root, 'lib', 'sdk-reforge.rb')),
+           'lib/sdk-reforge.rb must be removed'
+    refute Dir.exist?(File.join(root, 'lib', 'reforge')),
+           'lib/reforge/ directory must be removed'
+  end
+end

data/test/test_resolver.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# Tests for the new public API trio introduced by qfg-dk6.9:
+#   store     = Quonfig::ConfigStore.new(configs_hash)
+#   evaluator = Quonfig::Evaluator.new(store)
+#   resolver  = Quonfig::Resolver.new(store, evaluator)
+#   result    = resolver.get('my.flag', context)
+#
+# Mirrors the sdk-node pattern so the integration test suite (qfg-dk6.22-24)
+# can construct these directly without a full Client.
+#
+# We deliberately do NOT use PrefabProto — the protobuf gem was dropped in
+# qfg-dk6.4 and JSON Criterion types land in qfg-dk6.5 / operators port in
+# qfg-dk6.10. These tests use minimal Struct doubles that satisfy the
+# duck-typed shape the current CriteriaEvaluator reads.
+class TestResolverTrio < Minitest::Test
+  CONFIG_KEY = 'my.flag'
+  DEFAULT_VALUE = 'default_value'
+
+  # qfg-dk6.10 — configs are now plain ConfigResponse-shaped hashes (symbol
+  # top-level keys + string keys inside rules/criteria). Matches what
+  # Quonfig::Datadir.to_config_response and
+  # IntegrationTestHelpers.to_config_response emit.
+  def make_default_config(key: CONFIG_KEY, value: DEFAULT_VALUE)
+    {
+      id: '1',
+      key: key,
+      type: 'config',
+      value_type: 'string',
+      send_to_client_sdk: false,
+      default: {
+        'rules' => [
+          {
+            'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
+            'value' => { 'type' => 'string', 'value' => value }
+          }
+        ]
+      },
+      environment: nil
+    }
+  end
+
+  def base_client
+    MockBaseClient.new(Quonfig::Options.new)
+  end
+
+  # ---- ConfigStore ------------------------------------------------------
+
+  def test_config_store_constructs_with_hash
+    cfg = make_default_config
+    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
+
+    assert_equal cfg, store.get(CONFIG_KEY)
+    assert_equal [CONFIG_KEY], store.keys
+  end
+
+  def test_config_store_constructs_empty
+    store = Quonfig::ConfigStore.new
+    assert_nil store.get('missing')
+    assert_empty store.keys
+  end
+
+  def test_config_store_set_and_get
+    store = Quonfig::ConfigStore.new
+    cfg = make_default_config
+    store.set(CONFIG_KEY, cfg)
+    assert_equal cfg, store.get(CONFIG_KEY)
+  end
+
+  def test_config_store_all_configs_returns_hash
+    cfg = make_default_config
+    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
+
+    all = store.all_configs
+    assert_kind_of Hash, all
+    assert_equal cfg, all[CONFIG_KEY]
+  end
+
+  def test_config_store_all_configs_is_a_copy
+    cfg = make_default_config
+    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
+    store.all_configs['mutated'] = :nope
+    assert_nil store.get('mutated')
+  end
+
+  def test_config_store_clear_empties_the_store
+    store = Quonfig::ConfigStore.new({ CONFIG_KEY => make_default_config })
+    store.clear
+    assert_nil store.get(CONFIG_KEY)
+    assert_empty store.keys
+  end
+
+  # ---- Evaluator --------------------------------------------------------
+
+  def test_evaluator_accepts_store
+    store = Quonfig::ConfigStore.new
+    Quonfig::Evaluator.new(store, base_client: base_client)
+  end
+
+  # ---- Resolver ---------------------------------------------------------
+
+  def test_resolver_raw_returns_config_from_store
+    cfg = make_default_config
+    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
+    evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
+    resolver = Quonfig::Resolver.new(store, evaluator)
+
+    assert_equal cfg, resolver.raw(CONFIG_KEY)
+  end
+
+  def test_resolver_raw_returns_nil_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.raw('nope')
+  end
+
+  def test_resolver_get_returns_evaluation_for_default_row_with_empty_criteria
+    cfg = make_default_config
+    store = Quonfig::ConfigStore.new({ CONFIG_KEY => cfg })
+    evaluator = Quonfig::Evaluator.new(store, base_client: base_client)
+    resolver = Quonfig::Resolver.new(store, evaluator)
+
+    result = resolver.get(CONFIG_KEY, Quonfig::Context.new({}))
+
+    refute_nil result
+    assert_kind_of Quonfig::EvalResult, result
+    # The EvalResult exposes both the raw JSON value hash (#value) and the
+    # coerced Ruby value (#unwrapped_value). Prefer unwrapped_value for
+    # assertions — it mirrors what the real Client returns.
+    assert_equal DEFAULT_VALUE, result.unwrapped_value
+  end
+
+  def test_resolver_get_returns_nil_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({}))
+  end
+end

data/test/test_semantic_logger_filter.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'semantic_logger'
+
+# Verifies the corrected design: ONE Quonfig config gates many loggers.
+# The filter passes `quonfig.logger-name` as a context property so customer
+# rules can target `PROP_STARTS_WITH_ONE_OF my_app.db` etc.
+class TestSemanticLoggerFilter < Minitest::Test
+  CONFIG_KEY = 'log-levels.my-app'
+
+  # FakeClient lets us assert the exact key + context the filter passes to
+  # the SDK without standing up a full datadir. The single-key contract is
+  # the *specific mechanism* this bead is verifying — if the filter ever
+  # regresses to a per-logger key, this captured request goes wrong.
+  class FakeClient
+    attr_reader :calls
+
+    def initialize(level)
+      @level = level
+      @calls = []
+    end
+
+    def get(key, default = nil, context = nil)
+      @calls << { key: key, default: default, context: context }
+      @level.nil? ? default : @level
+    end
+  end
+
+  def make_log(name, level)
+    SemanticLogger::Log.new(name, level).tap { |log| log.level = level }
+  end
+
+  def filter_for(level)
+    client = FakeClient.new(level)
+    [Quonfig::SemanticLoggerFilter.new(client, config_key: CONFIG_KEY), client]
+  end
+
+  def test_calls_single_config_key_with_logger_name_in_context
+    filter, client = filter_for(:info)
+    filter.call(make_log('MyApp::Foo::Bar', :warn))
+
+    assert_equal 1, client.calls.size
+    assert_equal CONFIG_KEY, client.calls.first[:key]
+    ctx = client.calls.first[:context]
+    assert_equal({ 'quonfig' => { 'logger-name' => 'my_app.foo.bar' } }, ctx)
+  end
+
+  def test_passes_through_when_level_meets_configured_minimum
+    filter, _ = filter_for(:info)
+
+    assert_equal true, filter.call(make_log('Anything', :info))
+    assert_equal true, filter.call(make_log('Anything', :warn))
+    assert_equal true, filter.call(make_log('Anything', :error))
+    assert_equal true, filter.call(make_log('Anything', :fatal))
+  end
+
+  def test_suppresses_below_configured_minimum
+    filter, _ = filter_for(:warn)
+
+    assert_equal false, filter.call(make_log('Anything', :trace))
+    assert_equal false, filter.call(make_log('Anything', :debug))
+    assert_equal false, filter.call(make_log('Anything', :info))
+    assert_equal true,  filter.call(make_log('Anything', :warn))
+  end
+
+  def test_missing_key_falls_through_to_semantic_logger_default
+    filter, _ = filter_for(nil) # FakeClient returns the default (nil) when configured level is nil
+
+    assert_equal true, filter.call(make_log('Anything', :trace))
+    assert_equal true, filter.call(make_log('Anything', :debug))
+  end
+
+  def test_logger_name_normalization
+    filter, client = filter_for(:debug)
+
+    {
+      'MyApp::Foo::Bar' => 'my_app.foo.bar',
+      'HTMLParser'      => 'html_parser',
+      'foo'             => 'foo',
+      'A::B::CDPath'    => 'a.b.cd_path'
+    }.each do |raw, expected|
+      client.calls.clear
+      filter.call(make_log(raw, :info))
+      assert_equal expected, client.calls.first[:context]['quonfig']['logger-name'],
+                   "normalize(#{raw.inspect}) should be #{expected.inspect}"
+    end
+  end
+
+  def test_no_dotted_path_traversal_or_get_log_level
+    # Verifies the legacy hierarchical walk is gone — the filter must NOT
+    # synthesize keys like "log-levels.my_app" or call any `get_log_level`.
+    refute Quonfig::SemanticLoggerFilter.instance_methods.include?(:get_log_level)
+
+    filter, client = filter_for(:info)
+    filter.call(make_log('MyApp::Foo::Bar', :info))
+
+    keys = client.calls.map { |c| c[:key] }
+    assert_equal [CONFIG_KEY], keys.uniq,
+                 'Filter should call exactly the configured key, never derived per-logger keys'
+  end
+
+  def test_all_six_levels_mapped_correctly
+    expected = { trace: 0, debug: 1, info: 2, warn: 3, error: 4, fatal: 5 }
+    assert_equal expected, Quonfig::SemanticLoggerFilter::LEVELS
+  end
+
+  def test_string_level_from_config
+    filter, _ = filter_for('warn')
+
+    assert_equal false, filter.call(make_log('Anything', :info))
+    assert_equal true,  filter.call(make_log('Anything', :warn))
+  end
+
+  def test_raises_loaderror_when_semantic_logger_missing
+    Quonfig::SemanticLoggerFilter.stub(:semantic_logger_loaded?, false) do
+      err = assert_raises(LoadError) do
+        Quonfig::SemanticLoggerFilter.new(FakeClient.new(:info), config_key: CONFIG_KEY)
+      end
+      assert_match(/semantic_logger/i, err.message)
+    end
+  end
+end