shoulda-matchers 1.1.0 → 1.2.0

data/lib/shoulda/matchers/active_record/serialize_matcher.rb

@@ -18,15 +18,16 @@ module Shoulda # :nodoc:
       class SerializeMatcher # :nodoc:
         def initialize(name)
           @name = name.to_s
+          @options = {}
         end
 
         def as(type)
-          @type = type
+          @options[:type] = type
           self
         end
 
         def as_instance_of(type)
-          @instance_type = type
+          @options[:instance_type] = type
           self
         end
 
@@ -45,7 +46,7 @@ module Shoulda # :nodoc:
 
         def description
           description = "serialize :#{@name}"
-          description += " class_name => #{@type}" if @type
+          description += " class_name => #{@options[:type]}" if @options.key?(:type)
           description
         end
 
@@ -61,15 +62,15 @@ module Shoulda # :nodoc:
         end
 
         def class_valid?
-          if @type
+          if @options[:type]
             klass = model_class.serialized_attributes[@name]
-            if klass == @type
+            if klass == @options[:type]
               true
             else
-              if klass.respond_to?(:object_class) && klass.object_class == @type
+              if klass.respond_to?(:object_class) && klass.object_class == @options[:type]
                 true
               else
-                @missing = ":#{@name} should be a type of #{@type}"
+                @missing = ":#{@name} should be a type of #{@options[:type]}"
                 false
               end
             end
@@ -83,11 +84,11 @@ module Shoulda # :nodoc:
         end
 
         def instance_class_valid?
-          if @instance_type
-            if model_class.serialized_attributes[@name].class == @instance_type
+          if @options.key?(:instance_type)
+            if model_class.serialized_attributes[@name].class == @options[:instance_type]
               true
             else
-              @missing = ":#{@name} should be an instance of #{@type}"
+              @missing = ":#{@name} should be an instance of #{@options[:type]}"
               false
             end
           else
@@ -101,8 +102,8 @@ module Shoulda # :nodoc:
 
         def expectation
           expectation = "#{model_class.name} to serialize the attribute called :#{@name}"
-          expectation += " with a type of #{@type}" if @type
-          expectation += " with an instance of #{@instance_type}" if @instance_type
+          expectation += " with a type of #{@options[:type]}" if @options[:type]
+          expectation += " with an instance of #{@options[:instance_type]}" if @options[:instance_type]
           expectation
         end
       end

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = '1.1.0'.freeze
+    VERSION = '1.2.0'.freeze
   end
 end

data/shoulda-matchers.gemspec

@@ -26,5 +26,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency('cucumber',    '~> 1.1.9')
   s.add_development_dependency('rails',       '~> 3.0')
   s.add_development_dependency('rake',        '~> 0.9.2')
-  s.add_development_dependency('rspec-rails', '~> 2.6.1')
+  s.add_development_dependency('rspec-rails', '~> 2.8.1')
 end

data/spec/shoulda/action_controller/assign_to_matcher_spec.rb

@@ -2,12 +2,14 @@ require 'spec_helper'
 
 describe Shoulda::Matchers::ActionController::AssignToMatcher do
   it "should include the actual class in the failure message" do
-    define_constant(:WrongClass) do
-      def to_s; "wrong class" end
+    define_class(:WrongClass) do
+      def to_s
+        'wrong class'
+      end
     end
 
     controller = build_response { @var = WrongClass.new }
-    matcher = Shoulda::Matchers::ActionController::AssignToMatcher.new(:var).with_kind_of(Fixnum)
+    matcher = assign_to(:var).with_kind_of(Fixnum)
     matcher.matches?(controller)
 
     matcher.failure_message.should =~ /but got wrong class \(WrongClass\)$/

data/spec/shoulda/action_mailer/have_sent_email_spec.rb

@@ -272,6 +272,46 @@ describe Shoulda::Matchers::ActionMailer::HaveSentEmailMatcher do
     end
   end
 
