dry-configurable 0.7.0 → 0.8.3

data/spec/unit/dry/configurable/argument_parser_spec.rb

@@ -1,114 +0,0 @@
-RSpec.describe Dry::Configurable::ArgumentParser do
-  let(:klass) { Dry::Configurable::ArgumentParser }
-
-  context 'with no args' do
-    let(:parsed) { klass.new([]) }
-
-    it 'return default values' do
-      expect(parsed.value).to eq nil
-      expect(parsed.options).to eq({})
-    end
-  end
-
-  context 'with value and options' do
-    let(:parsed) { klass.new([value, options]) }
-
-    context 'valid options' do
-      let(:value) { 'dry-rb' }
-      let(:options) do
-        { reader: true }
-      end
-
-      it 'returns correct value and options' do
-        expect(parsed.value).to eq 'dry-rb'
-        expect(parsed.options).to eq(reader: true)
-      end
-    end
-
-    context 'invalid options' do
-      let(:value) { 'dry-rb' }
-      let(:options) do
-        { writer: true }
-      end
-
-      it 'returns correct values and empty options' do
-        expect(parsed.value).to eq 'dry-rb'
-        expect(parsed.options).to eq({})
-      end
-    end
-
-    context 'values as hash' do
-      let(:value) do
-        { db: 'dry-rb' }
-      end
-      let(:options) do
-        { reader: true }
-      end
-
-      it 'returns correct values and empty options' do
-        expect(parsed.value).to eq(db: 'dry-rb')
-        expect(parsed.options).to eq(reader: true)
-      end
-    end
-
-    context 'values as array' do
-      let(:value) { [1, 2, 3] }
-      let(:options) do
-        { reader: true }
-      end
-
-      it 'returns correct values and empty options' do
-        expect(parsed.value).to eq([1, 2, 3])
-        expect(parsed.options).to eq(reader: true)
-      end
-    end
-  end
-
-  context 'with value only' do
-    let(:parsed) { klass.new([value]) }
-    context 'valid options' do
-      let(:value) { 'dry-rb' }
-
-      it 'returns correct value and options' do
-        expect(parsed.value).to eq 'dry-rb'
-        expect(parsed.options).to eq({})
-      end
-    end
-
-    context 'with hash with non option key' do
-      let(:value) do
-        { writer: true }
-      end
-
-      it 'returns correct value and options' do
-        expect(parsed.value).to eq(writer: true)
-        expect(parsed.options).to eq({})
-      end
-    end
-
-    context 'with hash with option key' do
-      let(:value) do
-        { reader: true, writer: true }
-      end
-
-      it 'returns correct value and options' do
-        expect(parsed.value).to eq nil
-        expect(parsed.options).to eq(reader: true)
-      end
-    end
-  end
-
-  context 'with options only' do
-    let(:parsed) { klass.new([options]) }
-    context 'valid options' do
-      let(:options) do
-        { reader: true }
-      end
-
-      it 'returns correct value and options' do
-        expect(parsed.value).to eq nil
-        expect(parsed.options).to eq(reader: true)
-      end
-    end
-  end
-end

data/spec/unit/dry/configurable/config/value_spec.rb

@@ -1,55 +0,0 @@
-RSpec.describe Dry::Configurable::Config::Value do
-  let(:klass) { Dry::Configurable::Config::Value }
-  let(:config) { klass.new(name, value, processor) }
-  let(:name) { :db }
-  let(:value) { 'test' }
-  let(:processor) { ->(v) { v } }
-
-  describe '#initialize' do
-    it 'coerces string name to symbol' do
-      config = klass.new('db', value, processor)
-
-      expect(config.name).to eq(:db)
-    end
-  end
-
-  describe '#name' do
-    subject! { config.name }
-
-    it { is_expected.to eq(name) }
-  end
-
-  describe '#value' do
-    subject! { config.value }
-
-    context 'when value is not NONE' do
-      it { is_expected.to eq(value) }
-    end
-
-    context 'when value is NONE' do
-      let(:value) { klass::NONE }
-
-      it { is_expected.to be(nil) }
-    end
-  end
-
-  describe '#processor' do
-    subject! { config.processor }
-
-    it { is_expected.to eq(processor) }
-  end
-
-  describe '#none?' do
-    subject! { config.none? }
-
-    context 'when value is not NONE' do
-      it { is_expected.to be(false) }
-    end
-
-    context 'when value is NONE' do
-      let(:value) { klass::NONE }
-
-      it { is_expected.to be(true) }
-    end
-  end
-end

data/spec/unit/dry/configurable/config_spec.rb

