quonfig 0.0.2

data/test/test_client.rb

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'ostruct'
+require 'json'
+
+class TestConfigLoader < Minitest::Test
+  def setup
+    super
+    options = Quonfig::Options.new(
+      sdk_key: '1-test-sdk-key',
+      api_urls: ['https://primary.example.test']
+    )
+    @loader = Quonfig::ConfigLoader.new(MockBaseClient.new(options))
+  end
+
+  def test_fetch_200_populates_configs_and_stores_etag_then_304_is_a_noop
+    body = JSON.generate(
+      'configs' => [
+        { 'key' => 'my.flag', 'type' => 'config', 'valueType' => 'bool',
+          'default' => { 'rules' => [] } }
+      ],
+      'meta' => { 'version' => 'v1', 'environment' => 'production' }
+    )
+    ok_response = Faraday::Response.new(
+      status: 200, body: body,
+      response_headers: { 'ETag' => 'W/"etag-one"' }
+    )
+    not_modified = Faraday::Response.new(
+      status: 304, body: '', response_headers: {}
+    )
+
+    observed_headers = []
+
+    http_conn = Minitest::Mock.new
+    http_conn.expect(:get, ok_response) do |path, headers|
+      observed_headers << headers.dup
+      path == '/api/v2/configs' && !headers.key?('If-None-Match')
+    end
+    http_conn.expect(:get, not_modified) do |path, headers|
+      observed_headers << headers.dup
+      path == '/api/v2/configs' && headers['If-None-Match'] == 'W/"etag-one"'
+    end
+
+    Quonfig::HttpConnection.stub :new, ->(_uri, _key) { http_conn } do
+      assert_equal :updated, @loader.fetch!
+      assert_equal :not_modified, @loader.fetch!
+    end
+
+    assert_equal 'W/"etag-one"', @loader.etag
+    calc = @loader.calc_config
+    assert calc.key?('my.flag'), "expected 'my.flag' to be loaded"
+    assert_equal 'W/"etag-one"', observed_headers[1]['If-None-Match']
+    http_conn.verify
+  end
+
+  def test_set_and_rm_preserved
+    config = OpenStruct.new(key: 'x', rows: [1])
+    @loader.set(config, :test)
+    assert @loader.calc_config.key?('x')
+
+    @loader.rm('x')
+    refute @loader.calc_config.key?('x')
+  end
+
+  def test_no_highwater_mark_attribute
+    refute @loader.respond_to?(:highwater_mark),
+           'highwater_mark should be removed from ConfigLoader'
+  end
+end

data/test/test_context.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestContext < Minitest::Test
+  EXAMPLE_PROPERTIES = {
+    user: { key: 'some-user-key', name: 'Ted' },
+    team: { key: 'abc', plan: 'pro' }
+  }.freeze
+
+  def test_initialize_with_empty_context
+    context = Quonfig::Context.new({})
+    assert_empty context.contexts
+    assert context.blank?
+  end
+
+  def test_initialize_with_hash
+    context = Quonfig::Context.new(test: { foo: 'bar' })
+    assert_equal 1, context.contexts.size
+    assert_equal 'bar', context.get('test.foo')
+  end
+
+  def test_initialize_with_multiple_hashes
+    context = Quonfig::Context.new(test: { foo: 'bar' }, other: { foo: 'baz' })
+    assert_equal 2, context.contexts.size
+    assert_equal 'bar', context.get('test.foo')
+    assert_equal 'baz', context.get('other.foo')
+  end
+
+  def test_initialize_with_invalid_argument
+    assert_raises(ArgumentError) { Quonfig::Context.new([]) }
+  end
+
+  def test_setting
+    context = Quonfig::Context.new({})
+    context.set('user', { key: 'value' })
+    context.set(:other, { key: 'different', something: 'other' })
+
+    assert_equal(
+      stringify(user: { key: 'value' }, other: { key: 'different', something: 'other' }),
+      context.to_h
+    )
+  end
+
+  def test_getting
+    context = Quonfig::Context.new(EXAMPLE_PROPERTIES)
+    assert_equal('some-user-key', context.get('user.key'))
+    assert_equal('pro', context.get('team.plan'))
+  end
+
+  def test_dot_notation_getting
+    context = Quonfig::Context.new('user' => { 'key' => 'value' })
+    assert_equal('value', context.get('user.key'))
+  end
+
+  def test_dot_notation_getting_with_symbols
+    context = Quonfig::Context.new(user: { key: 'value' })
+    assert_equal('value', context.get('user.key'))
+  end
+
+  def test_get_returns_nil_for_missing_property
+    context = Quonfig::Context.new(user: { key: 'value' })
+    assert_nil context.get('user.missing')
+    assert_nil context.get('absent.key')
+  end
+
+  def test_clear
+    context = Quonfig::Context.new(EXAMPLE_PROPERTIES)
+    context.clear
+
+    assert_empty context.to_h
+    assert context.blank?
+  end
+
+  def test_to_h_stringifies_keys
+    context = Quonfig::Context.new(EXAMPLE_PROPERTIES)
+    assert_equal stringify(EXAMPLE_PROPERTIES), context.to_h
+  end
+
+  def test_legacy_flat_hash_shorthand_promotes_to_blank_named_context
+    # Pre-named-contexts callers passed a flat Hash. The constructor still
+    # accepts that shape and stuffs it under the empty-string named context.
+    context = Quonfig::Context.new('foo' => 'bar')
+    assert_equal 'bar', context.get('.foo')
+  end
+
+  def test_grouped_key_combines_named_contexts_by_key
+    context = Quonfig::Context.new(
+      user: { key: 'u1' },
+      team: { key: 't1' }
+    )
+
+    assert_equal 'team:t1|user:u1', context.grouped_key
+  end
+
+  def test_named_context_lookup_returns_namedcontext
+    context = Quonfig::Context.new(user: { key: 'u1', name: 'Ted' })
+    user = context.context('user')
+
+    assert_kind_of Quonfig::Context::NamedContext, user
+    assert_equal 'user', user.name
+    assert_equal({ 'key' => 'u1', 'name' => 'Ted' }, user.to_h)
+  end
+
+  def test_named_context_lookup_for_missing_returns_empty_namedcontext
+    context = Quonfig::Context.new(user: { key: 'u1' })
+    missing = context.context('absent')
+
+    assert_kind_of Quonfig::Context::NamedContext, missing
+    assert_equal 'absent', missing.name
+    assert_empty missing.to_h
+  end
+
+  def test_comparable
+    a = Quonfig::Context.new(user: { key: 'u1' })
+    b = Quonfig::Context.new(user: { key: 'u1' })
+    c = Quonfig::Context.new(user: { key: 'u2' })
+
+    assert_equal a, b
+    refute_equal a, c
+  end
+
+  private
+
+  def stringify(hash)
+    hash.map { |k, v| [k.to_s, stringify_keys(v)] }.to_h
+  end
+
+  def stringify_keys(value)
+    if value.is_a?(Hash)
+      value.transform_keys(&:to_s)
+    else
+      value
+    end
+  end
+end

data/test/test_datadir.rb

@@ -0,0 +1,199 @@
+# 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(ArgumentError) { Quonfig::Datadir.load_envelope(@tmpdir, nil) }
+    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(ArgumentError) { Quonfig::Datadir.load_envelope(@tmpdir, 'NotAnEnv') }
+    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_duration.rb

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