francois-shoulda 2.0.5.4 → 2.10.1

data/lib/shoulda/action_controller/matchers/set_session_matcher.rb

@@ -0,0 +1,87 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that a session key was set to the expected value.
+      #
+      # Example:
+      #
+      #   it { should set_session(:message) }
+      #   it { should set_session(:user_id).to(@user.id) }
+      #   it { should_not set_session(:user_id) }
+      def set_session(key)
+        SetSessionMatcher.new(key)
+      end
+
+      class SetSessionMatcher # :nodoc:
+
+        def initialize(key)
+          @key = key.to_s
+        end
+
+        def to(value)
+          @value = value
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          (assigned_value? && assigned_correct_value?) || cleared_value?
+        end
+
+        def failure_message
+          "Expected #{expectation}, but #{result}"
+        end
+
+        def negative_failure_message
+          "Didn't expect #{expectation}, but #{result}"
+        end
+
+        def description
+          description = "set session variable #{@key.inspect}"
+          description << " to #{@value.inspect}" if defined?(@value)
+          description
+        end
+
+        private
+
+        def assigned_value?
+          !assigned_value.blank?
+        end
+
+        def cleared_value?
+          defined?(@value) && @value.nil? && assigned_value.nil?
+        end
+
+        def assigned_correct_value?
+          return true if @value.nil?
+          assigned_value == @value
+        end
+
+        def assigned_value
+          session[@key]
+        end
+
+        def session
+          @controller.response.session.data
+        end
+
+        def expectation
+          expectation = "session variable #{@key} to be set"
+          expectation << " to #{@value.inspect}" if @value
+          expectation
+        end
+
+        def result
+          if session.empty?
+            "no session variables were set"
+          else
+            "the session was #{session.inspect}"
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/shoulda/action_controller/matchers/set_the_flash_matcher.rb

@@ -0,0 +1,85 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that the flash contains the given value. Can be a String, a
+      # Regexp, or nil (indicating that the flash should not be set).
+      #
+      # Example:
+      #
+      #   it { should set_the_flash }
+      #   it { should set_the_flash.to("Thank you for placing this order.") }
+      #   it { should set_the_flash.to(/created/i) }
+      #   it { should_not set_the_flash }
+      def set_the_flash
+        SetTheFlashMatcher.new
+      end
+
+      class SetTheFlashMatcher # :nodoc:
+
+        def to(value)
+          @value = value
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          sets_the_flash? && string_value_matches? && regexp_value_matches?
+        end
+
+        attr_reader :failure_message, :negative_failure_message
+
+        def description
+          description = "set the flash"
+          description << " to #{@value.inspect}" unless @value.nil?
+          description
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        private
+
+        def sets_the_flash?
+          !flash.blank?
+        end
+
+        def string_value_matches?
+          return true unless String === @value
+          flash.values.any? {|value| value == @value }
+        end
+
+        def regexp_value_matches?
+          return true unless Regexp === @value
+          flash.values.any? {|value| value =~ @value }
+        end
+
+        def flash
+          @controller.response.session['flash']
+        end
+
+        def expectation
+          expectation = "the flash to be set"
+          expectation << " to #{@value.inspect}" unless @value.nil?
+          expectation << ", but #{flash_description}"
+          expectation
+        end
+
+        def flash_description
+          if flash.blank?
+            "no flash was set"
+          else
+            "was #{flash.inspect}"
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/shoulda/action_mailer.rb

@@ -4,7 +4,7 @@ require 'shoulda/action_mailer/assertions'
 module Test # :nodoc: all
   module Unit
     class TestCase
-      include ThoughtBot::Shoulda::ActionMailer::Assertions
+      include Shoulda::ActionMailer::Assertions
     end
   end
 end

data/lib/shoulda/action_mailer/assertions.rb

@@ -1,39 +1,38 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module ActionMailer # :nodoc:
-      module Assertions
-        # Asserts that an email was delivered.  Can take a block that can further
-        # narrow down the types of emails you're expecting.
-        #
-        #  assert_sent_email
-        #
-        # Passes if ActionMailer::Base.deliveries has an email
-        #
-        #  assert_sent_email do |email|
-        #    email.subject =~ /hi there/ && email.to.include?('none@none.com')
-        #  end
-        #
-        # Passes if there is an email with subject containing 'hi there' and
-        # 'none@none.com' as one of the recipients.
-        #
-        def assert_sent_email
-          emails = ::ActionMailer::Base.deliveries
-          assert !emails.empty?, "No emails were sent"
-          if block_given?
-            matching_emails = emails.select {|email| yield email }
-            assert !matching_emails.empty?, "None of the emails matched."
-          end
+module Shoulda # :nodoc:
+  module ActionMailer # :nodoc:
+    module Assertions
+      # Asserts that an email was delivered.  Can take a block that can further
+      # narrow down the types of emails you're expecting.
+      #
+      #  assert_sent_email
+      #
+      # Passes if ActionMailer::Base.deliveries has an email
+      #
+      #  assert_sent_email do |email|
+      #    email.subject =~ /hi there/ && email.to.include?('none@none.com')
+      #  end
+      #
+      # Passes if there is an email with subject containing 'hi there' and
+      # 'none@none.com' as one of the recipients.
+      #
+      def assert_sent_email
+        emails = ::ActionMailer::Base.deliveries
+        assert !emails.empty?, "No emails were sent"
+        if block_given?
+          matching_emails = emails.select {|email| yield email }
+          assert !matching_emails.empty?, "None of the emails matched."
         end
