sinclair 1.6.5 → 1.7.0

data/spec/lib/sinclair/matchers_spec.rb

@@ -31,4 +31,34 @@ describe Sinclair::Matchers do
         .to eq(described_class::AddClassMethod.new(:method_name))
     end
   end
+
+  describe '#change_method' do
+    it 'has been added to DSL' do
+      expect(respond_to?(:change_method)).to be_truthy
+    end
+
+    it do
+      expect(change_method(:method_name)).to be_a(described_class::ChangeInstanceMethod)
+    end
+
+    it 'returns the matcher with correct argument' do
+      expect(change_method(:method_name))
+        .to eq(described_class::ChangeInstanceMethod.new(:method_name))
+    end
+  end
+
+  describe '#change_class_method' do
+    it 'has been added to DSL' do
+      expect(respond_to?(:change_class_method)).to be_truthy
+    end
+
+    it do
+      expect(change_class_method(:method_name)).to be_a(described_class::ChangeClassMethod)
+    end
+
+    it 'returns the matcher with correct argument' do
+      expect(change_class_method(:method_name))
+        .to eq(described_class::ChangeClassMethod.new(:method_name))
+    end
+  end
 end

data/spec/lib/sinclair/options/class_methods_spec.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Options::ClassMethods do
+  subject(:options) { klass.new }
+
+  describe '.with_options' do
+    let(:klass)     { Class.new(Sinclair::Options) }
+    let(:test_keys) { %i[timeout retries invalid] }
+
+    context 'when calling with keys' do
+      it 'add first method' do
+        expect { klass.send(:with_options, :timeout, 'retries') }
+          .to add_method(:timeout).to(klass)
+      end
+
+      it 'add second method' do
+        expect { klass.send(:with_options, :timeout, 'retries') }
+          .to add_method(:retries).to(klass)
+      end
+
+      it 'adds options to allowed' do
+        expect { klass.send(:with_options, :timeout, 'retries') }
+          .to change { klass.invalid_options_in(test_keys) }
+          .from(%i[timeout retries invalid])
+          .to([:invalid])
+      end
+
+      it do
+        expect { klass.send(:with_options, :timeout, 'retries') }
+          .not_to change {
+                    Sinclair::Options.invalid_options_in(%i[timeout retries invalid])
+                  }
+      end
+
+      context 'when when calling method after building' do
+        before { klass.send(:with_options, :timeout, 'retries') }
+
+        it { expect(options.timeout).to be_nil }
+      end
+
+      context 'when calling method twice' do
+        before { klass.send(:with_options, :timeout, retries: 10) }
+
+        it do
+          expect { klass.send(:with_options, :timeout, :retries) }
+            .not_to change {
+                      klass.invalid_options_in(%i[timeout retries invalid])
+                    }
+        end
+      end
+    end
+
+    context 'when calling with a hash' do
+      it 'adds method' do
+        expect { klass.send(:with_options, timeout_sec: 10, 'retries' => 20) }
+          .to add_method(:timeout_sec).to(klass)
+      end
+
+      context 'when when calling method after building' do
+        before { klass.send(:with_options, timeout_sec: 10, 'retries' => 20) }
+
+        it 'returns default value' do
+          expect(options.retries).to eq(20)
+        end
+      end
+    end
+
+    context 'when calling on subclass' do
+      let(:super_class) { Class.new(Sinclair::Options) }
+      let(:klass)       { Class.new(super_class) }
+
+      let(:test_keys) do
+        %i[timeout retries name protocol port invalid]
+      end
+
+      before { super_class.send(:with_options, :timeout, 'retries', name: 'My Connector') }
+
+      it 'add first method' do
+        expect { klass.send(:with_options, :protocol, 'port' => 443) }
+          .to add_method(:protocol).to(klass)
+      end
+
+      it 'add second method' do
+        expect { klass.send(:with_options, :protocol, 'port' => 443) }
+          .to add_method(:port).to(klass)
+      end
+
+      it do
+        expect { klass.send(:with_options, 'protocol', port: 443) }
+          .to change {
+                klass.invalid_options_in(test_keys)
+              }.from(%i[protocol port invalid])
+          .to([:invalid])
+      end
+
+      it do
+        expect { klass.send(:with_options, 'protocol', port: 443) }
+          .not_to change {
+                    super_class.invalid_options_in(%i[protocol port])
+                  }
+      end
+
+      context 'when overriding a method' do
+        it do
+          expect { klass.send(:with_options, :name, timeout: 10) }
+            .not_to change { klass.invalid_options_in(%i[name timeout]) }
+        end
+
+        it 'change methods to return new default' do
+          expect { klass.send(:with_options, :name, timeout: 10) }
+            .to change { klass.new.timeout }
+            .from(nil).to(10)
+        end
+
+        it 'change methods to return without default' do
+          expect { klass.send(:with_options, :name, timeout: 10) }
+            .to change { klass.new.name }
+            .from('My Connector').to(nil)
+        end
+      end
+    end
+  end
+
+  describe '.invalid_options_in' do
+    let(:klass)     { Class.new(Sinclair::Options) }
+    let(:test_keys) { %i[timeout invalid] }
+
+    it 'returns alls keys as invalid' do
+      expect(klass.invalid_options_in(test_keys))
+        .to eq(test_keys)
+    end
+
+    context 'when allowed options was never set' do
+      before { klass.allow(:timeout) }
+
+      it 'returns keys that are not allowed by the input' do
+        expect(klass.invalid_options_in(test_keys))
+          .to eq([:invalid])
+      end
+    end
+
+    context 'when calling on subclass' do
+      let(:super_class) { Class.new(Sinclair::Options) }
+      let(:klass)       { Class.new(super_class) }
+      let(:test_keys)   { %i[timeout invalid] }
+
+      before { super_class.allow(:timeout) }
+
+      context 'when not adding allowed options' do
+        it 'returns keys that are not allowed by the input' do
+          expect(klass.invalid_options_in(test_keys))
+            .to eq([:invalid])
+        end
+      end
+
+      context 'when adding keys' do
+        before { super_class.allow(:retries) }
+
+        it 'returns keys that are not allowed by the input' do
+          expect(klass.invalid_options_in(test_keys))
+            .to eq([:invalid])
+        end
+
+        it 'adds new key to accepted' do
+          expect(klass.invalid_options_in([:retries]))
+            .to be_empty
+        end
+      end
+    end
+  end
+
+  describe '.allow' do
+    let(:klass)     { Class.new(Sinclair::Options) }
+    let(:test_keys) { %i[timeout retries invalid] }
+
+    it 'adds options to allowed' do
+      expect { klass.allow(:timeout) }
+        .to change { klass.invalid_options_in(test_keys) }
+        .from(%i[timeout retries invalid])
+        .to(%i[retries invalid])
+    end
+
+    context 'when calling on subclass' do
+      let(:super_class) { Class.new(Sinclair::Options) }
+      let(:klass)       { Class.new(super_class) }
+
+      before { super_class.allow(:timeout) }
+
+      it 'adds options to allowed' do
+        expect { klass.allow(:retries) }
+          .to change { klass.invalid_options_in(test_keys) }
+          .from(%i[retries invalid])
+          .to(%i[invalid])
+      end
+    end
+  end
+
+  describe '.allowed_options' do
+    let(:klass) { Class.new(Sinclair::Options) }
+
+    context 'when class has not been changed' do
+      it { expect(klass.allowed_options).to be_a(Set) }
+    end
+
+    context 'when initializing with with options' do
+      let(:expected) do
+        Set.new %i[timeout retries port protocol]
+      end
+
+      before do
+        klass.send(
+          :with_options,
+          :timeout, :retries, port: 443, protocol: 'https'
+        )
+      end
+
+      it do
+        expect(klass.allowed_options)
+          .to eq(expected)
+      end
+
+      context 'when class is descendent' do
+        let(:descendent_class) { Class.new(klass) }
+        let(:expected) do
+          Set.new %i[timeout retries port protocol name]
+        end
+
+        before do
+          descendent_class.send(
+            :with_options,
+            :name
+          )
+        end
+
+        it do
+          expect(descendent_class.allowed_options)
+            .to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe '.skip_validation' do
+    let(:klass) { Class.new(Sinclair::Options) }
+
+    it 'skip initialization validation' do
+      klass.send(:skip_validation)
+
+      expect { klass.new(invalid: 10) }
+        .not_to raise_error
+    end
+  end
+end

