shoulda-matchers 2.7.0 → 2.8.0.rc1

data/spec/{shoulda/matchers/active_model/ensure_length_of_matcher_spec.rb → unit/shoulda/matchers/active_model/validate_length_of_matcher_spec.rb}

@@ -1,75 +1,93 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
+describe Shoulda::Matchers::ActiveModel, type: :model do
+  describe '#ensure_length_of' do
+    it 'is aliased to #validate_length_of' do
+      allow(matchers).to receive(:validate_length_of)
+
+      silence_warnings do
+        matchers.ensure_length_of(:attr)
+        expect(matchers).to have_received(:validate_length_of).with(:attr)
+      end
+    end
+  end
+
+  def matchers
+    @_matchers ||= Object.new.extend(described_class)
+  end
+end
+
+describe Shoulda::Matchers::ActiveModel::ValidateLengthOfMatcher, type: :model do
   context 'an attribute with a non-zero minimum length validation' do
     it 'accepts ensuring the correct minimum length' do
       expect(validating_length(minimum: 4)).
-        to ensure_length_of(:attr).is_at_least(4)
+        to validate_length_of(:attr).is_at_least(4)
     end
 
     it 'rejects ensuring a lower minimum length with any message' do
       expect(validating_length(minimum: 4)).
-        not_to ensure_length_of(:attr).is_at_least(3).with_short_message(/.*/)
+        not_to validate_length_of(:attr).is_at_least(3).with_short_message(/.*/)
     end
 
     it 'rejects ensuring a higher minimum length with any message' do
       expect(validating_length(minimum: 4)).
-        not_to ensure_length_of(:attr).is_at_least(5).with_short_message(/.*/)
+        not_to validate_length_of(:attr).is_at_least(5).with_short_message(/.*/)
     end
 
     it 'does not override the default message with a blank' do
       expect(validating_length(minimum: 4)).
-        to ensure_length_of(:attr).is_at_least(4).with_short_message(nil)
+        to validate_length_of(:attr).is_at_least(4).with_short_message(nil)
     end
   end
 
   context 'an attribute with a minimum length validation of 0' do
     it 'accepts ensuring the correct minimum length' do
       expect(validating_length(minimum: 0)).
-        to ensure_length_of(:attr).is_at_least(0)
+        to validate_length_of(:attr).is_at_least(0)
     end
   end
 
   context 'an attribute with a maximum length' do
     it 'accepts ensuring the correct maximum length' do
       expect(validating_length(maximum: 4)).
-        to ensure_length_of(:attr).is_at_most(4)
+        to validate_length_of(:attr).is_at_most(4)
     end
 
     it 'rejects ensuring a lower maximum length with any message' do
       expect(validating_length(maximum: 4)).
-        not_to ensure_length_of(:attr).is_at_most(3).with_long_message(/.*/)
+        not_to validate_length_of(:attr).is_at_most(3).with_long_message(/.*/)
     end
 
     it 'rejects ensuring a higher maximum length with any message' do
       expect(validating_length(maximum: 4)).
-        not_to ensure_length_of(:attr).is_at_most(5).with_long_message(/.*/)
+        not_to validate_length_of(:attr).is_at_most(5).with_long_message(/.*/)
     end
 
     it 'does not override the default message with a blank' do
       expect(validating_length(maximum: 4)).
-        to ensure_length_of(:attr).is_at_most(4).with_long_message(nil)
+        to validate_length_of(:attr).is_at_most(4).with_long_message(nil)
     end
   end
 
   context 'an attribute with a required exact length' do
     it 'accepts ensuring the correct length' do
-      expect(validating_length(is: 4)).to ensure_length_of(:attr).is_equal_to(4)
+      expect(validating_length(is: 4)).
+        to validate_length_of(:attr).is_equal_to(4)
     end
 
     it 'rejects ensuring a lower maximum length with any message' do
       expect(validating_length(is: 4)).
