quonfig 0.0.9 → 0.0.11

data/test/test_semantic_logger_filter.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'semantic_logger'
-
-# Verifies the SemanticLoggerFilter: ONE Quonfig config gates many loggers.
-# The filter injects the native SemanticLogger logger name under the
-# `quonfig-sdk-logging` context (keyed at `.key`) so customer rules can target
-# `PROP_STARTS_WITH_ONE_OF MyApp::` etc.
-#
-# Breaking change in 0.0.5: context key was renamed from `quonfig.logger-name`
-# (dotted snake_case, flat) to `quonfig-sdk-logging.key` (nested, verbatim
-# class name). Normalization was removed — logger names are passed through
-# as-is.
-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.
-  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-sdk-logging' => { 'key' => 'MyApp::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_passed_through_verbatim
-    # Normalization is gone. Native Ruby class names are preserved as-is,
-    # which matches how sdk-node and sdk-go pass the logger path.
-    filter, client = filter_for(:debug)
-
-    [
-      'MyApp::Foo::Bar',
-      'HTMLParser',
-      'foo',
-      'A::B::CDPath',
-      'MyApp::Services::Auth'
-    ].each do |raw|
-      client.calls.clear
-      filter.call(make_log(raw, :info))
-      assert_equal raw, client.calls.first[:context]['quonfig-sdk-logging']['key'],
-                   "logger name should be passed through verbatim: #{raw.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_normalize_method_is_gone
-    # The old normalize() method converted "MyApp::Foo" → "my_app.foo".
-    # It is intentionally removed so callers see native Ruby class names in
-    # context telemetry and rule matching.
-    refute Quonfig::SemanticLoggerFilter.instance_methods.include?(:normalize),
-           'normalize() should be removed — logger names are passed through as-is'
-  end
-
-  def test_context_key_constant_is_new_shape
-    # Sanity check that the context key constant exposes the new shape.
-    assert_equal 'quonfig-sdk-logging', Quonfig::SemanticLoggerFilter::LOGGER_CONTEXT_NAME
-    assert_equal 'key',                 Quonfig::SemanticLoggerFilter::LOGGER_CONTEXT_KEY_PROP
-  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

data/test/test_semver.rb