+  context "testing multiple email deliveries at once" do
+    let(:info1) do
+      {
+        :from => "do-not-reply@example.com",
+        :to => "one@me.com",
+        :subject => "subject",
+        :body => "body"
+      }
+    end
+
+    let(:info2) do
+      {
+        :from => "do-not-reply@example.com",
+        :to => "two@me.com",
+        :subject => "subject",
+        :body => "body"
+      }
+    end
+
+    before do
+      define_mailer(:mailer, [:the_email]) do
+        def the_email(params)
+          mail params
+        end
+      end
+      add_mail_to_deliveries(info1)
+      add_mail_to_deliveries(info2)
+    end
+
+    after { ::ActionMailer::Base.deliveries.clear }
+
+    it "should send an e-mail based on recipient 1" do
+      should have_sent_email.to("one@me.com")
+    end
+
+    it "should send an e-mail based on recipient 2" do
+      should have_sent_email.to("two@me.com")
+    end
+  end
+
   it "provides a detailed description of the e-mail expected to be sent" do
     matcher = have_sent_email
     matcher.description.should == 'send an email'

data/spec/shoulda/active_model/allow_mass_assignment_of_matcher_spec.rb

@@ -49,17 +49,19 @@ describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher do
     end
   end
 
-  context "an attribute on a class with no protected attributes" do
-    let(:model) { define_model(:example, :attr => :string).new }
+  unless active_model_3_2?
+    context "an attribute on a class with no protected attributes" do
+      let(:model) { define_model(:example, :attr => :string).new }
 
-    it "should accept being mass-assignable" do
-      model.should allow_mass_assignment_of(:attr)
-    end
+      it "should accept being mass-assignable" do
+        model.should allow_mass_assignment_of(:attr)
+      end
 
-    it "should assign a negative failure message" do
-      matcher = allow_mass_assignment_of(:attr)
-      matcher.matches?(model).should == true
-      matcher.negative_failure_message.should_not be_nil
+      it "should assign a negative failure message" do
+        matcher = allow_mass_assignment_of(:attr)
+        matcher.matches?(model).should == true
+        matcher.negative_failure_message.should_not be_nil
+      end
     end
   end
 
@@ -75,7 +77,7 @@ describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher do
     end
   end
 
-  if ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1
+  if active_model_3_1?
     context "an attribute included in the mass-assignment whitelist for admin role only" do
       let(:model) do
         define_model(:example, :attr => :string) do

data/spec/shoulda/active_model/ensure_inclusion_of_matcher_spec.rb

@@ -65,7 +65,59 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
     it "should accept ensuring the correct range and messages" do
       @model.should ensure_inclusion_of(:attr).in_range(2..5).with_low_message(/low/).with_high_message(/high/)
     end
+  end
+
+  context "an attribute which must be included in an array" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_inclusion_of :attr, :in => %w(one two)
+      end.new
+    end
+
+    it "accepts with correct array" do
+      @model.should ensure_inclusion_of(:attr).in_array(%w(one two))
+    end
+
+    it "rejects when only part of array matches" do
+      @model.should_not ensure_inclusion_of(:attr).in_array(%w(one wrong_value))
+    end
+
+    it "rejects when array doesn't match at all" do
+      @model.should_not ensure_inclusion_of(:attr).in_array(%w(cat dog))
+    end
+
+    it "has correct description" do
+      ensure_inclusion_of(:attr).in_array([true, 'dog']).description.should == 'ensure inclusion of attr in [true, "dog"]'
+    end
+
+    it "rejects allow_blank" do
+      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank(true)
+      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank(false)
+    end
 
+    it "rejects allow_nil" do
+      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(true)
+      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(false)
+    end
   end
 
+  context "allowed blank and allowed nil" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+          validates_inclusion_of :attr, :in => %w(one two), :allow_blank => true, :allow_nil => true
+      end.new
+    end
+
+    it "allows allow_blank" do
+      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank(true)
+      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank()
+      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank(false)
+    end
+
+    it "allows allow_nil" do
+      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(true)
+      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil()
+      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(false)
+    end
+  end
 end

data/spec/shoulda/active_model/helpers_spec.rb

@@ -26,19 +26,23 @@ def store_translations(options = {:without => []})
   }
 
   unless options[:without].include?(:model_attribute)
