jcnetdev-shoulda 4.2

data/lib/shoulda/controller_tests/formats/html.rb

@@ -0,0 +1,201 @@
+module ThoughtBot # :nodoc: 
+  module Shoulda # :nodoc: 
+    module Controller # :nodoc:
+      module HTML # :nodoc: all
+        def self.included(other)
+          other.class_eval do
+            extend ThoughtBot::Shoulda::Controller::HTML::ClassMethods
+          end
+        end
+  
+        module ClassMethods 
+          def controller_name_from_class
+            self.name.gsub(/Test/, '')
+          end
+
+          def make_show_html_tests(res)
+            context "on GET to #{controller_name_from_class}#show" do
+              setup do
+                record = get_existing_record(res)
+                parent_params = make_parent_params(res, record)
+                get :show, parent_params.merge({ res.identifier => record.to_param })          
+              end
+
+              if res.denied.actions.include?(:show)
+                should_not_assign_to res.object
+                should_redirect_to res.denied.redirect
+                should_set_the_flash_to res.denied.flash
+              else
+                should_assign_to res.object          
+                should_respond_with :success
+                should_render_template :show
+                should_not_set_the_flash
+              end
+            end
+          end
+
+          def make_edit_html_tests(res)
+            context "on GET to #{controller_name_from_class}#edit" do
+              setup do
+                @record = get_existing_record(res)
+                parent_params = make_parent_params(res, @record)
+                get :edit, parent_params.merge({ res.identifier => @record.to_param })          
+              end
+        
+              if res.denied.actions.include?(:edit)
+                should_not_assign_to res.object
+                should_redirect_to res.denied.redirect
+                should_set_the_flash_to res.denied.flash
+              else
+                should_assign_to res.object                    
+                should_respond_with :success
+                should_render_template :edit
+                should_not_set_the_flash
+                should_render_a_form
+                should "set @#{res.object} to requested instance" do
+                  assert_equal @record, assigns(res.object)
+                end
+              end
+            end
+          end
+
+          def make_index_html_tests(res)
+            context "on GET to #{controller_name_from_class}#index" do
+              setup do
+                record = get_existing_record(res) rescue nil
+                parent_params = make_parent_params(res, record)
+                get(:index, parent_params)          
+              end
+
+              if res.denied.actions.include?(:index)
+                should_not_assign_to res.object.to_s.pluralize
+                should_redirect_to res.denied.redirect
+                should_set_the_flash_to res.denied.flash          
+              else
+                should_respond_with :success
+                should_assign_to res.object.to_s.pluralize
+                should_render_template :index
+                should_not_set_the_flash
+              end
+            end
+          end
+
+          def make_new_html_tests(res)
+            context "on GET to #{controller_name_from_class}#new" do
+              setup do
+                record = get_existing_record(res) rescue nil
+                parent_params = make_parent_params(res, record)
+                get(:new, parent_params)          
+              end
+
+              if res.denied.actions.include?(:new)
+                should_not_assign_to res.object
+                should_redirect_to res.denied.redirect
+                should_set_the_flash_to res.denied.flash
+              else
+                should_respond_with :success
+                should_assign_to res.object
+                should_not_set_the_flash
+                should_render_template :new
+                should_render_a_form
+              end
+            end
+          end
+
+          def make_destroy_html_tests(res)
+            context "on DELETE to #{controller_name_from_class}#destroy" do
+              setup do
+                @record = get_existing_record(res)
+                parent_params = make_parent_params(res, @record)
+                delete :destroy, parent_params.merge({ res.identifier => @record.to_param })
+              end
+        
+              if res.denied.actions.include?(:destroy)
+                should_redirect_to res.denied.redirect
+                should_set_the_flash_to res.denied.flash
+          
+                should "not destroy record" do
+                  assert_nothing_raised { assert @record.reload }
+                end
+              else
+                should_set_the_flash_to res.destroy.flash
+                if res.destroy.redirect.is_a? Symbol
+                  should_respond_with res.destroy.redirect
+                else
+                  should_redirect_to res.destroy.redirect
+                end
+
+                should "destroy record" do
+                  assert_raises(::ActiveRecord::RecordNotFound, "@#{res.object} was not destroyed.") do
+                    @record.reload
+                  end
+                end
+              end
+            end
+          end
+
+          def make_create_html_tests(res)
+            context "on POST to #{controller_name_from_class}#create with #{res.create.params.inspect}" do
+              setup do
+                record = get_existing_record(res) rescue nil
+                parent_params = make_parent_params(res, record)
+                @count = res.klass.count
+                post :create, parent_params.merge(res.object => res.create.params)
+              end
+        
+              if res.denied.actions.include?(:create)
+                should_redirect_to res.denied.redirect
+                should_set_the_flash_to res.denied.flash
+                should_not_assign_to res.object
+          
+                should "not create new record" do
+                  assert_equal @count, res.klass.count
+                end          
+              else
+                should_assign_to res.object
+                should_set_the_flash_to res.create.flash
+                if res.create.redirect.is_a? Symbol
+                  should_respond_with res.create.redirect
+                else
+                  should_redirect_to res.create.redirect
+                end
+
+                should "not have errors on @#{res.object}" do
+                  assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"            
+                end
+              end      
+            end
+          end
+
+          def make_update_html_tests(res)
+            context "on PUT to #{controller_name_from_class}#update with #{res.create.params.inspect}" do
+              setup do
+                @record = get_existing_record(res)
+                parent_params = make_parent_params(res, @record)
+                put :update, parent_params.merge(res.identifier => @record.to_param, res.object => res.update.params)
+              end
+
+              if res.denied.actions.include?(:update)
+                should_not_assign_to res.object
+                should_redirect_to res.denied.redirect
+                should_set_the_flash_to res.denied.flash
+              else
+                should_assign_to res.object
+                should_set_the_flash_to(res.update.flash)
+                if res.update.redirect.is_a? Symbol
+                  should_respond_with res.update.redirect
+                else
+                  should_redirect_to res.update.redirect
+                end
+                
+                should "not have errors on @#{res.object}" do
+                  assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/controller_tests/formats/xml.rb

