shoulda-matchers 2.6.2 → 2.7.0

data/spec/shoulda/matchers/active_model/{ensure_inclusion_of_matcher_spec.rb → validate_inclusion_of_matcher_spec.rb}

@@ -1,6 +1,22 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
+describe Shoulda::Matchers::ActiveModel do
+  describe '#ensure_inclusion_of' do
+    it 'is aliased to #validate_inclusion_of' do
+      matchers.expects(:validate_inclusion_of).with(:attr)
+
+      silence_warnings do
+        matchers.ensure_inclusion_of(:attr)
+      end
+    end
+  end
+
+  def matchers
+    @_matchers ||= Object.new.extend(described_class)
+  end
+end
+
+describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher do
   shared_context 'for a generic attribute' do
     def self.testing_values_of_option(option_name, &block)
       [nil, true, false].each do |option_value|
@@ -172,7 +188,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
       end
 
       it 'does not match when validation uses the default message instead of given message' do
-        pending 'does not work'
+        skip 'does not work'
 
         builder = build_object_allowing(valid_values)
 
@@ -182,7 +198,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
       end
 
       it 'does not match when validation uses a message but it is not same as given' do
-        pending 'does not work'
+        skip 'does not work'
 
         builder = build_object_allowing(valid_values, message: 'a different message')
 
@@ -202,7 +218,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
       end
 
       it 'does not match when validation uses the default message instead of given message' do
-        pending 'does not work'
+        skip 'does not work'
 
         builder = build_object_allowing(valid_values)
 
@@ -212,7 +228,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
       end
 
       it 'does not match when validation uses a message but it does not match regex' do
-        pending 'does not work'
+        skip 'does not work'
 
         builder = build_object_allowing(valid_values, message: 'a different message')
 
@@ -433,16 +449,18 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
         end
       end
 
-      it 'prints a warning' do
-        valid_values = [true, false]
-        builder = build_object_allowing(valid_values)
-        message = 'You are using `ensure_inclusion_of` to assert that a boolean column allows boolean values and disallows non-boolean ones'
+      [[false, true], [true, false]].each do |booleans|
+        it 'prints a warning' do
+          valid_values = booleans
+          builder = build_object_allowing(valid_values)
+          message = 'You are using `validate_inclusion_of` to assert that a boolean column allows boolean values and disallows non-boolean ones'
 
-        stderr = capture(:stderr) do
-          expect_to_match_in_array(builder, valid_values)
-        end
+          stderr = capture(:stderr) do
+            expect_to_match_in_array(builder, valid_values)
+          end
 
-        expect(stderr.gsub(/\n+/, ' ')).to include(message)
+          expect(stderr.gsub(/\n+/, ' ')).to include(message)
+        end
       end
     end
   end
@@ -466,7 +484,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
           it 'prints a warning' do
             valid_values = [nil]
             builder = build_object_allowing(valid_values)
-            message = 'You are using `ensure_inclusion_of` to assert that a boolean column allows nil'
+            message = 'You are using `validate_inclusion_of` to assert that a boolean column allows nil'
 
             stderr = capture(:stderr) do
               expect_to_match_in_array(builder, valid_values)
@@ -599,13 +617,13 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
   end
 
   def expect_to_match(builder)
-    matcher = ensure_inclusion_of(builder.attribute)
+    matcher = validate_inclusion_of(builder.attribute)
     yield matcher if block_given?
     expect(builder.object).to(matcher)
   end
 
   def expect_not_to_match(builder)
-    matcher = ensure_inclusion_of(builder.attribute)
+    matcher = validate_inclusion_of(builder.attribute)
     yield matcher if block_given?
     expect(builder.object).not_to(matcher)
   end

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

@@ -47,6 +47,41 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
         expect(Example.count).to eq 0
         expect(validating_uniqueness_with_other).to matcher
       end
