shoulda-matchers 2.5.0 → 2.6.0

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_column_matcher_spec.rb

@@ -2,99 +2,99 @@ require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher do
   it 'accepts an existing database column' do
-    model(:nickname => :string).should have_db_column(:nickname)
+    expect(model(nickname: :string)).to have_db_column(:nickname)
   end
 
   it 'rejects a nonexistent database column' do
-    define_model(:employee).new.should_not have_db_column(:nickname)
+    expect(define_model(:employee).new).not_to have_db_column(:nickname)
   end
 
   context '#of_type' do
     it 'accepts a column of correct type' do
-      model(:nickname => :string).
-        should have_db_column(:nickname).of_type(:string)
+      expect(model(nickname: :string)).
+        to have_db_column(:nickname).of_type(:string)
     end
 
     it 'rejects a nonexistent database column' do
-      define_model(:superhero).new.
-        should_not have_db_column(:nickname).of_type(:string)
+      expect(define_model(:superhero).new).
+        not_to have_db_column(:nickname).of_type(:string)
     end
 
     it 'rejects a column of wrong type' do
-      model(:nickname => :integer).
-        should_not have_db_column(:nickname).of_type(:string)
+      expect(model(nickname: :integer)).
+        not_to have_db_column(:nickname).of_type(:string)
     end
   end
 
   context 'with precision option' do
     it 'accepts a column of correct precision' do
-      with_table(:salary, :decimal, :precision => 5).
-        should have_db_column(:salary).with_options(:precision => 5)
+      expect(with_table(:salary, :decimal, precision: 5)).
+        to have_db_column(:salary).with_options(precision: 5)
     end
 
     it 'rejects a column of wrong precision' do
-      with_table(:salary, :decimal, :precision => 6).
-        should_not have_db_column(:salary).with_options(:precision => 5)
+      expect(with_table(:salary, :decimal, precision: 6)).
+        not_to have_db_column(:salary).with_options(precision: 5)
     end
   end
 
   context 'with limit option' do
     it 'accepts a column of correct limit' do
-      with_table(:email, :string, :limit => 255).
-        should have_db_column(:email).with_options(:limit => 255)
+      expect(with_table(:email, :string, limit: 255)).
+        to have_db_column(:email).with_options(limit: 255)
     end
 
     it 'rejects a column of wrong limit' do
-      with_table(:email, :string, :limit => 100).
-        should_not have_db_column(:email).with_options(:limit => 255)
+      expect(with_table(:email, :string, limit: 100)).
+        not_to have_db_column(:email).with_options(limit: 255)
     end
   end
 
   context 'with default option' do
     it 'accepts a column with correct default' do
-      with_table(:admin, :boolean, :default => false).
-        should have_db_column(:admin).with_options(:default => false)
+      expect(with_table(:admin, :boolean, default: false)).
+        to have_db_column(:admin).with_options(default: false)
     end
 
     it 'rejects a column with wrong default' do
-      with_table(:admin, :boolean, :default => true).
-        should_not have_db_column(:admin).with_options(:default => false)
+      expect(with_table(:admin, :boolean, default: true)).
+        not_to have_db_column(:admin).with_options(default: false)
     end
   end
 
   context 'with null option' do
     it 'accepts a column of correct null' do
-      with_table(:admin, :boolean, :null => false).
-        should have_db_column(:admin).with_options(:null => false)
+      expect(with_table(:admin, :boolean, null: false)).
+        to have_db_column(:admin).with_options(null: false)
     end
 
     it 'rejects a column of wrong null' do
-      with_table(:admin, :boolean, :null => true).
-        should_not have_db_column(:admin).with_options(:null => false)
+      expect(with_table(:admin, :boolean, null: true)).
+        not_to have_db_column(:admin).with_options(null: false)
     end
   end
 
   context 'with scale option' do
     it 'accepts a column of correct scale' do