-        not_to ensure_length_of(:attr).is_equal_to(3).with_message(/.*/)
+        not_to validate_length_of(:attr).is_equal_to(3).with_message(/.*/)
     end
 
     it 'rejects ensuring a higher maximum length with any message' do
       expect(validating_length(is: 4)).
-        not_to ensure_length_of(:attr).is_equal_to(5).with_message(/.*/)
+        not_to validate_length_of(:attr).is_equal_to(5).with_message(/.*/)
     end
 
     it 'does not override the default message with a blank' do
       expect(validating_length(is: 4)).
-        to ensure_length_of(:attr).is_equal_to(4).with_message(nil)
+        to validate_length_of(:attr).is_equal_to(4).with_message(nil)
     end
   end
 
@@ -80,35 +98,35 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
         validates_numericality_of :attr
       end.new
 
-      expect(model).to ensure_length_of(:attr).is_equal_to(4)
+      expect(model).to validate_length_of(:attr).is_equal_to(4)
     end
   end
 
   context 'an attribute with a custom minimum length validation' do
     it 'accepts ensuring the correct minimum length' do
       expect(validating_length(minimum: 4, too_short: 'foobar')).
-        to ensure_length_of(:attr).is_at_least(4).with_short_message(/foo/)
+        to validate_length_of(:attr).is_at_least(4).with_short_message(/foo/)
     end
   end
 
   context 'an attribute with a custom maximum length validation' do
     it 'accepts ensuring the correct minimum length' do
       expect(validating_length(maximum: 4, too_long: 'foobar')).
-        to ensure_length_of(:attr).is_at_most(4).with_long_message(/foo/)
+        to validate_length_of(:attr).is_at_most(4).with_long_message(/foo/)
     end
   end
 
   context 'an attribute with a custom equal validation' do
     it 'accepts ensuring the correct exact length' do
       expect(validating_length(is: 4, message: 'foobar')).
-        to ensure_length_of(:attr).is_equal_to(4).with_message(/foo/)
+        to validate_length_of(:attr).is_equal_to(4).with_message(/foo/)
     end
   end
 
   context 'an attribute without a length validation' do
     it 'rejects ensuring a minimum length' do
       expect(define_model(:example, attr: :string).new).
-        not_to ensure_length_of(:attr).is_at_least(1)
+        not_to validate_length_of(:attr).is_at_least(1)
     end
   end
 
@@ -124,7 +142,8 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
 
       it "does not raise an exception" do
         expect {
-          expect(validating_length(maximum: 4)).to ensure_length_of(:attr).is_at_most(4)
+          expect(validating_length(maximum: 4)).
+            to validate_length_of(:attr).is_at_most(4)
         }.to_not raise_exception
       end
     end
@@ -138,7 +157,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
 
       it "does not raise an exception" do
         expect {
-          expect(validating_length(minimum: 4)).to ensure_length_of(:attr).is_at_least(4)
+          expect(validating_length(minimum: 4)).to validate_length_of(:attr).is_at_least(4)
         }.to_not raise_exception
       end
     end
@@ -152,7 +171,8 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
 
       it "does not raise an exception" do
         expect {
-          expect(validating_length(is: 4)).to ensure_length_of(:attr).is_equal_to(4)
+          expect(validating_length(is: 4)).
+            to validate_length_of(:attr).is_equal_to(4)
         }.to_not raise_exception
       end
     end

data/spec/{shoulda → unit/shoulda}/matchers/active_model/validate_numericality_of_matcher_spec.rb

@@ -1,7 +1,6 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
+require 'unit_spec_helper'
 
+describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :model do
   context 'with a model with a numericality validation' do
     it 'accepts' do
       expect(validating_numericality).to matcher
@@ -278,7 +277,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
         def set_attr!; self.attr = 5 end
       end.new
 
-      subject.stubs(:set_attr!)
+      allow(subject).to receive(:set_attr!)
       expect(subject).to matcher.odd
     end
   end