data/spec/lib/sinclair/options_spec.rb

@@ -5,243 +5,6 @@ require 'spec_helper'
 describe Sinclair::Options do
   subject(:options) { klass.new }
 
-  describe '.with_options' do
-    let(:klass)     { Class.new(described_class) }
-    let(:test_keys) { %i[timeout retries invalid] }
-
-    context 'when calling with keys' do
-      it 'add first method' do
-        expect { klass.send(:with_options, :timeout, 'retries') }
-          .to add_method(:timeout).to(klass)
-      end
-
-      it 'add second method' do
-        expect { klass.send(:with_options, :timeout, 'retries') }
-          .to add_method(:retries).to(klass)
-      end
-
-      it 'adds options to allowed' do
-        expect { klass.send(:with_options, :timeout, 'retries') }
-          .to change { klass.invalid_options_in(test_keys) }
-          .from(%i[timeout retries invalid])
-          .to([:invalid])
-      end
-
-      it do
-        expect { klass.send(:with_options, :timeout, 'retries') }
-          .not_to change {
-                    described_class.invalid_options_in(%i[timeout retries invalid])
-                  }
-      end
-
-      context 'when when calling method after building' do
-        before { klass.send(:with_options, :timeout, 'retries') }
-
-        it { expect(options.timeout).to be_nil }
-      end
-
-      context 'when calling method twice' do
-        before { klass.send(:with_options, :timeout, retries: 10) }
-
-        it do
-          expect { klass.send(:with_options, :timeout, :retries) }
-            .not_to change {
-                      klass.invalid_options_in(%i[timeout retries invalid])
-                    }
-        end
-      end
-    end
-
-    context 'when calling with a hash' do
-      it 'adds method' do
-        expect { klass.send(:with_options, timeout_sec: 10, 'retries' => 20) }
-          .to add_method(:timeout_sec).to(klass)
-      end
-
-      context 'when when calling method after building' do
-        before { klass.send(:with_options, timeout_sec: 10, 'retries' => 20) }
-
-        it 'returns default value' do
-          expect(options.retries).to eq(20)
-        end
-      end
-    end
-
-    context 'when calling on subclass' do
-      let(:super_class) { Class.new(described_class) }
-      let(:klass)       { Class.new(super_class) }
-
-      let(:test_keys) do
-        %i[timeout retries name protocol port invalid]
-      end
-
-      before { super_class.send(:with_options, :timeout, 'retries', name: 'My Connector') }
-
-      it 'add first method' do
-        expect { klass.send(:with_options, :protocol, 'port' => 443) }
-          .to add_method(:protocol).to(klass)
-      end
-
-      it 'add second method' do
-        expect { klass.send(:with_options, :protocol, 'port' => 443) }
-          .to add_method(:port).to(klass)
-      end
-
-      it do
-        expect { klass.send(:with_options, 'protocol', port: 443) }
-          .to change {
-                klass.invalid_options_in(test_keys)
-              }.from(%i[protocol port invalid])
-          .to([:invalid])
-      end
-
-      it do
-        expect { klass.send(:with_options, 'protocol', port: 443) }
-          .not_to change {
-                    super_class.invalid_options_in(%i[protocol port])
-                  }
-      end
-
-      context 'when overriding a method' do
-        it do
-          expect { klass.send(:with_options, :name, timeout: 10) }
-            .not_to change { klass.invalid_options_in(%i[name timeout]) }
-        end
-
-        it 'change methods to return new default' do
-          expect { klass.send(:with_options, :name, timeout: 10) }
-            .to change { klass.new.timeout }
-            .from(nil).to(10)
-        end
-
-        it 'change methods to return without default' do
-          expect { klass.send(:with_options, :name, timeout: 10) }
-            .to change { klass.new.name }
-            .from('My Connector').to(nil)
-        end
-      end
-    end
-  end
-
-  describe '.invalid_options_in' do
-    let(:klass)     { Class.new(described_class) }
-    let(:test_keys) { %i[timeout invalid] }
-
-    it 'returns alls keys as invalid' do
-      expect(klass.invalid_options_in(test_keys))
-        .to eq(test_keys)
-    end
-
-    context 'when allowed options was never set' do
-      before { klass.allow(:timeout) }
-
-      it 'returns keys that are not allowed by the input' do
-        expect(klass.invalid_options_in(test_keys))
-          .to eq([:invalid])
-      end
-    end
-
-    context 'when calling on subclass' do
-      let(:super_class) { Class.new(described_class) }
-      let(:klass)       { Class.new(super_class) }
-      let(:test_keys)   { %i[timeout invalid] }
-
-      before { super_class.allow(:timeout) }
-
-      context 'when not adding allowed options' do
-        it 'returns keys that are not allowed by the input' do
-          expect(klass.invalid_options_in(test_keys))
-            .to eq([:invalid])
-        end
-      end
-
-      context 'when adding keys' do
-        before { super_class.allow(:retries) }
-
-        it 'returns keys that are not allowed by the input' do
-          expect(klass.invalid_options_in(test_keys))
-            .to eq([:invalid])
-        end
-
-        it 'adds new key to accepted' do
-          expect(klass.invalid_options_in([:retries]))
-            .to be_empty
-        end
-      end
-    end
-  end
-
-  describe '.allow' do
-    let(:klass)     { Class.new(described_class) }
-    let(:test_keys) { %i[timeout retries invalid] }
-
-    it 'adds options to allowed' do
-      expect { klass.allow(:timeout) }
-        .to change { klass.invalid_options_in(test_keys) }
-        .from(%i[timeout retries invalid])
-        .to(%i[retries invalid])
-    end
-
-    context 'when calling on subclass' do
-      let(:super_class) { Class.new(described_class) }
-      let(:klass)       { Class.new(super_class) }
-
-      before { super_class.allow(:timeout) }
-
-      it 'adds options to allowed' do
-        expect { klass.allow(:retries) }
-          .to change { klass.invalid_options_in(test_keys) }
-          .from(%i[retries invalid])
-          .to(%i[invalid])
-      end
-    end
-  end
-
-  describe '.allowed_options' do
-    let(:klass) { Class.new(described_class) }
-
-    context 'when class has not been changed' do
-      it { expect(klass.allowed_options).to be_a(Set) }
-    end
-
-    context 'when initializing with with options' do
-      let(:expected) do
-        Set.new %i[timeout retries port protocol]
-      end
-
-      before do
-        klass.send(
-          :with_options,
-          :timeout, :retries, port: 443, protocol: 'https'
-        )
-      end
-
-      it do
-        expect(klass.allowed_options)
-          .to eq(expected)
-      end
-
-      context 'when class is descendent' do
-        let(:descendent_class) { Class.new(klass) }
-        let(:expected) do
-          Set.new %i[timeout retries port protocol name]
-        end
-
-        before do
-          descendent_class.send(
-            :with_options,
-            :name
-          )
-        end
-
-        it do
-          expect(descendent_class.allowed_options)
-            .to eq(expected)
-        end
-      end
-    end
-  end
-
   describe '#initialize' do
     let(:klass) { ConnectionOptions }
 