+      end
 
-        # Asserts that no ActionMailer mails were delivered
-        #
-        #  assert_did_not_send_email
-        def assert_did_not_send_email
-          msg = "Sent #{::ActionMailer::Base.deliveries.size} emails.\n"
-          ::ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
-          assert ::ActionMailer::Base.deliveries.empty?, msg
-        end
+      # Asserts that no ActionMailer mails were delivered
+      #
+      #  assert_did_not_send_email
+      def assert_did_not_send_email
+        msg = "Sent #{::ActionMailer::Base.deliveries.size} emails.\n"
+        ::ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
+        assert ::ActionMailer::Base.deliveries.empty?, msg
       end
     end
   end
 end
+

data/lib/shoulda/action_view.rb

@@ -0,0 +1,10 @@
+require 'shoulda'
+require 'shoulda/action_view/macros'
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      extend Shoulda::ActionView::Macros
+    end
+  end
+end

data/lib/shoulda/action_view/macros.rb

@@ -0,0 +1,56 @@
+module Shoulda # :nodoc:
+  module ActionView # :nodoc:
+    # = Macro test helpers for your view
+    #
+    # By using the macro helpers you can quickly and easily create concise and
+    # easy to read test suites.
+    #
+    # This code segment:
+    #   context "on GET to :new" do
+    #     setup do
+    #       get :new
+    #     end
+    #
+    #     should_render_a_form
+    #     should_render_page_with_metadata :title => /index/
+    #
+    #     should "do something else really cool" do
+    #       assert_select '#really_cool'
+    #     end
+    #   end
+    #
+    # Would produce 3 tests for the +show+ action
+    module Macros
+
+      # Macro that creates a test asserting that the rendered view contains a <form> element.
+      def should_render_a_form
+        should "display a form" do
+          assert_select "form", true, "The template doesn't contain a <form> element"
+        end
+      end
+
+      # Macro that creates a test asserting that the rendered view contains the selected metatags.
+      # Values can be string or Regexps.
+      # Example:
+      #
+      #   should_render_page_with_metadata :description => "Description of this page", :keywords => /post/
+      #
+      # You can also use this method to test the rendered views title.
+      #
+      # Example:
+      #   should_render_page_with_metadata :title => /index/
+      def should_render_page_with_metadata(options)
+        options.each do |key, value|
+          should "have metatag #{key}" do
+            if key.to_sym == :title
+              assert_select "title", value
+            else
+              assert_select "meta[name=?][content#{"*" if value.is_a?(Regexp)}=?]", key, value
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/shoulda/active_record.rb

@@ -1,12 +1,16 @@
 require 'shoulda'
+require 'shoulda/active_record/helpers'
+require 'shoulda/active_record/matchers'
 require 'shoulda/active_record/assertions'
 require 'shoulda/active_record/macros'
 
 module Test # :nodoc: all
   module Unit
     class TestCase
-      include ThoughtBot::Shoulda::ActiveRecord::Assertions
-      extend ThoughtBot::Shoulda::ActiveRecord::Macros
+      include Shoulda::ActiveRecord::Helpers
+      include Shoulda::ActiveRecord::Matchers
+      include Shoulda::ActiveRecord::Assertions
+      extend Shoulda::ActiveRecord::Macros
     end
   end
 end

data/lib/shoulda/active_record/assertions.rb