data/spec/{shoulda → unit/shoulda}/matchers/active_model/validate_presence_of_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
+describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher, type: :model do
   context 'a model with a presence validation' do
     it 'accepts' do
       expect(validating_presence).to matcher
@@ -33,7 +33,7 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
     end
 
     it 'provides the correct failure message' do
-      message = %{Expected errors to include "can't be blank" when attr is set to nil, got no errors}
+      message = %{Expected errors to include "can't be blank" when attr is set to nil,\ngot no errors}
 
       expect { expect(active_model).to matcher }.to fail_with_message(message)
     end

data/spec/{shoulda → unit/shoulda}/matchers/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
+describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :model do
   context 'a model without a a uniqueness validation' do
     it 'rejects' do
       model = define_model(:example, attr: :string) { attr_accessible :attr } .new
@@ -418,6 +418,131 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     end
   end
 
+  context 'when the validation allows blank' do
+    context 'when there is an existing record with a blank value' do
+      it 'accepts' do
+        model = model_allowing_blank
+        model.create!(attribute_name => '')
+        expect(model.new).to matcher.allow_blank
+      end
+    end
+
+    context 'when there is not an an existing record with a blank value' do
+      it 'still accepts' do
+        expect(record_allowing_blank).to matcher.allow_blank
+      end
+
+      it 'automatically creates a record' do
+        model = model_allowing_blank
+        matcher.allow_blank.matches?(model.new)
+
+        record_created = model.all.any? do |instance|
+          instance.__send__(attribute_name).blank?
+        end
+
+        expect(record_created).to be true
+      end
+    end
+
+    def attribute_name
+      :attr
+    end
+
+    def model_allowing_blank
+      _attribute_name = attribute_name
+
+      define_model(:example, attribute_name => :string) do
+        attr_accessible _attribute_name
+        validates_uniqueness_of _attribute_name, allow_blank: true
+      end
+    end
+
+    def record_allowing_blank
+      model_allowing_blank.new
+    end
+  end
+
+  context 'when the validation does not allow blank' do
+    context 'when there is an existing entry with a blank value' do
+      it 'rejects' do
+        model = model_disallowing_blank
+        model.create!(attribute_name => '')
+        expect(model.new).not_to matcher.allow_blank
+      end
+    end
+
+    it 'should not allow_blank' do
+      expect(record_disallowing_blank).not_to matcher.allow_blank
+    end
+
+    def attribute_name
+      :attr
+    end
+
+    def model_disallowing_blank
+      _attribute_name = attribute_name
+
+      define_model(:example, attribute_name => :string) do
+        attr_accessible _attribute_name
+        validates_uniqueness_of _attribute_name, allow_blank: false
+      end
+    end
+
+    def record_disallowing_blank
+      model_disallowing_blank.new
+    end
+  end
+
+  context "when testing that a polymorphic *_type column is one of the validation scopes" do
+    it "sets that column to a meaningful value that works with other validations on the same column" do
+      user_model = define_model :user
+      favorite_columns = {
+        favoriteable_id: { type: :integer, options: { null: false } },
+        favoriteable_type: { type: :string, options: { null: false } }
+      }
+      favorite_model = define_model :favorite, favorite_columns do
+        attr_accessible :favoriteable
+        belongs_to :favoriteable, polymorphic: true
+        validates :favoriteable, presence: true
+        validates :favoriteable_id, uniqueness: { scope: :favoriteable_type }
+      end
+
+      user = user_model.create!
+      favorite_model.create!(favoriteable: user)
+      new_favorite = favorite_model.new
+
+      expect(new_favorite).
+        to validate_uniqueness_of(:favoriteable_id).
+        scoped_to(:favoriteable_type)
+    end
+
+    context "if the model the *_type column refers to is namespaced, and shares the last part of its name with an existing model" do
+      it "still works" do
+        define_class 'User'
+        define_module 'Models'
+        user_model = define_model 'Models::User'
+        favorite_columns = {
+          favoriteable_id: { type: :integer, options: { null: false } },
+          favoriteable_type: { type: :string, options: { null: false } }
+        }
+        favorite_model = define_model 'Models::Favorite', favorite_columns do
+          attr_accessible :favoriteable
+          belongs_to :favoriteable, polymorphic: true
+          validates :favoriteable, presence: true
+          validates :favoriteable_id, uniqueness: { scope: :favoriteable_type }
+        end
+
+        user = user_model.create!
+        favorite_model.create!(favoriteable: user)
+        new_favorite = favorite_model.new
+
+        expect(new_favorite).
+          to validate_uniqueness_of(:favoriteable_id).
+          scoped_to(:favoriteable_type)
+      end
+    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 → unit/shoulda}/matchers/active_model/validation_message_finder_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
   context '#allow_description' do