-    translations[:activerecord][:errors][:models][:example][:attributes][:attr][:blank] = 'Don’t you do that to me!'
+    translations[:activerecord][:errors][:models][:example][:attributes][:attr][:blank] = "Don't you do that to me!"
+    translations[:activerecord][:errors][:models][:example][:attributes][:attr][:wrong_length] = "Don't you do that to me!"
   end
 
   unless options[:without].include?(:model)
     translations[:activerecord][:errors][:models][:example][:blank] = 'Give it one more try!'
+    translations[:activerecord][:errors][:models][:example][:wrong_length] = 'Give it one more try!'
   end
 
   unless options[:without].include?(:message)
     translations[:activerecord][:errors][:messages][:blank] = 'Oh no!'
+    translations[:activerecord][:errors][:messages][:wrong_length] = 'Oh no!'
   end
 
   unless options[:without].include?(:attribute)
     translations[:errors][:attributes][:attr][:blank] = 'Seriously?'
+    translations[:errors][:attributes][:attr][:wrong_length] = 'Seriously?'
   end
 
   I18n.backend.store_translations(:en, translations)
@@ -51,6 +55,7 @@ describe Shoulda::Matchers::ActiveModel::Helpers do
     before do
       define_model :example, :attr => :string do
         validates_presence_of :attr
+        validates_length_of :attr, :is => 40, :allow_blank => true
       end
       @model = Example.new
     end
@@ -58,40 +63,64 @@ describe Shoulda::Matchers::ActiveModel::Helpers do
     after { I18n.backend.reload! }
 
     context "if the translation for the model attribute’s error exists" do
-      it "provides the right error message" do
+      it "provides the right error message for validate_presence_of" do
         store_translations
         @model.should validate_presence_of(:attr)
       end
+
+      it "provides the right error message for validates_length_of" do
+        store_translations
+        @model.should ensure_length_of(:attr).is_equal_to(40)
+      end
     end
 
     context "if no translation for the model attribute’s error exists" do
       context "and the translation for the model’s error exists" do
-        it "provides the right error message" do
+        it "provides the right error message for validate_presence_of" do
           store_translations(:without => :model_attribute)
           @model.should validate_presence_of(:attr)
         end
+
+        it "provides the right error message for validates_length_of" do
+          store_translations(:without => :model_attribute)
+          @model.should ensure_length_of(:attr).is_equal_to(40)
+        end
       end
 
       context "and no translation for the model’s error exists" do
         context "and the translation for the message exists" do
-          it "provides the right error message" do
+          it "provides the right error message for validate_presence_of" do
             store_translations(:without => [:model_attribute, :model])
             @model.should validate_presence_of(:attr)
           end
+
+          it "provides the right error message for validates_length_of" do
+            store_translations(:without => [:model_attribute, :model])
+            @model.should ensure_length_of(:attr).is_equal_to(40)
+          end
         end
 
         context "and no translation for the message exists" do
           context "and the translation for the attribute exists" do
-            it "provides the right error message" do
+            it "provides the right error message for validate_presence_of" do
               store_translations(:without => [:model_attribute, :model, :message])
               @model.should validate_presence_of(:attr)
             end
+
+            it "provides the right error message for validates_length_of" do
+              store_translations(:without => [:model_attribute, :model, :message])
+              @model.should ensure_length_of(:attr).is_equal_to(40)
+            end
           end
 
           context "and no translation for the attribute exists" do
-            it "provides the general error message" do
+            it "provides the general error message for validate_presence_of" do
               @model.should validate_presence_of(:attr)
             end
+
+            it "provides the general error message for validates_length_of" do
+              @model.should ensure_length_of(:attr).is_equal_to(40)
+            end
           end
         end
       end

data/spec/shoulda/active_model/validate_presence_of_matcher_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
-
   context "a required attribute" do
     before do
       define_model :example, :attr => :string do

data/spec/shoulda/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -5,6 +5,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     before do
       @model = define_model(:example, :attr  => :string,
                                       :other => :integer) do
+        attr_accessible :attr, :other
         validates_uniqueness_of :attr
       end.new
     end
