shoulda-matchers 2.5.0 → 2.6.0

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

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
   context '#allow_description' do
     it 'describes its attribute' do
-      finder = build_finder(:attribute => :attr)
+      finder = build_finder(attribute: :attr)
 
       description = finder.allow_description('allowed values')
 
-      description.should eq 'allow attr to be set to allowed values'
+      expect(description).to eq 'allow attr to be set to allowed values'
     end
   end
 
@@ -17,35 +17,35 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
 
       message = finder.expected_message_from('some message')
 
-      message.should eq 'some message'
+      expect(message).to eq 'some message'
     end
   end
 
   context '#has_messages?' do
     it 'has messages when some validations fail' do
-      finder = build_finder(:format => /abc/, :value => 'xyz')
+      finder = build_finder(format: /abc/, value: 'xyz')
 
       result = finder.has_messages?
 
-      result.should be_true
+      expect(result).to eq true
     end
 
     it 'has no messages when all validations pass' do
-      finder = build_finder(:format => /abc/, :value => 'abc')
+      finder = build_finder(format: /abc/, value: 'abc')
 
       result = finder.has_messages?
 
-      result.should be_false
+      expect(result).to eq false
     end
   end
 
   context '#messages' do
     it 'returns errors for the given attribute' do
-      finder = build_finder(:format => /abc/, :value => 'xyz')
+      finder = build_finder(format: /abc/, value: 'xyz')
 
       messages = finder.messages
 
-      messages.should eq ['is invalid']
+      expect(messages).to eq ['is invalid']
     end
 
     it 'returns an empty array if there are no errors for the given attribute' do
@@ -53,30 +53,30 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
 
       messages = finder.messages
 
-      messages.should == []
+      expect(messages).to eq([])
     end
   end
 
   context '#messages_description' do
     it 'describes errors for the given attribute' do
       finder = build_finder(
-        :attribute => :attr,
-        :format => /abc/,
-        :value => 'xyz'
+        attribute: :attr,
+        format: /abc/,
+        value: 'xyz'
       )
 
       description = finder.messages_description
 
       expected_messages = ['attr is invalid ("xyz")']
-      description.should eq "errors: #{expected_messages}"
+      expect(description).to eq "errors: #{expected_messages}"
     end
 
     it 'describes errors when there are none' do
-      finder = build_finder(:format => /abc/, :value => 'abc')
+      finder = build_finder(format: /abc/, value: 'abc')
 
       description = finder.messages_description
 
-      description.should eq 'no errors'
+      expect(description).to eq 'no errors'
     end
 
     it 'should not fetch attribute values for errors that were copied from an autosaved belongs_to association' do
@@ -88,7 +88,7 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
       finder = Shoulda::Matchers::ActiveModel::ValidationMessageFinder.new(instance, :attribute)
 
       expected_messages = ['association.association_attribute is invalid']
-      finder.messages_description.should eq "errors: #{expected_messages}"
+      expect(finder.messages_description).to eq "errors: #{expected_messages}"
     end
 
   end
@@ -99,7 +99,7 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
 
       description = finder.source_description
 
-      description.should eq 'errors'
+      expect(description).to eq 'errors'
     end
   end
 
@@ -119,7 +119,7 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
   def build_instance_validating(attribute, format, value)
     model_class = define_model(:example, attribute => :string) do
       attr_accessible attribute
-      validates_format_of attribute, :with => format
+      validates_format_of attribute, with: format
     end
 
     model_class.new(attribute => value)

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

@@ -2,92 +2,92 @@ require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
   it 'accepts an existing declaration' do
-    accepting_children.should accept_nested_attributes_for(:children)
+    expect(accepting_children).to accept_nested_attributes_for(:children)
   end
 
   it 'rejects a missing declaration' do
     matcher = children_matcher
 
-    matcher.matches?(rejecting_children).should be_false
+    expect(matcher.matches?(rejecting_children)).to eq false
 
-    matcher.failure_message.
-      should eq 'Expected Parent to accept nested attributes for children (is not declared)'
+    expect(matcher.failure_message).
+      to eq 'Expected Parent to accept nested attributes for children (is not declared)'
   end
 
   context 'allow_destroy' do
     it 'accepts a valid truthy value' do
-      matching = accepting_children(:allow_destroy => true)
+      matching = accepting_children(allow_destroy: true)
 
-      matching.should children_matcher.allow_destroy(true)
+      expect(matching).to children_matcher.allow_destroy(true)
     end
 
     it 'accepts a valid falsey value' do
-      matching = accepting_children(:allow_destroy => false)
+      matching = accepting_children(allow_destroy: false)
 
-      matching.should children_matcher.allow_destroy(false)
+      expect(matching).to children_matcher.allow_destroy(false)
     end
 
     it 'rejects an invalid truthy value' do
       matcher = children_matcher
-      matching = accepting_children(:allow_destroy => true)
+      matching = accepting_children(allow_destroy: true)
 
-      matcher.allow_destroy(false).matches?(matching).should be_false
-      matcher.failure_message.should =~ /should not allow destroy/
+      expect(matcher.allow_destroy(false).matches?(matching)).to eq false
+      expect(matcher.failure_message).to match(/should not allow destroy/)
     end
 
     it 'rejects an invalid falsey value' do
       matcher = children_matcher
-      matching = accepting_children(:allow_destroy => false)
+      matching = accepting_children(allow_destroy: false)
 
-      matcher.allow_destroy(true).matches?(matching).should be_false
-      matcher.failure_message.should =~ /should allow destroy/
+      expect(matcher.allow_destroy(true).matches?(matching)).to eq false
+      expect(matcher.failure_message).to match(/should allow destroy/)
     end
   end
 
   context 'limit' do
     it 'accepts a correct value' do
