shoulda 2.0.6 → 2.9.0

data/lib/shoulda/macros.rb

@@ -1,74 +1,73 @@
 require 'shoulda/private_helpers'
 
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module Macros
-      # Macro that creates a test asserting a change between the return value
-      # of an expression that is run before and after the current setup block
-      # is run. This is similar to Active Support's <tt>assert_difference</tt>
-      # assertion, but supports more than just numeric values.  See also
-      # should_not_change.
-      #
-      # Example:
-      #
-      #   context "Creating a post" do
-      #     setup { Post.create }
-      #     should_change "Post.count", :by => 1
-      #   end
-      #
-      # As shown in this example, the <tt>:by</tt> option expects a numeric
-      # difference between the before and after values of the expression.  You
-      # may also specify <tt>:from</tt> and <tt>:to</tt> options:
-      #
-      #   should_change "Post.count", :from => 0, :to => 1
-      #   should_change "@post.title", :from => "old", :to => "new"
-      #
-      # Combinations of <tt>:by</tt>, <tt>:from</tt>, and <tt>:to</tt> are allowed:
-      #
-      #   should_change "@post.title"                # => assert the value changed in some way
-      #   should_change "@post.title", :from => "old" # => assert the value changed to anything other than "old"
-      #   should_change "@post.title", :to   => "new" # => assert the value changed from anything other than "new"
-      def should_change(expression, options = {})
-        by, from, to = get_options!([options], :by, :from, :to)
-        stmt = "change #{expression.inspect}"
-        stmt << " from #{from.inspect}" if from
-        stmt << " to #{to.inspect}" if to
-        stmt << " by #{by.inspect}" if by
+module Shoulda # :nodoc:
+  module Macros
+    # Macro that creates a test asserting a change between the return value
+    # of an expression that is run before and after the current setup block
+    # is run. This is similar to Active Support's <tt>assert_difference</tt>
+    # assertion, but supports more than just numeric values.  See also
+    # should_not_change.
+    #
+    # Example:
+    #
+    #   context "Creating a post" do
+    #     setup { Post.create }
+    #     should_change "Post.count", :by => 1
+    #   end
+    #
+    # As shown in this example, the <tt>:by</tt> option expects a numeric
+    # difference between the before and after values of the expression.  You
+    # may also specify <tt>:from</tt> and <tt>:to</tt> options:
+    #
+    #   should_change "Post.count", :from => 0, :to => 1
+    #   should_change "@post.title", :from => "old", :to => "new"
+    #
+    # Combinations of <tt>:by</tt>, <tt>:from</tt>, and <tt>:to</tt> are allowed:
+    #
+    #   should_change "@post.title"                # => assert the value changed in some way
+    #   should_change "@post.title", :from => "old" # => assert the value changed to anything other than "old"
+    #   should_change "@post.title", :to   => "new" # => assert the value changed from anything other than "new"
+    def should_change(expression, options = {})
+      by, from, to = get_options!([options], :by, :from, :to)
+      stmt = "change #{expression.inspect}"
+      stmt << " from #{from.inspect}" if from
+      stmt << " to #{to.inspect}" if to
+      stmt << " by #{by.inspect}" if by
 
-        expression_eval = lambda { eval(expression) }
-        before = lambda { @_before_should_change = expression_eval.bind(self).call }
-        should stmt, :before => before do
-          old_value = @_before_should_change
-          new_value = expression_eval.bind(self).call
-          assert_operator from, :===, old_value, "#{expression.inspect} did not originally match #{from.inspect}" if from
-          assert_not_equal old_value, new_value, "#{expression.inspect} did not change" unless by == 0
-          assert_operator to, :===, new_value, "#{expression.inspect} was not changed to match #{to.inspect}" if to
-          assert_equal old_value + by, new_value if by
-        end
+      expression_eval = lambda { eval(expression) }
+      before = lambda { @_before_should_change = expression_eval.bind(self).call }
+      should stmt, :before => before do
+        old_value = @_before_should_change
+        new_value = expression_eval.bind(self).call
+        assert_operator from, :===, old_value, "#{expression.inspect} did not originally match #{from.inspect}" if from
+        assert_not_equal old_value, new_value, "#{expression.inspect} did not change" unless by == 0
+        assert_operator to, :===, new_value, "#{expression.inspect} was not changed to match #{to.inspect}" if to
+        assert_equal old_value + by, new_value if by
       end