@@ -0,0 +1,170 @@
+module ThoughtBot # :nodoc: 
+  module Shoulda # :nodoc: 
+    module Controller # :nodoc:
+      module XML 
+        def self.included(other) #:nodoc:
+          other.class_eval do
+            extend ThoughtBot::Shoulda::Controller::XML::ClassMethods
+          end
+        end
+  
+        module ClassMethods
+          # Macro that creates a test asserting that the controller responded with an XML content-type
+          # and that the XML contains +<name/>+ as the root element.
+          def should_respond_with_xml_for(name = nil)
+            should "have ContentType set to 'application/xml'" do
+              assert_xml_response
+            end
+            
+            if name
+              should "return <#{name}/> as the root element" do
+                body = @response.body.first(100).map {|l| "  #{l}"}
+                assert_select name.to_s.dasherize, 1, "Body:\n#{body}...\nDoes not have <#{name}/> as the root element."
+              end
+            end
+          end
+          alias should_respond_with_xml should_respond_with_xml_for
+          
+          protected
+                    
+          def make_show_xml_tests(res) # :nodoc:
+            context "on GET to #{controller_name_from_class}#show as xml" do
+              setup do
+                request_xml
+                record = get_existing_record(res)
+                parent_params = make_parent_params(res, record)
+                get :show, parent_params.merge({ res.identifier => record.to_param })          
+              end
+
+              if res.denied.actions.include?(:show)
+                should_not_assign_to res.object
+                should_respond_with 401
+              else
+                should_assign_to res.object          
+                should_respond_with :success
+                should_respond_with_xml_for res.object
+              end
+            end
+          end
+
+          def make_edit_xml_tests(res) # :nodoc:
+            # XML doesn't need an :edit action
+          end
+
+          def make_new_xml_tests(res) # :nodoc:
+            # XML doesn't need a :new action
+          end
+
+          def make_index_xml_tests(res) # :nodoc:
+            context "on GET to #{controller_name_from_class}#index as xml" do
+              setup do
+                request_xml
+                parent_params = make_parent_params(res)
+                get(:index, parent_params)          
+              end
+
+              if res.denied.actions.include?(:index)
+                should_not_assign_to res.object.to_s.pluralize
+                should_respond_with 401          
+              else
+                should_respond_with :success
+                should_respond_with_xml_for res.object.to_s.pluralize
+                should_assign_to res.object.to_s.pluralize
+              end
+            end
+          end
+
+          def make_destroy_xml_tests(res) # :nodoc:
+            context "on DELETE to #{controller_name_from_class}#destroy as xml" do
+              setup do
+                request_xml
+                @record = get_existing_record(res)
+                parent_params = make_parent_params(res, @record)
+                delete :destroy, parent_params.merge({ res.identifier => @record.to_param })
+              end
+        
+              if res.denied.actions.include?(:destroy)
+                should_respond_with 401
+          
+                should "not destroy record" do
+                  assert @record.reload
+                end
+              else
+                should "destroy record" do
+                  assert_raises(::ActiveRecord::RecordNotFound, "@#{res.object} was not destroyed.") do
+                    @record.reload
+                  end
+                end
+              end
+            end
+          end
+
+          def make_create_xml_tests(res) # :nodoc:
+            context "on POST to #{controller_name_from_class}#create as xml" do
+              setup do
+                request_xml
+                parent_params = make_parent_params(res)
+                @count = res.klass.count
+                post :create, parent_params.merge(res.object => res.create.params)
+              end
+        
+              if res.denied.actions.include?(:create)
+                should_respond_with 401
+                should_not_assign_to res.object
+          
+                should "not create new record" do
+                  assert_equal @count, res.klass.count
+                end          
+              else
+                should_assign_to res.object
+
+                should "not have errors on @#{res.object}" do
+                  assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"            
+                end
+              end      
+            end
+          end
+
+          def make_update_xml_tests(res) # :nodoc:
+            context "on PUT to #{controller_name_from_class}#update as xml" do
+              setup do
+                request_xml
+                @record = get_existing_record(res)
+                parent_params = make_parent_params(res, @record)
+                put :update, parent_params.merge(res.identifier => @record.to_param, res.object => res.update.params)
+              end
+
+              if res.denied.actions.include?(:update)
+                should_not_assign_to res.object
+                should_respond_with 401
+              else
+                should_assign_to res.object
+
+                should "not have errors on @#{res.object}" do
+                  assert_equal [], assigns(res.object).errors.full_messages, "@#{res.object} has errors:"
+                end
+              end
+            end
+          end
+        end
+
+        # Sets the next request's format to 'application/xml'
+        def request_xml
+          @request.accept = "application/xml"
+        end
+        
+        # Asserts that the controller's response was 'application/xml'
+        def assert_xml_response
+          content_type = (@response.headers["Content-Type"] || @response.headers["type"]).to_s
+          regex = %r{\bapplication/xml\b}
+
+          msg = "Content Type '#{content_type.inspect}' doesn't match '#{regex.inspect}'\n"
+          msg += "Body: #{@response.body.first(100).chomp} ..." 
+
+          assert_match regex, content_type, msg
+        end
+        
+      end
+    end
+  end
+end