-      accepting_children(:limit => 3).should children_matcher.limit(3)
+      expect(accepting_children(limit: 3)).to children_matcher.limit(3)
     end
 
     it 'rejects a false value' do
       matcher = children_matcher
-      rejecting = accepting_children(:limit => 3)
+      rejecting = accepting_children(limit: 3)
 
-      matcher.limit(2).matches?(rejecting).should be_false
-      matcher.failure_message.should =~ /limit should be 2, got 3/
+      expect(matcher.limit(2).matches?(rejecting)).to eq false
+      expect(matcher.failure_message).to match(/limit should be 2, got 3/)
     end
   end
 
   context 'update_only' do
     it 'accepts a valid truthy value' do
-      accepting_children(:update_only => true).
-        should children_matcher.update_only(true)
+      expect(accepting_children(update_only: true)).
+        to children_matcher.update_only(true)
     end
 
     it 'accepts a valid falsey value' do
-      accepting_children(:update_only => false).
-        should children_matcher.update_only(false)
+      expect(accepting_children(update_only: false)).
+        to children_matcher.update_only(false)
     end
 
     it 'rejects an invalid truthy value' do
       matcher = children_matcher.update_only(false)
-      rejecting = accepting_children(:update_only => true)
+      rejecting = accepting_children(update_only: true)
 
-      matcher.matches?(rejecting).should be_false
-      matcher.failure_message.should =~ /should not be update only/
+      expect(matcher.matches?(rejecting)).to eq false
+      expect(matcher.failure_message).to match(/should not be update only/)
     end
 
     it 'rejects an invalid falsey value' do
       matcher = children_matcher.update_only(true)
-      rejecting = accepting_children(:update_only => false)
+      rejecting = accepting_children(update_only: false)
 
-      matcher.matches?(rejecting).should be_false
-      matcher.failure_message.should =~ /should be update only/
+      expect(matcher.matches?(rejecting)).to eq false
+      expect(matcher.failure_message).to match(/should be update only/)
     end
   end
 
   def accepting_children(options = {})
-    define_model :child, :parent_id => :integer
+    define_model :child, parent_id: :integer
     define_model :parent do
       has_many :children
       accepts_nested_attributes_for :children, options
@@ -99,7 +99,7 @@ describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
   end
 
   def rejecting_children
-    define_model :child, :parent_id => :integer
+    define_model :child, parent_id: :integer
     define_model :parent do
       has_many :children
     end.new

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

@@ -3,128 +3,178 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
   context 'belong_to' do
     it 'accepts a good association with the default foreign key' do
-      belonging_to_parent.should belong_to(:parent)
+      expect(belonging_to_parent).to belong_to(:parent)
     end
 
     it 'rejects a nonexistent association' do
-      define_model(:child).new.should_not belong_to(:parent)
+      expect(define_model(:child).new).not_to belong_to(:parent)
     end
 
     it 'rejects an association of the wrong type' do
-      define_model :parent, :child_id => :integer
-      define_model(:child) { has_one :parent }.new.should_not belong_to(:parent)
+      define_model :parent, child_id: :integer
+      expect(define_model(:child) { has_one :parent }.new).not_to belong_to(:parent)
     end
 
     it 'rejects an association that has a nonexistent foreign key' do
       define_model :parent
-      define_model(:child) { belongs_to :parent }.new.should_not belong_to(:parent)
+      expect(define_model(:child) { belongs_to :parent }.new).not_to belong_to(:parent)
     end
 
     it 'accepts an association with an existing custom foreign key' do
       define_model :parent
-      define_model :child, :guardian_id => :integer do
-        belongs_to :parent, :foreign_key => 'guardian_id'
+      define_model :child, guardian_id: :integer do
+        belongs_to :parent, foreign_key: 'guardian_id'
       end
 
-      Child.new.should belong_to(:parent)
+      expect(Child.new).to belong_to(:parent)
     end
 
     it 'accepts a polymorphic association' do
-      define_model :child, :parent_type => :string, :parent_id => :integer do
-        belongs_to :parent, :polymorphic => true
+      define_model :child, parent_type: :string, parent_id: :integer do
+        belongs_to :parent, polymorphic: true
       end
 
-      Child.new.should belong_to(:parent)
+      expect(Child.new).to belong_to(:parent)
     end
 
     it 'accepts an association with a valid :dependent option' do
-      belonging_to_parent(:dependent => :destroy).
-        should belong_to(:parent).dependent(:destroy)
+      expect(belonging_to_parent(dependent: :destroy)).
+        to belong_to(:parent).dependent(:destroy)
     end
 
     it 'rejects an association with a bad :dependent option' do
-      belonging_to_parent.should_not belong_to(:parent).dependent(:destroy)
+      expect(belonging_to_parent).not_to belong_to(:parent).dependent(:destroy)
     end
 
     it 'accepts an association with a valid :counter_cache option' do
-      belonging_to_parent(:counter_cache => :attribute_count).
-        should belong_to(:parent).counter_cache(:attribute_count)
+      expect(belonging_to_parent(counter_cache: :attribute_count)).
+        to belong_to(:parent).counter_cache(:attribute_count)
     end
 
     it 'defaults :counter_cache to true' do
-      belonging_to_parent(:counter_cache => true).
-        should belong_to(:parent).counter_cache
+      expect(belonging_to_parent(counter_cache: true)).
+        to belong_to(:parent).counter_cache
     end
 
     it 'rejects an association with a bad :counter_cache option' do
-      belonging_to_parent(:counter_cache => :attribute_count).
-        should_not belong_to(:parent).counter_cache(true)
+      expect(belonging_to_parent(counter_cache: :attribute_count)).
+        not_to belong_to(:parent).counter_cache(true)
     end
 
     it 'rejects an association that has no :counter_cache option' do
