mcmire-shoulda-matchers 2.5.0 → 2.6.1.docs.1

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

@@ -144,6 +144,44 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
     end
   end
 
+  if rails_4_x?
+    context 'against a pre-set password in a model that has_secure_password' do
+      it 'raises a CouldNotSetPasswordError exception' do
+        user_class = define_model :user, password_digest: :string do
+          has_secure_password validations: false
+          validates_presence_of :password
+        end
+
+        user = user_class.new
+        user.password = 'something'
+
+        error_class = Shoulda::Matchers::ActiveModel::CouldNotSetPasswordError
+        expect do
+          expect(user).to validate_presence_of(:password)
+        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
+
   def matcher
     validate_presence_of(:attr)
   end

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

@@ -122,6 +122,40 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
         not_to matcher.scoped_to(:fake)
     end
 
+    if rails_gte_4_1?
+      context 'when the scoped attribute is an enum' do
+        it 'accepts' do
+          expect(validating_scoped_uniqueness_with_enum([:scope1], scope1: 0)).
+            to matcher.scoped_to(:scope1)
+        end
+
+        context 'with a nil value' do
+          it 'accepts' do
+            expect(validating_scoped_uniqueness_with_enum([:scope1], scope1: nil)).
+              to matcher.scoped_to(:scope1)
+          end
+        end
+
+        context 'when too narrow of a scope is specified' do
+          it 'rejects' do
+            expect(validating_scoped_uniqueness_with_enum_with_two_scopes).
+              not_to matcher.scoped_to(:scope1, :scope2, :other)
+          end
+        end
+
+        context 'when too broad of a scope is specified' do
+          it 'rejects' do
+            expect(validating_scoped_uniqueness_with_enum_with_two_scopes).
+              not_to matcher.scoped_to(:scope1)
+          end
+        end
+
+        def validating_scoped_uniqueness_with_enum_with_two_scopes
+          validating_scoped_uniqueness_with_enum([:scope1, :scope2], scope1: 0, scope2: 0)
+        end
+      end
+    end
+
     context 'when the scoped attribute is a date' do
       it "accepts" do
         expect(validating_scoped_uniqueness([:scope1], :date, scope1: Date.today)).
@@ -250,6 +284,14 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
       model
     end
 
+    def validating_scoped_uniqueness_with_enum(*args)
+      attributes = args.extract_options!
+      model = define_scoped_model(*args)
+      model.enum scope1: [:foo, :bar]
+      create_existing_record(attributes)
+      model.new
+    end
+
     def validating_scoped_uniqueness_with_conflicting_next(*args)
       attributes = args.extract_options!
       model = define_scoped_model(*args).new
@@ -341,42 +383,6 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     end
   end
 
-  context "a model with non-nullable attribute" do
-    context "of type" do
-      [:string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean].each do |type|
-        context type do
-          it "does not raise an error" do
-            model = define_model_with_non_nullable(type)
-            expect { expect(model).to matcher }.not_to raise_error
-          end
-        end
-      end
-    end
-
-    context "that is a primary key" do
-      it "does not cause duplicate entry errors by re-using default values for primary keys" do
-        create_table :examples, id: false do |t|
-          t.string :attr
-          t.integer :non_nullable, primary: true
-        end
-        model_class = define_model(:example, attr: :string) do
-          validates_uniqueness_of :attr
-        end
-        model_1 = model_class.new
-        model_2 = model_class.new
-        expect(model_1).to matcher
-        expect { expect(model_2).to matcher }.not_to raise_error 
-      end
-    end
-
-    def define_model_with_non_nullable(type)
-      define_model(:example, attr: :string, non_nullable: { type: type, options: { null: false } }) do
-        attr_accessible :attr, :non_nullable
-        validates_uniqueness_of :attr
-      end.new
-    end
-  end
-
   def case_sensitive_validation_with_existing_value(attr_type)
     model = define_model(:example, attr: attr_type) do
       attr_accessible :attr

data/spec/shoulda/matchers/active_record/association_matcher_spec.rb

@@ -30,7 +30,6 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
     end
 
     it 'accepts a polymorphic association' do
-      define_model :parent
       define_model :child, parent_type: :string, parent_id: :integer do
         belongs_to :parent, polymorphic: true
       end
@@ -66,6 +65,21 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       expect(belonging_to_parent).not_to belong_to(:parent).counter_cache
     end
 
+    it 'accepts an association with a valid :inverse_of option' do
+      expect(belonging_to_parent(inverse_of: :children))
+        .to belong_to(:parent).inverse_of(:children)
+    end
+
+    it 'rejects an association with a bad :inverse_of option' do
+      expect(belonging_to_parent(inverse_of: :other_children))
+        .not_to belong_to(:parent).inverse_of(:children)
+    end
+
+    it 'rejects an association that has no :inverse_of option' do
+      expect(belonging_to_parent)
+        .not_to belong_to(:parent).inverse_of(:children)
+    end
+
     it 'accepts an association with a valid :conditions option' do
       define_model :parent, adopter: :boolean
       define_model(:child, parent_id: :integer).tap do |model|

data/spec/shoulda/matchers/active_record/association_matchers/model_reflection_spec.rb

@@ -57,6 +57,10 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatchers::ModelReflection d
   describe '#join_table' do
     context 'when the association was defined with a :join_table option' do
       it 'returns the value of the option' do
+        create_table :foos, id: false do |t|
+          t.integer :person_id
+          t.integer :country_id
+        end
         define_model(:person, country_id: :integer)
         country_model = define_model(:country) do
           has_and_belongs_to_many :people, join_table: 'foos'

data/spec/shoulda/matchers/active_record/have_db_index_matcher_spec.rb

@@ -52,6 +52,10 @@ describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
     expect(have_db_index(:user_id).unique(true).description).to match(/a unique index/)
   end
 
+  it 'describes a unique index as unique when no argument is given' do
+    expect(have_db_index(:user_id).unique.description).to match(/a unique index/)
+  end
+
   it 'describes a non-unique index as non-unique' do
     expect(have_db_index(:user_id).unique(false).description).to match(/a non-unique index/)
   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