technicalpickles-shoulda 2.0.0 → 2.0.1

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'lib/shoulda/context'
-require 'lib/shoulda/tasks'
+load 'tasks/shoulda.rake'
 
 # Test::Unit::UI::VERBOSE
 test_files_pattern = 'test/{unit,functional,other}/**/*_test.rb'

data/lib/shoulda/active_record/assertions.rb

@@ -56,7 +56,8 @@ module ThoughtBot # :nodoc:
         #
         #   @product = Product.new(:tangible => true)
         #   assert_bad_value(Product, :price, "0")
-        def assert_bad_value(object_or_klass, attribute, value, error_message_to_expect = /invalid/)
+        def assert_bad_value(object_or_klass, attribute, value,
+                             error_message_to_expect = DEFAULT_ERROR_MESSAGES[: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}"

data/lib/shoulda/active_record/macros.rb

@@ -1,6 +1,13 @@
 module ThoughtBot # :nodoc:
   module Shoulda # :nodoc:
     module ActiveRecord # :nodoc:
+      DEFAULT_ERROR_MESSAGES =
+        if Object.const_defined?(:I18n)
+          I18n.translate('active_record.error_messages')
+        else
+          ::ActiveRecord::Errors.default_error_messages
+        end
+
       # = Macro test helpers for your active record models
       #
       # These helpers will test most of the validations and associations for your ActiveRecord models.
@@ -36,14 +43,14 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/blank/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:blank]</tt>
         #
         # Example:
         #   should_require_attributes :name, :phone_number
         #
         def should_require_attributes(*attributes)
           message = get_options!(attributes, :message)
-          message ||= /blank/
+          message ||= DEFAULT_ERROR_MESSAGES[:blank]
           klass = model_class
 
           attributes.each do |attribute|
@@ -58,7 +65,7 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/taken/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:taken]</tt>
         # * <tt>:scoped_to</tt> - field(s) to scope the uniqueness to.
         #
         # Examples:
@@ -70,7 +77,7 @@ module ThoughtBot # :nodoc:
         def should_require_unique_attributes(*attributes)
           message, scope = get_options!(attributes, :message, :scoped_to)
           scope = [*scope].compact
-          message ||= /taken/
+          message ||= DEFAULT_ERROR_MESSAGES[:taken]
 
           klass = model_class
           attributes.each do |attribute|
@@ -118,7 +125,8 @@ module ThoughtBot # :nodoc:
               protected = klass.protected_attributes || []
               accessible = klass.accessible_attributes || []
 
-              assert protected.include?(attribute.to_s) || !accessible.include?(attribute.to_s),
+              assert protected.include?(attribute.to_s) ||
+                (!accessible.empty? && !accessible.include?(attribute.to_s)),
                      (accessible.empty? ?
                        "#{klass} is protecting #{protected.to_a.to_sentence}, but not #{attribute}." :
                        "#{klass} has made #{attribute} accessible")
@@ -155,14 +163,14 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/invalid/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:invalid]</tt>
         #
         # Example:
         #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
         #
         def should_not_allow_values_for(attribute, *bad_values)
           message = get_options!(bad_values, :message)
-          message ||= /invalid/
+          message ||= DEFAULT_ERROR_MESSAGES[:invalid]
           klass = model_class
           bad_values.each do |v|
             should "not allow #{attribute} to be set to #{v.inspect}" do
@@ -198,17 +206,17 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/short/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:too_short] % range.first</tt>
         # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/long/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:too_long] % range.last</tt>
         #
         # Example:
         #   should_ensure_length_in_range :password, (6..20)
         #
         def should_ensure_length_in_range(attribute, range, opts = {})
           short_message, long_message = get_options!([opts], :short_message, :long_message)
-          short_message ||= /short/
-          long_message  ||= /long/
+          short_message ||= DEFAULT_ERROR_MESSAGES[:too_short] % range.first
+          long_message  ||= DEFAULT_ERROR_MESSAGES[:too_long] % range.last
 
           klass = model_class
           min_length = range.first