@@ -67,8 +67,9 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
 
       description = finder.messages_description
 
-      expected_messages = ['is invalid (attribute: "attr", value: "xyz")']
-      expect(description).to eq "errors: #{expected_messages}"
+      expect(description).to eq(
+        %{ errors:\n* "is invalid" (attribute: attr, value: "xyz")}
+      )
     end
 
     it 'describes errors when there are none' do
@@ -76,7 +77,7 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
 
       description = finder.messages_description
 
-      expect(description).to 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
@@ -87,8 +88,9 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
       end.new
       finder = Shoulda::Matchers::ActiveModel::ValidationMessageFinder.new(instance, :attribute)
 
-      expected_messages = ['is invalid (attribute: "association.association_attribute")']
-      expect(finder.messages_description).to eq "errors: #{expected_messages}"
+      expect(finder.messages_description).to eq(
+        %{ errors:\n* "is invalid" (attribute: association.association_attribute)}
+      )
     end
 
   end

data/spec/{shoulda → unit/shoulda}/matchers/active_record/accept_nested_attributes_for_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
+describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher, type: :model do
   it 'accepts an existing declaration' do
     expect(accepting_children).to accept_nested_attributes_for(:children)
   end

data/spec/{shoulda → unit/shoulda}/matchers/active_record/association_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
+describe Shoulda::Matchers::ActiveRecord::AssociationMatcher, type: :model do
   context 'belong_to' do
     it 'accepts a good association with the default foreign key' do
       expect(belonging_to_parent).to belong_to(:parent)
@@ -29,6 +29,22 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       expect(Child.new).to belong_to(:parent)
     end
 
+    it 'accepts an association using an existing custom primary key' do
+      define_model :parent
+      define_model :child, parent_id: :integer, custom_primary_key: :integer do
+        belongs_to :parent, primary_key: :custom_primary_key
+      end
+      expect(Child.new).to belong_to(:parent).with_primary_key(:custom_primary_key)
+    end
+
+    it 'rejects an association with a bad :primary_key option' do
+      matcher = belong_to(:parent).with_primary_key(:custom_primary_key)
+
+      expect(belonging_to_parent).not_to matcher
+
+      expect(matcher.failure_message).to match(/Child does not have a custom_primary_key primary key/)
+    end
+
     it 'accepts a polymorphic association' do
       define_model :child, parent_type: :string, parent_id: :integer do
         belongs_to :parent, polymorphic: true
@@ -130,6 +146,31 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       }.to fail_with_message(message)
     end
 
+    it 'accepts an association with a namespaced class name' do
+      define_module 'Models'
+      define_model 'Models::Organization'
+      user_model = define_model 'Models::User', organization_id: :integer do
+        belongs_to :organization, class_name: 'Organization'
+      end
+
+      expect(user_model.new).
+        to belong_to(:organization).
+        class_name('Organization')
+    end
+
+    it 'resolves class_name within the context of the namespace before the global namespace' do
+      define_module 'Models'
+      define_model 'Organization'
+      define_model 'Models::Organization'
+      user_model = define_model 'Models::User', organization_id: :integer do
+        belongs_to :organization, class_name: 'Organization'
+      end
+
+      expect(user_model.new).
+        to belong_to(:organization).
+        class_name('Organization')
+    end
+
     it 'accepts an association with a matching :autosave option' do
       define_model :parent, adopter: :boolean
       define_model :child, parent_id: :integer do
