quonfig 0.0.9 → 0.0.11

data/test/test_caching_http_connection.rb

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

data/test/test_client.rb

@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# Quonfig::Client wires the JSON stack: ConfigStore + Evaluator + Resolver
-# (introduced in qfg-dk6.4-9). These tests drive Client through an injected
-# ConfigStore so they never touch the network or the filesystem. The legacy
-# protobuf ConfigClient/ConfigResolver path was removed in qfg-dk6.32.
-class TestClient < Minitest::Test
-  CONFIG_KEY = 'my.flag'
-
-  # ---- Test fixtures -----------------------------------------------------
-
-  # Plain ConfigResponse-shaped hash (mirrors what
-  # Quonfig::Datadir.to_config_response and IntegrationTestHelpers emit).
-  def make_config(key:, value:, type: 'string', criteria: nil)
-    {
-      'id' => '1',
-      'key' => key,
-      'type' => 'config',
-      'valueType' => type,
-      'sendToClientSdk' => false,
-      'default' => {
-        'rules' => [
-          {
-            'criteria' => criteria || [{ 'operator' => 'ALWAYS_TRUE' }],
-            'value' => { 'type' => type, 'value' => value }
-          }
-        ]
-      },
-      '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
-
-  # ---- Construction ------------------------------------------------------
-
-  def test_constructor_accepts_options_object
-    client = client_with(Quonfig::ConfigStore.new)
-    assert_kind_of Quonfig::Options, client.options
-  end
-
-  def test_constructor_wires_resolver_and_evaluator
-    store = Quonfig::ConfigStore.new
-    client = Quonfig::Client.new(Quonfig::Options.new, store: store)
-
-    assert_kind_of Quonfig::Resolver, client.resolver
-    assert_kind_of Quonfig::Evaluator, client.evaluator
-    assert_same store, client.store,
-                'Client must use the injected ConfigStore instance'
-  end
-
-  def test_instance_hash_is_unique_per_client
-    a = client_with(Quonfig::ConfigStore.new)
-    b = client_with(Quonfig::ConfigStore.new)
-    refute_equal a.instance_hash, b.instance_hash
-  end
-
-  # ---- get returns coerced JSON values, not PrefabProto ------------------
-
-  def test_get_returns_string_value
-    store = store_with(make_config(key: CONFIG_KEY, value: 'hello'))
-    assert_equal 'hello', client_with(store).get(CONFIG_KEY)
-  end
-
-  def test_get_returns_int_value
-    store = store_with(make_config(key: CONFIG_KEY, value: 42, type: 'int'))
-    assert_equal 42, client_with(store).get(CONFIG_KEY)
-  end
-
-  def test_get_returns_bool_value
-    store = store_with(make_config(key: CONFIG_KEY, value: true, type: 'bool'))
-    assert_equal true, client_with(store).get(CONFIG_KEY)
-  end
-
-  def test_get_returned_value_is_not_a_prefab_proto
-    store = store_with(make_config(key: CONFIG_KEY, value: 'hello'))
-    value = client_with(store).get(CONFIG_KEY)
-
-    refute value.respond_to?(:string_list),
-           'Client#get must return a plain Ruby value, not a PrefabProto::ConfigValue'
-    refute value.is_a?(Hash),
-           'Client#get must unwrap to the coerced Ruby value, not the JSON Value hash'
-  end
-
-  # ---- Missing key handling ---------------------------------------------
-
-  def test_get_returns_explicit_default_when_key_missing
-    store = Quonfig::ConfigStore.new
-    assert_equal 'fallback', client_with(store).get('nope', 'fallback')
-  end
-
-  def test_get_raises_missing_default_error_by_default
-    store = Quonfig::ConfigStore.new
-    assert_raises(Quonfig::Errors::MissingDefaultError) do
-      client_with(store).get('nope')
-    end
-  end
-
-  def test_get_returns_nil_when_on_no_default_is_return_nil
-    store = Quonfig::ConfigStore.new
-    client = client_with(store, on_no_default: Quonfig::Options::ON_NO_DEFAULT::RETURN_NIL)
-    assert_nil client.get('nope')
-  end
-
-  # ---- enabled? --------------------------------------------------------
-
-  def test_enabled_returns_true_when_value_is_true
-    store = store_with(make_config(key: CONFIG_KEY, value: true, type: 'bool'))
-    assert client_with(store).enabled?(CONFIG_KEY)
-  end
-
-  def test_enabled_returns_false_when_value_is_false
-    store = store_with(make_config(key: CONFIG_KEY, value: false, type: 'bool'))
-    refute client_with(store).enabled?(CONFIG_KEY)
-  end
-
-  def test_enabled_returns_false_for_missing_key
-    store = Quonfig::ConfigStore.new
-    refute client_with(store).enabled?('nope')
-  end
-
-  # ---- defined? + keys --------------------------------------------------
-
-  def test_defined_returns_true_for_known_key
-    store = store_with(make_config(key: CONFIG_KEY, value: 'x'))
-    assert client_with(store).defined?(CONFIG_KEY)
-  end
-
-  def test_defined_returns_false_for_unknown_key
-    store = store_with(make_config(key: CONFIG_KEY, value: 'x'))
-    refute client_with(store).defined?('absent')
-  end
-
-  def test_keys_returns_store_keys
-    store = store_with(
-      make_config(key: 'a', value: '1'),
-      make_config(key: 'b', value: '2')
-    )
-    assert_equal %w[a b].sort, client_with(store).keys.sort
-  end
-
-  # ---- Context: jit context is plain Hash, not PrefabProto::Context ----
-
-  def test_get_accepts_jit_context_as_plain_hash
-    cfg = make_config(
-      key: CONFIG_KEY,
-      value: 'matched',
-      criteria: [{
-        'operator' => 'PROP_IS_ONE_OF',
-        'propertyName' => 'user.role',
-        'valueToMatch' => { 'type' => 'string_list', 'value' => ['admin'] }
-      }]
-    )
-    store = store_with(cfg)
-
-    result = client_with(store).get(CONFIG_KEY, 'fallback', user: { 'role' => 'admin' })
-
-    assert_equal 'matched', result
-  end
-
-  def test_with_context_returns_bound_client
-    bound = client_with(Quonfig::ConfigStore.new).with_context(user: { 'key' => '1' })
-    assert_kind_of Quonfig::BoundClient, bound
-    assert_equal({ user: { 'key' => '1' } }, bound.context)
-  end
-
-  def test_in_context_yields_bound_client_when_block_given
-    yielded = nil
-    client_with(Quonfig::ConfigStore.new).in_context(user: { 'key' => '1' }) do |bound|
-      yielded = bound
-    end
-
-    assert_kind_of Quonfig::BoundClient, yielded
-    assert_equal({ user: { 'key' => '1' } }, yielded.context)
-  end
-
-  def test_global_context_is_merged_into_jit_context
-    cfg = make_config(
-      key: CONFIG_KEY,
-      value: 'admin-value',
-      criteria: [{
-        'operator' => 'PROP_IS_ONE_OF',
-        'propertyName' => 'user.role',
-        'valueToMatch' => { 'type' => 'string_list', 'value' => ['admin'] }
-      }]
-    )
-    store = store_with(cfg)
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(global_context: { user: { 'role' => 'admin' } }),
-      store: store
-    )
-
-    assert_equal 'admin-value', client.get(CONFIG_KEY, 'fallback')
-  end
-
-  def test_jit_context_overrides_global_context_at_the_property_level
-    cfg = make_config(
-      key: CONFIG_KEY,
-      value: 'jit-value',
-      criteria: [{
-        'operator' => 'PROP_IS_ONE_OF',
-        'propertyName' => 'user.role',
-        'valueToMatch' => { 'type' => 'string_list', 'value' => ['user'] }
-      }]
-    )
-    store = store_with(cfg)
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(global_context: { user: { 'role' => 'admin' } }),
-      store: store
-    )
-
-    # jit overrides global for this single property; keys unique to global preserved
-    assert_equal 'jit-value', client.get(CONFIG_KEY, 'fallback', user: { 'role' => 'user' })
-  end
-
-  def test_normalize_context_rejects_non_hash_jit_context
-    store = Quonfig::ConfigStore.new
-    assert_raises(ArgumentError) do
-      client_with(store).get('nope', 'fallback', 'not-a-hash')
-    end
-  end
-
-  # ---- Misc -------------------------------------------------------------
-
-  def test_stop_is_a_noop
-    client_with(Quonfig::ConfigStore.new).stop
-    pass
-  end
-
-  def test_inspect_includes_environment
-    client = client_with(Quonfig::ConfigStore.new, environment: 'Production')
-    assert_match(/environment="Production"/, client.inspect)
-  end
-
-  def test_no_prefab_proto_in_lib_quonfig_source
-    # qfg-dk6.32: scrub PrefabProto from the runtime lib path.
-    lib_dir = File.expand_path('../lib/quonfig', __dir__)
-    offenders = Dir.glob(File.join(lib_dir, '**/*.rb')).select do |path|
-      File.read(path).match?(/PrefabProto/)
-    end
-
-    assert_empty offenders,
-                 "lib/quonfig still references PrefabProto:\n#{offenders.join("\n")}"
-  end
-end