@@ -250,14 +258,14 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/short/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:too_short] % min_length</tt>
         #
         # Example:
         #   should_ensure_length_at_least :name, 3
         #
         def should_ensure_length_at_least(attribute, min_length, opts = {})
           short_message = get_options!([opts], :short_message)
-          short_message ||= /short/
+          short_message ||= DEFAULT_ERROR_MESSAGES[:too_short] % min_length
 
           klass = model_class
 
@@ -281,14 +289,14 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/short/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:wrong_length] % length</tt>
         #
         # Example:
         #   should_ensure_length_is :ssn, 9
         #
         def should_ensure_length_is(attribute, length, opts = {})
           message = get_options!([opts], :message)
-          message ||= /wrong length/
+          message ||= DEFAULT_ERROR_MESSAGES[:wrong_length] % length
 
           klass = model_class
 
@@ -316,17 +324,17 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/included/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:inclusion]</tt>
         # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/included/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:inclusion]</tt>
         #
         # Example:
         #   should_ensure_value_in_range :age, (0..100)
         #
         def should_ensure_value_in_range(attribute, range, opts = {})
           low_message, high_message = get_options!([opts], :low_message, :high_message)
-          low_message  ||= /included/
-          high_message ||= /included/
+          low_message  ||= DEFAULT_ERROR_MESSAGES[:inclusion]
+          high_message ||= DEFAULT_ERROR_MESSAGES[:inclusion]
 
           klass = model_class
           min   = range.first
@@ -361,14 +369,14 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/number/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:not_a_number]</tt>
         #
         # Example:
         #   should_only_allow_numeric_values_for :age
         #
         def should_only_allow_numeric_values_for(*attributes)
           message = get_options!(attributes, :message)
-          message ||= /number/
+          message ||= DEFAULT_ERROR_MESSAGES[:not_a_number]
           klass = model_class
           attributes.each do |attribute|
             attribute = attribute.to_sym
@@ -439,14 +447,19 @@ module ThoughtBot # :nodoc:
         # associated table has the required columns.  Works with polymorphic
         # associations.
         #
+        # Options:
+        # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+        #
         # Example:
         #   should_have_one :god # unless hindu
         #
         def should_have_one(*associations)
-          get_options!(associations)
+          dependent = get_options!(associations, :dependent)
           klass = model_class
           associations.each do |association|
-            should "have one #{association}" do
+            name = "have one #{association}"
+            name += " dependent => #{dependent}" if dependent
+            should name do
               reflection = klass.reflect_on_association(association)
               assert reflection, "#{klass.name} does not have any relationship to #{association}"
               assert_equal :has_one, reflection.macro
@@ -465,6 +478,12 @@ module ThoughtBot # :nodoc:
               end
               assert associated_klass.column_names.include?(fk.to_s),
                      "#{associated_klass.name} does not have a #{fk} foreign key."
+
+              if dependent
+                assert_equal dependent.to_s,
+                             reflection.options[:dependent].to_s,
+                             "#{association} should have #{dependent} dependency"
+              end
             end
           end
         end
@@ -604,14 +623,14 @@ module ThoughtBot # :nodoc:
         #
         # Options:
         # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>/must be accepted/</tt>
+        #   Regexp or string.  Default = <tt>I18n.translate('active_record.error_messages')[:accepted]</tt>
         #
         # Example:
         #   should_require_acceptance_of :eula
         #
         def should_require_acceptance_of(*attributes)
           message = get_options!(attributes, :message)
-          message ||= /must be accepted/
+          message ||= DEFAULT_ERROR_MESSAGES[:accepted]
           klass = model_class
 
           attributes.each do |attribute|

data/lib/shoulda/context.rb

@@ -1,6 +1,6 @@
 module Thoughtbot # :nodoc:
   module Shoulda