-      belonging_to_parent.should_not belong_to(:parent).counter_cache
+      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|
-        define_association_with_conditions(model, :belongs_to, :parent, :adopter => true)
+      define_model :parent, adopter: :boolean
+      define_model(:child, parent_id: :integer).tap do |model|
+        define_association_with_conditions(model, :belongs_to, :parent, adopter: true)
       end
 
-      Child.new.should belong_to(:parent).conditions(:adopter => true)
+      expect(Child.new).to belong_to(:parent).conditions(adopter: true)
     end
 
     it 'rejects an association with a bad :conditions option' do
-      define_model :parent, :adopter => :boolean
-      define_model :child, :parent_id => :integer do
+      define_model :parent, adopter: :boolean
+      define_model :child, parent_id: :integer do
         belongs_to :parent
       end
 
-      Child.new.should_not belong_to(:parent).conditions(:adopter => true)
+      expect(Child.new).not_to belong_to(:parent).conditions(adopter: true)
     end
 
     it 'accepts an association without a :class_name option' do
-      belonging_to_parent.should belong_to(:parent).class_name('Parent')
+      expect(belonging_to_parent).to belong_to(:parent).class_name('Parent')
     end
 
     it 'accepts an association with a valid :class_name option' do
       define_model :tree_parent
-      define_model :child, :parent_id => :integer do
-        belongs_to :parent, :class_name => 'TreeParent'
+      define_model :child, parent_id: :integer do
+        belongs_to :parent, class_name: 'TreeParent'
       end
 
-      Child.new.should belong_to(:parent).class_name('TreeParent')
+      expect(Child.new).to belong_to(:parent).class_name('TreeParent')
     end
 
     it 'rejects an association with a bad :class_name option' do
-      belonging_to_parent.should_not belong_to(:parent).class_name('TreeChild')
+      expect(belonging_to_parent).not_to belong_to(:parent).class_name('TreeChild')
+    end
+
+    it 'rejects an association with non-existent implicit class name' do
+      expect(belonging_to_non_existent_class(:child, :parent)).not_to belong_to(:parent)
+    end
+
+    it 'rejects an association with non-existent explicit class name' do
+      expect(belonging_to_non_existent_class(:child, :parent, class_name: 'Parent')).not_to belong_to(:parent)
+    end
+
+    it 'adds error message when rejecting an association with non-existent class' do
+      message = 'Expected Child to have a belongs_to association called parent (Parent2 does not exist)'
+      expect {
+        expect(belonging_to_non_existent_class(:child, :parent, class_name: 'Parent2')).to belong_to(:parent)
+      }.to fail_with_message(message)
+    end
+
+    it 'accepts an association with a matching :autosave option' do
+      define_model :parent, adopter: :boolean
+      define_model :child, parent_id: :integer do
+        belongs_to :parent, autosave: true
+      end
+      expect(Child.new).to belong_to(:parent).autosave(true)
+    end
+
+    it 'rejects an association with a non-matching :autosave option with the correct message' do
+      define_model :parent, adopter: :boolean
+      define_model :child, parent_id: :integer do
+        belongs_to :parent, autosave: false
+      end
+
+      message = 'Expected Child to have a belongs_to association called parent (parent should have autosave set to true)'
+      expect {
+        expect(Child.new).to belong_to(:parent).autosave(true)
+      }.to fail_with_message(message)
     end
 
     context 'an association with a :validate option' do
       [false, true].each do |validate_value|
-        context "when the model has :validate => #{validate_value}" do
+        context "when the model has validate: #{validate_value}" do
           it 'accepts a matching validate option' do
-            belonging_to_parent(:validate => validate_value).
-              should belong_to(:parent).validate(validate_value)
+            expect(belonging_to_parent(validate: validate_value)).
+              to belong_to(:parent).validate(validate_value)
           end
 
           it 'rejects a non-matching validate option' do
-            belonging_to_parent(:validate => validate_value).
-              should_not belong_to(:parent).validate(!validate_value)
+            expect(belonging_to_parent(validate: validate_value)).
+              not_to belong_to(:parent).validate(!validate_value)
           end
 
           it 'defaults to validate(true)' do
             if validate_value
-              belonging_to_parent(:validate => validate_value).
-                should belong_to(:parent).validate
+              expect(belonging_to_parent(validate: validate_value)).
+                to belong_to(:parent).validate
             else
-              belonging_to_parent(:validate => validate_value).
-                should_not belong_to(:parent).validate
+              expect(belonging_to_parent(validate: validate_value)).
+                not_to belong_to(:parent).validate
             end
           end
 
           it 'will not break matcher when validate option is unspecified' do
-            belonging_to_parent(:validate => validate_value).should belong_to(:parent)
+            expect(belonging_to_parent(validate: validate_value)).to belong_to(:parent)
           end
         end
       end
@@ -132,43 +182,43 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
     context 'an association without a :validate option' do
       it 'accepts validate(false)' do
-        belonging_to_parent.should belong_to(:parent).validate(false)
+        expect(belonging_to_parent).to belong_to(:parent).validate(false)
       end
 
       it 'rejects validate(true)' do
-        belonging_to_parent.should_not belong_to(:parent).validate(true)
+        expect(belonging_to_parent).not_to belong_to(:parent).validate(true)
       end
 
       it 'rejects validate()' do
-        belonging_to_parent.should_not belong_to(:parent).validate
+        expect(belonging_to_parent).not_to belong_to(:parent).validate
       end
     end
 
     context 'an association with a :touch option' do
       [false, true].each do |touch_value|
-        context "when the model has :touch => #{touch_value}" do
+        context "when the model has touch: #{touch_value}" do
           it 'accepts a matching touch option' do
