quonfig 0.0.9 → 0.0.11

data/test/test_datadir.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'json'
-require 'tmpdir'
-require 'fileutils'
-
-# qfg-dk6.18 — Quonfig::Datadir loads JSON config files from a workspace
-# directory and produces a ConfigEnvelope (and a populated ConfigStore) for
-# offline / datadir mode. Mirrors sdk-node/src/datadir.ts.
-class TestDatadir < Minitest::Test
-  CONFIG_SUBDIRS = %w[configs feature-flags segments schemas log-levels].freeze
-
-  def setup
-    @tmpdir = Dir.mktmpdir('quonfig-datadir-test')
-    CONFIG_SUBDIRS.each { |sub| FileUtils.mkdir_p(File.join(@tmpdir, sub)) }
-    File.write(File.join(@tmpdir, 'quonfig.json'), JSON.generate({ environments: %w[Production Staging] }))
-  end
-
-  def teardown
-    FileUtils.remove_entry(@tmpdir) if @tmpdir && Dir.exist?(@tmpdir)
-    ENV.delete('QUONFIG_ENVIRONMENT')
-  end
-
-  def write_config(subdir, filename, body)
-    File.write(File.join(@tmpdir, subdir, filename), JSON.generate(body))
-  end
-
-  def sample_config(key, environment_id: 'Production')
-    {
-      'id' => '111',
-      'key' => key,
-      'type' => 'config',
-      'valueType' => 'string',
-      'sendToClientSdk' => false,
-      'default' => { 'rules' => [{ 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }], 'value' => { 'type' => 'string', 'value' => 'hello' } }] },
-      'environments' => [{ 'id' => environment_id, 'rules' => [{ 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }], 'value' => { 'type' => 'string', 'value' => 'env-hello' } }] }]
-    }
-  end
-
-  def sample_flag(key)
-    {
-      'id' => '222',
-      'key' => key,
-      'type' => 'feature_flag',
-      'valueType' => 'bool',
-      'default' => { 'rules' => [{ 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }], 'value' => { 'type' => 'bool', 'value' => false } }] },
-      'environments' => []
-    }
-  end
-
-  def test_load_envelope_returns_config_envelope
-    write_config('configs', 'a.config.json', sample_config('a.config'))
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    assert_instance_of Quonfig::ConfigEnvelope, envelope
-  end
-
-  def test_load_envelope_reads_configs_from_each_subdir
-    write_config('configs', 'a.config.json', sample_config('a.config'))
-    write_config('feature-flags', 'b.flag.json', sample_flag('b.flag'))
-    write_config('log-levels', 'c.log.json', sample_config('c.log'))
-    write_config('segments', 'd.segment.json', sample_config('d.segment'))
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    keys = envelope.configs.map { |c| c['key'] }
-    assert_equal %w[a.config c.log d.segment b.flag].sort, keys.sort
-  end
-
-  def test_load_envelope_skips_non_json_and_missing_subdirs
-    write_config('configs', 'a.config.json', sample_config('a.config'))
-    File.write(File.join(@tmpdir, 'configs', 'README.md'), '# ignore me')
-    FileUtils.rm_rf(File.join(@tmpdir, 'segments'))
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    keys = envelope.configs.map { |c| c['key'] }
-    assert_equal ['a.config'], keys
-  end
-
-  def test_load_envelope_picks_environment_block_by_id
-    write_config('configs', 'a.config.json', sample_config('a.config', environment_id: 'Production'))
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    cfg = envelope.configs.first
-    refute_nil cfg['environment'], 'expected environment field to be populated'
-    assert_equal 'Production', cfg['environment']['id']
-  end
-
-  def test_load_envelope_environment_field_nil_when_no_match
-    write_config('configs', 'a.config.json', sample_config('a.config', environment_id: 'Other'))
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    cfg = envelope.configs.first
-    assert_nil cfg['environment']
-  end
-
-  def test_load_envelope_send_to_client_sdk_true_for_feature_flag
-    write_config('feature-flags', 'b.flag.json', sample_flag('b.flag'))
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    cfg = envelope.configs.first
-    assert_equal true, cfg['sendToClientSdk'], 'feature_flag must always sendToClientSdk=true'
-  end
-
-  def test_load_envelope_default_rules_when_missing
-    raw = sample_config('a.config')
-    raw.delete('default')
-    write_config('configs', 'a.config.json', raw)
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    cfg = envelope.configs.first
-    assert_equal({ 'rules' => [] }, cfg['default'])
-  end
-
-  def test_load_envelope_meta_includes_version_and_environment
-    write_config('configs', 'a.config.json', sample_config('a.config'))
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    assert_equal "datadir:#{@tmpdir}", envelope.meta['version']
-    assert_equal 'Production', envelope.meta['environment']
-  end
-
-  def test_resolve_environment_from_env_var
-    write_config('configs', 'a.config.json', sample_config('a.config'))
-    ENV['QUONFIG_ENVIRONMENT'] = 'Production'
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, nil)
-
-    assert_equal 'Production', envelope.meta['environment']
-  end
-
-  def test_constructor_environment_supersedes_env_var
-    write_config('configs', 'a.config.json', sample_config('a.config'))
-    ENV['QUONFIG_ENVIRONMENT'] = 'Staging'
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'Production')
-
-    assert_equal 'Production', envelope.meta['environment']
-  end
-
-  def test_raises_when_no_environment
-    err = assert_raises(Quonfig::Errors::MissingEnvironmentError) do
-      Quonfig::Datadir.load_envelope(@tmpdir, nil)
-    end
-    assert_match(/Environment required for datadir mode/, err.message)
-  end
-
-  def test_raises_when_quonfig_json_missing
-    File.delete(File.join(@tmpdir, 'quonfig.json'))
-
-    err = assert_raises(ArgumentError) { Quonfig::Datadir.load_envelope(@tmpdir, 'Production') }
-    assert_match(/missing quonfig\.json/, err.message)
-  end
-
-  def test_raises_when_environment_not_in_workspace
-    err = assert_raises(Quonfig::Errors::InvalidEnvironmentError) do
-      Quonfig::Datadir.load_envelope(@tmpdir, 'NotAnEnv')
-    end
-    assert_match(/Environment "NotAnEnv" not found/, err.message)
-    assert_match(/Production/, err.message)
-  end
-
-  def test_allows_any_environment_when_quonfig_json_environments_empty
-    File.write(File.join(@tmpdir, 'quonfig.json'), JSON.generate({ environments: [] }))
-    write_config('configs', 'a.config.json', sample_config('a.config'))
-
-    envelope = Quonfig::Datadir.load_envelope(@tmpdir, 'AnythingGoes')
-
-    assert_equal 'AnythingGoes', envelope.meta['environment']
-  end
-
-  def test_load_store_returns_populated_config_store
-    write_config('configs', 'a.config.json', sample_config('a.config'))
-    write_config('feature-flags', 'b.flag.json', sample_flag('b.flag'))
-
-    store = Quonfig::Datadir.load_store(@tmpdir, 'Production')
-
-    assert_instance_of Quonfig::ConfigStore, store
-    assert_equal %w[a.config b.flag].sort, store.keys.sort
-    assert_equal 'a.config', store.get('a.config')['key']
-  end
-
-  # Verification against the real integration-test-data fixture (path-based).
-  # Skips when the sibling repo is not present (e.g. limited CI checkouts).
-  def test_load_store_with_integration_test_data_fixture
-    fixture = File.expand_path('../../integration-test-data/data/integration-tests', __dir__)
-    skip "integration-test-data not present at #{fixture}" unless Dir.exist?(fixture)
-
-    store = Quonfig::Datadir.load_store(fixture, 'Production')
-
-    refute_empty store.keys, 'expected at least one config key from integration-test-data'
-    assert(store.keys.any? { |k| k.start_with?('a.') } || store.keys.include?('already.in.use'),
-           "expected to find familiar fixture keys; got: #{store.keys.first(5).inspect}")
-  end
-end

