shoulda-matchers 2.6.0 → 2.6.1.rc1

data/spec/shoulda/matchers/active_model/numericality_matchers/comparison_matcher_spec.rb

@@ -5,6 +5,12 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
 
   it_behaves_like 'a numerical submatcher'
 
+  describe '#diff_to_compare' do
+    it { expect(subject.diff_to_compare).to eq 0.000_001 }
+    it { expect(described_class.new(matcher, 2**34, :>).diff_to_compare).to eq 1 }
+    it { expect(described_class.new(matcher, -2**34, :>).diff_to_compare).to eq 1 }
+  end
+
   context 'when initialized without correct numerical matcher' do
     it 'raises an argument error' do
       fake_matcher = matcher

data/spec/shoulda/matchers/active_model/validate_numericality_of_matcher_spec.rb

@@ -236,6 +236,28 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
     end
   end
 
+  context 'with large numbers' do
+    it do
+      expect(validating_numericality(greater_than: 100_000))
+        .to matcher.is_greater_than(100_000)
+    end
+
+    it do
+      expect(validating_numericality(less_than: 100_000))
+        .to matcher.is_less_than(100_000)
+    end
+
+    it do
+      expect(validating_numericality(greater_than_or_equal_to: 100_000))
+        .to matcher.is_greater_than_or_equal_to(100_000)
+    end
+
+    it do
+      expect(validating_numericality(less_than_or_equal_to: 100_000))
+        .to matcher.is_less_than_or_equal_to(100_000)
+    end
+  end
+
   context 'with a custom validation message' do
     it 'accepts when the messages match' do
       expect(validating_numericality(message: 'custom')).

data/spec/shoulda/matchers/active_model/validate_presence_of_matcher_spec.rb

@@ -146,9 +146,9 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
 
   if rails_4_x?
     context 'against a pre-set password in a model that has_secure_password' do
-      it 'raises an error to instruct the user' do
+      it 'raises a CouldNotSetPasswordError exception' do
         user_class = define_model :user, password_digest: :string do
-          has_secure_password
+          has_secure_password validations: false
           validates_presence_of :password
         end
 
@@ -156,9 +156,28 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
         user.password = 'something'
 
         error_class = Shoulda::Matchers::ActiveModel::CouldNotSetPasswordError
-        expect {
+        expect do
           expect(user).to validate_presence_of(:password)
-        }.to raise_error(error_class)
+        end.to raise_error(error_class)
+      end
+    end
+  end
+
+  context 'when the attribute being tested intercepts the blank value we set on it (issue #479)' do
+    context 'for a non-collection attribute' do
+      it 'does not raise an error' do
+        record = define_model :example, attr: :string do
+          validates :attr, presence: true
+
+          def attr=(value)
+            value = '' if value.nil?
+            super(value)
+          end
+        end.new
+
+        expect do
+          expect(record).to validate_presence_of(:attr)
+        end.not_to raise_error
       end
     end
   end

