quonfig 0.0.10 → 0.0.12

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_details_getters.rb

@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# Coverage for the *_details getters on Quonfig::Client and Quonfig::BoundClient.
-# These return Quonfig::EvaluationDetails carrying an OpenFeature-aligned
-# +reason+ and (on the error path) error_code / error_message. They never raise.
-class TestDetailsGetters < Minitest::Test
-  Details = Quonfig::EvaluationDetails
-
-  INTEGRATION_FIXTURE_DIR = File.expand_path(
-    '../../integration-test-data/data/integration-tests', __dir__
-  )
-
-  # ---- Helpers --------------------------------------------------------
-
-  def fixture_client
-    skip "integration-test-data sibling missing at #{INTEGRATION_FIXTURE_DIR}" unless Dir.exist?(INTEGRATION_FIXTURE_DIR)
-
-    Quonfig::Client.new(
-      Quonfig::Options.new(
-        datadir: INTEGRATION_FIXTURE_DIR,
-        environment: 'Production',
-        enable_sse: false,
-        enable_polling: false
-      )
-    )
-  end
-
-  # An ALWAYS_TRUE-only config: no targeting rules anywhere -> STATIC.
-  def make_static_config(key:, value:, type:)
-    {
-      'id' => '1',
-      'key' => key,
-      'type' => 'config',
-      'valueType' => type,
-      'sendToClientSdk' => false,
-      'default' => {
-        'rules' => [
-          {
-            'criteria' => [{ 'operator' => 'ALWAYS_TRUE' }],
-            'value' => { 'type' => type, 'value' => value }
-          }
-        ]
-      },
-      'environment' => nil
-    }
-  end
-
-  def static_client(key:, value:, type:)
-    store = Quonfig::ConfigStore.new
-    store.set(key, make_static_config(key: key, value: value, type: type))
-    Quonfig::Client.new(Quonfig::Options.new, store: store)
-  end
-
-  # ---- STATIC reason --------------------------------------------------
-
-  def test_get_bool_details_static_reason_for_always_true_only_config
-    client = static_client(key: 'plain', value: true, type: 'bool')
-    details = client.get_bool_details('plain')
-    assert_kind_of Details, details
-    assert_equal true, details.value
-    assert_equal Details::REASON_STATIC, details.reason
-    assert_nil details.error_code
-    assert_nil details.error_message
-  end
-
-  def test_get_string_details_static_reason
-    client = static_client(key: 'plain.s', value: 'hi', type: 'string')
-    details = client.get_string_details('plain.s')
-    assert_equal 'hi', details.value
-    assert_equal Details::REASON_STATIC, details.reason
-  end
-
-  def test_static_reason_via_integration_fixture_always_true
-    client = fixture_client
-    details = client.get_bool_details('always.true')
-    assert_equal true, details.value
-    assert_equal Details::REASON_STATIC, details.reason
-  ensure
-    client&.stop
-  end
-
-  # ---- TARGETING_MATCH reason ----------------------------------------
-
-  def test_targeting_match_reason_via_integration_fixture
-    client = fixture_client
-    details = client.get_bool_details('of.targeting', context: { 'user' => { 'plan' => 'pro' } })
-    assert_equal true, details.value
-    assert_equal Details::REASON_TARGETING_MATCH, details.reason
-  ensure
-    client&.stop
-  end
-
-  def test_targeting_match_falls_through_to_default_branch_still_targeting
-    # The of.targeting fixture has a property-match rule + an ALWAYS_TRUE
-    # fallback. Even when the fallback wins, the *config* has targeting rules,
-    # so wire_reason / of_reason returns TARGETING_MATCH.
-    client = fixture_client
-    details = client.get_bool_details('of.targeting', context: { 'user' => { 'plan' => 'free' } })
-    assert_equal false, details.value
-    assert_equal Details::REASON_TARGETING_MATCH, details.reason
-  ensure
-    client&.stop
-  end
-
-  # ---- SPLIT reason ---------------------------------------------------
-
-  def test_split_reason_via_integration_fixture
-    client = fixture_client
-    # Pick a deterministic targetingKey so the outcome is reproducible.
-    details = client.get_string_details('of.weighted', context: { 'user' => { 'id' => 'user-123' } })
-    assert_equal Details::REASON_SPLIT, details.reason
-    assert_includes %w[variant-a variant-b], details.value
-  ensure
-    client&.stop
-  end
-
-  # ---- DEFAULT reason -------------------------------------------------
-
-  def test_default_reason_when_no_rule_matches
-    # Config exists but no rule matches against the empty context.
-    config = {
-      'id' => '9',
-      'key' => 'no.match.here',
-      'type' => 'config',
-      'valueType' => 'string',
-      'sendToClientSdk' => false,
-      'default' => {
-        'rules' => [
-          {
-            'criteria' => [
-              {
-                'propertyName' => 'user.plan',
-                'operator' => 'PROP_IS_ONE_OF',
-                'valueToMatch' => { 'type' => 'string_list', 'value' => ['enterprise'] }
-              }
-            ],
-            'value' => { 'type' => 'string', 'value' => 'gold' }
-          }
-        ]
-      },
-      'environment' => nil
-    }
-    store = Quonfig::ConfigStore.new
-    store.set('no.match.here', config)
-    client = Quonfig::Client.new(Quonfig::Options.new, store: store)
-
-    details = client.get_string_details('no.match.here')
-    assert_nil details.value
-    assert_equal Details::REASON_DEFAULT, details.reason
-    assert_nil details.error_code
-  end
-
-  # ---- ERROR / FLAG_NOT_FOUND ----------------------------------------
-
-  def test_flag_not_found_returns_error_details
-    client = Quonfig::Client.new(Quonfig::Options.new, store: Quonfig::ConfigStore.new)
-    details = client.get_bool_details('does.not.exist')
-    assert_nil details.value
-    assert_equal Details::REASON_ERROR, details.reason
-    assert_equal Details::ERROR_FLAG_NOT_FOUND, details.error_code
-    refute_nil details.error_message
-  end
-
-  def test_flag_not_found_for_string_details
-    client = Quonfig::Client.new(Quonfig::Options.new, store: Quonfig::ConfigStore.new)
-    details = client.get_string_details('nope')
-    assert_equal Details::REASON_ERROR, details.reason
-    assert_equal Details::ERROR_FLAG_NOT_FOUND, details.error_code
-  end
-
-  # ---- ERROR / TYPE_MISMATCH -----------------------------------------
-
-  def test_type_mismatch_for_int_when_value_is_string
-    client = static_client(key: 'wrong.type', value: 'oops', type: 'string')
-    details = client.get_int_details('wrong.type')
-    assert_nil details.value
-    assert_equal Details::REASON_ERROR, details.reason
-    assert_equal Details::ERROR_TYPE_MISMATCH, details.error_code
-    refute_nil details.error_message
-  end
-
-  def test_type_mismatch_for_bool_when_value_is_string
-    client = static_client(key: 'bool.miss', value: 'true', type: 'string')
-    details = client.get_bool_details('bool.miss')
-    assert_equal Details::REASON_ERROR, details.reason
-    assert_equal Details::ERROR_TYPE_MISMATCH, details.error_code
-  end
-
-  def test_type_mismatch_for_string_list_when_value_is_string
-    client = static_client(key: 'list.miss', value: 'a,b', type: 'string')
-    details = client.get_string_list_details('list.miss')
-    assert_equal Details::REASON_ERROR, details.reason
-    assert_equal Details::ERROR_TYPE_MISMATCH, details.error_code
-  end
-
-  # ---- json passes through unchanged ---------------------------------
-
-  def test_get_json_details_returns_hash_with_static_reason
-    payload = { 'a' => 1, 'b' => [1, 2] }
-    client = static_client(key: 'shape', value: payload, type: 'json')
-    details = client.get_json_details('shape')
-    assert_equal payload, details.value
-    assert_equal Details::REASON_STATIC, details.reason
-  end
-
-  # ---- Float / Int success path -------------------------------------
-
-  def test_get_int_details_static_reason
-    client = static_client(key: 'i', value: 42, type: 'int')
-    details = client.get_int_details('i')
-    assert_equal 42, details.value
-    assert_equal Details::REASON_STATIC, details.reason
-  end
-
-  def test_get_float_details_static_reason
-    client = static_client(key: 'f', value: 3.14, type: 'double')
-    details = client.get_float_details('f')
-    assert_in_delta 3.14, details.value, 1e-9
-    assert_equal Details::REASON_STATIC, details.reason
-  end
-
-  def test_get_string_list_details_static_reason
-    client = static_client(key: 'sl', value: %w[a b], type: 'string_list')
-    details = client.get_string_list_details('sl')
-    assert_equal %w[a b], details.value
-    assert_equal Details::REASON_STATIC, details.reason
-  end
-
-  # ---- BoundClient mirror --------------------------------------------
-
-  def test_bound_client_get_bool_details_passes_context
-    client = fixture_client
-    bound = client.in_context('user' => { 'plan' => 'pro' })
-    details = bound.get_bool_details('of.targeting')
-    assert_equal true, details.value
-    assert_equal Details::REASON_TARGETING_MATCH, details.reason
-  ensure
-    client&.stop
-  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