francois-shoulda 2.0.5.4 → 2.10.1

data/lib/shoulda/helpers.rb

@@ -1,10 +1,8 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module Helpers
-      # Prints a message to stdout, tagged with the name of the calling method.
-      def report!(msg = "")
-        puts("#{caller.first}: #{msg}")
-      end
+module Shoulda # :nodoc:
+  module Helpers
+    # Prints a message to stdout, tagged with the name of the calling method.
+    def report!(msg = "")
+      puts("#{caller.first}: #{msg}")
     end
   end
 end

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

@@ -2,18 +2,12 @@ require 'rubygems'
 require 'active_support'
 require 'shoulda'
 
-require 'shoulda/active_record' if defined? ActiveRecord::Base
-require 'shoulda/controller'    if defined? ActionController::Base
-require 'shoulda/action_mailer' if defined? ActionMailer::Base
+require 'shoulda/active_record'     if defined? ActiveRecord::Base
+require 'shoulda/action_controller' if defined? ActionController::Base
+require 'shoulda/action_view'       if defined? ActionView::Base
+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,11 @@
+require 'shoulda/active_record/matchers'
+require 'shoulda/action_controller/matchers'
+require 'active_support/test_case'
+
+# :enddoc:
+module ActiveSupport
+  class TestCase
+    include Shoulda::ActiveRecord::Matchers
+    include Shoulda::ActionController::Matchers
+  end
+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,7 @@
-require 'shoulda/rails'
+if RAILS_ENV == 'test'
+  if defined? Spec
+    require 'shoulda/rspec'
+  else
+    require 'shoulda/rails' 
+  end
+end

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,14 +1,14 @@
-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_validate_presence_of :comments
     #     should_not_allow_mass_assignment_of :name
     #   end
     def should_fail(&block)
@@ -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/fixtures/tags.yml

@@ -8,4 +8,4 @@ third:
   id: 3
   name: Nothing
 invalid:
-  name: a
+  name: a

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
@@ -33,46 +33,31 @@ class PostsControllerTest < Test::Unit::TestCase
   should_route :get,    '/users/5/posts/new', :action => :new, :user_id => 5
   should_route :put,    '/users/5/posts/1',   :action => :update, :id => 1, :user_id => 5
 
-  context "The public" do
-    setup do
-      @request.session[:logged_in] = false
-    end
-
-    should_be_restful do |resource|
-      resource.parent = :user
-
-      resource.denied.actions = [:index, :show, :edit, :new, :create, :update, :destroy]
-      resource.denied.flash = /what/i
-      resource.denied.redirect = '"/"'
-    end
-  end
-
   context "Logged in" do
     setup do
       @request.session[:logged_in] = true
     end
 
-    should_be_restful do |resource|
-      resource.parent = :user
-
-      resource.create.params = { :title => "first post", :body => 'blah blah blah'}
-      resource.update.params = { :title => "changed" }
-    end
-
     context "viewing posts for a user" do
       setup do
         get :index, :user_id => users(:first)
       end
       should_respond_with :success
       should_assign_to :user, :class => User, :equals => 'users(:first)'
+      should_assign_to(:user) { users(:first) }
       should_fail do
         should_assign_to :user, :class => Post
       end
       should_fail do
         should_assign_to :user, :equals => 'posts(:first)'
       end
+      should_fail do
+        should_assign_to(:user) { posts(:first) }
+      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
@@ -84,8 +69,22 @@ class PostsControllerTest < Test::Unit::TestCase
       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'
+      context "deprecated" do # to avoid redefining a test
+        should_return_from_session :special, "'$2 off your next purchase'"
+      end
+      should_fail do
+        should_return_from_session :special, "'not special'"
+      end
+      should_set_session(:mischief) { nil }
+      should_return_from_session :malarky, "nil"
+      should_set_session :special, "'$2 off your next purchase'"
+      should_set_session :special_user_id, '@user.id'
+      context "with a block" do
+        should_set_session(:special_user_id) { @user.id }
+      end
+      should_fail do # to avoid redefining a test
+        should_set_session(:special_user_id) { 'value' }
+      end
       should_assign_to :user, :posts
       should_not_assign_to :foo, :bar
     end
@@ -93,13 +92,34 @@ class PostsControllerTest < Test::Unit::TestCase
     context "viewing a post on GET to #show" do
       setup { get :show, :user_id => users(:first), :id => posts(:first) }
       should_render_with_layout 'wide'
-      should_render_with_layout :wide
+      context "with a symbol" do # to avoid redefining a test
+        should_render_with_layout :wide
+      end
+      should_assign_to :false_flag
     end
 
     context "on GET to #new" do
       setup { get :new, :user_id => users(:first) }
       should_render_without_layout
     end
+
+    context "on POST to #create" do
+      setup do
+        post :create, :user_id => users(:first),
+                      :post    => { :title => "first post",
+                                    :body  => 'blah blah blah' }
+      end
+
+      should_redirect_to 'user_post_url(@post.user, @post)'
+      should_redirect_to('the created post') { user_post_url(users(:first),
+                                                             assigns(:post)) }
+      should_fail do
+        should_redirect_to 'user_posts_url(@post.user)'
+      end
+      should_fail do
+        should_redirect_to('elsewhere') { user_posts_url(users(:first)) }
+      end
+    end
   end
 
 end