-            belonging_to_parent(:touch => touch_value).
-              should belong_to(:parent).touch(touch_value)
+            expect(belonging_to_parent(touch: touch_value)).
+              to belong_to(:parent).touch(touch_value)
           end
 
           it 'rejects a non-matching touch option' do
-            belonging_to_parent(:touch => touch_value).
-              should_not belong_to(:parent).touch(!touch_value)
+            expect(belonging_to_parent(touch: touch_value)).
+              not_to belong_to(:parent).touch(!touch_value)
           end
 
           it 'defaults to touch(true)' do
             if touch_value
-              belonging_to_parent(:touch => touch_value).
-                should belong_to(:parent).touch
+              expect(belonging_to_parent(touch: touch_value)).
+                to belong_to(:parent).touch
             else
-              belonging_to_parent(:touch => touch_value).
-                should_not belong_to(:parent).touch
+              expect(belonging_to_parent(touch: touch_value)).
+                not_to belong_to(:parent).touch
             end
           end
 
           it 'will not break matcher when touch option is unspecified' do
-            belonging_to_parent(:touch => touch_value).should belong_to(:parent)
+            expect(belonging_to_parent(touch: touch_value)).to belong_to(:parent)
           end
         end
       end
@@ -176,51 +226,57 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
     context 'an association without a :touch option' do
       it 'accepts touch(false)' do
-        belonging_to_parent.should belong_to(:parent).touch(false)
+        expect(belonging_to_parent).to belong_to(:parent).touch(false)
       end
 
       it 'rejects touch(true)' do
-        belonging_to_parent.should_not belong_to(:parent).touch(true)
+        expect(belonging_to_parent).not_to belong_to(:parent).touch(true)
       end
 
       it 'rejects touch()' do
-        belonging_to_parent.should_not belong_to(:parent).touch
+        expect(belonging_to_parent).not_to belong_to(:parent).touch
       end
     end
 
     def belonging_to_parent(options = {})
       define_model :parent
-      define_model :child, :parent_id => :integer do
+      define_model :child, parent_id: :integer do
         belongs_to :parent, options
       end.new
     end
+
+    def belonging_to_non_existent_class(model_name, assoc_name, options = {})
+      define_model model_name, "#{assoc_name}_id" => :integer do
+        belongs_to assoc_name, options
+      end.new
+    end
   end
 
   context 'have_many' do
     it 'accepts a valid association without any options' do
-      having_many_children.should have_many(:children)
+      expect(having_many_children).to have_many(:children)
     end
 
     it 'accepts a valid association with a :through option' do
       define_model :child
-      define_model :conception, :child_id => :integer,
-        :parent_id => :integer do
+      define_model :conception, child_id: :integer,
+        parent_id: :integer do
         belongs_to :child
         end
       define_model :parent do
         has_many :conceptions
-        has_many :children, :through => :conceptions
+        has_many :children, through: :conceptions
       end
-      Parent.new.should have_many(:children)
+      expect(Parent.new).to have_many(:children)
     end
 
     it 'accepts a valid association with an :as option' do
-      define_model :child, :guardian_type => :string, :guardian_id => :integer
+      define_model :child, guardian_type: :string, guardian_id: :integer
       define_model :parent do
-        has_many :children, :as => :guardian
+        has_many :children, as: :guardian
       end
 
-      Parent.new.should have_many(:children)
+      expect(Parent.new).to have_many(:children)
     end
 
     it 'rejects an association that has a nonexistent foreign key' do
@@ -229,164 +285,199 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
         has_many :children
       end
 
-      Parent.new.should_not have_many(:children)
+      expect(Parent.new).not_to have_many(:children)
     end
 
     it 'rejects an association with a bad :as option' do
-      define_model :child, :caretaker_type => :string,
-        :caretaker_id => :integer
+      define_model :child, caretaker_type: :string,
+        caretaker_id: :integer
       define_model :parent do
-        has_many :children, :as => :guardian
+        has_many :children, as: :guardian
       end
 
-      Parent.new.should_not have_many(:children)
+      expect(Parent.new).not_to have_many(:children)
     end
 
     it 'rejects an association that has a bad :through option' do
       matcher = have_many(:children).through(:conceptions)
 
-      matcher.matches?(having_many_children).should be_false
+      expect(matcher.matches?(having_many_children)).to eq false
 
-      matcher.failure_message.should =~ /does not have any relationship to conceptions/
+      expect(matcher.failure_message).to match(/does not have any relationship to conceptions/)
     end
 
     it 'rejects an association that has the wrong :through option' do
       define_model :child
 
-      define_model :conception, :child_id => :integer,
-        :parent_id => :integer do
+      define_model :conception, child_id: :integer,
+        parent_id: :integer do
         belongs_to :child
       end
 
       define_model :parent do
         has_many :conceptions
         has_many :relationships
-        has_many :children, :through => :conceptions
+        has_many :children, through: :conceptions
       end
 
       matcher = have_many(:children).through(:relationships)
-      matcher.matches?(Parent.new).should be_false
-      matcher.failure_message.should =~ /through relationships, but got it through conceptions/
+      expect(matcher.matches?(Parent.new)).to eq false
+      expect(matcher.failure_message).to match(/through relationships, but got it through conceptions/)
     end
 
     it 'accepts an association with a valid :dependent option' do
-      having_many_children(:dependent => :destroy).
-        should have_many(:children).dependent(:destroy)
+      expect(having_many_children(dependent: :destroy)).
+        to have_many(:children).dependent(:destroy)
     end
 
     it 'rejects an association with a bad :dependent option' do
       matcher = have_many(:children).dependent(:destroy)
 