+    end
 
-      # Macro that creates a test asserting no change between the return value
-      # of an expression that is run before and after the current setup block
-      # is run. This is the logical opposite of should_change.
-      #
-      # Example:
-      #
-      #   context "Updating a post" do
-      #     setup { @post.update_attributes(:title => "new") }
-      #     should_not_change "Post.count"
-      #   end
-      def should_not_change(expression)
-        expression_eval = lambda { eval(expression) }
-        before = lambda { @_before_should_not_change = expression_eval.bind(self).call }
-        should "not change #{expression.inspect}", :before => before do
-          new_value = expression_eval.bind(self).call
-          assert_equal @_before_should_not_change, new_value, "#{expression.inspect} changed"
-        end
+    # Macro that creates a test asserting no change between the return value
+    # of an expression that is run before and after the current setup block
+    # is run. This is the logical opposite of should_change.
+    #
+    # Example:
+    #
+    #   context "Updating a post" do
+    #     setup { @post.update_attributes(:title => "new") }
+    #     should_not_change "Post.count"
+    #   end
+    def should_not_change(expression)
+      expression_eval = lambda { eval(expression) }
+      before = lambda { @_before_should_not_change = expression_eval.bind(self).call }
+      should "not change #{expression.inspect}", :before => before do
+        new_value = expression_eval.bind(self).call
+        assert_equal @_before_should_not_change, new_value, "#{expression.inspect} changed"
       end
+    end
 
-      private
+    private
 
-      include ThoughtBot::Shoulda::Private
-    end
+    include Shoulda::Private
   end
 end
+

data/lib/shoulda/private_helpers.rb

@@ -1,22 +1,20 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module Private # :nodoc:
-      # Returns the values for the entries in the args hash who's keys are listed in the wanted array.
-      # Will raise if there are keys in the args hash that aren't listed.
-      def get_options!(args, *wanted)
-        ret  = []
-        opts = (args.last.is_a?(Hash) ? args.pop : {})
-        wanted.each {|w| ret << opts.delete(w)}
-        raise ArgumentError, "Unsupported options given: #{opts.keys.join(', ')}" unless opts.keys.empty?
-        return *ret
-      end
+module Shoulda # :nodoc:
+  module Private # :nodoc:
+    # Returns the values for the entries in the args hash who's keys are listed in the wanted array.
+    # Will raise if there are keys in the args hash that aren't listed.
+    def get_options!(args, *wanted)
+      ret  = []
+      opts = (args.last.is_a?(Hash) ? args.pop : {})
+      wanted.each {|w| ret << opts.delete(w)}
+      raise ArgumentError, "Unsupported options given: #{opts.keys.join(', ')}" unless opts.keys.empty?
+      return *ret
+    end
 
-      # Returns the model class constant, as determined by the test class name.
-      #
-      #   class TestUser; model_class; end => User
-      def model_class
-        self.name.gsub(/Test$/, '').constantize
-      end
+    # Returns the model class constant, as determined by the test class name.
+    #
+    #   class TestUser; model_class; end => User
+    def model_class
+      self.name.gsub(/Test$/, '').constantize
     end
   end
 end

data/lib/shoulda/rails.rb

@@ -8,12 +8,5 @@ require 'shoulda/action_mailer' if defined? ActionMailer::Base
 
 if defined?(RAILS_ROOT)
   # load in the 3rd party macros from vendorized plugins and gems
