quonfig 0.0.10 → 0.0.12

data/test/test_fixed_size_hash.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'test_helper'
-
-module Quonfig
-  class FixedSizeHashTest < Minitest::Test
-    def setup
-      @max_size = 3
-      @hash = FixedSizeHash.new(@max_size)
-    end
-
-    def test_acts_like_a_regular_hash_when_under_max_size
-      @hash[:a] = 1
-      @hash[:b] = 2
-
-      assert_equal 1, @hash[:a]
-      assert_equal 2, @hash[:b]
-      assert_equal 2, @hash.size
-    end
-
-    def test_enforces_max_size_by_evicting_first_added_item
-      @hash[:a] = 1
-      @hash[:b] = 2
-      @hash[:c] = 3
-      assert_equal @max_size, @hash.size
-
-      @hash[:d] = 4
-      assert_equal @max_size, @hash.size
-      assert_nil @hash[:a]  # First item should be evicted
-      assert_equal 4, @hash[:d]
-    end
-
-    def test_updating_existing_key_does_not_trigger_eviction
-      @hash[:a] = 1
-      @hash[:b] = 2
-      @hash[:c] = 3
-
-      @hash[:b] = 'new value'  # Update existing key
-
-      assert_equal @max_size, @hash.size
-      assert_equal 1, @hash[:a]  # First item should still be present
-      assert_equal 'new value', @hash[:b]
-      assert_equal 3, @hash[:c]
-    end
-
-    def test_handles_nil_values
-      @hash[:a] = nil
-      @hash[:b] = 2
-      @hash[:c] = 3
-      @hash[:d] = 4
-
-      assert_nil @hash[:a]  # First item should be evicted
-      assert_equal 4, @hash[:d]
-    end
-
-    def test_preserves_hash_methods
-      @hash[:a] = 1
-      @hash[:b] = 2
-
-      assert_equal [:a, :b], @hash.keys
-      assert_equal [1, 2], @hash.values
-      assert @hash.key?(:a)
-      refute @hash.key?(:z)
-    end
-
-    def test_handles_string_keys
-      @hash['a'] = 1
-      @hash['b'] = 2
-      @hash['c'] = 3
-      @hash['d'] = 4
-
-      assert_nil @hash['a']  # First item should be evicted
-      assert_equal 4, @hash['d']
-    end
-
-    def test_handles_object_keys
-      key1 = Object.new
-      key2 = Object.new
-      key3 = Object.new
-      key4 = Object.new
-
-      @hash[key1] = 1
-      @hash[key2] = 2
-      @hash[key3] = 3
-      @hash[key4] = 4
-
-      assert_nil @hash[key1]  # First item should be evicted
-      assert_equal 4, @hash[key4]
-    end
-
-    def test_can_be_initialized_empty
-      assert_equal 0, @hash.size
-    end
-
-    def test_enumerable_methods
-      @hash[:a] = 1
-      @hash[:b] = 2
-
-      mapped = @hash.map { |k, v| [k, v * 2] }.to_h
-      assert_equal({ a: 2, b: 4 }, mapped)
-
-      filtered = @hash.select { |_, v| v > 1 }
-      assert_equal({ b: 2 }, filtered.to_h)
-    end
-
-    def test_clear_maintains_max_size_constraint
-      @hash[:a] = 1
-      @hash[:b] = 2
-      @hash.clear
-
-      assert_equal 0, @hash.size
-
-      # Should still enforce max size after clear
-      (@max_size + 1).times { |i| @hash[i] = i }
-      assert_equal @max_size, @hash.size
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'minitest/focus'
-require 'minitest/reporters'
-Minitest::Reporters.use! unless ENV['RM_INFO']
-
-require 'quonfig'
-
-Dir.glob(File.join(File.dirname(__FILE__), 'support', '**', '*.rb')).each do |file|
-  require file
-end
-
-Minitest::Test.class_eval do
-  include CommonHelpers
-  extend CommonHelpers
-end

data/test/test_http_connection.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'base64'
-require 'json'
-
-module Quonfig
-  class HttpConnectionTest < Minitest::Test
-    URI = 'https://primary.quonfig.com'
-    SDK_KEY = 'abc.def.123'
-
-    def test_uses_basic_auth_with_username_1
-      conn = HttpConnection.new(URI, SDK_KEY).connection
-      expected = 'Basic ' + Base64.strict_encode64("1:#{SDK_KEY}")
-      assert_equal expected, conn.headers['Authorization']
-    end
-
-    def test_json_content_type_and_accept_headers
-      conn = HttpConnection.new(URI, SDK_KEY).connection
-      assert_equal 'application/json', conn.headers['Content-Type']
-      assert_equal 'application/json', conn.headers['Accept']
-    end
-
-    def test_x_quonfig_sdk_version_header
-      conn = HttpConnection.new(URI, SDK_KEY).connection
-      assert_equal "ruby-#{Quonfig::VERSION}", conn.headers['X-Quonfig-SDK-Version']
-    end
-
-    def test_no_protobuf_content_type
-      conn = HttpConnection.new(URI, SDK_KEY).connection
-      refute_equal 'application/x-protobuf', conn.headers['Content-Type']
-      refute_equal 'application/x-protobuf', conn.headers['Accept']
-    end
-
-    def test_post_serializes_body_as_json
-      stubs = Faraday::Adapter::Test::Stubs.new
-      captured_body = nil
-      captured_content_type = nil
-      stubs.post('/telemetry') do |env|
-        captured_body = env.body
-        captured_content_type = env.request_headers['Content-Type']
-        [200, {}, '']
-      end
-
-      http = HttpConnection.new(URI, SDK_KEY)
-      http.define_singleton_method(:connection) do |headers = {}|
-        Faraday.new(URI) do |conn|
-          conn.headers.merge!(HttpConnection::JSON_HEADERS.merge(headers))
-          conn.adapter :test, stubs
-        end
-      end
-
-      body = { hello: 'world', n: 3 }
-      http.post('/telemetry', body)
-
-      assert_equal 'application/json', captured_content_type
-      assert_equal body.to_json, captured_body
-      stubs.verify_stubbed_calls
-    end
-  end
-
-  class OptionsDefaultApiUrlsTest < Minitest::Test
-    def test_default_api_urls_use_quonfig_domain
-      assert_includes Options::DEFAULT_API_URLS, 'https://primary.quonfig.com'
-      refute(Options::DEFAULT_API_URLS.any? { |s| s.include?('reforge.com') })
-    end
-
-    def test_telemetry_destination_honors_quonfig_domain_env
-      with_env('QUONFIG_DOMAIN', 'quonfig-staging.com') do
-        assert_equal 'https://telemetry.quonfig-staging.com',
-                     Options.new.telemetry_destination
-      end
-    end
-
-    def test_telemetry_destination_default
-      with_env('QUONFIG_DOMAIN', nil) do
-        assert_equal 'https://telemetry.quonfig.com', Options.new.telemetry_destination
-      end
-    end
-  end
-end