-      with_table(:salary, :decimal, :precision => 10, :scale => 2).
-        should have_db_column(:salary).with_options(:scale => 2)
+      expect(with_table(:salary, :decimal, precision: 10, scale: 2)).
+        to have_db_column(:salary).with_options(scale: 2)
     end
 
     it 'rejects a column of wrong scale' do
-      with_table(:salary, :decimal, :precision => 10, :scale => 4).
-        should_not have_db_column(:salary).with_options(:scale => 2)
+      expect(with_table(:salary, :decimal, precision: 10, scale: 4)).
+        not_to have_db_column(:salary).with_options(scale: 2)
     end
   end
 
   context 'with primary option' do
     it 'accepts a column that is primary' do
-      with_table(:custom_id, :integer, :primary => true).
-        should have_db_column(:id).with_options(:primary => true)
+      expect(with_table(:custom_id, :integer, primary: true)).
+        to have_db_column(:id).with_options(primary: true)
     end
 
     it 'rejects a column that is not primary' do
-      with_table(:whatever, :integer, :primary => false).
-        should_not have_db_column(:whatever).with_options(:primary => true)
+      expect(with_table(:whatever, :integer, primary: false)).
+        not_to have_db_column(:whatever).with_options(primary: true)
     end
   end
 
@@ -104,7 +104,7 @@ describe Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher do
 
   def with_table(column_name, column_type, options)
     create_table 'employees' do |table|
-      table.send(column_type, column_name, options)
+      table.__send__(column_type, column_name, options)
     end
     define_model_class('Employee').new
   end

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

@@ -3,23 +3,23 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
   context 'have_db_index' do
     it 'accepts an existing index' do
-      with_index_on(:age).should have_db_index(:age)
+      expect(with_index_on(:age)).to have_db_index(:age)
     end
 
     it 'rejects a nonexistent index' do
-      define_model(:employee).new.should_not have_db_index(:age)
+      expect(define_model(:employee).new).not_to have_db_index(:age)
     end
   end
 
   context 'have_db_index with unique option' do
     it 'accepts an index of correct unique' do
-      with_index_on(:ssn, :unique => true).
-        should have_db_index(:ssn).unique(true)
+      expect(with_index_on(:ssn, unique: true)).
+        to have_db_index(:ssn).unique(true)
     end
 
     it 'rejects an index of wrong unique' do
-      with_index_on(:ssn, :unique => false).
-        should_not have_db_index(:ssn).unique(true)
+      expect(with_index_on(:ssn, unique: false)).
+        not_to have_db_index(:ssn).unique(true)
     end
   end
 
@@ -30,8 +30,8 @@ describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
         table.string  :geocodable_type
       end
       db_connection.add_index :geocodings, [:geocodable_type, :geocodable_id]
-      define_model_class('Geocoding').new.
-        should have_db_index([:geocodable_type, :geocodable_id])
+      expect(define_model_class('Geocoding').new).
+        to have_db_index([:geocodable_type, :geocodable_id])
     end
 
     it 'rejects a nonexistent index' do
@@ -39,34 +39,38 @@ describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
         table.integer :geocodable_id
         table.string  :geocodable_type
       end
-      define_model_class('Geocoding').new.
-        should_not have_db_index([:geocodable_type, :geocodable_id])
+      expect(define_model_class('Geocoding').new).
+        not_to have_db_index([:geocodable_type, :geocodable_id])
     end
   end
 
   it 'join columns with and when describing multiple columns' do
-    have_db_index([:user_id, :post_id]).description.should =~ /on columns user_id and post_id/
+    expect(have_db_index([:user_id, :post_id]).description).to match(/on columns user_id and post_id/)
   end
 
   it 'describes a unique index as unique' do
-    have_db_index(:user_id).unique(true).description.should =~ /a unique index/
+    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
-    have_db_index(:user_id).unique(false).description.should =~ /a non-unique index/
+    expect(have_db_index(:user_id).unique(false).description).to match(/a non-unique index/)
   end
 
   it "does not display an index's uniqueness when it's not important" do