-  Dir[File.join(RAILS_ROOT, "vendor", "{plugins,gems}", "*", "shoulda_macros", "*.rb")].each do |macro_file_path|
-    require macro_file_path
-  end
-
-  # load in the local application specific macros
-  Dir[File.join(RAILS_ROOT, "test", "shoulda_macros", "*.rb")].each do |macro_file_path|
-    require macro_file_path
-  end
+  Shoulda.autoload_macros RAILS_ROOT, File.join("vendor", "{plugins,gems}", "*")
 end

data/lib/shoulda/rspec.rb

@@ -0,0 +1,5 @@
+require 'shoulda/active_record/matchers'
+
+Spec::Runner.configure do |config|
+  config.include Shoulda::ActiveRecord::Matchers, :type => :model
+end

data/lib/shoulda/tasks/list_tests.rake

@@ -13,7 +13,12 @@ namespace :shoulda do
     test_files = Dir.glob(File.join('test', '**', '*_test.rb'))
     test_files.each do |file|
       load file
-      klass = File.basename(file, '.rb').classify.constantize
+      klass = File.basename(file, '.rb').classify
+      unless Object.const_defined?(klass.to_s)
+        puts "Skipping #{klass} because it doesn't map to a Class"
+        next
+      end
+      klass = klass.constantize
 
       puts klass.name.gsub('Test', '')
 

data/lib/shoulda/test_unit.rb

@@ -0,0 +1,19 @@
+require 'shoulda/context'
+require 'shoulda/proc_extensions'
+require 'shoulda/assertions'
+require 'shoulda/macros'
+require 'shoulda/helpers'
+require 'shoulda/autoload_macros'
+require 'shoulda/rails' if defined? RAILS_ROOT
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      extend Shoulda::ClassMethods
+      include Shoulda::Assertions
+      extend Shoulda::Macros
+      include Shoulda::Helpers
+    end
+  end
+end
+

data/rails/init.rb

@@ -1 +1 @@
-require 'shoulda/rails'
+require 'shoulda/rails' if RAILS_ENV == 'test'

data/test/README

@@ -6,7 +6,7 @@ The test directory contains the following files and subdirectories:
 
 * rails_root - contains the stripped down rails application that the tests run against.  The rails root contains:
 ** the models, controllers, and views defined under app/
-** the sqlite3.rb environment file
+** the test.rb environment file
 ** a migration file for each model
 ** a shoulda initializer that simulates loading the plugin but without relying on vendor/plugins
 * fixtures - contain the sample DB data for each model
@@ -14,7 +14,7 @@ The test directory contains the following files and subdirectories:
 * unit - model tests for each of the models under rails_root/app
 * other - tests for the shoulda contexts, should statements, and assertions
 * test_helper.rb - responsible for initializing the test environment
-** sets the rails_env to sqlite3
+** sets the rails_env to test
 ** sets the rails_root
 ** runs all the migrations against the in-memory sqlite3 db
 ** adds some magic to load the right fixture files

data/test/fail_macros.rb

@@ -1,15 +1,15 @@
-module Thoughtbot
-  module Shoulda
-    class << self
-      attr_accessor :expected_exceptions
-    end
+module Shoulda
+  class << self
+    attr_accessor :expected_exceptions
+  end
 
+  module ClassMethods
     # Enables the core shoulda test suite to test for failure scenarios.  For
     # example, to ensure that a set of test macros should fail, do this:
     #
     #   should_fail do
-    #     should_require_attributes :comments
-    #     should_protect_attributes :name
+    #     should_validate_presence_of :comments
+    #     should_not_allow_mass_assignment_of :name
     #   end
     def should_fail(&block)
       context "should fail when trying to run:" do
@@ -18,17 +18,17 @@ module Thoughtbot
         Shoulda.expected_exceptions = nil
       end
     end
+  end
 