-      having_many_children.should_not matcher
+      expect(having_many_children).not_to matcher
 
-      matcher.failure_message.should =~ /children should have destroy dependency/
+      expect(matcher.failure_message).to match(/children should have destroy dependency/)
     end
 
     it 'accepts an association with a valid :source option' do
-      having_many_children(:source => :user).
-        should have_many(:children).source(:user)
+      expect(having_many_children(source: :user)).
+        to have_many(:children).source(:user)
     end
 
     it 'rejects an association with a bad :source option' do
       matcher = have_many(:children).source(:user)
 
-      having_many_children.should_not matcher
+      expect(having_many_children).not_to matcher
 
-      matcher.failure_message.should =~ /children should have user as source option/
+      expect(matcher.failure_message).to match(/children should have user as source option/)
     end
 
     it 'accepts an association with a valid :order option' do
-      having_many_children(:order => :id).
-        should have_many(:children).order(:id)
+      expect(having_many_children(order: :id)).
+        to have_many(:children).order(:id)
     end
 
     it 'rejects an association with a bad :order option' do
       matcher = have_many(:children).order(:id)
 
-      having_many_children.should_not matcher
+      expect(having_many_children).not_to matcher
 
-      matcher.failure_message.should =~ /children should be ordered by id/
+      expect(matcher.failure_message).to match(/children should be ordered by id/)
     end
 
     it 'accepts an association with a valid :conditions option' do
-      define_model :child, :parent_id => :integer, :adopted => :boolean
+      define_model :child, parent_id: :integer, adopted: :boolean
       define_model(:parent).tap do |model|
-        define_association_with_conditions(model, :has_many, :children, :adopted => true)
+        define_association_with_conditions(model, :has_many, :children, adopted: true)
       end
 
-      Parent.new.should have_many(:children).conditions(:adopted => true)
+      expect(Parent.new).to have_many(:children).conditions(adopted: true)
     end
 
     it 'rejects an association with a bad :conditions option' do
-      define_model :child, :parent_id => :integer, :adopted => :boolean
+      define_model :child, parent_id: :integer, adopted: :boolean
       define_model :parent do
         has_many :children
       end
 
-      Parent.new.should_not have_many(:children).conditions(:adopted => true)
+      expect(Parent.new).not_to have_many(:children).conditions(adopted: true)
     end
 
     it 'accepts an association without a :class_name option' do
-      having_many_children.should have_many(:children).class_name('Child')
+      expect(having_many_children).to have_many(:children).class_name('Child')
     end
 
     it 'accepts an association with a valid :class_name option' do
-      define_model :node, :parent_id => :integer
+      define_model :node, parent_id: :integer
       define_model :parent do
-        has_many :children, :class_name => 'Node'
+        has_many :children, class_name: 'Node'
       end
 
-      Parent.new.should have_many(:children).class_name('Node')
+      expect(Parent.new).to have_many(:children).class_name('Node')
     end
 
     it 'rejects an association with a bad :class_name option' do
-      having_many_children.should_not have_many(:children).class_name('Node')
+      expect(having_many_children).not_to have_many(:children).class_name('Node')
+    end
+
+    it 'rejects an association with non-existent implicit class name' do
+      expect(having_many_non_existent_class(:parent, :children)).not_to have_many(:children)
+    end
+
+    it 'rejects an association with non-existent explicit class name' do
+      expect(having_many_non_existent_class(:parent, :children, class_name: 'Child')).not_to have_many(:children)
+    end
+
+    it 'adds error message when rejecting an association with non-existent class' do
+      message = 'Expected Parent to have a has_many association called children (Child2 does not exist)'
+      expect {
+        expect(having_many_non_existent_class(:parent, :children, class_name: 'Child2')).to have_many(:children)
+      }.to fail_with_message(message)
+    end
+
+    it 'accepts an association with a matching :autosave option' do
+      define_model :child, parent_id: :integer
+      define_model :parent do
+        has_many :children, autosave: true
+      end
+      expect(Parent.new).to have_many(:children).autosave(true)
+    end
+
+    it 'rejects an association with a non-matching :autosave option with the correct message' do
+      define_model :child, parent_id: :integer
+      define_model :parent do
+        has_many :children, autosave: false
+      end
+
+      message = 'Expected Parent to have a has_many association called children (children should have autosave set to true)'
+      expect {
+        expect(Parent.new).to have_many(:children).autosave(true)
+      }.to fail_with_message(message)
     end
 
     context 'validate' do
       it 'accepts when the :validate option matches' do
-        having_many_children(:validate => false).should have_many(:children).validate(false)
+        expect(having_many_children(validate: false)).to have_many(:children).validate(false)
       end
 
       it 'rejects when the :validate option does not match' do
-        having_many_children(:validate => true).should_not have_many(:children).validate(false)
+        expect(having_many_children(validate: true)).not_to have_many(:children).validate(false)
       end
 
       it 'assumes validate() means validate(true)' do
-        having_many_children(:validate => false).should_not have_many(:children).validate
+        expect(having_many_children(validate: false)).not_to have_many(:children).validate
       end
 
       it 'matches validate(false) to having no validate option specified' do
-        having_many_children.should have_many(:children).validate(false)
+        expect(having_many_children).to have_many(:children).validate(false)
       end
     end
 
     it 'accepts an association with a nonstandard reverse foreign key, using :inverse_of' do
-      define_model :child, :ancestor_id => :integer do
-        belongs_to :ancestor, :inverse_of => :children, :class_name => :Parent
+      define_model :child, ancestor_id: :integer do
+        belongs_to :ancestor, inverse_of: :children, class_name: :Parent
       end
 
       define_model :parent do
-        has_many :children, :inverse_of => :ancestor
+        has_many :children, inverse_of: :ancestor
       end
 
