quonfig 0.0.2

data/test/integration/test_post.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+#
+# AUTO-GENERATED from integration-test-data/tests/eval/post.yaml.
+# Regenerate with `bundle exec ruby scripts/generate_integration_tests.rb`.
+# Do NOT edit by hand — changes will be overwritten.
+
+require 'test_helper'
+require 'integration/test_helpers'
+
+class TestPost < Minitest::Test
+  def setup
+    @store = IntegrationTestHelpers.build_store("post")
+  end
+
+  # reports context shape aggregation
+  def test_reports_context_shape_aggregation
+    skip("post/aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # reports evaluation summary
+  def test_reports_evaluation_summary
+    skip("post/aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # reports example contexts
+  def test_reports_example_contexts
+    skip("post/aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # example contexts without key are not reported
+  def test_example_contexts_without_key_are_not_reported
+    skip("post/aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+end

data/test/integration/test_telemetry.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+#
+# AUTO-GENERATED from integration-test-data/tests/eval/telemetry.yaml.
+# Regenerate with `bundle exec ruby scripts/generate_integration_tests.rb`.
+# Do NOT edit by hand — changes will be overwritten.
+
+require 'test_helper'
+require 'integration/test_helpers'
+
+class TestTelemetry < Minitest::Test
+  def setup
+    @store = IntegrationTestHelpers.build_store("telemetry")
+  end
+
+  # reason is STATIC for config with no targeting rules
+  def test_reason_is_static_for_config_with_no_targeting_rules
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # reason is STATIC for feature flag with only ALWAYS_TRUE rules
+  def test_reason_is_static_for_feature_flag_with_only_always_true_rules
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # reason is TARGETING_MATCH when config has targeting rules but evaluation falls through
+  def test_reason_is_targeting_match_when_config_has_targeting_rules_but_evaluation_falls_through
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # reason is TARGETING_MATCH when a targeting rule matches
+  def test_reason_is_targeting_match_when_a_targeting_rule_matches
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # reason is SPLIT for weighted value evaluation
+  def test_reason_is_split_for_weighted_value_evaluation
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # reason is TARGETING_MATCH for feature flag fallthrough with targeting rules
+  def test_reason_is_targeting_match_for_feature_flag_fallthrough_with_targeting_rules
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # evaluation summary deduplicates identical evaluations
+  def test_evaluation_summary_deduplicates_identical_evaluations
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # evaluation summary creates separate counters for different rules of same config
+  def test_evaluation_summary_creates_separate_counters_for_different_rules_of_same_config
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # evaluation summary groups by config key
+  def test_evaluation_summary_groups_by_config_key
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # selectedValue wraps string correctly
+  def test_selectedvalue_wraps_string_correctly
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # selectedValue wraps boolean correctly
+  def test_selectedvalue_wraps_boolean_correctly
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # selectedValue wraps int correctly
+  def test_selectedvalue_wraps_int_correctly
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # selectedValue wraps double correctly
+  def test_selectedvalue_wraps_double_correctly
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # selectedValue wraps string list correctly
+  def test_selectedvalue_wraps_string_list_correctly
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # context shape merges fields across multiple records
+  def test_context_shape_merges_fields_across_multiple_records
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # example contexts deduplicates by key value
+  def test_example_contexts_deduplicates_by_key_value
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # telemetry disabled emits nothing
+  def test_telemetry_disabled_emits_nothing
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # shapes only mode reports shapes but not examples
+  def test_shapes_only_mode_reports_shapes_but_not_examples
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # log level evaluations are excluded from telemetry
+  def test_log_level_evaluations_are_excluded_from_telemetry
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+
+  # empty context produces no context telemetry
+  def test_empty_context_produces_no_context_telemetry
+    skip("telemetry aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+  end
+end

data/test/support/common_helpers.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module CommonHelpers
+  require 'timecop'
+
+  def setup
+    $oldstderr, $stderr = $stderr, StringIO.new
+    $logs = StringIO.new
+
+    if defined?(SemanticLogger)
+      SemanticLogger.add_appender(io: $logs)
+      SemanticLogger.sync!
+    end
+  end
+
+  def teardown
+    if $logs && !$logs.string.empty?
+      log_lines = $logs.string.split("\n").reject do |line|
+        line.match(/Quonfig::ConfigClient -- No success loading checkpoints/)
+      end
+
+      if log_lines.size > 0
+        $logs = nil
+        raise "Unexpected logs. Handle logs with assert_logged\n\n#{log_lines}"
+      end
+    end
+
+    # note this skips the output check in environments like rubymine that hijack the output
+    if $stderr != $oldstderr && $stderr.respond_to?(:string) && !$stderr.string.empty?
+      if !RUBY_VERSION.start_with?('2.')
+        # Filter out ld-eventsource frozen string literal warnings in Ruby 3.4+
+        stderr_lines = $stderr.string.split("\n").reject do |line|
+          line.include?('ld-eventsource') && line.include?('literal string will be frozen in the future')
+        end
+
+        if !stderr_lines.empty?
+          raise "Unexpected stderr. Handle stderr with assert_stderr\n\n#{stderr_lines.join("\n")}"
+        end
+      end
+    end
+
+    $stderr = $oldstderr if $oldstderr
+
+    Timecop.return
+  end
+
+  def with_env(key, value, &block)
+    old_value = ENV.fetch(key, nil)
+
+    ENV[key] = value
+    block.call
+  ensure
+    ENV[key] = old_value
+  end
+
+  FakeResponse = Struct.new(:status, :body)
+
+  def wait_for(condition, max_wait: 10, sleep_time: 0.01)
+    wait_time = 0
+    while !condition.call
+      wait_time += sleep_time
+      sleep sleep_time
+
+      raise "Waited #{max_wait} seconds for the condition to be true, but it never was" if wait_time > max_wait
+    end
+  end
+
+  def context(properties)
+    Quonfig::Context.new(properties)
+  end
+
+  def assert_logged(expected)
+    # we do a uniq here because logging can happen in a separate thread so the
+    # number of times a log might happen could be slightly variable.
+    actuals = $logs.string.split("\n").uniq
+    expected.each do |expectation|
+      matched = false
+
+      actuals.each do |actual|
+        matched = true if actual.match(expectation)
+      end
+
+      assert(matched, "expectation: #{expectation}, got: #{actuals}")
+    end
+    # mark nil to indicate we handled it
+    $logs = nil
+  end
+
+  def assert_stderr(expected)
+    skip "Cannot verify stderr in current environment" unless $stderr.respond_to?(:string)
+    $stderr.string.split("\n").uniq.each do |line|
+      matched = false
+
+      expected.reject! do |expectation|
+        matched = true if line.include?(expectation)
+      end
+
+      assert(matched, "expectation: #{expected}, got: #{line}")
+    end
+
+    assert expected.empty?, "Expected stderr to include: #{expected}, but it did not"
+
+    # restore since we've handled it
+    $stderr = $oldstderr
+  end
+end

data/test/support/mock_base_client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Minimal stand-in for Quonfig::Client used by Evaluator/ConfigLoader tests.
+# We deliberately keep this tiny so the tests don't depend on the live
+# ConfigStore/Resolver/Evaluator wiring — they exercise their target in
+# isolation.
+class MockBaseClient
+  STAGING_ENV_ID = 1
+  PRODUCTION_ENV_ID = 2
+  TEST_ENV_ID = 3
+
+  attr_reader :options
+
+  def initialize(options = Quonfig::Options.new)
+    @options = options
+  end
+
+  def instance_hash
+    'mock-base-client-instance-hash'
+  end
+
+  def project_id
+    1
+  end
+
+  def log; end
+end

data/test/support/mock_config_loader.rb

@@ -0,0 +1 @@
+# frozen_string_literal: true

data/test/test_bound_client.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# BoundClient is a pure delegation wrapper: it forwards typed-getter calls to
+# the underlying client with its bound context. These tests exercise that
+# wrapper with a tiny FakeClient double so they do not depend on the rest of
+# the eval pipeline (which is mid-JSON-migration and not fully green yet).
+class TestBoundClient < Minitest::Test
+  # Minimal stand-in for Quonfig::Client that records the context each typed
+  # getter was called with. BoundClient only exercises the public typed-getter
+  # surface + enabled?, so that's all we need here.
+  class FakeClient
+    attr_reader :calls
+
+    def initialize
+      @calls = []
+    end
+
+    def get_string(key, default: Quonfig::NO_DEFAULT_PROVIDED, context: Quonfig::NO_DEFAULT_PROVIDED)
+      @calls << [:get_string, key, default, context]
+      context
+    end
+
+    def get_int(key, default: Quonfig::NO_DEFAULT_PROVIDED, context: Quonfig::NO_DEFAULT_PROVIDED)
+      @calls << [:get_int, key, default, context]
+      context
+    end
+
+    def enabled?(feature_name, jit_context = Quonfig::NO_DEFAULT_PROVIDED)
+      @calls << [:enabled?, feature_name, jit_context]
+      jit_context
+    end
+  end
+
+  def test_get_string_uses_bound_context
+    fake = FakeClient.new
+    bound = Quonfig::BoundClient.new(fake, user: { 'key' => '99' })
+
+    bound.get_string('my.str')
+
+    call = fake.calls.last
+    assert_equal :get_string,                 call[0]
+    assert_equal 'my.str',                    call[1]
+    assert_equal Quonfig::NO_DEFAULT_PROVIDED, call[2]
+    assert_equal({ user: { 'key' => '99' } }, call[3])
+  end
+
+  def test_enabled_uses_bound_context
+    fake = FakeClient.new
+    bound = Quonfig::BoundClient.new(fake, user: { 'key' => '99' })
+
+    bound.enabled?('my.flag')
+
+    call = fake.calls.last
+    assert_equal :enabled?,                   call[0]
+    assert_equal 'my.flag',                   call[1]
+    assert_equal({ user: { 'key' => '99' } }, call[2])
+  end
+
+  def test_in_context_returns_new_bound_with_merged_context
+    fake = FakeClient.new
+    bound = Quonfig::BoundClient.new(fake, user: { 'key' => '99' })
+
+    chained = bound.in_context(org: { 'id' => 'acme' })
+
+    assert_kind_of Quonfig::BoundClient, chained
+    refute_same bound, chained,
+                'in_context should return a NEW BoundClient, not self'
+
+    expected = { user: { 'key' => '99' }, org: { 'id' => 'acme' } }
+    assert_equal expected, chained.context
+  end
+
+  def test_in_context_merged_context_is_used_on_typed_getter
+    fake = FakeClient.new
+    bound = Quonfig::BoundClient.new(fake, user: { 'key' => '99' })
+    chained = bound.in_context(org: { 'id' => 'acme' })
+
+    chained.get_string('my.str')
+
+    ctx_arg = fake.calls.last[3]
+    assert_equal({ user: { 'key' => '99' }, org: { 'id' => 'acme' } }, ctx_arg)
+  end
+
+  def test_in_context_later_keys_within_same_named_ctx_override_earlier
+    fake = FakeClient.new
+    bound = Quonfig::BoundClient.new(fake, user: { 'key' => '99', 'plan' => 'free' })
+
+    chained = bound.in_context(user: { 'plan' => 'pro' })
+
+    # 'plan' overridden; 'key' preserved from parent bound
+    assert_equal({ user: { 'key' => '99', 'plan' => 'pro' } }, chained.context)
+  end
+
+  def test_in_context_does_not_mutate_parent_bound_context
+    fake = FakeClient.new
+    bound = Quonfig::BoundClient.new(fake, user: { 'key' => '99' })
+
+    bound.in_context(org: { 'id' => 'acme' })
+
+    assert_equal({ user: { 'key' => '99' } }, bound.context)
+  end
+
+  def test_bound_client_is_frozen
+    bound = Quonfig::BoundClient.new(FakeClient.new, user: { 'key' => '99' })
+    assert_predicate bound, :frozen?
+  end
+end

data/test/test_caching_http_connection.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Quonfig
+  class CachingHttpConnectionTest < Minitest::Test
+    def setup
+      @uri = 'https://api.example.com'
+      @sdk_key = 'test-key'
+      @path = '/some/path'
+
+      # Reset the cache before each test
+      CachingHttpConnection.reset_cache!
+
+      # Setup the mock HTTP connection
+      @http_connection = Minitest::Mock.new
+      @http_connection.expect(:uri, @uri)
+
+      # Stub the HttpConnection constructor
+      HttpConnection.stub :new, @http_connection do
+        @subject = CachingHttpConnection.new(@uri, @sdk_key)
+      end
+    end
+
+    def test_caches_responses_with_etag_and_max_age
+      response_body = 'response data'
+      response = Faraday::Response.new(
+        status: 200,
+        body: response_body,
+        response_headers: {
+          'ETag' => 'abc123',
+          'Cache-Control' => 'max-age=60'
+        }
+      )
+
+      # Expect two calls to uri (one for each request) and one call to get
+      @http_connection.expect(:uri, @uri)
+      @http_connection.expect(:get, response, [@path])
+
+      HttpConnection.stub :new, @http_connection do
+        # First request should miss cache
+        first_response = @subject.get(@path)
+        assert_equal response_body, first_response.body
+        assert_equal 'MISS', first_response.headers['X-Cache']
+
+        # Second request should hit cache
+        second_response = @subject.get(@path)
+        assert_equal response_body, second_response.body
+        assert_equal 'HIT', second_response.headers['X-Cache']
+      end
+
+      @http_connection.verify
+    end
+
+    def test_respects_max_age_directive
+      response = Faraday::Response.new(
+        status: 200,
+        body: 'fresh data',
+        response_headers: {
+          'ETag' => 'abc123',
+          'Cache-Control' => 'max-age=60'
+        }
+      )
+
+      mock = Minitest::Mock.new
+      def mock.uri
+        'https://api.example.com'
+      end
+
+      # First request
+      mock.expect(:get, response, [@path])
+      # After max-age expires, new request with etag
+      mock.expect(:get, response, [@path, { 'If-None-Match' => 'abc123' }])
+
+      Timecop.freeze do
+        subject = CachingHttpConnection.new(@uri, @sdk_key)
+        subject.instance_variable_set('@connection', mock)
+
+        # Initial request
+        subject.get(@path)
+
+        # Within max-age window
+        Timecop.travel(59)
+        cached_response = subject.get(@path)
+        assert_equal 'HIT', cached_response.headers['X-Cache']
+
+        # After max-age window
+        Timecop.travel(61)
+        new_response = subject.get(@path)
+        assert_equal 'MISS', new_response.headers['X-Cache']
+      end
+
+      mock.verify
+    end
+    def test_handles_304_not_modified
+      initial_response = Faraday::Response.new(
+        status: 200,
+        body: 'cached data',
+        response_headers: { 'ETag' => 'abc123' }
+      )
+
+      not_modified_response = Faraday::Response.new(
+        status: 304,
+        body: '',
+        response_headers: { 'ETag' => 'abc123' }
+      )
+
+      mock = Minitest::Mock.new
+      def mock.uri
+        'https://api.example.com'
+      end
+
+      # First request with single arg
+      mock.expect(:get, initial_response, [@path])
+
+      # Second request with both path and headers
+      mock.expect(:get, not_modified_response, [@path, { 'If-None-Match' => 'abc123' }])
+
+      subject = CachingHttpConnection.new(@uri, @sdk_key)
+      subject.instance_variable_set('@connection', mock)
+
+      # Initial request to populate cache
+      first_response = subject.get(@path)
+      assert_equal 'cached data', first_response.body
+      assert_equal 'MISS', first_response.headers['X-Cache']
+
+      # Subsequent request gets 304
+      cached_response = subject.get(@path)
+      assert_equal 'cached data', cached_response.body
+      assert_equal 200, cached_response.status
+      assert_equal 'HIT', cached_response.headers['X-Cache']
+
+      mock.verify
+    end
+
+    def test_does_not_cache_no_store_responses
+      response = Faraday::Response.new(
+        status: 200,
+        body: 'uncacheable data',
+        response_headers: { 'Cache-Control' => 'no-store' }
+      )
+
+      mock = Minitest::Mock.new
+      def mock.uri
+        'https://api.example.com'
+      end
+      # Both gets with single arg
+      mock.expect(:get, response, [@path])
+      mock.expect(:get, response, [@path])
+
+      subject = CachingHttpConnection.new(@uri, @sdk_key)
+      subject.instance_variable_set('@connection', mock)
+
+      2.times do
+        result = subject.get(@path)
+        assert_equal 'MISS', result.headers['X-Cache']
+      end
+
+      mock.verify
+    end
+    def test_cache_is_shared_across_instances
+      HttpConnection.stub :new, @http_connection do
+        instance1 = CachingHttpConnection.new(@uri, @sdk_key)
+        instance2 = CachingHttpConnection.new(@uri, @sdk_key)
+
+        assert_same instance1.class.cache, instance2.class.cache
+      end
+    end
+
+    def test_cache_can_be_reset
+      old_cache = CachingHttpConnection.cache
+      CachingHttpConnection.reset_cache!
+      refute_same CachingHttpConnection.cache, old_cache
+    end
+
+    def test_adds_if_none_match_header_when_cached
+      # First response to be cached
+      initial_response = Faraday::Response.new(
+        status: 200,
+        body: 'cached data',
+        response_headers: { 'ETag' => 'abc123' }
+      )
+
+      # Second request should have If-None-Match header
+      not_modified_response = Faraday::Response.new(
+        status: 304,
+        body: '',
+        response_headers: { 'ETag' => 'abc123' }
+      )
+
+      mock = Minitest::Mock.new
+      def mock.uri
+        'https://api.example.com'
+      end
+
+      # First request should not have If-None-Match
+      mock.expect(:get, initial_response, [@path])
+
+      # Second request should have If-None-Match header
+      mock.expect(:get, not_modified_response, [@path, { 'If-None-Match' => 'abc123' }])
+
+      subject = CachingHttpConnection.new(@uri, @sdk_key)
+      subject.instance_variable_set('@connection', mock)
+
+      # Initial request to populate cache
+      first_response = subject.get(@path)
+      assert_equal 'cached data', first_response.body
+      assert_equal 'MISS', first_response.headers['X-Cache']
+
+      # Second request should use If-None-Match
+      cached_response = subject.get(@path)
+      assert_equal 'cached data', cached_response.body
+      assert_equal 'HIT', cached_response.headers['X-Cache']
+
+      mock.verify
+    end
+  end
+end