sinclair 1.6.6 → 1.6.7

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