+
+      context "and the table uses non-nullable columns, set beforehand" do
+        it "does not require the record to be persisted" do
+          model = define_model_with_non_nullable_column
+          record = model.new(required_attribute_name => "some value")
+          expect(record).to validate_uniqueness_of(unique_attribute_name)
+        end
+
+        def define_model_with_non_nullable_column
+          model = define_model(:example,
+            unique_attribute_name => :string,
+            required_attribute_name => {
+              type: :string,
+              options: { null: false }
+            }
+          )
+
+          model.tap do
+            model.attr_accessible(
+              required_attribute_name,
+              unique_attribute_name
+            )
+            model.validates_presence_of(required_attribute_name)
+            model.validates_uniqueness_of(unique_attribute_name)
+          end
+        end
+
+        def required_attribute_name
+          :required_attribute_name
+        end
+
+        def unique_attribute_name
+          :unique_attribute_name
+        end
+      end
     end
 
     def define_model_with_other(options = {})

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

@@ -712,7 +712,62 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
         has_and_belongs_to_many :relatives
       end
 
-      expect(Person.new).not_to have_and_belong_to_many(:relatives)
+      expected_failure_message = "join table people_relatives doesn't exist"
+
+      expect do
+        expect(Person.new).to have_and_belong_to_many(:relatives)
+      end.to fail_with_message_including(expected_failure_message)
+    end
+
+    it 'rejects an association with a join table with incorrect columns' do
+      define_model :relative
+      define_model :person do
+        has_and_belongs_to_many :relatives
+      end
+
+      define_model :people_relative, id: false, some_crazy_id: :integer
+
+      expect do
+        expect(Person.new).to have_and_belong_to_many(:relatives)
+      end.to fail_with_message_including('missing columns: person_id, relative_id')
+    end
+
+    context 'using a custom foreign key' do
+      it 'rejects an association with a join table with incorrect columns' do
+        define_model :relative
+        define_model :person do
+          has_and_belongs_to_many :relatives,
+            foreign_key: :custom_foreign_key_id
+        end
+
+        define_model :people_relative,
+          id: false,
+          custom_foreign_key_id: :integer,
+          some_crazy_id: :integer
+
+        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
+    end
+
+    context 'using a custom association foreign key' do
+      it 'rejects an association with a join table with incorrect columns' do
+        define_model :relative
+        define_model :person do
+          has_and_belongs_to_many :relatives,
+            association_foreign_key: :custom_association_foreign_key_id
+        end
+
+        define_model :people_relative,
+          id: false,
+          custom_association_foreign_key_id: :integer,
+          some_crazy_id: :integer
+
+        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
     end
 
     it 'rejects an association of the wrong type' do

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

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+describe Shoulda::Matchers::ActiveRecord::DefineEnumForMatcher do
+  if active_record_supports_enum?
+    describe "with only the attribute name specified" do
+      it "accepts a record where the attribute is defined as an enum" do
+        expect(record_with_array_values).to define_enum_for(enum_attribute)
+      end
+
+      it "rejects a record where the attribute is not defined as an enum" do
+        message = "Expected #{record_with_array_values.class} to define :#{non_enum_attribute} as an enum"
+
+        expect do
+          expect(record_with_array_values).to define_enum_for(non_enum_attribute)
+        end.to fail_with_message(message)
+      end
+
+      it "rejects a record where the attribute is not defined as an enum with should not" do
+        message = "Did not expect #{record_with_array_values.class} to define :#{enum_attribute} as an enum"
+
+        expect do
+          expect(record_with_array_values).to_not define_enum_for(enum_attribute)
+        end.to fail_with_message(message)
+      end
+    end
+
+    describe "with both attribute name and enum values specified" do
+      context "when the actual enum values are an array" do
+        it "accepts a record where the attribute is defined as an enum and the enum values match" do
+          expect(record_with_array_values).to define_enum_for(enum_attribute).
+            with(["published", "unpublished", "draft"])
+        end
+
+        it "accepts a record where the attribute is not defined as an enum" do
+          message = %{Expected #{record_with_array_values.class} to define :#{non_enum_attribute} as an enum with ["open", "close"]}
+
+          expect do
+            expect(record_with_array_values).to define_enum_for(non_enum_attribute).with(["open", "close"])
+          end.to fail_with_message(message)
+        end
+
+        it "accepts a record where the attribute is defined as an enum but the enum values do not match" do
+          message = %{Expected #{record_with_array_values.class} to define :#{enum_attribute} as an enum with ["open", "close"]}
+
+          expect do
+            expect(record_with_array_values).to define_enum_for(enum_attribute).with(["open", "close"])
+          end.to fail_with_message(message)
+        end
+      end
+
+      context "when the actual enum values are a hash" do
+        it "accepts a record where the attribute is defined as an enum and the enum values match" do
+          expect(record_with_hash_values).to define_enum_for(enum_attribute).with(active: 0, archived: 1)
+        end
+
+        it "accepts a record where the enum values match when expected enum values are given as an array" do
+          expect(record_with_hash_values).to define_enum_for(enum_attribute).with(["active", "archived"])
+        end
+
+        it "accepts a record where the attribute is defined as an enum but the enum values do not match" do
+          message = %{Expected #{record_with_hash_values.class} to define :#{enum_attribute} as an enum with {:active=>5, :archived=>10}}
+
+          expect do
+            expect(record_with_hash_values).to define_enum_for(enum_attribute).with(active: 5, archived: 10)
+          end.to fail_with_message(message)
+        end
+
+        it "rejects a record where the attribute is not defined as an enum" do
+          message = %{Expected #{record_with_hash_values.class} to define :record_with_hash_values as an enum with {:active=>5, :archived=>10}}
+
+          expect do
+            expect(record_with_hash_values)
+              .to define_enum_for(:record_with_hash_values).with(active: 5, archived: 10)
+          end.to fail_with_message(message)
+        end
+      end
+    end
+
+    def enum_attribute
+      :status
+    end
+
+    def non_enum_attribute
+      :condition
+    end
+
+    def record_with_array_values
+      _enum_attribute = enum_attribute
+      define_model :record_with_array_values do
+        enum(_enum_attribute => %w(published unpublished draft))
+      end.new
+    end
+
+    def record_with_hash_values
+      _enum_attribute = enum_attribute
+      define_model :record_with_hash_values do
+        enum(_enum_attribute => { active: 0, archived: 1 })
+      end.new
+    end
+  end
+end

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

@@ -5,17 +5,17 @@ module Shoulda::Matchers::Doublespeak
     it 'responds to any method' do
       double = described_class.new
 
-      expect(double.respond_to?(:foo)).to be_true
-      expect(double.respond_to?(:bar)).to be_true
-      expect(double.respond_to?(:baz)).to be_true
+      expect(double.respond_to?(:foo)).to be true
+      expect(double.respond_to?(:bar)).to be true
+      expect(double.respond_to?(:baz)).to be true
     end
 
     it 'returns nil from any method call' do
       double = described_class.new
 
-      expect(double.foo).to be_nil
-      expect(double.bar).to be_nil
-      expect(double.baz).to be_nil
+      expect(double.foo).to be nil
+      expect(double.bar).to be nil
+      expect(double.baz).to be nil
     end
 
     it 'records every method call' do

data/spec/shoulda/matchers/independent/{delegate_matcher → delegate_method_matcher}/stubbed_target_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::Independent::DelegateMatcher::StubbedTarget do
+describe Shoulda::Matchers::Independent::DelegateMethodMatcher::StubbedTarget do
   subject(:target) { described_class.new(:stubbed_method) }
 
   describe '#has_received_method?' do

data/spec/shoulda/matchers/independent/{delegate_matcher_spec.rb → delegate_method_matcher_spec.rb}

@@ -1,32 +1,68 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::Independent::DelegateMatcher do
+describe Shoulda::Matchers::Independent::DelegateMethodMatcher 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)
+    context 'against an instance' do
+      subject { Object.new }
 
-        expect(matcher.description).
-          to eq 'delegate method #method_name to :target'
+      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_name to #target object'
+        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_name to #target object as #alternate'
+
+          expect(matcher.description).to eq message
+        end
       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'
+      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_name to #target object passing arguments [:foo, {:bar=>[1, 2]}]'
 
-        expect(matcher.description).to eq message
+          expect(matcher.description).to eq message
+        end
       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]}]'