data/test/test_client_network_mode.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'webrick'
-require 'json'
-
-# Verifies Client#initialize (qfg-s7h) wires HTTP fetch + ConfigStore together
-# so `Quonfig.get(...)` / `Quonfig.enabled?(...)` return real values — not the
-# defaults — when only an `sdk_key:` + `api_urls:` are supplied. This is the
-# regression test for the P0 documented in test-ruby/FRICTION.md where
-# network-mode was accepted but silently ignored in v0.0.3.
-class TestClientNetworkMode < Minitest::Test
-  PORT = 18_094
-
-  SAMPLE_CONFIG = {
-    'id' => 'c1',
-    'key' => 'log-levels.test-ruby',
-    'type' => 'log_level',
-    'valueType' => 'log_level',
-    'sendToClientSdk' => false,
-    'default' => {
-      'rules' => [
-        {
-          'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
-          'value' => { 'type' => 'log_level', 'value' => 'WARN' }
-        }
-      ]
-    }
-  }.freeze
-
-  def setup
-    super
-    @server = nil
-    @fetch_count = 0
-  end
-
-  def teardown
-    @server&.shutdown
-    super
-  end
-
-  def start_server
-    log = WEBrick::Log.new(StringIO.new)
-    @server = WEBrick::HTTPServer.new(
-      Port: PORT, Logger: log, AccessLog: []
-    )
-    @server.mount_proc '/api/v2/configs' do |_req, res|
-      @fetch_count += 1
-      res.status = 200
-      res['Content-Type'] = 'application/json'
-      res['ETag'] = "v#{@fetch_count}"
-      res.body = JSON.generate(
-        'configs' => [SAMPLE_CONFIG],
-        'meta' => { 'version' => "v#{@fetch_count}", 'environment' => 'dev' }
-      )
-    end
-    Thread.new { @server.start }
-    # Wait for server to be ready.
-    50.times do
-      break if tcp_open?
-      sleep 0.05
-    end
-  end
-
-  def tcp_open?
-    require 'socket'
-    TCPSocket.new('127.0.0.1', PORT).tap(&:close)
-    true
-  rescue StandardError
-    false
-  end
-
-  def test_initialize_fetches_configs_from_api_urls_and_populates_store
-    start_server
-
-    client = Quonfig::Client.new(
-      sdk_key: 'test-key',
-      api_urls: ["http://127.0.0.1:#{PORT}"],
-      enable_sse: false,
-      enable_polling: false
-    )
-
-    assert_equal 1, @fetch_count, 'expected exactly one HTTP fetch during init'
-    assert_includes client.keys, 'log-levels.test-ruby'
-    assert_equal 'WARN', client.get('log-levels.test-ruby', 'default')
-  ensure
-    client&.stop
-  end
-
-  def test_initialize_raises_on_fetch_failure_by_default
-    # No server started -> connection refused everywhere
-    assert_raises(RuntimeError, Quonfig::Errors::InitializationTimeoutError) do
-      Quonfig::Client.new(
-        sdk_key: 'test-key',
-        api_urls: ['http://127.0.0.1:1'], # almost certainly unreachable
-        enable_sse: false,
-        enable_polling: false,
-        initialization_timeout_sec: 2
-      )
-    end
-  end
-
-  def test_initialize_returns_empty_store_when_on_init_failure_is_return
-    client = Quonfig::Client.new(
-      sdk_key: 'test-key',
-      api_urls: ['http://127.0.0.1:1'],
-      enable_sse: false,
-      enable_polling: false,
-      initialization_timeout_sec: 2,
-      on_init_failure: Quonfig::Options::ON_INITIALIZATION_FAILURE::RETURN
-    )
-
-    assert_empty client.keys
-    assert_logged [/Initialization did not complete cleanly/]
-  ensure
-    client&.stop
-  end
-
-  def test_initialize_skips_network_when_store_injected
-    # store: passed -> Client should not try any I/O. Unreachable URL must
-    # be fine when a store is injected.
-    store = Quonfig::ConfigStore.new
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(
-        sdk_key: 'test-key',
-        api_urls: ['http://127.0.0.1:1'],
-        enable_sse: false,
-        enable_polling: false
-      ),
-      store: store
-    )
-    assert_same store, client.store
-  ensure
-    client&.stop
-  end
-end