@@ -1,108 +0,0 @@
-require 'test_helper'
-class TestSemanticVersion < Minitest::Test
-  def test_parse_valid_version
-    version = SemanticVersion.parse('1.2.3')
-    assert_equal 1, version.major
-    assert_equal 2, version.minor
-    assert_equal 3, version.patch
-    assert_nil version.prerelease
-    assert_nil version.build_metadata
-  end
-
-  def test_parse_version_with_prerelease
-    version = SemanticVersion.parse('1.2.3-alpha.1')
-    assert_equal 1, version.major
-    assert_equal 2, version.minor
-    assert_equal 3, version.patch
-    assert_equal 'alpha.1', version.prerelease
-    assert_nil version.build_metadata
-  end
-
-  def test_parse_version_with_build_metadata
-    version = SemanticVersion.parse('1.2.3+build.123')
-    assert_equal 1, version.major
-    assert_equal 2, version.minor
-    assert_equal 3, version.patch
-    assert_nil version.prerelease
-    assert_equal 'build.123', version.build_metadata
-  end
-
-  def test_parse_full_version
-    version = SemanticVersion.parse('1.2.3-alpha.1+build.123')
-    assert_equal 1, version.major
-    assert_equal 2, version.minor
-    assert_equal 3, version.patch
-    assert_equal 'alpha.1', version.prerelease
-    assert_equal 'build.123', version.build_metadata
-  end
-
-  def test_parse_invalid_version
-    assert_raises(ArgumentError) { SemanticVersion.parse('invalid') }
-    assert_raises(ArgumentError) { SemanticVersion.parse('1.2') }
-    assert_raises(ArgumentError) { SemanticVersion.parse('1.2.3.4') }
-    assert_raises(ArgumentError) { SemanticVersion.parse('') }
-  end
-
-  def test_parse_quietly
-    assert_nil SemanticVersion.parse_quietly('invalid')
-    refute_nil SemanticVersion.parse_quietly('1.2.3')
-  end
-
-  def test_to_string
-    assert_equal '1.2.3', SemanticVersion.parse('1.2.3').to_s
-    assert_equal '1.2.3-alpha.1', SemanticVersion.parse('1.2.3-alpha.1').to_s
-    assert_equal '1.2.3+build.123', SemanticVersion.parse('1.2.3+build.123').to_s
-    assert_equal '1.2.3-alpha.1+build.123', SemanticVersion.parse('1.2.3-alpha.1+build.123').to_s
-  end
-
-  def test_equality
-    v1 = SemanticVersion.parse('1.2.3')
-    v2 = SemanticVersion.parse('1.2.3')
-    v3 = SemanticVersion.parse('1.2.4')
-    v4 = SemanticVersion.parse('1.2.3-alpha')
-    v5 = SemanticVersion.parse('1.2.3+build.123')
-
-    assert_equal v1, v2
-    refute_equal v1, v3
-    refute_equal v1, v4
-    assert_equal v1, v5  # build metadata is ignored in equality
-  end
-
-  def test_comparison
-    versions = [
-      '1.0.0-alpha',
-      '1.0.0-alpha.1',
-      '1.0.0-beta.2',
-      '1.0.0-beta.11',
-      '1.0.0-rc.1',
-      '1.0.0',
-      '2.0.0',
-      '2.1.0',
-      '2.1.1'
-    ].map { |v| SemanticVersion.parse(v) }
-
-    # Test that each version is less than the next version
-    (versions.length - 1).times do |i|
-      assert versions[i] < versions[i + 1], "Expected #{versions[i]} < #{versions[i + 1]}"
-    end
-  end
-
-  def test_prerelease_comparison
-    # Test specific prerelease comparison cases
-    cases = [
-      ['1.0.0-alpha', '1.0.0-alpha.1', -1],
-      ['1.0.0-alpha.1', '1.0.0-alpha.beta', -1],
-      ['1.0.0-alpha.beta', '1.0.0-beta', -1],
-      ['1.0.0-beta', '1.0.0-beta.2', -1],
-      ['1.0.0-beta.2', '1.0.0-beta.11', -1],
-      ['1.0.0-beta.11', '1.0.0-rc.1', -1],
-      ['1.0.0-rc.1', '1.0.0', -1]
-    ]
-
-    cases.each do |v1_str, v2_str, expected|
-      v1 = SemanticVersion.parse(v1_str)
-      v2 = SemanticVersion.parse(v2_str)
-      assert_equal expected, (v1 <=> v2), "Expected #{v1} <=> #{v2} to be #{expected}"
-    end
-  end
-end

