dry-configurable 0.1.7 → 0.7.0

data/spec/support/shared_examples/configurable.rb

@@ -1,108 +1,391 @@
 RSpec.shared_examples 'a configurable class' do
   describe Dry::Configurable do
     describe 'settings' do
-      context 'without default value' do
-        before do
-          klass.setting :dsn
+      context 'without processor option' do
+        context 'without default value' do
+          before do
+            klass.setting :dsn
+          end
+
+          it 'returns nil' do
+            expect(klass.config.dsn).to be(nil)
+          end
         end
 
-        it 'returns nil' do
-          expect(klass.config.dsn).to be(nil)
+        context 'with default value' do
+          context 'with a nil default value' do
+            before do
+              klass.setting :dsn, nil
+            end
+
+            it 'returns the default value' do
+              expect(klass.config.dsn).to be(nil)
+            end
+          end
+
+          context 'with a false default value' do
+            before do
+              klass.setting :dsn, false
+            end
+
+            it 'returns the default value' do
+              expect(klass.config.dsn).to be(false)
+            end
+          end
+
+          context 'with a string default value' do
+            before do
+              klass.setting :dsn, 'sqlite:memory'
+            end
+
+            it 'returns the default value' do
+              expect(klass.config.dsn).to eq('sqlite:memory')
+            end
+          end
+
+          context 'with a hash default value' do
+            before do
+              klass.setting :db_config, {
+                user: 'root',
+                password: ''
+              }
+            end
+
+            it 'returns the default value' do
+              expect(klass.config.db_config).to eq(
+                user: 'root',
+                password: ''
+              )
+            end
+          end
         end
-      end
 
-      context 'with default value' do
-        before do
-          klass.setting :dsn, 'sqlite:memory'
+        context 'reader option' do
+          context 'without passing option' do
+            before do
+              klass.setting :dsn
+            end
+
+            before do
+              klass.configure do |config|
+                config.dsn = 'jdbc:sqlite:memory'
+              end
+            end
+
+            it 'will not create a getter method' do
+              expect(klass.respond_to?(:dsn)).to be_falsey
+            end
+          end
+
+          context 'with hash as value ' do
+            before do
+              klass.setting :dsn, { foo: 'bar' }, reader: true
+            end
+
+            it 'will create a getter method' do
+              expect(klass.dsn).to eq(foo: 'bar')
+              expect(klass.respond_to?(:dsn)).to be_truthy
+            end
+          end
+
+          context 'with option set to true' do
+            before do
+              klass.setting :dsn, 'testing', reader: true
+            end
+
+            it 'will create a getter method' do
+              expect(klass.dsn).to eq 'testing'
+              expect(klass.respond_to?(:dsn)).to be_truthy
+            end
+          end
+
+          context 'with nested configuration' do
+            before do
+              klass.setting :dsn, reader: true do
+                setting :pool, 5
+              end
+            end
+
+            it 'will create a nested getter method' do
+              expect(klass.dsn.pool).to eq 5
+            end
+          end
+
+          context 'with processor' do
+            context 'with default value' do
+              before do
+                klass.setting(:dsn, 'memory', reader: true) { |dsn| "sqlite:#{dsn}" }
+              end
+
+              it 'returns the default value' do
+                expect(klass.dsn).to eq('sqlite:memory')
+              end
+            end
+
+            context 'without default value' do
+              before do
+                klass.setting(:dsn, reader: true) { |dsn| "sqlite:#{dsn}" }
+              end
+
+              it 'returns the default value' do
+                expect(klass.dsn).to eq(nil)
+              end
+            end
+          end
         end
 
-        it 'returns the default value' do
-          expect(klass.config.dsn).to eq('sqlite:memory')
+        context 'nested configuration' do
+          before do
+            klass.setting :database do
+              setting :dsn, 'sqlite:memory'
+            end
+          end
+
+          it 'returns the default value' do
+            expect(klass.config.database.dsn).to eq('sqlite:memory')
+          end
         end
       end
 
-      context 'nested configuration' do
-        before do
-          klass.setting :database do
-            setting :dsn, 'sqlite:memory'
+      context 'with processor' do
+        context 'without default value' do
+          before do
+            klass.setting(:dsn) { |dsn| "sqlite:#{dsn}" }
+          end
+
+          it 'returns nil' do
+            expect(klass.config.dsn).to be(nil)
           end
         end
 
-        it 'returns the default value' do
-          expect(klass.config.database.dsn).to eq('sqlite:memory')
+        context 'with default value' do
+          before do
+            klass.setting(:dsn, 'memory') { |dsn| "sqlite:#{dsn}" }
+          end
+
+          it 'returns the default value' do
+            expect(klass.config.dsn).to eq('sqlite:memory')
+          end
+        end
+
+        context 'nested configuration' do
+          before do
+            klass.setting :database do
+              setting(:dsn, 'memory') { |dsn| "sqlite:#{dsn}" }
+            end
+          end
+
+          it 'returns the default value' do
+            expect(klass.config.database.dsn).to eq('sqlite:memory')
+          end
         end
       end
     end
 
     describe 'configuration' do
       context 'without nesting' do
-        before do
-          klass.setting :dsn, 'sqlite:memory'
-        end
+        context 'without processor' do
+          before do
+            klass.setting :dsn, 'sqlite:memory'
+          end
 
-        before do
-          klass.configure do |config|
-            config.dsn = 'jdbc:sqlite:memory'
+          before do
+            klass.configure do |config|
+              config.dsn = 'jdbc:sqlite:memory'
+            end
+          end
+
+          it 'updates the config value' do
+            expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
           end
         end
 