data/test/test_internal_logger.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestInternalLogger < Minitest::Test
-
-  def teardown
-    # using_quonfig_log_filter! mutates the shared @@instances list — restore
-    # the default :warn level so it doesn't bleed into other tests' $logs.
-    Quonfig::InternalLogger.class_variable_get(:@@instances).each do |logger|
-      logger.level = :warn
-    end
-    super
-  end
-
-  def test_levels
-    logger_a = Quonfig::InternalLogger.new(A)
-    logger_b = Quonfig::InternalLogger.new(B)
-
-    assert_equal :warn, logger_a.level
-    assert_equal :warn, logger_b.level
-
-    Quonfig::InternalLogger.using_quonfig_log_filter!
-    assert_equal :trace, logger_a.level
-    assert_equal :trace, logger_b.level
-  end
-
-end
-
-class A
-end
-
-class B
-end

data/test/test_options.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestOptions < Minitest::Test
-  API_KEY = 'abcdefg'
-
-  def test_default_api_urls_point_to_quonfig
-    # DEFAULT_API_URLS is the hardcoded fallback when neither QUONFIG_DOMAIN
-    # nor an explicit api_urls: kwarg is set. Domain-derivation happens at
-    # construction time, not at constant load time — see derive_api_urls.
-    assert_equal [
-      'https://primary.quonfig.com',
-      'https://secondary.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
-
-  # ---- QUONFIG_DOMAIN tests (qfg-w6gg) ----
-  # A single env var `QUONFIG_DOMAIN` governs api, sse, and telemetry URL
-  # derivation. Resolution order (highest wins): explicit kwargs >
-  # QUONFIG_DOMAIN > hardcoded default 'quonfig.com'.
-
-  def test_default_domain_is_quonfig_com
-    with_env('QUONFIG_DOMAIN', nil) do
-      options = Quonfig::Options.new
-      assert_equal [
-        'https://primary.quonfig.com',
-        'https://secondary.quonfig.com',
-      ], options.api_urls
-      assert_equal 'https://telemetry.quonfig.com', options.telemetry_destination
-    end
-  end
-
-  def test_quonfig_domain_env_var_derives_all_urls
-    with_env('QUONFIG_DOMAIN', 'quonfig-staging.com') do
-      options = Quonfig::Options.new
-      assert_equal [
-        'https://primary.quonfig-staging.com',
-        'https://secondary.quonfig-staging.com',
-      ], options.api_urls
-      assert_equal [
-        'https://stream.primary.quonfig-staging.com',
-        'https://stream.secondary.quonfig-staging.com',
-      ], options.sse_api_urls
-      assert_equal 'https://telemetry.quonfig-staging.com', options.telemetry_destination
-    end
-  end
-
-  def test_explicit_api_urls_override_quonfig_domain
-    with_env('QUONFIG_DOMAIN', 'quonfig-staging.com') do
-      options = Quonfig::Options.new(api_urls: ['http://localhost:8080'])
-      assert_equal ['http://localhost:8080'], options.api_urls
-    end
-  end
-
-  def test_explicit_telemetry_url_overrides_quonfig_domain
-    with_env('QUONFIG_DOMAIN', 'quonfig-staging.com') do
-      options = Quonfig::Options.new(telemetry_url: 'http://localhost:6555')
-      assert_equal 'http://localhost:6555', options.telemetry_destination
-    end
-  end
-
-  def test_quonfig_telemetry_url_env_var_no_longer_read
-    # QUONFIG_TELEMETRY_URL has been removed. Setting it must not affect
-    # anything; the default (quonfig.com) wins.
-    with_env('QUONFIG_DOMAIN', nil) do
-      with_env('QUONFIG_TELEMETRY_URL', 'https://should-be-ignored.example.com') do
-        assert_equal 'https://telemetry.quonfig.com',
-                     Quonfig::Options.new.telemetry_destination
-      end
-    end
-  end
-end

data/test/test_rate_limit_cache.rb

@@ -1,44 +0,0 @@
-# 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

@@ -1,79 +0,0 @@
-# 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

@@ -1,65 +0,0 @@
-# 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