@@ -47,6 +48,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
   context "a unique attribute with a custom error and an existing value" do
     before do
       @model = define_model(:example, :attr => :string) do
+        attr_accessible :attr
         validates_uniqueness_of :attr, :message => 'Bad value'
       end.new
       Example.create!(:attr => 'value')
@@ -70,6 +72,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
       @model = define_model(:example, :attr   => :string,
                                       :scope1 => :integer,
                                       :scope2 => :integer) do
+        attr_accessible :attr, :scope1, :scope2
         validates_uniqueness_of :attr, :scope => [:scope1, :scope2]
       end.new
       @existing = Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2)
@@ -98,7 +101,9 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
 
   context "a non-unique attribute with an existing value" do
     before do
-      @model = define_model(:example, :attr => :string).new
+      @model = define_model(:example, :attr => :string) do
+        attr_accessible :attr
+      end.new
       Example.create!(:attr => 'value')
     end
 
@@ -110,6 +115,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
   context "a case sensitive unique attribute with an existing value" do
     before do
       @model = define_model(:example, :attr  => :string) do
+        attr_accessible :attr
         validates_uniqueness_of :attr, :case_sensitive => true
       end.new
       Example.create!(:attr => 'value')
@@ -127,6 +133,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
   context "a case sensitive unique integer attribute with an existing value" do
     before do
       @model = define_model(:example, :attr  => :integer) do
+        attr_accessible :attr
         validates_uniqueness_of :attr, :case_sensitive => true
       end.new
       Example.create!(:attr => 'value')

data/spec/shoulda/active_record/serialize_matcher_spec.rb

@@ -59,7 +59,7 @@ describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
 
     context "a serializer that is an instance of a class" do
       before do
-        define_constant(:ExampleSerializer, Object) do
+        define_class(:ExampleSerializer, Object) do
           def load(*); end
           def dump(*); end
         end

data/spec/support/active_model_versions.rb

@@ -0,0 +1,9 @@
+RSpec.configure do |c|
+  def active_model_3_1?
+    ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1
+  end
+
+  def active_model_3_2?
+    ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 2
+  end
+end

data/spec/support/model_builder.rb

@@ -28,11 +28,19 @@ module ModelBuilder
     end
   end
 
-  def define_constant(class_name, base = Object, &block)
+  def define_class(class_name, base = Object, &block)
     class_name = class_name.to_s.camelize
 
-    Class.new(base).tap do |constant_class|
-      Object.const_set(class_name, constant_class)
+    # FIXME: ActionMailer 3.2 calls `name.underscore` immediately upon
+    # subclassing. Class.new.name == nil. So, Class.new(ActionMailer::Base)
+    # errors out since it's trying to do `nil.underscore`. This is very ugly but
+    # allows us to test against ActionMailer 3.2.x.
+    eval <<-A_REAL_CLASS_FOR_ACTION_MAILER_3_2
+    class ::#{class_name} < #{base}
+    end
+    A_REAL_CLASS_FOR_ACTION_MAILER_3_2
+
+    Object.const_get(class_name).tap do |constant_class|
       constant_class.unloadable
 
       if block_given?
@@ -46,11 +54,11 @@ module ModelBuilder
   end
 
   def define_model_class(class_name, &block)
-    define_constant(class_name, ActiveRecord::Base, &block)
+    define_class(class_name, ActiveRecord::Base, &block)
   end
 
   def define_active_model_class(class_name, options = {}, &block)
-    define_constant(class_name, Object) do
+    define_class(class_name, Object) do
       include ActiveModel::Validations
 
       options[:accessors].each do |column|
@@ -78,13 +86,13 @@ module ModelBuilder
 
   def define_mailer(name, paths, &block)
     class_name = name.to_s.pluralize.classify
-    define_constant(class_name, ActionMailer::Base, &block)
+    define_class(class_name, ActionMailer::Base, &block)
   end
 
   def define_controller(class_name, &block)
     class_name = class_name.to_s
     class_name << 'Controller' unless class_name =~ /Controller$/
-    define_constant(class_name, ActionController::Base, &block)
+    define_class(class_name, ActionController::Base, &block)
   end
 
   def define_routes(&block)