-    have_db_index(:user_id).description.should_not =~ /unique/
+    expect(have_db_index(:user_id).description).not_to match(/unique/)
   end
 
   it 'allows an IndexDefinition to have a truthy value for unique' do
     index_definition = stub('ActiveRecord::ConnectionAdapters::IndexDefinition',
-      :unique => 7, :name => :age)
+      unique: 7, name: :age)
     matcher = have_db_index(:age).unique(true)
-    matcher.stubs(:matched_index => index_definition)
+    matcher.stubs(matched_index: index_definition)
 
-    with_index_on(:age).should matcher
+    expect(with_index_on(:age)).to matcher
   end
 
   def with_index_on(column_name, index_options = {})

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

@@ -3,38 +3,38 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveRecord::HaveReadonlyAttributeMatcher do
   context 'a read-only attribute' do
     it 'accepts' do
-      with_readonly_attr.should have_readonly_attribute(:attr)
+      expect(with_readonly_attr).to have_readonly_attribute(:attr)
     end
   end
 
   context 'an attribute that is not part of the read-only set' do
     it 'rejects being read-only' do
-      model = define_model :example, :attr => :string, :other => :string do
+      model = define_model :example, attr: :string, other: :string do
         attr_readonly :attr
       end.new
 
-      model.should_not have_readonly_attribute(:other)
+      expect(model).not_to have_readonly_attribute(:other)
     end
   end
 
   context 'an attribute on a class with no readonly attributes' do
     it 'rejects being read-only' do
-      define_model(:example, :attr => :string).new.
-        should_not have_readonly_attribute(:attr)
+      expect(define_model(:example, attr: :string).new).
+        not_to have_readonly_attribute(:attr)
     end
 
     it 'assigns a failure message' do
-      model = define_model(:example, :attr => :string).new
+      model = define_model(:example, attr: :string).new
       matcher = have_readonly_attribute(:attr)
 
       matcher.matches?(model)
 
-      matcher.failure_message.should_not be_nil
+      expect(matcher.failure_message).not_to be_nil
     end
   end
 
   def with_readonly_attr
-    define_model :example, :attr => :string do
+    define_model :example, attr: :string do
       attr_readonly :attr
     end.new
   end

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

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
   it 'accepts when the attribute is serialized' do
-    with_serialized_attr.should serialize(:attr)
+    expect(with_serialized_attr).to serialize(:attr)
   end
 
   context 'when attribute is not serialized' do
     it 'rejects' do
-      unserialized_model.should_not serialize(:attr)
+      expect(unserialized_model).not_to serialize(:attr)
     end
 
     it 'assigns a helpful failure message' do
@@ -15,7 +15,7 @@ describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
 
       matcher.matches?(unserialized_model)
 
-      matcher.failure_message.should =~ /to serialize the attribute called :attr/
+      expect(matcher.failure_message).to match(/to serialize the attribute called :attr/)
     end
 
     it 'assigns a helpful failure message when using #as' do
@@ -23,7 +23,7 @@ describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
 
       matcher.matches?(unserialized_model)
 
-      matcher.failure_message.should =~ /with a type of Hash/
+      expect(matcher.failure_message).to match(/with a type of Hash/)
     end
 
     it 'assigns a helpful failure message when using #as_instance_of' do
@@ -31,44 +31,44 @@ describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
 
       matcher.matches?(unserialized_model)
 
-      matcher.failure_message.should =~ /with an instance of Hash/
+      expect(matcher.failure_message).to match(/with an instance of Hash/)
     end
 
     def unserialized_model
-      @model ||= define_model(:example, :attr => :string).new
+      @model ||= define_model(:example, attr: :string).new
     end
   end
 
   context 'an attribute that is serialized as a specific type' do
     it 'accepts when the types match' do