@@ -288,6 +329,22 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       expect(Parent.new).not_to have_many(:children)
     end
 
+    it 'accepts an association using an existing custom primary key' do
+      define_model :child, parent_id: :integer
+      define_model :parent, custom_primary_key: :integer do
+        has_many :children, primary_key: :custom_primary_key
+      end
+      expect(Parent.new).to have_many(:children).with_primary_key(:custom_primary_key)
+    end
+
+    it 'rejects an association with a bad :primary_key option' do
+      matcher = have_many(:children).with_primary_key(:custom_primary_key)
+
+      expect(having_many_children).not_to matcher
+
+      expect(matcher.failure_message).to match(/Parent does not have a custom_primary_key primary key/)
+    end
+
     it 'rejects an association with a bad :as option' do
       define_model :child, caretaker_type: :string,
         caretaker_id: :integer
@@ -325,6 +382,16 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       expect(matcher.failure_message).to match(/through relationships, but got it through conceptions/)
     end
 
+    it 'produces a failure message without exception when association is missing :through option' do
+      define_model :child
+      define_model :parent
+      matcher = have_many(:children).through(:relationships).source(:child)
+      failure_message = 'Expected Parent to have a has_many association called children (no association called children)'
+
+      matcher.matches?(Parent.new)
+      expect(matcher.failure_message).to eq failure_message
+    end
+
     it 'accepts an association with a valid :dependent option' do
       expect(having_many_children(dependent: :destroy)).
         to have_many(:children).dependent(:destroy)
@@ -414,6 +481,31 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       }.to fail_with_message(message)
     end
 
+    it 'accepts an association with a namespaced class name' do
+      define_module 'Models'
+      define_model 'Models::Friend', user_id: :integer
+      friend_model = define_model 'Models::User' do
+        has_many :friends, class_name: 'Friend'
+      end
+
+      expect(friend_model.new).
+        to have_many(:friends).
+        class_name('Friend')
+    end
+
+    it 'resolves class_name within the context of the namespace before the global namespace' do
+      define_module 'Models'
+      define_model 'Friend'
+      define_model 'Models::Friend', user_id: :integer
+      friend_model = define_model 'Models::User' do
+        has_many :friends, class_name: 'Friend'
+      end
+
+      expect(friend_model.new).
+        to have_many(:friends).
+        class_name('Friend')
+    end
+
     it 'accepts an association with a matching :autosave option' do
       define_model :child, parent_id: :integer
       define_model :parent do
@@ -527,6 +619,22 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       expect(Person.new).to have_one(:detail).with_foreign_key(:detailed_person_id)
     end
 
+    it 'accepts an association using an existing custom primary key' do
+      define_model :detail, person_id: :integer
+      define_model :person, custom_primary_key: :integer do
+        has_one :detail, primary_key: :custom_primary_key
+      end
+      expect(Person.new).to have_one(:detail).with_primary_key(:custom_primary_key)
+    end
+
+    it 'rejects an association with a bad :primary_key option' do
+      matcher = have_one(:detail).with_primary_key(:custom_primary_key)
+
+      expect(having_one_detail).not_to matcher
+
+      expect(matcher.failure_message).to match(/Person does not have a custom_primary_key primary key/)
+    end
+
     it 'rejects an association with a bad :as option' do
       define_model :detail, detailable_id: :integer,
         detailable_type: :string
@@ -584,26 +692,6 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       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 do
@@ -632,6 +720,52 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       }.to fail_with_message(message)
     end
 