@@ -1,95 +1,68 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module ActiveRecord # :nodoc:
-      module Assertions
-        # Asserts that the given object can be saved
-        #
-        #  assert_save User.new(params)
-        def assert_save(obj)
-          assert obj.save, "Errors: #{pretty_error_messages obj}"
-          obj.reload
-        end
-
-        # Asserts that the given object is valid
-        #
-        #  assert_valid User.new(params)
-        def assert_valid(obj)
-          assert obj.valid?, "Errors: #{pretty_error_messages obj}"
-        end
-
-        # Asserts that the given object is invalid, in the ActiveRecord sense.
-        # Calls #valid? on the object, and fails the assertion if the value is true.
-        #
-        #  assert_invalid User.new(params)
-        def assert_invalid(obj)
-          assert !obj.valid?, "<#{obj.inspect}> should have been invalid"
-        end
-
-        # Asserts that an Active Record model validates with the passed
-        # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
-        # contained within the list of errors for that attribute.
-        #
-        #   assert_good_value(User.new, :email, "user@example.com")
-        #   assert_good_value(User.new, :ssn, "123456789", /length/)
-        #
-        # If a class is passed as the first argument, a new object will be
-        # instantiated before the assertion.  If an instance variable exists with
-        # the same name as the class (underscored), that object will be used
-        # instead.
-        #
-        #   assert_good_value(User, :email, "user@example.com")
-        #
-        #   @product = Product.new(:tangible => false)
-        #   assert_good_value(Product, :price, "0")
-        def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = //)
-          object = get_instance_of(object_or_klass)
-          object.send("#{attribute}=", value)
-          object.valid?
-          assert_does_not_contain(object.errors.on(attribute), error_message_to_avoid, "when set to #{value.inspect}")
-        end
-
-        # Asserts that an Active Record model invalidates the passed
-        # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
-        # contained within the list of errors for that attribute.
-        #
-        #   assert_bad_value(User.new, :email, "invalid")
-        #   assert_bad_value(User.new, :ssn, "123", /length/)
-        #
-        # If a class is passed as the first argument, a new object will be
-        # instantiated before the assertion.  If an instance variable exists with
-        # the same name as the class (underscored), that object will be used
-        # instead.
-        #
-        #   assert_bad_value(User, :email, "invalid")
-        #
-        #   @product = Product.new(:tangible => true)
-        #   assert_bad_value(Product, :price, "0")
-        def assert_bad_value(object_or_klass, attribute, value,
-                             error_message_to_expect = self.class.default_error_message(:invalid))
-          object = get_instance_of(object_or_klass)
-          object.send("#{attribute}=", value)
-          assert !object.valid?, "#{object.class} allowed #{value.inspect} as a value for #{attribute}"
-          assert object.errors.on(attribute), "There are no errors on #{attribute} after being set to #{value.inspect}"
-          assert_contains(object.errors.on(attribute), error_message_to_expect, "when set to #{value.inspect}")
-        end
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Assertions
+      # Asserts that the given object can be saved
+      #
+      #  assert_save User.new(params)
+      def assert_save(obj)
+        assert obj.save, "Errors: #{pretty_error_messages obj}"
+        obj.reload
+      end
 
-        def pretty_error_messages(obj)
-          obj.errors.map do |a, m| 
-            msg = "#{a} #{m}" 
-            msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
-          end
-        end
+      # Asserts that the given object is valid
+      #
+      #  assert_valid User.new(params)
+      def assert_valid(obj)
+        assert obj.valid?, "Errors: #{pretty_error_messages obj}"
+      end
 
-        private
+      # Asserts that an Active Record model validates with the passed
+      # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
+      # contained within the list of errors for that attribute.
+      #
+      #   assert_good_value(User.new, :email, "user@example.com")
+      #   assert_good_value(User.new, :ssn, "123456789", /length/)
+      #
+      # If a class is passed as the first argument, a new object will be
+      # instantiated before the assertion.  If an instance variable exists with
+      # the same name as the class (underscored), that object will be used
+      # instead.
+      #
+      #   assert_good_value(User, :email, "user@example.com")
+      #
+      #   @product = Product.new(:tangible => false)
+      #   assert_good_value(Product, :price, "0")
+      def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = nil)
+        object = get_instance_of(object_or_klass)
+        matcher = allow_value(value).
+                    for(attribute).
+                    with_message(error_message_to_avoid)
+        assert_accepts(matcher, object)
+      end
 
-        def get_instance_of(object_or_klass)
-          if object_or_klass.is_a?(Class)
-            klass = object_or_klass
-            instance_variable_get("@#{klass.to_s.underscore}") || klass.new
-          else
-            object_or_klass
-          end
-        end
+      # Asserts that an Active Record model invalidates the passed
+      # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
+      # contained within the list of errors for that attribute.
+      #
+      #   assert_bad_value(User.new, :email, "invalid")
+      #   assert_bad_value(User.new, :ssn, "123", /length/)
+      #
+      # If a class is passed as the first argument, a new object will be
+      # instantiated before the assertion.  If an instance variable exists with
+      # the same name as the class (underscored), that object will be used
+      # instead.
+      #
+      #   assert_bad_value(User, :email, "invalid")
+      #
+      #   @product = Product.new(:tangible => true)
+      #   assert_bad_value(Product, :price, "0")
+      def assert_bad_value(object_or_klass, attribute, value,
+                           error_message_to_expect = nil)
+        object = get_instance_of(object_or_klass)
+        matcher = allow_value(value).
+                    for(attribute).
+                    with_message(error_message_to_expect)
+        assert_rejects(matcher, object)
       end
     end
   end