quonfig 0.0.2

data/test/test_encryption.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestEncryption < Minitest::Test
+  def test_encryption
+    secret = Quonfig::Encryption.generate_new_hex_key
+
+    enc = Quonfig::Encryption.new(secret)
+
+    clear_text = "hello world"
+    encrypted = enc.encrypt(clear_text)
+    decrypted = enc.decrypt(encrypted)
+    assert_equal clear_text, decrypted
+  end
+end

data/test/test_evaluator.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# qfg-dk6.10: operator-level tests for Quonfig::Evaluator against the JSON
+# Criterion shape (propertyName / operator / valueToMatch). Mirrors sdk-node's
+# evaluator behaviour — the node suite is the authoritative spec.
+#
+# The Evaluator consumes configs in the shape produced by
+# IntegrationTestHelpers.to_config_response / Quonfig::Datadir.to_config_response:
+#   {
+#     id:, key:, type:, value_type:,
+#     send_to_client_sdk:, default: { 'rules' => [...] }, environment: {...}
+#   }
+# Rules/criteria inside stay as plain JSON hashes (string keys), matching what
+# lands on disk in integration-test-data.
+class TestEvaluator < Minitest::Test
+  def build_config(rules, key: 'my.key', value_type: 'string', environment: nil)
+    {
+      id: 'id-1',
+      key: key,
+      type: 'config',
+      value_type: value_type,
+      send_to_client_sdk: false,
+      default: { 'rules' => rules },
+      environment: environment
+    }
+  end
+
+  def evaluate(config, context_hash = {}, extra_configs: {})
+    store = Quonfig::ConfigStore.new
+    store.set(config[:key], config)
+    extra_configs.each { |k, v| store.set(k, v) }
+    evaluator = Quonfig::Evaluator.new(store)
+    resolver = Quonfig::Resolver.new(store, evaluator)
+    resolver.get(config[:key], Quonfig::Context.new(context_hash))
+  end
+
+  def value_match_rule(criteria, value_type, value)
+    {
+      'criteria' => criteria,
+      'value' => { 'type' => value_type, 'value' => value }
+    }
+  end
+
+  # ------ ALWAYS_TRUE ------
+
+  def test_always_true
+    cfg = build_config([
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'hit')
+    ])
+    assert_equal 'hit', evaluate(cfg).unwrapped_value
+  end
+
+  # ------ PROP_IS_ONE_OF / PROP_IS_NOT_ONE_OF ------
+
+  def test_prop_is_one_of_matches
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_IS_ONE_OF',
+           'valueToMatch' => { 'type' => 'string_list', 'value' => %w[a@b.com c@d.com] } }],
+        'string', 'match'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'nope')
+    ])
+    assert_equal 'match', evaluate(cfg, { user: { email: 'a@b.com' } }).unwrapped_value
+    assert_equal 'nope', evaluate(cfg, { user: { email: 'z@z.com' } }).unwrapped_value
+  end
+
+  def test_prop_is_not_one_of_inverse
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_IS_NOT_ONE_OF',
+           'valueToMatch' => { 'type' => 'string_list', 'value' => %w[a@b.com] } }],
+        'string', 'match'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'nope')
+    ])
+    # Missing context => NOT_ONE_OF is true (sdk-node parity)
+    assert_equal 'match', evaluate(cfg, {}).unwrapped_value
+    assert_equal 'nope', evaluate(cfg, { user: { email: 'a@b.com' } }).unwrapped_value
+    assert_equal 'match', evaluate(cfg, { user: { email: 'z@z.com' } }).unwrapped_value
+  end
+
+  # ------ PROP_STARTS_WITH / ENDS_WITH / CONTAINS ------
+
+  def test_starts_with
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_STARTS_WITH_ONE_OF',
+           'valueToMatch' => { 'type' => 'string_list', 'value' => %w[admin- root-] } }],
+        'string', 'yes'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+    ])
+    assert_equal 'yes', evaluate(cfg, { user: { email: 'admin-bob' } }).unwrapped_value
+    assert_equal 'no', evaluate(cfg, { user: { email: 'bob' } }).unwrapped_value
+  end
+
+  def test_ends_with
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_ENDS_WITH_ONE_OF',
+           'valueToMatch' => { 'type' => 'string_list', 'value' => ['@prefab.cloud'] } }],
+        'string', 'yes'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+    ])
+    assert_equal 'yes', evaluate(cfg, { user: { email: 'b@prefab.cloud' } }).unwrapped_value
+    assert_equal 'no', evaluate(cfg, { user: { email: 'b@other.com' } }).unwrapped_value
+  end
+
+  def test_contains
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_CONTAINS_ONE_OF',
+           'valueToMatch' => { 'type' => 'string_list', 'value' => ['admin'] } }],
+        'string', 'yes'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+    ])
+    assert_equal 'yes', evaluate(cfg, { user: { email: 'admin@x.com' } }).unwrapped_value
+    assert_equal 'no', evaluate(cfg, { user: { email: 'b@x.com' } }).unwrapped_value
+  end
+
+  # ------ PROP_MATCHES / DOES_NOT_MATCH ------
+
+  def test_prop_matches
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_MATCHES',
+           'valueToMatch' => { 'type' => 'string', 'value' => '^admin' } }],
+        'string', 'yes'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+    ])
+    assert_equal 'yes', evaluate(cfg, { user: { email: 'admin-foo' } }).unwrapped_value
+    assert_equal 'no', evaluate(cfg, { user: { email: 'foo' } }).unwrapped_value
+  end
+
+  # ------ HIERARCHICAL_MATCH ------
+
+  def test_hierarchical_match
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'team.path', 'operator' => 'HIERARCHICAL_MATCH',
+           'valueToMatch' => { 'type' => 'string', 'value' => 'orgs/a' } }],
+        'string', 'yes'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+    ])
+    assert_equal 'yes', evaluate(cfg, { team: { path: 'orgs/a/team1' } }).unwrapped_value
+    assert_equal 'no',  evaluate(cfg, { team: { path: 'orgs/b/team1' } }).unwrapped_value
+  end
+
+  # ------ IN_INT_RANGE ------
+
+  def test_in_int_range
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.age', 'operator' => 'IN_INT_RANGE',
+           'valueToMatch' => { 'type' => 'int_range', 'value' => { 'start' => 18, 'end' => 30 } } }],
+        'string', 'yes'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+    ])
+    assert_equal 'yes', evaluate(cfg, { user: { age: 20 } }).unwrapped_value
+    assert_equal 'no',  evaluate(cfg, { user: { age: 30 } }).unwrapped_value  # end exclusive
+    assert_equal 'yes', evaluate(cfg, { user: { age: 18 } }).unwrapped_value  # start inclusive
+  end
+
+  # ------ NUMERIC COMPARISONS ------
+
+  def test_prop_greater_than_lt_etc
+    %w[PROP_GREATER_THAN PROP_GREATER_THAN_OR_EQUAL PROP_LESS_THAN PROP_LESS_THAN_OR_EQUAL].each do |op|
+      cfg = build_config([
+        value_match_rule(
+          [{ 'propertyName' => 'user.age', 'operator' => op,
+             'valueToMatch' => { 'type' => 'int', 'value' => 10 } }],
+          'string', 'yes'
+        ),
+        value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+      ])
+      expected = case op
+                 when 'PROP_GREATER_THAN' then { 9 => 'no', 10 => 'no', 11 => 'yes' }
+                 when 'PROP_GREATER_THAN_OR_EQUAL' then { 9 => 'no', 10 => 'yes', 11 => 'yes' }
+                 when 'PROP_LESS_THAN' then { 9 => 'yes', 10 => 'no', 11 => 'no' }
+                 when 'PROP_LESS_THAN_OR_EQUAL' then { 9 => 'yes', 10 => 'yes', 11 => 'no' }
+                 end
+      expected.each do |age, want|
+        assert_equal want, evaluate(cfg, { user: { age: age } }).unwrapped_value,
+                     "op=#{op} age=#{age}"
+      end
+    end
+  end
+
+  # ------ DATE COMPARISONS (BEFORE / AFTER) ------
+
+  def test_prop_before_after
+    cfg_before = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.created_at', 'operator' => 'PROP_BEFORE',
+           'valueToMatch' => { 'type' => 'string', 'value' => '2025-01-01T00:00:00Z' } }],
+        'string', 'yes'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+    ])
+    assert_equal 'yes', evaluate(cfg_before, { user: { created_at: '2024-06-01T00:00:00Z' } }).unwrapped_value
+    assert_equal 'no',  evaluate(cfg_before, { user: { created_at: '2025-06-01T00:00:00Z' } }).unwrapped_value
+  end
+
+  # ------ SEMVER COMPARISONS ------
+
+  def test_semver_eq_gt_lt
+    [
+      ['PROP_SEMVER_EQUAL',        '1.2.3', '1.2.3', 'yes'],
+      ['PROP_SEMVER_EQUAL',        '1.2.4', '1.2.3', 'no'],
+      ['PROP_SEMVER_GREATER_THAN', '1.2.4', '1.2.3', 'yes'],
+      ['PROP_SEMVER_GREATER_THAN', '1.2.3', '1.2.4', 'no'],
+      ['PROP_SEMVER_LESS_THAN',    '1.2.2', '1.2.3', 'yes'],
+      ['PROP_SEMVER_LESS_THAN',    '1.2.4', '1.2.3', 'no']
+    ].each do |op, context_ver, match_ver, want|
+      cfg = build_config([
+        value_match_rule(
+          [{ 'propertyName' => 'app.version', 'operator' => op,
+             'valueToMatch' => { 'type' => 'string', 'value' => match_ver } }],
+          'string', 'yes'
+        ),
+        value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'no')
+      ])
+      assert_equal want, evaluate(cfg, { app: { version: context_ver } }).unwrapped_value,
+                   "op=#{op} ctx=#{context_ver} match=#{match_ver}"
+    end
+  end
+
+  # ------ IN_SEG / NOT_IN_SEG ------
+
+  def test_in_seg_resolves_via_store
+    segment = build_config([
+      value_match_rule(
+        [{ 'propertyName' => 'user.email', 'operator' => 'PROP_IS_ONE_OF',
+           'valueToMatch' => { 'type' => 'string_list', 'value' => ['ok@x.com'] } }],
+        'bool', true
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'bool', false)
+    ], key: 'seg.key', value_type: 'bool')
+
+    cfg = build_config([
+      value_match_rule(
+        [{ 'propertyName' => '', 'operator' => 'IN_SEG',
+           'valueToMatch' => { 'type' => 'string', 'value' => 'seg.key' } }],
+        'string', 'in'
+      ),
+      value_match_rule([{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'out')
+    ])
+
+    extra = { 'seg.key' => segment }
+    assert_equal 'in',  evaluate(cfg, { user: { email: 'ok@x.com' } }, extra_configs: extra).unwrapped_value
+    assert_equal 'out', evaluate(cfg, { user: { email: 'no@x.com' } }, extra_configs: extra).unwrapped_value
+  end
+
+  # ------ ENVIRONMENT-SPECIFIC RULES ------
+
+  def test_environment_rules_precede_default
+    env_rule = value_match_rule(
+      [{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'from-env'
+    )
+    default_rule = value_match_rule(
+      [{ 'operator' => 'ALWAYS_TRUE' }], 'string', 'from-default'
+    )
+    cfg = build_config(
+      [default_rule],
+      environment: { 'id' => 'Production', 'rules' => [env_rule] }
+    )
+    # default evaluator has no envID set, so falls back to default rules
+    assert_equal 'from-default', evaluate(cfg).unwrapped_value
+
+    store = Quonfig::ConfigStore.new
+    store.set(cfg[:key], cfg)
+    evaluator = Quonfig::Evaluator.new(store, env_id: 'Production')
+    resolver = Quonfig::Resolver.new(store, evaluator)
+    result = resolver.get(cfg[:key], Quonfig::Context.new({}))
+    assert_equal 'from-env', result.unwrapped_value
+  end
+end

data/test/test_exponential_backoff.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestExponentialBackoff < Minitest::Test
+  def test_backoff
+    backoff = Quonfig::ExponentialBackoff.new(max_delay: 120)
+
+    assert_equal 2, backoff.call
+    assert_equal 4, backoff.call
+    assert_equal 8, backoff.call
+    assert_equal 16, backoff.call
+    assert_equal 32, backoff.call
+    assert_equal 64, backoff.call
+    assert_equal 120, backoff.call
+    assert_equal 120, backoff.call
+  end
+
+  def test_backoff_with_15x_multiplier_matches_quonfig_spec
+    # Spec: initial 8s, multiplier 1.5, max 600s (matches sdk-node reporter.ts)
+    backoff = Quonfig::ExponentialBackoff.new(
+      initial_delay: 8, max_delay: 600, multiplier: 1.5
+    )
+
+    assert_equal 8, backoff.call
+    assert_equal 12.0, backoff.call
+    assert_equal 18.0, backoff.call
+    assert_equal 27.0, backoff.call
+    assert_equal 40.5, backoff.call
+    assert_equal 60.75, backoff.call
+  end
+
+  def test_periodic_sync_default_matches_quonfig_spec
+    mod = Class.new { include Quonfig::PeriodicSync }.new
+    interval = mod.send(:calculate_sync_interval, nil)
+
+    # Spec: initial 8s, multiplier 1.5, max 600s
+    assert_equal 8, interval.call
+    assert_equal 12.0, interval.call
+    assert_equal 18.0, interval.call
+    assert_equal 27.0, interval.call
+    assert_equal 40.5, interval.call
+  end
+end

data/test/test_fixed_size_hash.rb

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

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

@@ -0,0 +1,79 @@
+# 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-0.1.0', 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_telemetry_url_env
+      with_env('QUONFIG_TELEMETRY_URL', 'https://override-telemetry.example.com') do
+        assert_equal 'https://override-telemetry.example.com',
+                     Options.new.telemetry_destination
+      end
+    end
+
+    def test_telemetry_destination_default
+      assert_equal 'https://telemetry.quonfig.com', Options.new.telemetry_destination
+    end
+  end
+end

data/test/test_internal_logger.rb

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