-      Parent.new.should have_many(:children)
+      expect(Parent.new).to have_many(:children)
     end
 
     it 'rejects an association with a nonstandard reverse foreign key, if :inverse_of is not correct' do
-      define_model :child, :mother_id => :integer do
-        belongs_to :mother, :inverse_of => :children, :class_name => :Parent
+      define_model :child, mother_id: :integer do
+        belongs_to :mother, inverse_of: :children, class_name: :Parent
       end
 
       define_model :parent do
-        has_many :children, :inverse_of => :ancestor
+        has_many :children, inverse_of: :ancestor
       end
 
-      Parent.new.should_not have_many(:children)
+      expect(Parent.new).not_to have_many(:children)
     end
 
     def having_many_children(options = {})
-      define_model :child, :parent_id => :integer
+      define_model :child, parent_id: :integer
       define_model(:parent).tap do |model|
         if options.key?(:order)
           order = options.delete(:order)
@@ -396,21 +487,27 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
         end
       end.new
     end
+
+    def having_many_non_existent_class(model_name, assoc_name, options = {})
+      define_model model_name do
+        has_many assoc_name, options
+      end.new
+    end
   end
 
   context 'have_one' do
     it 'accepts a valid association without any options' do
-      having_one_detail.should have_one(:detail)
+      expect(having_one_detail).to have_one(:detail)
     end
 
     it 'accepts a valid association with an :as option' do
-      define_model :detail, :detailable_id => :integer,
-        :detailable_type => :string
+      define_model :detail, detailable_id: :integer,
+        detailable_type: :string
       define_model :person do
-        has_one :detail, :as => :detailable
+        has_one :detail, as: :detailable
       end
 
-      Person.new.should have_one(:detail)
+      expect(Person.new).to have_one(:detail)
     end
 
     it 'rejects an association that has a nonexistent foreign key' do
@@ -419,85 +516,120 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
         has_one :detail
       end
 
-      Person.new.should_not have_one(:detail)
+      expect(Person.new).not_to have_one(:detail)
     end
 
     it 'accepts an association with an existing custom foreign key' do
-      define_model :detail, :detailed_person_id => :integer
+      define_model :detail, detailed_person_id: :integer
       define_model :person do
-        has_one :detail, :foreign_key => :detailed_person_id
+        has_one :detail, foreign_key: :detailed_person_id
       end
-      Person.new.should have_one(:detail).with_foreign_key(:detailed_person_id)
+      expect(Person.new).to have_one(:detail).with_foreign_key(:detailed_person_id)
     end
 
     it 'rejects an association with a bad :as option' do
-      define_model :detail, :detailable_id => :integer,
-        :detailable_type => :string
+      define_model :detail, detailable_id: :integer,
+        detailable_type: :string
       define_model :person do
-        has_one :detail, :as => :describable
+        has_one :detail, as: :describable
       end
 
-      Person.new.should_not have_one(:detail)
+      expect(Person.new).not_to have_one(:detail)
     end
 
     it 'accepts an association with a valid :dependent option' do
-      having_one_detail(:dependent => :destroy).
-        should have_one(:detail).dependent(:destroy)
+      expect(having_one_detail(dependent: :destroy)).
+        to have_one(:detail).dependent(:destroy)
     end
 
     it 'rejects an association with a bad :dependent option' do
       matcher = have_one(:detail).dependent(:destroy)
 
-      having_one_detail.should_not matcher
+      expect(having_one_detail).not_to matcher
 
-      matcher.failure_message.should =~ /detail should have destroy dependency/
+      expect(matcher.failure_message).to match(/detail should have destroy dependency/)
     end
 
     it 'accepts an association with a valid :order option' do
-      having_one_detail(:order => :id).should have_one(:detail).order(:id)
+      expect(having_one_detail(order: :id)).to have_one(:detail).order(:id)
     end
 
     it 'rejects an association with a bad :order option' do
       matcher = have_one(:detail).order(:id)
 
-      having_one_detail.should_not matcher
+      expect(having_one_detail).not_to matcher
 
-      matcher.failure_message.should =~ /detail should be ordered by id/
+      expect(matcher.failure_message).to match(/detail should be ordered by id/)
     end
 
     it 'accepts an association with a valid :conditions option' do
-      define_model :detail, :person_id => :integer, :disabled => :boolean
+      define_model :detail, person_id: :integer, disabled: :boolean
       define_model(:person).tap do |model|
-        define_association_with_conditions(model, :has_one, :detail, :disabled => true)
+        define_association_with_conditions(model, :has_one, :detail, disabled: true)
       end
 
-      Person.new.should have_one(:detail).conditions(:disabled => true)
+      expect(Person.new).to have_one(:detail).conditions(disabled: true)
     end
 
     it 'rejects an association with a bad :conditions option' do
-      define_model :detail, :person_id => :integer, :disabled => :boolean
+      define_model :detail, person_id: :integer, disabled: :boolean
       define_model :person do
         has_one :detail
       end
 
-      Person.new.should_not have_one(:detail).conditions(:disabled => true)
+      expect(Person.new).not_to have_one(:detail).conditions(disabled: true)
     end
 
     it 'accepts an association without a :class_name option' do
-      having_one_detail.should have_one(:detail).class_name('Detail')
+      expect(having_one_detail).to have_one(:detail).class_name('Detail')
+    end
+
+    it 'accepts an association with a matching :autosave option' do
+      define_model :detail, person_id: :integer, disabled: :boolean
+      define_model :person do
+        has_one :detail, autosave: true
+      end
+      expect(Person.new).to have_one(:detail).autosave(true)
+    end
+
+    it 'rejects an association with a non-matching :autosave option with the correct message' do
+      define_model :detail, person_id: :integer, disabled: :boolean
+      define_model :person do
+        has_one :detail, autosave: false
+      end
+
+      message = 'Expected Person to have a has_one association called detail (detail should have autosave set to true)'
+      expect {
+        expect(Person.new).to have_one(:detail).autosave(true)
+      }.to fail_with_message(message)
     end
 
     it 'accepts an association with a valid :class_name option' do