-    VERSION = '2.0.0'
+    VERSION = '2.0.1'
 
     class << self
       attr_accessor :contexts

data/lib/shoulda/controller/macros.rb

@@ -134,6 +134,37 @@ module ThoughtBot # :nodoc:
           end
         end
 
+        # Macro that creates a test asserting that the response content type was 'content_type'.
+        # Example:
+        #
+        #   should_respond_with_content_type 'application/rss+xml'
+        def should_respond_with_content_type(content_type)
+          should "respond with content type of #{content_type}" do
+            content_type = Mime::EXTENSION_LOOKUP[content_type.to_s].to_s if content_type.is_a? Symbol
+            if content_type.is_a? Regexp
+              assert_match content_type, @response.content_type, "Expected to match #{content_type} but was actually #{@response.content_type}"
+            else
+              assert_equal content_type, @response.content_type, "Expected #{content_type} but was actually #{@response.content_type}"
+            end
+          end
+        end
+
+        # Macro that creates a test asserting that a value returned from the session is correct.
+        # The given string is evaled to produce the resulting redirect path.  All of the instance variables
+        # set by the controller are available to the evaled string.
+        # Example:
+        #
+        #   should_return_from_session :user_id, '@user.id'
+        #   should_return_from_session :message, '"Free stuff"'
+        def should_return_from_session(key, expected)
+          should "return the correct value from the session for key #{key}" do
+            instantiate_variables_from_assigns do
+              expected_value = eval(expected, self.send(:binding), __FILE__, __LINE__)
+              assert_equal expected_value, session[key], "Expected #{expected_value.inspect} but was #{session[key]}"
+            end
+          end
+        end
+
         # Macro that creates a test asserting that the controller rendered the given template.
         # Example:
         #
@@ -144,6 +175,32 @@ module ThoughtBot # :nodoc:
           end
         end
 
+        # Macro that creates a test asserting that the controller rendered with the given layout.
+        # Example:
+        #
+        #   should_render_with_layout 'special'
+        def should_render_with_layout(expected_layout = 'application')
+          if expected_layout
+            should "render with #{expected_layout} layout" do
+              response_layout = @response.layout.blank? ? "" : @response.layout.split('/').last
+              assert_equal expected_layout, 
+                           response_layout, 
+                           "Expected to render with layout #{expected_layout} but was rendered with #{response_layout}"
+            end
+          else
+            should "render without layout" do
+              assert_nil @response.layout, 
+                         "Expected no layout, but was rendered using #{@response.layout}"
+            end
+          end
+        end
+
+        # Macro that creates a test asserting that the controller rendered without a layout.
+        # Same as @should_render_with_layout false@
+        def should_render_without_layout
+          should_render_with_layout nil
+        end
+
         # Macro that creates a test asserting that the controller returned a redirect to the given path.
         # The given string is evaled to produce the resulting redirect path.  All of the instance variables
         # set by the controller are available to the evaled string.
@@ -165,6 +222,44 @@ module ThoughtBot # :nodoc:
             assert_select "form", true, "The template doesn't contain a <form> element"
           end
         end
+        
+        # Macro that creates a routing test. It tries to use the given HTTP
+        # +method+ on the given +path+, and asserts that it routes to the
+        # given +options+.
+        #
+        # If you don't specify a :controller, it will try to guess the controller
+        # based on the current test.
+        #
+        # +to_param+ is called on the +options+ given.
+        #
+        # Examples:
+        #
+        #   should_route :get, '/posts', :action => :index
+        #   should_route :post, '/posts', :controller => :posts, :action => :create
+        #   should_route :get, '/posts/1', :action => :show, :id => 1
+        #   should_route :put, '/posts/1', :action => :update, :id => "1"
+        #   should_route :delete, '/posts/1', :action => :destroy, :id => 1
+        #   should_route :get, '/posts/new', :action => :new
+        # 
+        def should_route(method, path, options)
+          unless options[:controller]
+            options[:controller] = self.name.gsub(/ControllerTest$/, '').tableize
+          end
+          options[:controller] = options[:controller].to_s
+          options[:action] = options[:action].to_s
+
+          populated_path = path.dup
+          options.each do |key, value|
+            options[key] = value.to_param if value.respond_to? :to_param
+            populated_path.gsub!(key.inspect, value.to_s)
+          end
+
+          should_name = "route #{method.to_s.upcase} #{populated_path} to/from #{options.inspect}"
+
+          should should_name do
+            assert_routing({:method => method, :path => populated_path}, options)
+          end
+        end
       end
     end
   end