@@ -323,6 +86,34 @@ describe Sinclair::Options do
       end
     end
 
+    context 'when initializing with invalid args a class that skips validation' do
+      let(:klass) { OpenOptions }
+
+      it do
+        expect { klass.new(valid_option: 20, invalid: 10) }
+          .not_to raise_error
+      end
+
+      it 'initialize option' do
+        expect(klass.new(valid_option: 20, invalid: 10).valid_option)
+          .to eq(20)
+      end
+
+      context 'when initializing a subclass' do
+        let(:klass) { Class.new(OpenOptions) }
+
+        it do
+          expect { klass.new(valid_option: 20, invalid: 10) }
+            .not_to raise_error
+        end
+
+        it 'initialize option' do
+          expect(klass.new(valid_option: 20, invalid: 10).valid_option)
+            .to eq(20)
+        end
+      end
+    end
+
     context 'when initializing with string or symbol keys' do
       it do
         expect { klass.new('timeout' => 20, retries: 30) }

data/spec/support/models/builder_options.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class BuilderOptions < Sinclair::Options
+  with_options :name
+
+  skip_validation
+end

data/spec/support/models/login_configurable.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class LoginConfigurable
+  extend Sinclair::Configurable
+
+  configurable_by LoginConfig
+end

data/spec/support/models/open_options.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class OpenOptions < Sinclair::Options
+  with_options :valid_option
+
+  skip_validation
+end