data/test/test_should_log.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# Verifies the client-level should_log?(logger_path:, desired_level:, contexts:)
-# API — a Reforge-style convenience built on top of the primitive get() that
-# uses the client's `logger_key` option as the config key and injects the
-# logger path under `quonfig-sdk-logging.key`. Parallels sdk-node's
-# shouldLog({loggerPath}) and sdk-go's ShouldLogPath.
-class TestShouldLog < Minitest::Test
-  LOG_LEVEL_KEY = 'log-level.my-app'
-
-  # Minimal config fixture mirroring what ConfigStore expects: a string
-  # config whose rule returns the configured log level.
-  def make_log_level_config(key:, level:)
-    {
-      'id' => '1',
-      'key' => key,
-      'type' => 'config',
-      'valueType' => 'string',
-      'sendToClientSdk' => false,
-      'default' => {
-        'rules' => [
-          { 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
-            'value' => { 'type' => 'string', 'value' => level } }
-        ]
-      },
-      'environment' => nil
-    }
-  end
-
-  def store_with(*configs)
-    store = Quonfig::ConfigStore.new
-    configs.each { |c| store.set(c['key'], c) }
-    store
-  end
-
-  def client_with(store, **options)
-    Quonfig::Client.new(Quonfig::Options.new(**options), store: store)
-  end
-
-  # ---- logger_key option surface ---------------------------------------
-
-  def test_logger_key_option_defaults_to_nil
-    assert_nil Quonfig::Options.new.logger_key
-  end
-
-  def test_logger_key_option_accepts_value
-    opts = Quonfig::Options.new(logger_key: LOG_LEVEL_KEY)
-    assert_equal LOG_LEVEL_KEY, opts.logger_key
-  end
-
-  def test_client_exposes_logger_key_from_options
-    client = client_with(Quonfig::ConfigStore.new, logger_key: LOG_LEVEL_KEY)
-    assert_equal LOG_LEVEL_KEY, client.logger_key
-  end
-
-  # ---- should_log? requires logger_key ---------------------------------
-
-  def test_should_log_raises_without_logger_key
-    client = client_with(Quonfig::ConfigStore.new)
-    err = assert_raises(Quonfig::Error) do
-      client.should_log?(logger_path: 'MyApp::Foo', desired_level: :info)
-    end
-    assert_match(/logger_key/, err.message)
-  end
-
-  # ---- should_log? gating ----------------------------------------------
-
-  def test_should_log_true_when_desired_at_or_above_configured
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'info'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :info)
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :warn)
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :error)
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :fatal)
-  end
-
-  def test_should_log_false_when_desired_below_configured
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'warn'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    assert_equal false, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :trace)
-    assert_equal false, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :debug)
-    assert_equal false, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :info)
-    assert_equal true,  client.should_log?(logger_path: 'MyApp::Foo', desired_level: :warn)
-  end
-
-  def test_should_log_accepts_string_desired_level
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'warn'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    assert_equal true,  client.should_log?(logger_path: 'MyApp::Foo', desired_level: 'warn')
-    assert_equal false, client.should_log?(logger_path: 'MyApp::Foo', desired_level: 'info')
-  end
-
-  def test_should_log_returns_true_when_no_config_found
-    # Missing config key → log everything (match go/node).
-    client = client_with(Quonfig::ConfigStore.new, logger_key: LOG_LEVEL_KEY)
-    assert_equal true, client.should_log?(logger_path: 'MyApp::Foo', desired_level: :trace)
-  end
-
-  # ---- context injection -----------------------------------------------
-
-  # Capture what context reaches get() by injecting a spy client that wraps
-  # a real store-backed client.
-  class ContextCapturingClient
-    attr_reader :captured_contexts
-
-    def initialize(delegate)
-      @delegate = delegate
-      @captured_contexts = []
-    end
-
-    def logger_key
-      @delegate.logger_key
-    end
-
-    def get(key, default = Quonfig::NO_DEFAULT_PROVIDED, jit_context = Quonfig::NO_DEFAULT_PROVIDED)
-      @captured_contexts << jit_context
-      @delegate.get(key, default, jit_context)
-    end
-  end
-
-  def test_should_log_injects_logger_path_under_quonfig_sdk_logging_key
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    # Reach into the context that get() sees. We do this by asserting on the
-    # resolver via a fake — simplest path: call should_log? with a sentinel
-    # path and verify the evaluator would see it. We assert via the public
-    # contract: context reaches get(), so we patch get() temporarily.
-    captured = []
-    client.define_singleton_method(:get) do |key, default = nil, jit_context = nil|
-      captured << { key: key, jit_context: jit_context }
-      'trace'
-    end
-
-    client.should_log?(logger_path: 'MyApp::Services::Auth', desired_level: :info)
-
-    assert_equal 1, captured.size
-    assert_equal LOG_LEVEL_KEY, captured.first[:key]
-    ctx = captured.first[:jit_context]
-    assert_equal({ 'quonfig-sdk-logging' => { 'key' => 'MyApp::Services::Auth' } }, ctx)
-  end
-
-  def test_should_log_merges_caller_contexts_with_logger_context
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    captured = []
-    client.define_singleton_method(:get) do |key, default = nil, jit_context = nil|
-      captured << jit_context
-      'trace'
-    end
-
-    client.should_log?(
-      logger_path: 'MyApp::Foo',
-      desired_level: :info,
-      contexts: { 'user' => { 'id' => 'u1' } }
-    )
-
-    assert_equal(
-      {
-        'user' => { 'id' => 'u1' },
-        'quonfig-sdk-logging' => { 'key' => 'MyApp::Foo' }
-      },
-      captured.first
-    )
-  end
-
-  def test_should_log_logger_path_verbatim_no_normalization
-    store = store_with(make_log_level_config(key: LOG_LEVEL_KEY, level: 'trace'))
-    client = client_with(store, logger_key: LOG_LEVEL_KEY)
-
-    captured = []
-    client.define_singleton_method(:get) do |key, default = nil, jit_context = nil|
-      captured << jit_context
-      'trace'
-    end
-
-    client.should_log?(logger_path: 'HTMLParser', desired_level: :info)
-    assert_equal 'HTMLParser', captured.first['quonfig-sdk-logging']['key']
-  end
-end