data/lib/shoulda/controller.rb

@@ -2,7 +2,6 @@ require 'shoulda'
 require 'shoulda/controller/helpers'
 require 'shoulda/controller/resource_options'
 require 'shoulda/controller/macros'
-require 'shoulda/controller/routing'
 
 module Test # :nodoc: all
   module Unit

data/test/functional/posts_controller_test.rb

@@ -67,6 +67,31 @@ class PostsControllerTest < Test::Unit::TestCase
       should_assign_to :user, :posts
       should_not_assign_to :foo, :bar
     end
+
+    context "viewing posts for a user with rss format" do
+      setup do
+        get :index, :user_id => users(:first), :format => 'rss'
+        @user = users(:first)
+      end
+      should_respond_with :success
+      should_respond_with_content_type 'application/rss+xml'
+      should_respond_with_content_type :rss
+      should_respond_with_content_type /rss/
+      should_return_from_session :special, "'$2 off your next purchase'"
+      should_return_from_session :special_user_id, '@user.id'
+      should_assign_to :user, :posts
+      should_not_assign_to :foo, :bar
+    end
+
+    context "viewing a post on GET to #show" do
+      setup { get :show, :user_id => users(:first), :id => posts(:first) }
+      should_render_with_layout 'wide'
+    end
+
+    context "on GET to #new" do
+      setup { get :new, :user_id => users(:first) }
+      should_render_without_layout
+    end
   end
 
 end

data/test/rails_root/app/controllers/posts_controller.rb

@@ -8,6 +8,12 @@ class PostsController < ApplicationController
     respond_to do |format|
       format.html # index.rhtml
       format.xml  { render :xml => @posts.to_xml }
+      format.rss do
+        headers['Content-Type'] = 'application/rss+xml'
+        session[:special] = '$2 off your next purchase'
+        session[:special_user_id] = @user.id
+        head :ok
+      end
     end
   end
 
@@ -15,13 +21,14 @@ class PostsController < ApplicationController
     @post = @user.posts.find(params[:id])
 
     respond_to do |format|
-      format.html # show.rhtml
+      format.html { render :layout => 'wide' }
       format.xml  { render :xml => @post.to_xml }
     end
   end
 
   def new
     @post = @user.posts.build
+    render :layout => false
   end
 
   def edit

data/test/rails_root/app/models/user.rb

@@ -5,7 +5,7 @@ class User < ActiveRecord::Base
   has_many :friendships
   has_many :friends, :through => :friendships
 
-  has_one :address, :as => :addressable
+  has_one :address, :as => :addressable, :dependent => :destroy
 
   named_scope :old,      :conditions => "age > 50"
   named_scope :eighteen, :conditions => { :age => 18 }

data/test/rails_root/config/environment.rb

@@ -1,6 +1,6 @@
 # Specifies gem version of Rails to use when vendor/rails is not present
 old_verbose, $VERBOSE = $VERBOSE, nil
-RAILS_GEM_VERSION = '2.1.0' unless defined? RAILS_GEM_VERSION
+RAILS_GEM_VERSION = '>= 2.1.0' unless defined? RAILS_GEM_VERSION
 $VERBOSE = old_verbose
 
 require File.join(File.dirname(__FILE__), 'boot')