-      define_model :person_detail, :person_id => :integer
+      define_model :person_detail, person_id: :integer
       define_model :person do
-        has_one :detail, :class_name => 'PersonDetail'
+        has_one :detail, class_name: 'PersonDetail'
       end
 
-      Person.new.should have_one(:detail).class_name('PersonDetail')
+      expect(Person.new).to have_one(:detail).class_name('PersonDetail')
     end
 
     it 'rejects an association with a bad :class_name option' do
-      having_one_detail.should_not have_one(:detail).class_name('NotSet')
+      expect(having_one_detail).not_to have_one(:detail).class_name('NotSet')
+    end
+
+    it 'rejects an association with non-existent implicit class name' do
+      expect(having_one_non_existent(:pserson, :detail)).not_to have_one(:detail)
+    end
+
+    it 'rejects an association with non-existent explicit class name' do
+      expect(having_one_non_existent(:person, :detail, class_name: 'Detail')).not_to have_one(:detail)
+    end
+
+    it 'adds error message when rejecting an association with non-existent class' do
+      message = 'Expected Person to have a has_one association called detail (Detail2 does not exist)'
+      expect {
+        expect(having_one_non_existent(:person, :detail, class_name: 'Detail2')).to have_one(:detail)
+      }.to fail_with_message(message)
     end
 
     it 'accepts an association with a through' do
@@ -509,39 +641,39 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
       define_model :person do
         has_one :account
-        has_one :detail, :through => :account
+        has_one :detail, through: :account
       end
 
-      Person.new.should have_one(:detail).through(:account)
+      expect(Person.new).to have_one(:detail).through(:account)
     end
 
     it 'rejects an association with a bad through' do
-      having_one_detail.should_not have_one(:detail).through(:account)
+      expect(having_one_detail).not_to have_one(:detail).through(:account)
     end
 
     context 'validate' do
       it 'accepts when the :validate option matches' do
-        having_one_detail(:validate => false).
-          should have_one(:detail).validate(false)
+        expect(having_one_detail(validate: false)).
+          to have_one(:detail).validate(false)
       end
 
       it 'rejects when the :validate option does not match' do
-        having_one_detail(:validate => true).
-          should_not have_one(:detail).validate(false)
+        expect(having_one_detail(validate: true)).
+          not_to have_one(:detail).validate(false)
       end
 
       it 'assumes validate() means validate(true)' do
-        having_one_detail(:validate => false).
-          should_not have_one(:detail).validate
+        expect(having_one_detail(validate: false)).
+          not_to have_one(:detail).validate
       end
 
       it 'matches validate(false) to having no validate option specified' do
-        having_one_detail.should have_one(:detail).validate(false)
+        expect(having_one_detail).to have_one(:detail).validate(false)
       end
     end
 
     def having_one_detail(options = {})
-      define_model :detail, :person_id => :integer
+      define_model :detail, person_id: :integer
       define_model(:person).tap do |model|
         if options.key?(:order)
           order = options.delete(:order)
@@ -551,21 +683,27 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
         end
       end.new
     end
+
+    def having_one_non_existent(model_name, assoc_name, options = {})
+      define_model model_name do
+        has_one assoc_name, options
+      end.new
+    end
   end
 
   context 'have_and_belong_to_many' do
     it 'accepts a valid association' do
-      having_and_belonging_to_many_relatives.
-        should have_and_belong_to_many(:relatives)
+      expect(having_and_belonging_to_many_relatives).
+        to have_and_belong_to_many(:relatives)
     end
 
     it 'rejects a nonexistent association' do
       define_model :relative
       define_model :person
-      define_model :people_relative, :id => false, :person_id => :integer,
-        :relative_id => :integer
+      define_model :people_relative, id: false, person_id: :integer,
+        relative_id: :integer
 
-      Person.new.should_not have_and_belong_to_many(:relatives)
+      expect(Person.new).not_to have_and_belong_to_many(:relatives)
     end
 
     it 'rejects an association with a nonexistent join table' do
@@ -574,92 +712,140 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
         has_and_belongs_to_many :relatives
       end
 
-      Person.new.should_not have_and_belong_to_many(:relatives)
+      expect(Person.new).not_to have_and_belong_to_many(:relatives)
     end
 
     it 'rejects an association of the wrong type' do
-      define_model :relative, :person_id => :integer
+      define_model :relative, person_id: :integer
       define_model :person do
         has_many :relatives
       end
 
-      Person.new.should_not have_and_belong_to_many(:relatives)
+      expect(Person.new).not_to have_and_belong_to_many(:relatives)
     end
 
     it 'accepts an association with a valid :conditions option' do
-      define_model :relative, :adopted => :boolean
+      define_model :relative, adopted: :boolean
       define_model(:person).tap do |model|
-        define_association_with_conditions(model, :has_and_belongs_to_many, :relatives, :adopted => true)
+        define_association_with_conditions(model, :has_and_belongs_to_many, :relatives, adopted: true)
       end
-      define_model :people_relative, :id => false, :person_id => :integer,
-        :relative_id => :integer
+      define_model :people_relative, id: false, person_id: :integer,
+        relative_id: :integer
 
-      Person.new.should have_and_belong_to_many(:relatives).conditions(:adopted => true)
+      expect(Person.new).to have_and_belong_to_many(:relatives).conditions(adopted: true)
     end
 
     it 'rejects an association with a bad :conditions option' do