data/test/test_dev_context.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'json'
-require 'tmpdir'
-require 'fileutils'
-
-# qfg-pj0.5 — Dev-context injection. When enable_quonfig_user_context: true
-# (or env var QUONFIG_DEV_CONTEXT=true), the SDK reads ~/.quonfig/tokens.json
-# (written by `qfg login`) and merges {'quonfig-user' => {'email' => ...}}
-# into globalContext. Customer-supplied keys win on collision.
-#
-# Mirror of sdk-node qfg-pj0.3 / sdk-go qfg-pj0.4.
-class TestDevContext < Minitest::Test
-  def setup
-    super
-    @tmphome = Dir.mktmpdir('quonfig-dev-ctx-')
-    FileUtils.mkdir_p(File.join(@tmphome, '.quonfig'))
-    @old_home = ENV.fetch('HOME', nil)
-    ENV['HOME'] = @tmphome
-    ENV.delete('QUONFIG_DEV_CONTEXT')
-  end
-
-  def teardown
-    ENV['HOME'] = @old_home
-    ENV.delete('QUONFIG_DEV_CONTEXT')
-    FileUtils.remove_entry(@tmphome) if @tmphome && Dir.exist?(@tmphome)
-    super
-  end
-
-  def write_tokens(payload)
-    File.write(File.join(@tmphome, '.quonfig', 'tokens.json'), JSON.generate(payload))
-  end
-
-  def global_context_of(client)
-    client.instance_variable_get(:@global_context)
-  end
-
-  # 1. RED: injects quonfig-user.email when option enabled and file exists
-  def test_injects_quonfig_user_email_when_option_enabled
-    write_tokens(userEmail: 'bob@foo.com', accessToken: 'x', refreshToken: 'y', expiresAt: 0)
-
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(enable_quonfig_user_context: true),
-      store: Quonfig::ConfigStore.new
-    )
-
-    assert_equal({ 'quonfig-user' => { 'email' => 'bob@foo.com' } }, global_context_of(client))
-  end
-
-  # 2. RED: no-op when option disabled and no env var
-  def test_no_op_when_option_disabled
-    write_tokens(userEmail: 'bob@foo.com')
-
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(global_context: { user: { 'plan' => 'pro' } }),
-      store: Quonfig::ConfigStore.new
-    )
-
-    assert_equal({ user: { 'plan' => 'pro' } }, global_context_of(client))
-  end
-
-  # 3. RED: no-op when option enabled but file missing
-  def test_no_op_when_file_missing
-    # No tokens.json written.
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(
-        enable_quonfig_user_context: true,
-        global_context: { user: { 'plan' => 'pro' } }
-      ),
-      store: Quonfig::ConfigStore.new
-    )
-
-    assert_equal({ user: { 'plan' => 'pro' } }, global_context_of(client))
-  end
-
-  # 4. RED: no-op when file unparseable; warning emitted; init succeeds
-  def test_no_op_when_file_unparseable
-    File.write(File.join(@tmphome, '.quonfig', 'tokens.json'), '{not valid json')
-
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(enable_quonfig_user_context: true),
-      store: Quonfig::ConfigStore.new
-    )
-
-    assert_equal({}, global_context_of(client))
-    # The dev-context loader emits a warning to stderr that we want to verify.
-    assert_stderr(['quonfig'])
-  end
-
-  # 5. RED: customer-supplied quonfig-user keys win on collision
-  def test_customer_global_context_wins
-    write_tokens(userEmail: 'bob@foo.com')
-
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(
-        enable_quonfig_user_context: true,
-        global_context: { 'quonfig-user' => { 'email' => 'override@x.com' } }
-      ),
-      store: Quonfig::ConfigStore.new
-    )
-
-    assert_equal({ 'quonfig-user' => { 'email' => 'override@x.com' } }, global_context_of(client))
-  end
-
-  # 6. RED: env var QUONFIG_DEV_CONTEXT=true enables when option absent
-  def test_env_var_enables_when_option_absent
-    write_tokens(userEmail: 'bob@foo.com')
-    ENV['QUONFIG_DEV_CONTEXT'] = 'true'
-
-    client = Quonfig::Client.new(
-      Quonfig::Options.new,
-      store: Quonfig::ConfigStore.new
-    )
-
-    assert_equal({ 'quonfig-user' => { 'email' => 'bob@foo.com' } }, global_context_of(client))
-  end
-
-  # 7. RED: integration — rule keyed on quonfig-user.email fires when injected
-  def test_attribute_reaches_eval_context
-    write_tokens(userEmail: 'bob@foo.com')
-
-    flag_config = {
-      'id' => 'cfg-flag',
-      'key' => 'my-flag',
-      'type' => 'feature_flag',
-      'valueType' => 'bool',
-      'sendToClientSdk' => false,
-      'default' => {
-        'rules' => [
-          { 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }], 'value' => { 'type' => 'bool', 'value' => false } }
-        ]
-      },
-      'environment' => {
-        'id' => 'Production',
-        'rules' => [
-          {
-            'criteria' => [{
-              'propertyName' => 'quonfig-user.email',
-              'operator' => 'PROP_IS_ONE_OF',
-              'valueToMatch' => { 'type' => 'string_list', 'value' => ['bob@foo.com'] }
-            }],
-            'value' => { 'type' => 'bool', 'value' => true }
-          },
-          { 'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }], 'value' => { 'type' => 'bool', 'value' => false } }
-        ]
-      }
-    }
-
-    store = Quonfig::ConfigStore.new
-    store.set('my-flag', flag_config)
-
-    client = Quonfig::Client.new(
-      Quonfig::Options.new(
-        enable_quonfig_user_context: true,
-        environment: 'Production'
-      ),
-      store: store
-    )
-
-    assert_equal true, client.get_bool('my-flag')
-  end
-end