@@ -1,186 +0,0 @@
-RSpec.describe Dry::Configurable::Config do
-  let(:klass) { Dry::Configurable::Config }
-  let(:config) { klass.create(settings) }
-  let(:settings) do
-    [
-      value_class.new(:db, 'sqlite', ->(v) { "#{v}:memory" }),
-      value_class.new(:user, 'root', ->(v) { v }),
-      value_class.new(:pass, none, ->(v) { v })
-    ]
-  end
-  let(:value_class) { Dry::Configurable::Config::Value }
-  let(:none) { value_class::NONE }
-
-  describe '.create' do
-    it 'creates a config subclass from the given settings' do
-      expect(config.class).to be < klass
-
-      expect(config.db).to eq('sqlite:memory')
-      expect(config.user).to eq('root')
-      expect(config.pass).to be(nil)
-
-      expect { config.db = 'ineedm0ar' }.to change(config, :db)
-        .from('sqlite:memory')
-        .to('ineedm0ar:memory')
-      expect { config.user = 'whoami' }.to change(config, :user)
-        .from('root')
-        .to('whoami')
-      expect { config.pass = 'h4xz0rz' }.to change(config, :pass)
-        .from(nil)
-        .to('h4xz0rz')
-    end
-  end
-
-  describe '#clone' do
-    subject!(:clone) { config.clone }
-
-    it 'clones and returns the config' do
-      expect(clone.db).to eq(config.db)
-      expect(clone.user).to eq(config.user)
-      expect(clone.pass).to eq(config.pass)
-      is_expected.to_not be(config)
-    end
-  end
-
-  describe '#dup' do
-    subject!(:dup) { config.dup }
-
-    it 'dups and returns the config' do
-      expect(dup.db).to eq(config.db)
-      expect(dup.user).to eq(config.user)
-      expect(dup.pass).to eq(config.pass)
-      is_expected.to_not be(config)
-    end
-  end
-
-  describe '#finalize!' do
-    subject!(:dup) { config.finalize! }
-
-    it 'freezes itself and the config' do
-      expect { config.user = 'whoami' }
-        .to raise_error(Dry::Configurable::FrozenConfig, 'Cannot modify frozen config')
-    end
-  end
-
-  describe '#to_h' do
-    subject! { config.to_h }
-
-    context 'without nesting' do
-      it 'returns a config hash' do
-        is_expected.to eq(
-          db: 'sqlite:memory',
-          user: 'root',
-          pass: nil
-        )
-      end
-    end
-
-    context 'with nesting' do
-      let(:nested_setting) do
-        ::Dry::Configurable::NestedConfig.new do
-          setting(:bar, 'baz') { |v| v }
-        end.tap(&:create_config)
-      end
-      let(:settings) do
-        [
-          value_class.new(:db, 'sqlite', ->(v) { "#{v}:memory" }),
-          value_class.new(:user, 'root', ->(v) { v }),
-          value_class.new(:pass, none, ->(v) { v }),
-          value_class.new(:foo, nested_setting, ->(v) { v })
-        ]
-      end
-      it 'returns a config hash' do
-        is_expected.to eq(
-          db: 'sqlite:memory',
-          user: 'root',
-          pass: nil,
-          foo: {
-            bar: 'baz'
-          }
-        )
-      end
-    end
-  end
-
-  describe '#to_hash' do
-    subject! { config.to_hash }
-
-    context 'without nesting' do
-      it 'returns a config hash' do
-        is_expected.to eq(
-          db: 'sqlite:memory',
-          user: 'root',
-          pass: nil
-        )
-      end
-    end
-
-    context 'with nesting' do
-      let(:nested_setting) do
-        klass.create([value_class.new(:bar, 'baz', ->(v) { v })])
-      end
-      let(:settings) do
-        [
-          value_class.new(:db, 'sqlite', ->(v) { "#{v}:memory" }),
-          value_class.new(:user, 'root', ->(v) { v }),
-          value_class.new(:pass, none, ->(v) { v }),
-          value_class.new(:foo, nested_setting, ->(v) { v })
-        ]
-      end
-      it 'returns a config hash' do
-        is_expected.to eq(
-          db: 'sqlite:memory',
-          user: 'root',
-          pass: nil,
-          foo: {
-            bar: 'baz'
-          }
-        )
-      end
-    end
-  end
-
-  describe '#[]' do
-    it 'returns given setting' do
-      expect(config[:db]).to eq('sqlite:memory')
-      expect(config[:user]).to eq('root')
-      expect(config[:pass]).to be(nil)
-    end
-
-    it 'raises an ArgumentError when setting does not exist' do
-      expect { config[:unknown] }.to raise_error(
-        ArgumentError, '+unknown+ is not a setting name'
-      )
-    end
-
-    it 'accepts setting name as a string' do
-      expect(config['user']).to eq('root')
-    end
-  end
-
-  describe '#[]=' do
-    it 'sets given setting' do
-      expect { config[:db] = 'ineedm0ar' }.to change(config, :db)
-        .from('sqlite:memory')
-        .to('ineedm0ar:memory')
-      expect { config[:user] = 'whoami' }.to change(config, :user)
-        .from('root')
-        .to('whoami')
-      expect { config[:pass] = 'h4xz0rz' }.to change(config, :pass)
-        .from(nil)
-        .to('h4xz0rz')
-    end
-
-    it 'raises an ArgumentError when setting does not exist' do
-      expect { config[:unknown] = 'unknown' }.to raise_error(
-        ArgumentError, '+unknown+ is not a setting name'
-      )
-    end
-
-    it 'accepts setting name as a string' do
-      expect { config['user'] = 'whoami' }.to change(config, :user)
-        .from('root')
-        .to('whoami')
-    end
-  end
-end