sinclair 1.6.6 → 1.8.0

data/spec/lib/sinclair/config_spec.rb

@@ -13,6 +13,10 @@ describe Sinclair::Config do
     it_behaves_like 'a config class with .config_attributes method'
   end
 
+  describe '.add_configs' do
+    it_behaves_like 'a config class with .add_configs method'
+  end
+
   describe '#to_hash' do
     it 'returns empty hash' do
       expect(config.as_json).to eq({})
@@ -104,4 +108,85 @@ describe Sinclair::Config do
       end
     end
   end
+
+  describe '#as_options' do
+    let(:expected_options) do
+      klass.options_class.new(username: :user, password: nil)
+    end
+
+    let(:builder) do
+      Sinclair::ConfigBuilder.new(config, :username, :password)
+    end
+
+    before do
+      klass.add_configs(:password, username: :user)
+    end
+
+    it do
+      expect(config.as_options).to be_a(Sinclair::Options)
+    end
+
+    it 'returns an option with default values' do
+      expect(config.as_options)
+        .to eq(expected_options)
+    end
+
+    context 'when config has been changed' do
+      let(:expected_options) do
+        klass.options_class.new(
+          username: :other_user, password: :some_password
+        )
+      end
+
+      before do
+        builder.username :other_user
+        builder.password :some_password
+      end
+
+      it 'returns an option with values from config' do
+        expect(config.as_options)
+          .to eq(expected_options)
+      end
+    end
+
+    context 'when passing options_hash' do
+      let(:expected_options) do
+        klass.options_class.new(
+          username: :user, password: :some_password
+        )
+      end
+
+      it 'returns merged options' do
+        expect(config.as_options(password: :some_password))
+          .to eq(expected_options)
+      end
+    end
+
+    context 'when passing options_hash with string keys' do
+      let(:expected_options) do
+        klass.options_class.new(
+          username: :user, password: :some_password
+        )
+      end
+
+      it 'returns merged options' do
+        expect(config.as_options('password' => :some_password))
+          .to eq(expected_options)
+      end
+
+      context 'when the config is changed' do
+        let(:options) { config.as_options }
+
+        it 'changes the option returned' do
+          expect { builder.username :other_user }
+            .to change { config.as_options.username }
+        end
+
+        it 'changes the option previously returned' do
+          expect { builder.username :other_user }
+            .not_to change(options, :username)
+        end
+      end
+    end
+  end
 end

data/spec/lib/sinclair/matchers/add_class_method_to_spec.rb

@@ -13,22 +13,46 @@ describe Sinclair::Matchers::AddClassMethodTo do
       proc { klass.send(:define_singleton_method, method) {} }
     end
 
-    context 'when a method is added' do
-      it { expect(matcher).to be_matches(event_proc) }
-    end
+    context 'when class does not have the method yet' do
+      context 'when a method is added' do
+        it { expect(matcher).to be_matches(event_proc) }
+      end
 
-    context 'when a method is not added' do
-      let(:event_proc) { proc {} }
+      context 'when a method is not added' do
+        let(:event_proc) { proc {} }
 