data/spec/shoulda/matchers/doublespeak/double_collection_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe DoubleCollection do
+    describe '#register_stub' do
+      it 'calls DoubleImplementationRegistry.find correctly' do
+        double_collection = described_class.new(:klass)
+        DoubleImplementationRegistry.expects(:find).with(:stub)
+        double_collection.register_stub(:a_method)
+      end
+
+      it 'calls Double.new correctly' do
+        DoubleImplementationRegistry.stubs(:find).returns(:implementation)
+        double_collection = described_class.new(:klass)
+        Double.expects(:new).with(:klass, :a_method, :implementation)
+        double_collection.register_stub(:a_method)
+      end
+    end
+
+    describe '#register_proxy' do
+      it 'calls DoubleImplementationRegistry.find correctly' do
+        double_collection = described_class.new(:klass)
+        DoubleImplementationRegistry.expects(:find).with(:proxy)
+        double_collection.register_proxy(:a_method)
+      end
+
+      it 'calls Double.new correctly' do
+        DoubleImplementationRegistry.stubs(:find).returns(:implementation)
+        double_collection = described_class.new(:klass)
+        Double.expects(:new).with(:klass, :a_method, :implementation)
+        double_collection.register_proxy(:a_method)
+      end
+    end
+
+    describe '#activate' do
+      it 'replaces all registered methods with doubles' do
+        klass = create_class(first_method: 1, second_method: 2)
+        double_collection = described_class.new(klass)
+        double_collection.register_stub(:first_method)
+        double_collection.register_stub(:second_method)
+
+        double_collection.activate
+
+        instance = klass.new
+        expect(instance.first_method).to eq nil
+        expect(instance.second_method).to eq nil
+      end
+    end
+
+    describe '#deactivate' do
+      it 'restores the original methods that were doubled' do
+        klass = create_class(first_method: 1, second_method: 2)
+        double_collection = described_class.new(klass)
+        double_collection.register_stub(:first_method)
+        double_collection.register_stub(:second_method)
+
+        double_collection.activate
+        double_collection.deactivate
+
+        instance = klass.new
+        expect(instance.first_method).to eq 1
+        expect(instance.second_method).to eq 2
+      end
+    end
+
+    describe '#calls_to' do
+      it 'returns all calls to the given method' do
+        klass = create_class(a_method: nil)
+        double_collection = described_class.new(klass)
+        double_collection.register_stub(:a_method)
+        double_collection.activate
+
+        actual_calls = [
+          { args: [:some, :args, :here] },
+          { args: [:some, :args], block: -> { :whatever } }
+        ]
+        instance = klass.new
+        instance.a_method(*actual_calls[0][:args])
+        instance.a_method(*actual_calls[1][:args], &actual_calls[1][:block])
+
+        calls = double_collection.calls_to(:a_method)
+        expect(calls[0].args).to eq actual_calls[0][:args]
+        expect(calls[1].args).to eq actual_calls[1][:args]
+        expect(calls[1].block).to eq actual_calls[1][:block]
+      end
+
+      it 'returns an empty array if the method has never been doubled' do
+        klass = create_class
+        double_collection = described_class.new(klass)
+        expect(double_collection.calls_to(:non_existent_method)).to eq []
+      end
+    end
+
+    def create_class(methods = {})
+      Class.new.tap do |klass|
+        methods.each do |name, value|
+          klass.__send__(:define_method, name) { |*args| value }
+        end
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/doublespeak/double_implementation_registry_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe DoubleImplementationRegistry do
+    describe '.find' do
+      it 'returns an instance of StubImplementation if given :stub' do
+        expect(described_class.find(:stub)).to be_a(StubImplementation)
+      end
+
+      it 'returns ProxyImplementation if given :proxy' do
+        expect(described_class.find(:proxy)).to be_a(ProxyImplementation)
+      end
+
+      it 'raises an ArgumentError if not given a registered implementation' do
+        expect {
+          expect(described_class.find(:something_else))
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/doublespeak/double_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe Double do
+    describe '#to_return' do
+      it 'tells its implementation to call the given block' do
+        sent_block = -> { }
+        actual_block = nil
+        implementation = stub
+        implementation.singleton_class.__send__(:define_method, :returns) do |&block|
+          actual_block = block
+        end
+        double = described_class.new(:klass, :a_method, implementation)
+        double.to_return(&sent_block)
+        expect(actual_block).to eq sent_block
+      end
+
+      it 'tells its implementation to return the given value' do
+        implementation = mock()
+        implementation.expects(:returns).with(:implementation)
+        double = described_class.new(:klass, :a_method, implementation)
+        double.to_return(:implementation)
+      end
+
+      it 'prefers a block over a non-block' do
+        sent_block = -> { }
+        actual_block = nil
+        implementation = stub
+        implementation.singleton_class.__send__(:define_method, :returns) do |&block|
+          actual_block = block
+        end
+        double = described_class.new(:klass, :a_method, implementation)
+        double.to_return(:value, &sent_block)
+        expect(actual_block).to eq sent_block
+      end
+    end
+
+    describe '#activate' do
+      it 'replaces the method with an implementation' do
+        implementation = stub
+        klass = create_class(a_method: 42)
+        instance = klass.new
+        double = described_class.new(klass, :a_method, implementation)
+        args = [:any, :args]
+        block = -> {}
+        implementation.expects(:call).with(double, instance, args, block)
+
+        double.activate
+        instance.a_method(*args, &block)
+      end
+    end
+
+    describe '#deactivate' do
+      it 'restores the original method after being doubled' do
+        implementation = stub(call: nil)
+        klass = create_class(a_method: 42)
+        instance = klass.new
+        double = described_class.new(klass, :a_method, implementation)
+
+        double.activate
+        double.deactivate
+        expect(instance.a_method).to eq 42
+      end
+
+      it 'still restores the original method if #activate was called twice' do
+        implementation = stub(call: nil)
+        klass = create_class(a_method: 42)
+        instance = klass.new
+        double = described_class.new(klass, :a_method, implementation)
+
+        double.activate
+        double.activate
+        double.deactivate
+        expect(instance.a_method).to eq 42
+      end
+
+      it 'does nothing if the method has not been doubled' do
+        implementation = stub(call: nil)
+        klass = create_class(a_method: 42)
+        instance = klass.new
+        double = described_class.new(klass, :a_method, implementation)
+
+        double.deactivate
+        expect(instance.a_method).to eq 42
+      end
+    end
+
+    describe '#record_call' do
+      it 'stores the arguments and block given to the method in calls' do
+        double = described_class.new(:klass, :a_method, :implementation)
+        calls = [
+          [:any, :args], :block,
+          [:more, :args]
+        ]
+        double.record_call(calls[0][0], calls[0][1])
+        double.record_call(calls[1][0], nil)
+
+        expect(double.calls[0].args).to eq calls[0][0]
+        expect(double.calls[0].block).to eq calls[0][1]
+        expect(double.calls[1].args).to eq calls[1][0]
+      end
+    end
+
+    describe '#call_original_method' do
+      it 'binds the stored method object to the class and calls it with the given args and block' do
+        klass = create_class(a_method: nil)
+        instance = klass.new
+        actual_args = actual_block = method_called = nil
+        expected_args = [:one, :two, :three]
+        expected_block = -> { }
+        double = described_class.new(klass, :a_method, :implementation)
+
+        klass.__send__(:define_method, :a_method) do |*args, &block|
+          actual_args = expected_args
+          actual_block = expected_block
+          method_called = true
+        end
+
+        double.activate
+        double.call_original_method(instance, expected_args, expected_block)
+
+        expect(expected_args).to eq actual_args
+        expect(expected_block).to eq actual_block
+        expect(method_called).to eq true
+      end
+
+      it 'does nothing if no method has been stored' do
+        double = described_class.new(:klass, :a_method, :implementation)
+
+        expect {
+          double.call_original_method(:instance, [:any, :args], nil)
+        }.not_to raise_error
+      end
+    end
+
+    def create_class(methods = {})
+      Class.new.tap do |klass|
+        methods.each do |name, value|
+          klass.__send__(:define_method, name) { |*args| value }
+        end
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/doublespeak/object_double_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe ObjectDouble do
+    it 'responds to any method' do
+      double = described_class.new
+
+      expect(double.respond_to?(:foo)).to be_true
+      expect(double.respond_to?(:bar)).to be_true
+      expect(double.respond_to?(:baz)).to be_true
+    end
+
+    it 'returns nil from any method call' do
+      double = described_class.new
+
+      expect(double.foo).to be_nil
+      expect(double.bar).to be_nil
+      expect(double.baz).to be_nil
+    end
+
+    it 'records every method call' do
+      double = described_class.new
+
+      block = -> { :some_return_value }
+      double.foo
+      double.bar(42)
+      double.baz(:zing, :zang, &block)
+
+      expect(double.calls.size).to eq 3
+      double.calls[0].tap do |call|
+        expect(call.args).to eq []
+        expect(call.block).to eq nil
+      end
+      double.calls[1].tap do |call|
+        expect(call.args).to eq [42]
+        expect(call.block).to eq nil
+      end
+      double.calls[2].tap do |call|
+        expect(call.args).to eq [:zing, :zang]
+        expect(call.block).to eq block
+      end
+    end
+
+    describe '#calls_to' do
+      it 'returns all of the invocations of the given method and their arguments/block' do
+        double = described_class.new
+
+        block = -> { :some_return_value }
+        double.foo
+        double.foo(42)
+        double.foo(:zing, :zang, &block)
+        double.some_other_method(:doesnt_matter)
+
+        calls = double.calls_to(:foo)
+
+        expect(calls.size).to eq 3
+        calls[0].tap do |call|
+          expect(call.args).to eq []
+          expect(call.block).to eq nil
+        end
+        calls[1].tap do |call|
+          expect(call.args).to eq [42]
+          expect(call.block).to eq nil
+        end
+        calls[2].tap do |call|
+          expect(call.args).to eq [:zing, :zang]
+          expect(call.block).to eq block
+        end
+      end
+
+      it 'returns an empty array if the given method was never called' do
+        double = described_class.new
+        expect(double.calls_to(:unknown_method)).to eq []
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/doublespeak/proxy_implementation_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe ProxyImplementation do
+    describe '#returns' do
+      it 'delegates to its stub_implementation' do
+        stub_implementation = build_stub_implementation
+        stub_implementation.expects(:returns).with(:value)
+        implementation = described_class.new(stub_implementation)
+        implementation.returns(:value)
+      end
+    end
+
+    describe '#call' do
+      it 'delegates to its stub_implementation' do
+        stub_implementation = build_stub_implementation
+        double = build_double
+        stub_implementation.expects(:call).with(double, :object, :args, :block)
+        implementation = described_class.new(stub_implementation)
+        implementation.call(double, :object, :args, :block)
+      end
+
+      it 'calls #call_original_method on the double' do
+        stub_implementation = build_stub_implementation
+        implementation = described_class.new(stub_implementation)
+        double = build_double
+        double.expects(:call_original_method).with(:object, :args, :block)
+        implementation.call(double, :object, :args, :block)
+      end
+    end
+
+    def build_stub_implementation
+      stub(returns: nil, call: nil)
+    end
+
+    def build_double
+      stub(call_original_method: nil)
+    end
+  end
+end