data/test/test_duration.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DurationTest < Minitest::Test
-  MINUTES_IN_SECONDS = 60
-  HOURS_IN_SECONDS = 60 * MINUTES_IN_SECONDS
-  DAYS_IN_SECONDS = 24 * HOURS_IN_SECONDS
-
-  TESTS = [
-    ['PT0M0S', 0],
-    ['PT6M', 6 * MINUTES_IN_SECONDS],
-    ['PT90S', 90],
-    ['P1D', DAYS_IN_SECONDS],
-    ['PT1.5M', 1.5 * MINUTES_IN_SECONDS],
-    ['P0.75D', 0.75 * DAYS_IN_SECONDS],
-    ['PT1M90.3S', MINUTES_IN_SECONDS + 90.3],
-    ['PT1H', HOURS_IN_SECONDS],
-    ['PT1.3H', 1.3 * HOURS_IN_SECONDS],
-    ['P1.5DT1.5M', 1.5 * DAYS_IN_SECONDS + MINUTES_IN_SECONDS * 1.5],
-    ['P1.5DT1.5H1.5M', 1.5 * DAYS_IN_SECONDS + 1.5 * HOURS_IN_SECONDS + MINUTES_IN_SECONDS * 1.5],
-    ['P1.5DT1.5H1.5M3.5S', 1.5 * DAYS_IN_SECONDS + 1.5 * HOURS_IN_SECONDS + MINUTES_IN_SECONDS * 1.5 + 3.5],
-    ['P1DT2H3M4S', DAYS_IN_SECONDS + 2 * HOURS_IN_SECONDS + 3 * MINUTES_IN_SECONDS + 4],
-    ['PT1H30M', HOURS_IN_SECONDS + 30 * MINUTES_IN_SECONDS],
-    ['P0.5DT0.25H', 0.5 * DAYS_IN_SECONDS + 0.25 * HOURS_IN_SECONDS],
-    ['PT15M30S', 15 * MINUTES_IN_SECONDS + 30],
-    ['PT0.000347222H', 0.000347222 * HOURS_IN_SECONDS],
-    ['PT23H59M59S', 23 * HOURS_IN_SECONDS + 59 * MINUTES_IN_SECONDS + 59],
-    ['P0.25DT3.75H', 0.25 * DAYS_IN_SECONDS + 3.75 * HOURS_IN_SECONDS],
-  ]
-
-  def test_parsing
-    TESTS.each do |test|
-      assert_equal test[1], Quonfig::Duration.parse(test[0]), "Failed parsing #{test[0]}"
-    end
-  end
-end