+    it 'accepts an association with a namespaced class name' do
+      define_module 'Models'
+      define_model 'Models::Account', user_id: :integer
+      user_model = define_model 'Models::User' do
+        has_one :account, class_name: 'Account'
+      end
+
+      expect(user_model.new).
+        to have_one(:account).
+        class_name('Account')
+    end
+
+    it 'resolves class_name within the context of the namespace before the global namespace' do
+      define_module 'Models'
+      define_model 'Account'
+      define_model 'Models::Account', user_id: :integer
+      user_model = define_model 'Models::User' do
+        has_one :account, class_name: 'Account'
+      end
+
+      expect(user_model.new).
+        to have_one(:account).
+        class_name('Account')
+    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 through' do
       define_model :detail
 
@@ -747,7 +881,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
         expect do
           expect(Person.new).to have_and_belong_to_many(:relatives)
-        end.to fail_with_message_including('missing columns: custom_foreign_key_id, relative_id')
+        end.to fail_with_message_including('missing column: relative_id')
       end
     end
 
@@ -766,8 +900,26 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
         expect do
           expect(Person.new).to have_and_belong_to_many(:relatives)
-        end.to fail_with_message_including('missing columns: person_id, custom_association_foreign_key_id')
+        end.to fail_with_message_including('missing column: person_id')
+      end
+
+      it 'accepts foreign keys when they are symbols' do
+        define_model :relative
+        define_model :person do
+          has_and_belongs_to_many :relatives,
+                                  foreign_key: :some_foreign_key_id,
+                                  association_foreign_key: :custom_association_foreign_key_id
+        end
+
+        define_model :people_relative,
+                     id: false,
+                     custom_association_foreign_key_id: :integer,
+                     some_foreign_key_id: :integer
+
+        expect(Person.new).to have_and_belong_to_many(:relatives)
+
       end
+
     end
 
     it 'rejects an association of the wrong type' do
@@ -841,6 +993,45 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       }.to fail_with_message(message)
     end
 
+    it 'accepts an association with a namespaced class name' do
+      possible_join_table_names = [:groups_users, :models_groups_users, :groups_models_users]
+      possible_join_table_names.each do |join_table_name|
+        create_table join_table_name, id: false do |t|
+          t.integer :group_id
+          t.integer :user_id
+        end
+      end
+      define_module 'Models'
+      define_model 'Models::Group'
+      user_model = define_model 'Models::User' do
+        has_and_belongs_to_many :groups, class_name: 'Group'
+      end
+
+      expect(user_model.new).
+        to have_and_belong_to_many(:groups).
+        class_name('Group')
+    end
+
+    it 'resolves class_name within the context of the namespace before the global namespace' do
+      possible_join_table_names = [:groups_users, :models_groups_users, :groups_models_users]
+      possible_join_table_names.each do |join_table_name|
+        create_table join_table_name, id: false do |t|
+          t.integer :group_id
+          t.integer :user_id
+        end
+      end
+      define_module 'Models'
+      define_model 'Group'
+      define_model 'Models::Group'
+      user_model = define_model 'Models::User' do
+        has_and_belongs_to_many :groups, class_name: 'Group'
+      end
+
+      expect(user_model.new).
+        to have_and_belong_to_many(:groups).
+        class_name('Group')
+    end
+
     it 'accepts an association with a matching :autosave option' do
       define_model :relatives, adopted: :boolean
       define_model :person do
@@ -907,7 +1098,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
     args = []
     options = {}
     if Shoulda::Matchers::RailsShim.active_record_major_version == 4
-      args << lambda { where(conditions) }
+      args << proc { where(conditions) }
     else
       options[:conditions] = conditions
     end
@@ -919,7 +1110,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
     args = []
     options = {}
     if Shoulda::Matchers::RailsShim.active_record_major_version == 4
-      args << lambda { order(order) }
+      args << proc { order(order) }
     else
       options[:order] = order
     end