+    context 'against a class' do
+      subject { Object }
+
+      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_name to .target object'
+        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_name to .target object 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_name to .target object passing arguments [:foo, {:bar=>[1, 2]}]'
 
-        expect(matcher.description).to eq message
+          expect(matcher.description).to eq message
+        end
       end
     end
   end
@@ -80,8 +116,8 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
     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',
-        'Calls on PostOffice#mailman: (none)'
+        'Expected PostOffice to delegate #deliver_mail to #mailman object',
+        'Method calls sent to PostOffice#mailman: (none)'
       ].join("\n")
 
       expect {
@@ -91,8 +127,8 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
     it 'uses the proper syntax for class methods in errors' do
       message = [
-        'Expected PostOffice.deliver_mail to delegate to PostOffice.mailman',
-        'Calls on PostOffice.mailman: (none)'
+        'Expected PostOffice to delegate .deliver_mail to .mailman object',
+        'Method calls sent to PostOffice.mailman: (none)'
       ].join("\n")
 
       expect {
@@ -123,7 +159,7 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
     it 'produces the correct failure message if the assertion was negated' do
       post_office = PostOffice.new
-      message = 'Expected PostOffice#deliver_mail not to delegate to PostOffice#mailman, but it did'
+      message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object, but it did'
 
       expect {
         expect(post_office).not_to delegate_method(:deliver_mail).to(:mailman)
@@ -131,6 +167,29 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
     end
   end
 
+  context 'given a private method that delegates properly' do
+    before do
+      define_class(:mailman)
+
+      define_class(:post_office) do
+        def deliver_mail
+          mailman.deliver_mail
+        end
+
+        def mailman
+          Mailman.new
+        end
+
+        private :mailman
+      end
+    end
+
+    it 'accepts' do
+      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
     before do
       define_class(:mailman)
@@ -155,7 +214,7 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
       it 'produces the correct failure message if the assertion was negated' do
         post_office = PostOffice.new
-        message = 'Expected PostOffice#deliver_mail not to delegate to PostOffice#mailman with arguments: ["221B Baker St.", {:hastily=>true}], but it did'
+        message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object passing arguments ["221B Baker St.", {:hastily=>true}], but it did'
 
         expect {
           expect(post_office).
@@ -177,8 +236,8 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
       it 'has a failure message that indicates which arguments were expected' do
         post_office = PostOffice.new
         message = [
-          'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman with arguments: ["123 Nowhere Ln."]',
-          'Calls on PostOffice#mailman:',
+          'Expected PostOffice to delegate #deliver_mail to #mailman object passing arguments ["123 Nowhere Ln."]',
+          'Method calls sent to PostOffice#mailman:',
           '1) deliver_mail("221B Baker St.", {:hastily=>true})'
         ].join("\n")
 
@@ -214,7 +273,7 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
       it 'produces the correct failure message if the assertion was negated' do
         post_office = PostOffice.new
-        message = 'Expected PostOffice#deliver_mail not to delegate to PostOffice#mailman as #deliver_mail_and_avoid_dogs, but it did'
+        message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object as #deliver_mail_and_avoid_dogs, but it did'
 
         expect {
           expect(post_office).
@@ -235,8 +294,8 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
       it 'has a failure message that indicates which method was expected' do
         post_office = PostOffice.new
         message = [
-          'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman as #watch_tv',
-          'Calls on PostOffice#mailman:',
+          'Expected PostOffice to delegate #deliver_mail to #mailman object as #watch_tv',
+          'Method calls sent to PostOffice#mailman:',
           '1) deliver_mail_and_avoid_dogs()'
         ].join("\n")