-      define_model :relative, :adopted => :boolean
+      define_model :relative, adopted: :boolean
       define_model :person do
         has_and_belongs_to_many :relatives
       end
-      define_model :people_relative, :id => false, :person_id => :integer,
-        :relative_id => :integer
+      define_model :people_relative, id: false, person_id: :integer,
+        relative_id: :integer
 
-      Person.new.should_not have_and_belong_to_many(:relatives).conditions(:adopted => true)
+      expect(Person.new).not_to have_and_belong_to_many(:relatives).conditions(adopted: true)
     end
 
     it 'accepts an association without a :class_name option' do
-      having_and_belonging_to_many_relatives.
-        should have_and_belong_to_many(:relatives).class_name('Relative')
+      expect(having_and_belonging_to_many_relatives).
+        to have_and_belong_to_many(:relatives).class_name('Relative')
     end
 
     it 'accepts an association with a valid :class_name option' do
-      define_model :person_relative, :adopted => :boolean
+      define_model :person_relative, adopted: :boolean
       define_model :person do
-        has_and_belongs_to_many :relatives, :class_name => 'PersonRelative'
+        has_and_belongs_to_many :relatives, class_name: 'PersonRelative'
       end
 
-      define_model :people_person_relative, :person_id => :integer,
-        :person_relative_id => :integer
+      define_model :people_person_relative, person_id: :integer,
+        person_relative_id: :integer
 
-      Person.new.should have_and_belong_to_many(:relatives).class_name('PersonRelative')
+      expect(Person.new).to have_and_belong_to_many(:relatives).class_name('PersonRelative')
     end
 
     it 'rejects an association with a bad :class_name option' do
-      having_and_belonging_to_many_relatives.
-        should_not have_and_belong_to_many(:relatives).class_name('PersonRelatives')
+      expect(having_and_belonging_to_many_relatives).
+        not_to have_and_belong_to_many(:relatives).class_name('PersonRelatives')
+    end
+
+    it 'rejects an association with non-existent implicit class name' do
+      expect(having_and_belonging_to_many_non_existent_class(:person, :relatives)).
+        not_to have_and_belong_to_many(:relatives)
+    end
+
+    it 'rejects an association with non-existent explicit class name' do
+      expect(having_and_belonging_to_many_non_existent_class(:person, :relatives, class_name: 'Relative')).
+        not_to have_and_belong_to_many(:relatives)
+    end
+
+    it 'adds error message when rejecting an association with non-existent class' do
+      message = 'Expected Person to have a has_and_belongs_to_many association called relatives (Relative2 does not exist)'
+      expect {
+        expect(having_and_belonging_to_many_non_existent_class(:person, :relatives, class_name: 'Relative2')).
+          to have_and_belong_to_many(:relatives)
+      }.to fail_with_message(message)
+    end
+
+    it 'accepts an association with a matching :autosave option' do
+      define_model :relatives, adopted: :boolean
+      define_model :person do
+        has_and_belongs_to_many :relatives, autosave: true
+      end
+      define_model :people_relative, person_id: :integer,
+                                     relative_id: :integer
+      expect(Person.new).to have_and_belong_to_many(:relatives).autosave(true)
+    end
+
+    it 'rejects an association with a non-matching :autosave option with the correct message' do
+      define_model :relatives, adopted: :boolean
+      define_model :person do
+        has_and_belongs_to_many :relatives
+      end
+      define_model :people_relative, person_id: :integer,
+                                     relative_id: :integer
+
+      message = 'Expected Person to have a has_and_belongs_to_many association called relatives (relatives should have autosave set to true)'
+      expect {
+        expect(Person.new).to have_and_belong_to_many(:relatives).autosave(true)
+      }.to fail_with_message(message)
     end
 
     context 'validate' do
       it 'accepts when the :validate option matches' do
-        having_and_belonging_to_many_relatives(:validate => false).
-          should have_and_belong_to_many(:relatives).validate(false)
+        expect(having_and_belonging_to_many_relatives(validate: false)).
+          to have_and_belong_to_many(:relatives).validate(false)
       end
 
       it 'rejects when the :validate option does not match' do
-        having_and_belonging_to_many_relatives(:validate => true).
-          should have_and_belong_to_many(:relatives).validate(false)
+        expect(having_and_belonging_to_many_relatives(validate: true)).
+          to have_and_belong_to_many(:relatives).validate(false)
       end
 
       it 'assumes validate() means validate(true)' do
-        having_and_belonging_to_many_relatives(:validate => false).
-          should_not have_and_belong_to_many(:relatives).validate
+        expect(having_and_belonging_to_many_relatives(validate: false)).
+          not_to have_and_belong_to_many(:relatives).validate
       end
 
       it 'matches validate(false) to having no validate option specified' do
-        having_and_belonging_to_many_relatives.
-          should have_and_belong_to_many(:relatives).validate(false)
+        expect(having_and_belonging_to_many_relatives).
+          to have_and_belong_to_many(:relatives).validate(false)
       end
     end
 
     def having_and_belonging_to_many_relatives(options = {})
       define_model :relative
-      define_model :people_relative, :id => false, :person_id => :integer,
-        :relative_id => :integer
+      define_model :people_relative, id: false, person_id: :integer,
+        relative_id: :integer
       define_model :person do
         has_and_belongs_to_many :relatives
       end.new
     end
+
+    def having_and_belonging_to_many_non_existent_class(model_name, assoc_name, options = {})
+      define_model model_name do
+        has_and_belongs_to_many assoc_name, options
+      end.new
+    end
   end
 
   def define_association_with_conditions(model, macro, name, conditions, other_options={})