data/spec/support/shared_examples/config.rb

@@ -115,3 +115,51 @@ shared_examples 'a config class with .config_attributes method' do
     end
   end
 end
+
+shared_examples 'a config class with .add_configs method' do
+  let(:setter_block) do
+    proc { |value| config.instance_variable_set(:@name, value) }
+  end
+
+  it_behaves_like 'a config methods builder adding config' do
+    let(:code_block) { proc { klass.add_configs(:name) } }
+
+    it 'sets nil value by default' do
+      code_block.call
+      expect(config.name).to be_nil
+    end
+
+    it 'adds attributes to class' do
+      expect(&code_block).to change(klass, :config_attributes)
+        .from([]).to(%i[name])
+    end
+
+    it do
+      expect(&code_block)
+        .to add_method(:name)
+        .to(klass.options_class)
+    end
+  end
+
+  context 'when giving defaults' do
+    it_behaves_like 'a config methods builder adding config' do
+      let(:code_block) { proc { klass.add_configs(name: 'Bob') } }
+
+      it 'sets default value' do
+        code_block.call
+        expect(config.name).to eq('Bob')
+      end
+
+      it 'adds attributes to class' do
+        expect(&code_block).to change(klass, :config_attributes)
+          .from([]).to(%i[name])
+      end
+
+      it do
+        expect(&code_block)
+          .to add_method(:name)
+          .to(klass.options_class)
+      end
+    end
+  end
+end