-    class Context
-      # alias_method_chain hack to allow the should_fail macro to work
-      def should_with_failure_scenario(name, options = {}, &block)
-        if Shoulda.expected_exceptions
-          expected_exceptions = Shoulda.expected_exceptions
-          failure_block = lambda { assert_raise(*expected_exceptions, &block.bind(self)) }
-        end
-        should_without_failure_scenario(name, options, &(failure_block || block))
+  class Context
+    # alias_method_chain hack to allow the should_fail macro to work
+    def should_with_failure_scenario(name, options = {}, &block)
+      if Shoulda.expected_exceptions
+        expected_exceptions = Shoulda.expected_exceptions
+        failure_block = lambda { assert_raise(*expected_exceptions, &block.bind(self)) }
       end
-      alias_method_chain :should, :failure_scenario
+      should_without_failure_scenario(name, options, &(failure_block || block))
     end
+    alias_method_chain :should, :failure_scenario
   end
 end

data/test/functional/posts_controller_test.rb

@@ -13,7 +13,7 @@ class PostsControllerTest < Test::Unit::TestCase
     @response   = ActionController::TestResponse.new
     @post       = Post.find(:first)
   end
-  
+
   # autodetects the :controller
   should_route :get,    '/posts',     :action => :index
   # explicitly specify :controller
@@ -24,7 +24,7 @@ class PostsControllerTest < Test::Unit::TestCase
   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
-  
+
   # Test the nested routes
   should_route :get,    '/users/5/posts',     :action => :index, :user_id => 5
   should_route :post,   '/users/5/posts',     :action => :create, :user_id => 5
@@ -73,6 +73,8 @@ class PostsControllerTest < Test::Unit::TestCase
       end
       should_assign_to :posts
       should_not_assign_to :foo, :bar
+      should_render_page_with_metadata :description => /Posts/, :title => /index/
+      should_render_page_with_metadata :keywords => "posts"
     end
 
     context "viewing posts for a user with rss format" do
@@ -94,6 +96,7 @@ class PostsControllerTest < Test::Unit::TestCase
       setup { get :show, :user_id => users(:first), :id => posts(:first) }
       should_render_with_layout 'wide'
       should_render_with_layout :wide
+      should_assign_to :false_flag
     end
 
     context "on GET to #new" do

data/test/matchers/allow_mass_assignment_of_matcher_test.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AllowMassAssignmentOfMatcherTest < Test::Unit::TestCase # :nodoc:
+
+  context "an attribute that is blacklisted from mass-assignment" do
+    setup do
+      define_model :example, :attr => :string do
+        attr_protected :attr
+      end
+      @model = Example.new
+    end
+
+    should "reject being mass-assignable" do
+      assert_rejects allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute that is not whitelisted for mass-assignment" do
+    setup do
+      define_model :example, :attr => :string, :other => :string do
+        attr_accessible :other
+      end
+      @model = Example.new
+    end
+
+    should "reject being mass-assignable" do
+      assert_rejects allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute that is whitelisted for mass-assignment" do
+    setup do
+      define_model :example, :attr => :string do
+        attr_accessible :attr
+      end
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute not included in the mass-assignment blacklist" do
+    setup do
+      define_model :example, :attr => :string, :other => :string do
+        attr_protected :other
+      end
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute on a class with no protected attributes" do
+    setup do
+      define_model :example, :attr => :string
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+end

data/test/matchers/allow_value_matcher_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AllowValueMatcherTest < Test::Unit::TestCase # :nodoc:
+
+  context "an attribute with a format validation" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /abc/
+      end
+      @model = Example.new
+    end
+
+    should "allow a good value" do
+      assert_accepts allow_value("abcde").for(:attr), @model
+    end
+    
+    should "not allow a bad value" do
+      assert_rejects allow_value("xyz").for(:attr), @model
+    end
+  end
+
+  context "an attribute with a format validation and a custom message" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /abc/, :message => 'bad value'
+      end
+      @model = Example.new
+    end
+
+    should "allow a good value" do
+      assert_accepts allow_value('abcde').for(:attr).with_message(/bad/),
+                     @model
+    end
+    
+    should "not allow a bad value" do
+      assert_rejects allow_value('xyz').for(:attr).with_message(/bad/),
+                     @model
+    end
+  end
+
+end