-        it 'updates the config value' do
-          expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
+        context 'with processor' do
+          before do
+            klass.setting(:dsn, 'sqlite') { |dsn| "#{dsn}:memory" }
+          end
+
+          before do
+            klass.configure do |config|
+              config.dsn = 'jdbc:sqlite'
+            end
+          end
+
+          it 'updates the config value' do
+            expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
+          end
         end
       end
 
       context 'with nesting' do
-        before do
-          klass.setting :database do
-            setting :dsn, 'sqlite:memory'
+        context 'without processor' do
+          before do
+            klass.setting :database do
+              setting :dsn, 'sqlite:memory'
+            end
+
+            klass.configure do |config|
+              config.database.dsn = 'jdbc:sqlite:memory'
+            end
           end
 
-          klass.configure do |config|
-            config.database.dsn = 'jdbc:sqlite:memory'
+          it 'updates the config value' do
+            expect(klass.config.database.dsn).to eq('jdbc:sqlite:memory')
           end
         end
 
-        it 'updates the config value' do
-          expect(klass.config.database.dsn).to eq('jdbc:sqlite:memory')
+        context 'with processor' do
+          before do
+            klass.setting :database do
+              setting(:dsn, 'sqlite') { |dsn| "#{dsn}:memory" }
+            end
+
+            klass.configure do |config|
+              config.database.dsn = 'jdbc:sqlite'
+            end
+          end
+
+          it 'updates the config value' do
+            expect(klass.config.database.dsn).to eq('jdbc:sqlite:memory')
+          end
         end
       end
 
-      context 'when inherited' do
+      context 'when finalized' do
         before do
           klass.setting :dsn
           klass.configure do |config|
-            config.dsn = 'jdbc:sqlite:memory'
+            config.dsn = 'jdbc:sqlite'
           end
+          klass.finalize!
         end
 
-        subject!(:subclass) { Class.new(klass) }
+        it 'disallows modification' do
+          expect do
+            klass.configure do |config|
+              config.dsn = 'jdbc:sqlite'
+            end
+          end.to raise_error(Dry::Configurable::FrozenConfig, 'Cannot modify frozen config')
+        end
 
-        it 'retains its configuration' do
-          expect(subclass.config.dsn).to eq('jdbc:sqlite:memory')
+        it 'disallows direct modification on config' do
+          expect do
+            klass.config.dsn = 'jdbc:sqlite:memory'
+          end.to raise_error(Dry::Configurable::FrozenConfig, 'Cannot modify frozen config')
         end
+      end
 
-        context 'when the inherited config is modified' do
+      context 'when inherited' do
+        context 'without processor' do
           before do
-            subclass.configure do |config|
-              config.dsn = 'jdbc:sqlite:file'
+            klass.setting :dsn
+            klass.configure do |config|
+              config.dsn = 'jdbc:sqlite:memory'
             end
           end
 
-          it 'does not modify the original' do
-            expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
+          subject!(:subclass) { Class.new(klass) }
+
+          it 'retains its configuration' do
+            expect(subclass.config.dsn).to eq('jdbc:sqlite:memory')
+          end
+
+          context 'when the inherited config is modified' do
+            before do
+              subclass.configure do |config|
+                config.dsn = 'jdbc:sqlite:file'
+              end
+            end
+
+            it 'does not modify the original' do
+              expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
+              expect(subclass.config.dsn).to eq('jdbc:sqlite:file')
+            end
+          end
+        end
+
+        context 'with processor' do
+          before do
+            klass.setting(:dsn) { |dsn| "#{dsn}:memory" }
+            klass.configure do |config|
+              config.dsn = 'jdbc:sqlite'
+            end
+          end
+
+          subject!(:subclass) { Class.new(klass) }
+
+          it 'retains its configuration' do
+            expect(subclass.config.dsn).to eq('jdbc:sqlite:memory')
+          end
+
+          context 'when the inherited config is modified' do
+            before do
+              subclass.configure do |config|
+                config.dsn = 'sqlite'
+              end
+            end
+
+            it 'does not modify the original' do
+              expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
+              expect(subclass.config.dsn).to eq('sqlite:memory')
+            end
           end
         end
 
         context 'when the inherited settings are modified' do
           before do
+            klass.setting :dsn
             subclass.setting :db
+            klass.configure do |config|
+              config.dsn = 'jdbc:sqlite:memory'
+            end
           end
 
+          subject!(:subclass) { Class.new(klass) }
+
           it 'does not modify the original' do
-            expect(klass._settings.keys).to_not include(:db)
+            expect(klass.settings).to_not include(:db)
           end
         end
       end
     end
+
+    context 'Test Interface' do
+      before { klass.enable_test_interface }
+
+      describe 'reset_config' do
+        before do
+          klass.setting :dsn, nil
+          klass.setting :pool do
+            setting :size, nil
+          end
+
+          klass.configure do |config|
+            config.dsn = 'sqlite:memory'
+            config.pool.size = 5
+          end
+
+          klass.reset_config
+        end
+
+        it 'resets configuration to default values' do
+          expect(klass.config.dsn).to be_nil
+          expect(klass.config.pool.size).to be_nil
+        end
+      end
+    end
+
+    context 'Try to set new value after config has been created' do
+      before do
+        klass.setting :dsn, 'sqlite:memory'
+        klass.config
+      end
+
+      it 'raise an exception' do
+        expect { klass.setting :pool, 5 }.to raise_error(
+          Dry::Configurable::AlreadyDefinedConfig
+        )
+      end
+    end
   end
 end

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

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

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