@@ -10,5 +10,5 @@ Rails::Initializer.run do |config|
   config.cache_classes = false
   config.whiny_nils = true
 end
- 
+
 # Dependencies.log_activity = true

data/test/test_helper.rb

@@ -5,15 +5,15 @@ ENV['RAILS_ENV'] = 'sqlite3'
 rails_root = File.dirname(__FILE__) + '/rails_root'
 
 require "#{rails_root}/config/environment.rb"
- 
+
 # Load the testing framework
 require 'test_help'
 silence_warnings { RAILS_ENV = ENV['RAILS_ENV'] }
- 
+
 # Run the migrations
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Migrator.migrate("#{RAILS_ROOT}/db/migrate")
- 
+
 # Setup the fixtures path
 Test::Unit::TestCase.fixture_path = File.join(File.dirname(__FILE__), "fixtures")
 
@@ -25,7 +25,9 @@ class Test::Unit::TestCase #:nodoc:
       Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
     end
   end
- 
+
   self.use_transactional_fixtures = false
   self.use_instantiated_fixtures  = false
 end
+
+require 'test/fail_macros'

data/test/unit/tag_test.rb

@@ -7,4 +7,8 @@ class TagTest < Test::Unit::TestCase
   should_ensure_length_at_least :name, 2
 
   should_protect_attributes :secret
+
+  should_fail do
+    should_protect_attributes :name
+  end
 end

data/test/unit/user_test.rb

@@ -10,6 +10,7 @@ class UserTest < Test::Unit::TestCase
   should_have_many :friends
 
   should_have_one :address
+  should_have_one :address, :dependent => :destroy
 
   should_have_indices :email, :name, [:email, :name]
   should_have_index :age
@@ -44,4 +45,8 @@ class UserTest < Test::Unit::TestCase
   should_only_allow_numeric_values_for :ssn
 
   should_have_readonly_attributes :name
+
+  should_fail do
+    should_protect_attributes :name, :age
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: technicalpickles-shoulda
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors: 
 - Tammer Saleh

data/lib/shoulda/controller/routing/macros.rb

@@ -1,47 +0,0 @@
-module ThoughtBot
-  module Shoulda
-    module Controller
-      module Routing
-        module Macros
-          # Macro that creates a routing test. It tries to use the given HTTP
-          # +method+ on the given +path+, and asserts that it routes to the
-          # given +options+.
-          #
-          # If you don't specify a :controller, it will try to guess the controller
-          # based on the current test.
-          #
-          # +to_param+ is called on the +options+ given.
-          #
-          # Examples:
-          #
-          #   should_route :get, '/posts', :action => :index
-          #   should_route :post, '/posts', :controller => :posts, :action => :create
-          #   should_route :get, '/posts/1', :action => :show, :id => 1
-          #   should_route :put, '/posts/1', :action => :update, :id => "1"
-          #   should_route :delete, '/posts/1', :action => :destroy, :id => 1
-          #   should_route :get, '/posts/new', :action => :new
-          # 
-          def should_route(method, path, options)
-            unless options[:controller]
-              options[:controller] = self.name.gsub(/ControllerTest$/, '').tableize
-            end
-            options[:controller] = options[:controller].to_s
-            options[:action] = options[:action].to_s
-
-            populated_path = path.dup
-            options.each do |key, value|
-              options[key] = value.to_param if value.respond_to? :to_param
-              populated_path.gsub!(key.inspect, value.to_s)
-            end
-
-            should_name = "route #{method.to_s.upcase} #{populated_path} to/from #{options.inspect}"
-
-            should should_name do
-              assert_routing({:method => method, :path => populated_path}, options)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/shoulda/controller/routing.rb

@@ -1,10 +0,0 @@
-require 'shoulda'
-require 'shoulda/controller/routing/macros'
-
-module Test # :nodoc: all
-  module Unit
-    class TestCase
-      extend ThoughtBot::Shoulda::Controller::Routing::Macros
-    end
-  end
-end