data/test/test_encryption.rb

@@ -1,16 +0,0 @@
-# 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_evaluation_summaries_aggregator.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestEvaluationSummariesAggregator < Minitest::Test
-  def make_aggregator(max_keys: 100)
-    Quonfig::Telemetry::EvaluationSummariesAggregator.new(max_keys: max_keys)
-  end
-
-  def record_eval(agg, overrides = {})
-    defaults = {
-      config_id: 'c1',
-      config_key: 'my-test-key',
-      config_type: 'config',
-      conditional_value_index: 0,
-      weighted_value_index: nil,
-      selected_value: 'hello',
-      reason: 1
-    }
-    agg.record(**defaults.merge(overrides))
-  end
-
-  def test_record_dedupes_identical_evaluations_into_one_counter
-    agg = make_aggregator
-
-    record_eval(agg)
-    record_eval(agg)
-    record_eval(agg)
-
-    event = agg.drain_event
-    refute_nil event
-    summaries = event['summaries']['summaries']
-    assert_equal 1, summaries.size
-
-    counters = summaries[0]['counters']
-    assert_equal 1, counters.size
-    assert_equal 3, counters[0]['count']
-  end
-
-  def test_record_creates_separate_counters_for_different_rule_indexes
-    agg = make_aggregator
-
-    record_eval(agg, conditional_value_index: 0)
-    record_eval(agg, conditional_value_index: 1)
-    record_eval(agg, conditional_value_index: 1)
-
-    summaries = agg.drain_event['summaries']['summaries']
-    assert_equal 1, summaries.size
-
-    counters = summaries[0]['counters']
-    assert_equal 2, counters.size
-
-    by_idx = counters.each_with_object({}) { |c, h| h[c['conditionalValueIndex']] = c['count'] }
-    assert_equal 1, by_idx[0]
-    assert_equal 2, by_idx[1]
-  end
-
-  def test_record_groups_by_config_key_and_type
-    agg = make_aggregator
-
-    record_eval(agg, config_key: 'alpha', config_type: 'config')
-    record_eval(agg, config_key: 'alpha', config_type: 'config')
-    record_eval(agg, config_key: 'beta',  config_type: 'feature_flag')
-
-    summaries = agg.drain_event['summaries']['summaries']
-    assert_equal 2, summaries.size
-
-    by_key = summaries.each_with_object({}) { |s, h| h[s['key']] = s }
-    assert_equal 'config',        by_key['alpha']['type']
-    assert_equal 'feature_flag',  by_key['beta']['type']
-    assert_equal 2, by_key['alpha']['counters'][0]['count']
-    assert_equal 1, by_key['beta']['counters'][0]['count']
-  end
-
-  def test_drain_event_nil_when_empty
-    agg = make_aggregator
-    assert_nil agg.drain_event
-  end
-
-  def test_drain_clears_state
-    agg = make_aggregator
-    record_eval(agg)
-
-    refute_nil agg.drain_event
-    assert_nil agg.drain_event, 'second drain with no new records should be nil'
-  end
-
-  def test_drain_event_wire_shape
-    agg = make_aggregator
-
-    record_eval(agg,
-                config_id: 'cid-42',
-                config_key: 'my-test-key',
-                config_type: 'config',
-                conditional_value_index: 1,
-                weighted_value_index: nil,
-                selected_value: 'my-test-value',
-                reason: 2)
-
-    event = agg.drain_event
-    refute_nil event
-    assert event.key?('summaries'), 'top-level event key is summaries'
-
-    inner = event['summaries']
-    assert_kind_of Integer, inner['start']
-    assert_kind_of Integer, inner['end']
-    assert inner['end'] >= inner['start']
-
-    summary = inner['summaries'][0]
-    assert_equal 'my-test-key', summary['key']
-    assert_equal 'config',      summary['type']
-
-    counter = summary['counters'][0]
-    assert_equal 'cid-42',         counter['configId']
-    assert_equal 1,                counter['conditionalValueIndex']
-    assert_equal 0,                counter['configRowIndex']
-    assert_equal 1,                counter['count']
-    assert_equal 2,                counter['reason']
-    assert_equal({ 'string' => 'my-test-value' }, counter['selectedValue'])
-    refute counter.key?('weightedValueIndex'),
-           'weightedValueIndex omitted when nil'
-  end
-
-  def test_selected_value_wrapper_keys_match_prefab_shape
-    agg = make_aggregator
-
-    record_eval(agg, selected_value: true,      conditional_value_index: 0)
-    record_eval(agg, selected_value: 3,         conditional_value_index: 1)
-    record_eval(agg, selected_value: 1.5,       conditional_value_index: 2)
-    record_eval(agg, selected_value: 'hi',      conditional_value_index: 3)
-    record_eval(agg, selected_value: %w[a b],   conditional_value_index: 4)
-
-    counters = agg.drain_event['summaries']['summaries'][0]['counters']
-    by_idx = counters.each_with_object({}) { |c, h| h[c['conditionalValueIndex']] = c['selectedValue'] }
-
-    assert_equal({ 'bool'       => true },  by_idx[0])
-    assert_equal({ 'int'        => 3 },     by_idx[1])
-    assert_equal({ 'double'     => 1.5 },   by_idx[2])
-    assert_equal({ 'string'     => 'hi' },  by_idx[3])
-    assert_equal({ 'stringList' => %w[a b] }, by_idx[4])
-  end
-
-  def test_weighted_value_index_included_when_present
-    agg = make_aggregator
-
-    record_eval(agg, weighted_value_index: 2, reason: 3)
-
-    counter = agg.drain_event['summaries']['summaries'][0]['counters'][0]
-    assert_equal 2, counter['weightedValueIndex']
-    assert_equal 3, counter['reason']
-  end
-
-  def test_log_level_evaluations_are_excluded
-    agg = make_aggregator
-
-    record_eval(agg, config_type: 'log_level')
-
-    assert_nil agg.drain_event
-  end
-
-  def test_record_caps_at_max_keys
-    agg = make_aggregator(max_keys: 2)
-
-    record_eval(agg, config_key: 'a')
-    record_eval(agg, config_key: 'b')
-    record_eval(agg, config_key: 'c') # dropped — at cap
-
-    summaries = agg.drain_event['summaries']['summaries']
-    keys = summaries.map { |s| s['key'] }.sort
-    assert_equal %w[a b], keys
-  end
-
-  def test_noop_when_max_keys_zero
-    agg = make_aggregator(max_keys: 0)
-
-    record_eval(agg)
-
-    assert_nil agg.drain_event
-  end
-end