data/lib/shoulda/gem/proc_extensions.rb

@@ -0,0 +1,14 @@
+# Stolen straight from ActiveSupport
+
+class Proc #:nodoc:
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end

data/lib/shoulda/gem/shoulda.rb

@@ -0,0 +1,246 @@
+require File.join(File.dirname(__FILE__), 'proc_extensions')
+
+module Thoughtbot
+  module Shoulda
+    class << self
+      attr_accessor :current_context
+    end
+
+    VERSION = '1.1.1'
+
+    # = Should statements
+    #
+    # Should statements are just syntactic sugar over normal Test::Unit test methods.  A should block 
+    # contains all the normal code and assertions you're used to seeing, with the added benefit that 
+    # they can be wrapped inside context blocks (see below).
+    #
+    # == Example:
+    #
+    #  class UserTest << Test::Unit::TestCase
+    #    
+    #    def setup
+    #      @user = User.new("John", "Doe")
+    #    end
+    #
+    #    should "return its full name"
+    #      assert_equal 'John Doe', @user.full_name
+    #    end
+    #  
+    #  end
+    #   
+    # ...will produce the following test:
+    # * <tt>"test: User should return its full name. "</tt>
+    #
+    # Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
+
+    def should(name, &blk)
+      if Shoulda.current_context
+        block_given? ? Shoulda.current_context.should(name, &blk) : Should.current_context.should_eventually(name)
+      else
+        context_name = self.name.gsub(/Test/, "")
+        context = Thoughtbot::Shoulda::Context.new(context_name, self) do
+          block_given? ? should(name, &blk) : should_eventually(name)
+        end
+        context.build
+      end
+    end
+
+    # Just like should, but never runs, and instead prints an 'X' in the Test::Unit output.
+    def should_eventually(name, &blk)
+      context_name = self.name.gsub(/Test/, "")
+      context = Thoughtbot::Shoulda::Context.new(context_name, self) do
+        should_eventually(name, &blk)
+      end
+      context.build
+    end
+
+    # = Contexts
+    # 
+    # A context block groups should statements under a common set of setup/teardown methods.  
+    # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
+    # and readability of your test code.
+    #
+    # A context block can contain setup, should, should_eventually, and teardown blocks.
+    #
+    #  class UserTest << Test::Unit::TestCase
+    #    context "A User instance" do
+    #      setup do
+    #        @user = User.find(:first)
+    #      end
+    #    
+    #      should "return its full name"
+    #        assert_equal 'John Doe', @user.full_name
+    #      end
+    #    end
+    #  end
+    #
+    # This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
+    #
+    # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each 
+    # should statement.  They then run their teardown blocks from in to out after each should statement.
+    #
+    #  class UserTest << Test::Unit::TestCase
+    #    context "A User instance" do
+    #      setup do
+    #        @user = User.find(:first)
+    #      end
+    #    
+    #      should "return its full name"
+    #        assert_equal 'John Doe', @user.full_name
+    #      end
+    #    
+    #      context "with a profile" do
+    #        setup do
+    #          @user.profile = Profile.find(:first)
+    #        end
+    #      
+    #        should "return true when sent :has_profile?"
+    #          assert @user.has_profile?
+    #        end
+    #      end
+    #    end
+    #  end
+    #
+    # This code will produce the following methods 
+    # * <tt>"test: A User instance should return its full name. "</tt>
+    # * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
+    #
+    # <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt> 
+    # tests</b>.  This means you do not have to fully commit to the context/should syntax in a test file.
+
+    def context(name, &blk)
+      if Shoulda.current_context
+        Shoulda.current_context.context(name, &blk)
+      else
+        context = Thoughtbot::Shoulda::Context.new(name, self, &blk)
+        context.build
+      end
+    end
+
+    class Context # :nodoc:
+
+      attr_accessor :name               # my name
+      attr_accessor :parent             # may be another context, or the original test::unit class.
+      attr_accessor :subcontexts        # array of contexts nested under myself
+      attr_accessor :setup_blocks       # block given via a setup method
+      attr_accessor :teardown_blocks    # block given via a teardown method
+      attr_accessor :shoulds            # array of hashes representing the should statements
+      attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
+
+      def initialize(name, parent, &blk)
+        Shoulda.current_context = self
+        self.name               = name
+        self.parent             = parent
+        self.setup_blocks       = []
+        self.teardown_blocks    = []
+        self.shoulds            = []
+        self.should_eventuallys = []
+        self.subcontexts        = []
+
+        blk.bind(self).call
+        Shoulda.current_context = nil
+      end
+
+      def context(name, &blk)
+        subcontexts << Context.new(name, self, &blk)
+        Shoulda.current_context = self
+      end
+
+      def setup(&blk)
+        self.setup_blocks << blk
+      end
+
+      def teardown(&blk)
+        self.teardown_blocks << blk
+      end
+
+      def should(name, &blk)
+        if block_given?
+          self.shoulds << { :name => name, :block => blk }
+        else
+         self.should_eventuallys << { :name => name }
+       end
+      end
+
+      def should_eventually(name, &blk)
+        self.should_eventuallys << { :name => name, :block => blk }
+      end
+
+      def full_name
+        parent_name = parent.full_name if am_subcontext?
+        return [parent_name, name].join(" ").strip
+      end
+
+      def am_subcontext?
+        parent.is_a?(self.class) # my parent is the same class as myself.
+      end
+
+      def test_unit_class
+        am_subcontext? ? parent.test_unit_class : parent
+      end
+
+      def create_test_from_should_hash(should)
+        test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
+
+        if test_unit_class.instance_methods.include?(test_name.to_s)
+          warn "  * WARNING: '#{test_name}' is already defined" 
+        end
+        
+        context = self
+        test_unit_class.send(:define_method, test_name) do
+          begin
+            context.run_all_setup_blocks(self)
+            should[:block].bind(self).call
+          ensure
+            context.run_all_teardown_blocks(self)
+          end
+        end
+      end
+
+      def run_all_setup_blocks(binding)
+        self.parent.run_all_setup_blocks(binding) if am_subcontext?
+        setup_blocks.each do |setup_block|
+          setup_block.bind(binding).call
+        end
+      end
+
+      def run_all_teardown_blocks(binding)
+        teardown_blocks.reverse.each do |teardown_block|
+          teardown_block.bind(binding).call
+        end
+        self.parent.run_all_teardown_blocks(binding) if am_subcontext?
+      end
+
+      def print_should_eventuallys
+        should_eventuallys.each do |should|
+          test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
+          puts "  * DEFERRED: " + test_name
+        end
+      end
+
+      def build
+        shoulds.each do |should|
+          create_test_from_should_hash(should)
+        end
+
+        subcontexts.each { |context| context.build }
+
+        print_should_eventuallys
+      end
+
+      def method_missing(method, *args, &blk)
+        test_unit_class.send(method, *args, &blk)
+      end
+
+    end
+  end
+end
+
+module Test # :nodoc: all
+  module Unit 
+    class TestCase
+      extend Thoughtbot::Shoulda
+    end
+  end
+end
+