-      it { expect(matcher).not_to be_matches(event_proc) }
-    end
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when the wrong method is added' do
+        let(:event_proc) do
+          proc { klass.send(:define_singleton_method, :another_method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
 
-    context 'when the wrong method is added' do
-      let(:event_proc) do
-        proc { klass.send(:define_singleton_method, :another_method) {} }
+      context 'when method already existed' do
+        before { event_proc.call }
+
+        it { expect(matcher).not_to be_matches(event_proc) }
       end
 
-      it { expect(matcher).not_to be_matches(event_proc) }
+      context 'when method is added to instances' do
+        let(:event_proc) do
+          proc { klass.send(:define_method, method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when class already has the method' do
+      before { klass.send(:define_singleton_method, method) {} }
+
+      context 'when a method is changed' do
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
     end
 
     context 'when a block is given' do
@@ -36,7 +60,7 @@ describe Sinclair::Matchers::AddClassMethodTo do
         expect { matcher.matches?(event_proc) { 1 } }
           .to raise_error(
             SyntaxError, 'Block not received by the `add_class_method_to` matcher. ' \
-          'Perhaps you want to use `{ ... }` instead of do/end?'
+            'Perhaps you want to use `{ ... }` instead of do/end?'
           )
       end
     end
@@ -45,7 +69,7 @@ describe Sinclair::Matchers::AddClassMethodTo do
   describe '#failure_message_for_should' do
     it 'returns information on the instance class and method' do
       expect(matcher.failure_message_for_should)
-        .to eq("expected class_method '#{method}' to be added to #{klass} but it didn't")
+        .to eq("expected class method '#{method}' to be added to #{klass} but it didn't")
     end
 
     context 'when method already exited' do
@@ -56,7 +80,7 @@ describe Sinclair::Matchers::AddClassMethodTo do
 
       it 'returns information on the instance class and method' do
         expect(matcher.failure_message_for_should)
-          .to eq("expected class_method '#{method}' to be added to #{klass} but it already existed")
+          .to eq("expected class method '#{method}' to be added to #{klass} but it already existed")
       end
     end
   end
@@ -64,14 +88,14 @@ describe Sinclair::Matchers::AddClassMethodTo do
   describe '#failure_message_for_should_not' do
     it 'returns information on the instance class and method' do
       expect(matcher.failure_message_for_should_not)
-        .to eq("expected class_method '#{method}' not to be added to #{klass} but it was")
+        .to eq("expected class method '#{method}' not to be added to #{klass} but it was")
     end
   end
 
   describe 'description' do
     it 'returns information on the instance class and method' do
       expect(matcher.description)
-        .to eq("add method class_method '#{method}' to #{klass}")
+        .to eq("add class method '#{method}' to #{klass}")
     end
   end
 end

data/spec/lib/sinclair/matchers/add_instance_method_to_spec.rb

@@ -14,22 +14,46 @@ describe Sinclair::Matchers::AddInstanceMethodTo do
       proc { klass.send(:define_method, method) {} }
     end
 
-    context 'when a method is added' do
-      it { expect(matcher).to be_matches(event_proc) }
-    end
+    context 'when class does not have the method yet' do
+      context 'when a method is added' do
+        it { expect(matcher).to be_matches(event_proc) }
+      end
 
-    context 'when a method is not added' do
-      let(:event_proc) { proc {} }
+      context 'when a method is not added' do
+        let(:event_proc) { proc {} }
 
-      it { expect(matcher).not_to be_matches(event_proc) }
-    end
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when the wrong method is added' do
+        let(:event_proc) do
+          proc { klass.send(:define_method, :another_method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when method already existed' do
+        before { event_proc.call }
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
 
-    context 'when the wrong method is added' do
-      let(:event_proc) do
-        proc { klass.send(:define_method, :another_method) {} }
+      context 'when method is added to the class' do
+        let(:event_proc) do
+          proc { klass.send(:define_singleton_method, method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
       end
+    end
 
-      it { expect(matcher).not_to be_matches(event_proc) }
+    context 'when class already has the method' do
+      before { klass.send(:define_method, method) {} }
+
+      context 'when a method is changed' do
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
     end
 
     context 'when initializing with class' do
@@ -45,7 +69,7 @@ describe Sinclair::Matchers::AddInstanceMethodTo do
         expect { matcher.matches?(event_proc) { 1 } }
           .to raise_error(
             SyntaxError, 'Block not received by the `add_instance_method_to` matcher. ' \
-          'Perhaps you want to use `{ ... }` instead of do/end?'
+            'Perhaps you want to use `{ ... }` instead of do/end?'
           )
       end
     end

data/spec/lib/sinclair/matchers/change_class_method_on_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::ChangeClassMethodOn do
+  subject(:matcher) { described_class.new(klass, method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+
+  describe '#matches?' do
+    let(:event_proc) do
+      proc { klass.send(:define_singleton_method, method) {} }
+    end
+
+    context 'when class has the method' do
+      before { klass.send(:define_singleton_method, method) {} }
+
+      context 'when a method is changed' do
+        it { expect(matcher).to be_matches(event_proc) }
+      end
+
+      context 'when a method is not changed' do
+        let(:event_proc) { proc {} }
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when the wrong method is changed' do
+        let(:event_proc) do
+          proc { klass.send(:define_singleton_method, :another_method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when method is changed on the class' do
+        let(:event_proc) do
+          proc { klass.send(:define_method, method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when class does not have the method' do
+      context 'when a method is added' do
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when a block is given' do
+      it do
+        expect { matcher.matches?(event_proc) { 1 } }
+          .to raise_error(
+            SyntaxError, 'Block not received by the `change_class_method_on` matcher. ' \
+            'Perhaps you want to use `{ ... }` instead of do/end?'
+          )
+      end
+    end
+  end
+
+  describe '#failure_message_for_should' do
+    context 'when method already exited' do
+      before do
+        klass.send(:define_singleton_method, method) {}
+        matcher.matches?(proc {})
+      end
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected class method '#{method}' to be changed on #{klass} but it didn't")
+      end
+    end
+
+    context 'when method did not exite' do
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected class method '#{method}' to be changed on #{klass} but it didn't exist")
+      end
+    end
+
+    context 'when initializing with class and method already existed' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      before do
+        klass.send(:define_singleton_method, method) {}
+        matcher.matches?(proc {})
+      end
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected class method '#{method}' to be changed on #{klass} but it didn't")
+      end
+    end
+
+    context 'when initializing with class and method didnt exist' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected class method '#{method}' to be changed on #{klass} but it didn't exist")
+      end
+    end
+  end
+
+  describe '#failure_message_for_should_not' do
+    it 'returns information on the instance class and method' do
+      expect(matcher.failure_message_for_should_not)
+        .to eq("expected class method '#{method}' not to be changed on #{klass} but it was")
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should_not)
+          .to eq("expected class method '#{method}' not to be changed on #{klass} but it was")
+      end
+    end
+  end
+
+  describe 'description' do
+    it 'returns information on the instance class and method' do
+      expect(matcher.description)
+        .to eq("change class method '#{method}' on #{klass}")
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.description)
+          .to eq("change class method '#{method}' on #{klass}")
+      end
+    end
+  end
+end

data/spec/lib/sinclair/matchers/change_class_method_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::ChangeClassMethod do
+  subject(:matcher) { described_class.new(method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+
+  describe '#on' do
+    it do
+      expect(matcher.on(klass.new))
+        .to be_a(Sinclair::Matchers::ChangeClassMethodOn)
+    end
+
+    it 'returns an add_class_method_to' do
+      expect(matcher.on(klass))
+        .to eq(Sinclair::Matchers::ChangeClassMethodOn.new(klass, method))
+    end
+  end
+
+  describe '#matches?' do
+    it do
+      expect { matcher.matches?(proc {}) }
+        .to raise_error(
+          SyntaxError, 'You should specify which class the method is being changed on' \
+          "change_class_method(:#{method}).on(klass)"
+        )
+    end
+  end
+
+  describe '#supports_block_expectations?' do
+    it do
+      expect(matcher).to be_supports_block_expectations
+    end
+  end
+end

data/spec/lib/sinclair/matchers/change_instance_method_on_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::ChangeInstanceMethodOn do
+  subject(:matcher) { described_class.new(instance, method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+  let(:instance) { klass.new }
+
+  describe '#matches?' do
+    let(:event_proc) do
+      proc { klass.send(:define_method, method) {} }
+    end
+
+    context 'when class has the method' do
+      before { klass.send(:define_method, method) {} }
+
+      context 'when a method is changed' do
+        it { expect(matcher).to be_matches(event_proc) }
+      end
+
+      context 'when a method is not changed' do
+        let(:event_proc) { proc {} }
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when the wrong method is changed' do
+        let(:event_proc) do
+          proc { klass.send(:define_method, :another_method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when method is changed on the class' do
+        let(:event_proc) do
+          proc { klass.send(:define_singleton_method, method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when class does not have the method' do
+      context 'when a method is added' do
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      before { klass.send(:define_method, method) {} }
+
+      context 'when a method is added' do
+        it { expect(matcher).to be_matches(event_proc) }
+      end
+    end
+
+    context 'when a block is given' do
+      it do
+        expect { matcher.matches?(event_proc) { 1 } }
+          .to raise_error(
+            SyntaxError, 'Block not received by the `change_instance_method_on` matcher. ' \
+            'Perhaps you want to use `{ ... }` instead of do/end?'
+          )
+      end
+    end
+  end
+
+  describe '#failure_message_for_should' do
+    context 'when method already exited' do
+      before do
+        klass.send(:define_method, method) {}
+        matcher.matches?(proc {})
+      end
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected '#{method}' to be changed on #{klass} but it didn't")
+      end
+    end
+
+    context 'when method did not exite' do
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected '#{method}' to be changed on #{klass} but it didn't exist")
+      end
+    end
+
+    context 'when initializing with class and method already existed' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      before do
+        klass.send(:define_method, method) {}
+        matcher.matches?(proc {})
+      end
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected '#{method}' to be changed on #{klass} but it didn't")
+      end
+    end
+
+    context 'when initializing with class and method didnt exist' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected '#{method}' to be changed on #{klass} but it didn't exist")
+      end
+    end
+  end
+
+  describe '#failure_message_for_should_not' do
+    it 'returns information on the instance class and method' do
+      expect(matcher.failure_message_for_should_not)
+        .to eq("expected '#{method}' not to be changed on #{klass} but it was")
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should_not)
+          .to eq("expected '#{method}' not to be changed on #{klass} but it was")
+      end
+    end
+  end
+
+  describe 'description' do
+    it 'returns information on the instance class and method' do
+      expect(matcher.description)
+        .to eq("change method '#{method}' on #{klass} instances")
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.description)
+          .to eq("change method '#{method}' on #{klass} instances")
+      end
+    end
+  end
+end

data/spec/lib/sinclair/matchers/change_instance_method_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::ChangeInstanceMethod do
+  subject(:matcher) { described_class.new(method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+  let(:instance) { klass.new }
+
+  describe '#on' do
+    it do
+      expect(matcher.on(klass.new)).to be_a(Sinclair::Matchers::ChangeInstanceMethodOn)
+    end
+
+    it 'returns an change_instance_method_on' do
+      expect(matcher.on(instance))
+        .to eq(Sinclair::Matchers::ChangeInstanceMethodOn.new(instance, method))
+    end
+  end
+
+  describe '#matches?' do
+    it do
+      expect { matcher.matches?(proc {}) }
+        .to raise_error(
+          SyntaxError, 'You should specify which instance the method is being changed on' \
+          "change_method(:#{method}).on(instance)"
+        )
+    end
+  end
+
+  describe '#supports_block_expectations?' do
+    it do
+      expect(matcher).to be_supports_block_expectations
+    end
+  end
+end

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/support/models/login_configurable.rb

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