-      with_serialized_attr(Hash).should serialize(:attr).as(Hash)
+      expect(with_serialized_attr(Hash)).to serialize(:attr).as(Hash)
     end
 
     it 'rejects when the types do not match' do
-      with_serialized_attr(Hash).should_not serialize(:attr).as(String)
+      expect(with_serialized_attr(Hash)).not_to serialize(:attr).as(String)
     end
 
     it 'rejects when using as_instance_of' do
-      with_serialized_attr(Hash).should_not serialize(:attr).as_instance_of(Hash)
+      expect(with_serialized_attr(Hash)).not_to serialize(:attr).as_instance_of(Hash)
     end
   end
 
   context 'a serializer that is an instance of a class' do
     it 'accepts when using #as_instance_of' do
       define_serializer(:ExampleSerializer)
-      with_serialized_attr(ExampleSerializer.new).
-        should serialize(:attr).as_instance_of(ExampleSerializer)
+      expect(with_serialized_attr(ExampleSerializer.new)).
+        to serialize(:attr).as_instance_of(ExampleSerializer)
     end
 
     it 'rejects when using #as' do
       define_serializer(:ExampleSerializer)
-      with_serialized_attr(ExampleSerializer.new).
-        should_not serialize(:attr).as(ExampleSerializer)
+      expect(with_serialized_attr(ExampleSerializer.new)).
+        not_to serialize(:attr).as(ExampleSerializer)
     end
   end
 
   def with_serialized_attr(type = nil)
-    define_model(:example, :attr => :string) do
+    define_model(:example, attr: :string) do
       if type
         serialize :attr, type
       else

data/spec/shoulda/matchers/independent/delegate_matcher/stubbed_target_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::Independent::DelegateMatcher::StubbedTarget do
+  subject(:target) { described_class.new(:stubbed_method) }
+
+  describe '#has_received_method?' do
+    it 'returns true when the method has been called on the target' do
+      target.stubbed_method
+
+      expect(target).to have_received_method
+    end
+
+    it 'returns false when the method has not been called on the target' do
+      expect(target).not_to have_received_method
+    end
+  end
+
+  describe '#has_received_arguments?' do
+    context 'method is called with specified arguments' do
+      it 'returns true' do
+        target.stubbed_method(:arg1, :arg2)
+
+        expect(target).to have_received_arguments(:arg1, :arg2)
+      end
+    end
+
+    context 'method is not called with specified arguments' do
+      it 'returns false' do
+        target.stubbed_method
+
+        expect(target).not_to have_received_arguments(:arg1)
+      end
+    end
+
+    context 'method is called with arguments in incorrect order' do
+      it 'returns false' do
+        target.stubbed_method(:arg2, :arg1)
+
+        expect(target).not_to have_received_arguments(:arg1, :arg2)
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/independent/delegate_matcher_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::Independent::DelegateMatcher do
+  describe '#description' do
+    context 'by default' do
+      it 'states that it should delegate method to the right object' do
+        matcher = delegate_method(:method_name).to(:target)
+
+        expect(matcher.description)
+          .to eq 'delegate method #method_name to :target'
+      end
+    end
+
+    context 'with #as chain' do
+      it 'states that it should delegate method to the right object and method' do
+        matcher = delegate_method(:method_name).to(:target).as(:alternate)
+        message = 'delegate method #method_name to :target as #alternate'
+
+        expect(matcher.description).to eq message
+      end
+    end
+
+    context 'with #with_argument chain' do
+      it 'states that it should delegate method to the right object with right argument' do
+        matcher = delegate_method(:method_name).to(:target)
+          .with_arguments(:foo, bar: [1, 2])
+        message = 'delegate method #method_name to :target with arguments: [:foo, {:bar=>[1, 2]}]'
+
+        expect(matcher.description).to eq message
+      end
+    end
+  end
+
+  it 'raises an error if no delegation target is defined' do
+    expect {
+      delegate_method(:name).matches?(Object.new)
+    }.to raise_exception described_class::TargetNotDefinedError
+  end
+
+  it 'raises an error if called with #should_not' do
+    expect {
+      delegate_method(:name).to(:anyone).does_not_match?(Object.new)
+    }.to raise_exception described_class::InvalidDelegateMatcher
+  end
+
+  context 'given a method that does not delegate' do
+    before do
+      define_class(:post_office) do
+        def deliver_mail
+          :delivered
+        end
+      end
+    end
+
+    it 'rejects' do
+      post_office = PostOffice.new
+      matcher = delegate_method(:deliver_mail).to(:mailman)
+
+      expect(matcher.matches?(post_office)).to be false
+    end
+
+    it 'has a failure message that indicates which method should have been delegated' do
+      post_office = PostOffice.new
+      message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman'
+
+      expect {
+        expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
+      }.to fail_with_message(message)
+    end
+
+    it 'uses the proper syntax for class methods in errors' do
+      message = 'Expected PostOffice.deliver_mail to delegate to PostOffice.mailman'
+
+      expect {
+        expect(PostOffice).to delegate_method(:deliver_mail).to(:mailman)
+      }.to fail_with_message(message)
+    end
+  end
+
+  context 'given a method that delegates properly' do
+    it 'accepts' do
+      define_class(:mailman)
+
+      define_class(:post_office) do
+        def deliver_mail
+          mailman.deliver_mail
+        end
+
+        def mailman
+          Mailman.new
+        end
+      end
+
+      post_office = PostOffice.new
+
+      expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
+    end
+  end
+
+  context 'given a method that delegates properly with arguments' do
+    let(:post_office) { PostOffice.new }
+
+    before do
+      define_class(:mailman)
+
+      define_class(:post_office) do
+        def deliver_mail(*args)
+          mailman.deliver_mail('221B Baker St.', hastily: true)
+        end
+
+        def mailman
+          Mailman.new
+        end
+      end
+    end
+
+    context 'when given the correct arguments' do
+      it 'accepts' do
+        expect(post_office).to delegate_method(:deliver_mail)
+          .to(:mailman).with_arguments('221B Baker St.', hastily: true)
+      end
+    end
+
+    context 'when not given the correct arguments' do
+      it 'rejects' do
+        matcher = delegate_method(:deliver_mail).to(:mailman)
+          .with_arguments('123 Nowhere Ln.')
+
+        expect(matcher.matches?(post_office)).to be_false
+      end
+
+      it 'has a failure message that indicates which arguments were expected' do
+        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman with arguments: ["123 Nowhere Ln."]'
+
+        expect {
+          expect(post_office).to delegate_method(:deliver_mail)
+            .to(:mailman).with_arguments('123 Nowhere Ln.')
+        }.to fail_with_message(message)
+      end
+    end
+  end
+
+  context 'given a method that delegates properly to a method of a different name' do
+    let(:post_office) { PostOffice.new }
+
+    before do
+      define_class(:mailman)
+
+      define_class(:post_office) do
+        def deliver_mail
+          mailman.deliver_mail_and_avoid_dogs
+        end
+
+        def mailman
+          Mailman.new
+        end
+      end
+    end
+
+    context 'when given the correct method name' do
+      it 'accepts' do
+        expect(post_office).to delegate_method(:deliver_mail)
+          .to(:mailman).as(:deliver_mail_and_avoid_dogs)
+      end
+    end
+
+    context 'when given an incorrect method name' do
+      it 'rejects' do
+        matcher = delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
+
+        expect(matcher.matches?(post_office)).to be_false
+      end
+
+      it 'has a failure message that indicates which method was expected' do
+        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman as #watch_tv'
+
+        expect {
+          expect(post_office).to delegate_method(:deliver_mail)
+            .to(:mailman).as(:watch_tv)
+        }.to fail_with_message(message)
+      end
+    end
+  end
+end