rspec-rails-w-factory_girl 1.3.2

data/lib/spec/rails/example/routing_helpers.rb

@@ -0,0 +1,66 @@
+require 'rack/utils'
+
+module Spec
+  module Rails
+    module Example
+      module RoutingHelpers
+        
+        class RouteFor
+          def initialize(example, options)
+            @example, @options = example, options
+          end
+
+          def ==(expected)
+            if Hash === expected
+              path, querystring = expected[:path].split('?')
+              path_string = path
+              path = expected.merge(:path => path)
+            else
+              path, querystring = expected.split('?')
+              path_string = path
+              path = { :path => path, :method => :get }
+            end
+            params = querystring.blank? ? {} : Rack::Utils.parse_query(querystring).symbolize_keys!
+            begin
+              @example.assert_routing(path, @options, {}, params)
+              true
+            rescue ActionController::RoutingError, ::Test::Unit::AssertionFailedError => e
+              raise e.class, "#{e}\nIf you're expecting this failure, we suggest {:#{path[:method]}=>\"#{path[:path]}\"}.should_not be_routable"
+            end
+          end
+        end
+        # Uses ActionController::Routing::Routes to generate
+        # the correct route for a given set of options.
+        # == Examples
+        #   route_for(:controller => 'registrations', :action => 'edit', :id => '1')
+        #     => '/registrations/1/edit'
+        #   route_for(:controller => 'registrations', :action => 'create')
+        #     => {:path => "/registrations", :method => :post}
+        def route_for(options)
+          RouteFor.new(self, options)
+        end
+
+        # Uses ActionController::Routing::Routes to parse
+        # an incoming path so the parameters it generates can be checked
+        #
+        # Note that this method is obsoleted by the route_to matcher.
+        # == Example
+        #   params_from(:get, '/registrations/1/edit')
+        #     => :controller => 'registrations', :action => 'edit', :id => '1'
+        def params_from(method, path)
+          ensure_that_routes_are_loaded
+          path, querystring = path.split('?')
+          params = ActionController::Routing::Routes.recognize_path(path, :method => method)
+          querystring.blank? ? params : params.merge(Rack::Utils.parse_query(querystring).symbolize_keys!)
+        end
+
+      private
+
+        def ensure_that_routes_are_loaded
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+        end
+
+      end
+    end
+  end
+end

data/lib/spec/rails/example/view_example_group.rb

@@ -0,0 +1,199 @@
+module Spec
+  module Rails
+    module Example
+      class ViewExampleGroupController < ApplicationController #:nodoc:
+        include Spec::Rails::Example::RenderObserver
+        attr_reader :template
+
+        def add_helper_for(template_path)
+          add_helper(template_path.split('/')[0])
+        end
+
+        def add_helper(name)
+          begin
+            helper_module = "#{name}_helper".camelize.constantize
+          rescue
+            return
+          end
+          (class << template; self; end).class_eval do
+            include helper_module
+          end
+        end
+        
+        def forget_variables_added_to_assigns
+        end
+      end
+
+      # View Examples live in $RAILS_ROOT/spec/views/.
+      #
+      # View Specs use Spec::Rails::Example::ViewExampleGroup,
+      # which provides access to views without invoking any of your controllers.
+      # See Spec::Rails::Expectations::Matchers for information about specific
+      # expectations that you can set on views.
+      #
+      # == Example
+      #
+      #   describe "login/login" do
+      #     before do
+      #       render 'login/login'
+      #     end
+      # 
+      #     it "should display login form" do
+      #       response.should have_tag("form[action=/login]") do
+      #         with_tag("input[type=text][name=email]")
+      #         with_tag("input[type=password][name=password]")
+      #         with_tag("input[type=submit][value=Login]")
+      #       end
+      #     end
+      #   end
+      class ViewExampleGroup < FunctionalExampleGroup
+        if ActionView::Base.respond_to?(:load_helpers) # Rails 2.0.x
+          ActionView::Helpers.constants.each do |name|
+            const = ActionView::Helpers.const_get(name)
+            include const if name.include?("Helper") && Module === const
+          end
+        elsif ActionView::Base.respond_to?(:helper_modules) # Rails 2.1.x
+          ActionView::Base.helper_modules.each do |helper_module|
+            include helper_module
+          end
+        else # Rails 2.2.x
+          include ActionView::Helpers
+        end
+
+        tests ViewExampleGroupController
+        class << self
+          def inherited(klass) # :nodoc:
+            klass.subject { template }
+            super
+          end
+        end
+
+        before {ensure_that_flash_and_session_work_properly}
+        after  {ensure_that_base_view_path_is_not_set_across_example_groups}
+
+        def ensure_that_flash_and_session_work_properly #:nodoc:
+          @controller.class.__send__ :public, :flash
+          @controller.__send__ :initialize_template_class, @response
+          @controller.__send__ :assign_shortcuts, @request, @response
+          @controller.__send__ :initialize_current_url
+          @session = @controller.session
+        end
+
+        def ensure_that_base_view_path_is_not_set_across_example_groups #:nodoc:
+          ActionView::Base.base_view_path = nil
+        end
+
+        def set_base_view_path(options) #:nodoc:
+          ActionView::Base.base_view_path = base_view_path(options)
+        end
+
+        def base_view_path(options) #:nodoc:
+          "/#{derived_controller_name(options)}/"
+        end
+
+        def derived_controller_name(options) #:nodoc:
+          parts = subject_of_render(options).split('/').reject { |part| part.empty? }
+          "#{parts[0..-2].join('/')}"
+        end
+
+        def derived_action_name(options) #:nodoc:
+          parts = subject_of_render(options).split('/').reject { |part| part.empty? }
+          "#{parts.last}".split('.').first
+        end
+
+        def subject_of_render(options) #:nodoc:
+          [:template, :partial, :file].each do |render_type|
+            if options.has_key?(render_type)
+              return options[render_type]
+            end
+          end
+          return ""
+        end
+
+        def add_helpers(options) #:nodoc:
+          @controller.add_helper("application")
+          @controller.add_helper(derived_controller_name(options))
+          @controller.add_helper(options[:helper]) if options[:helper]
+          options[:helpers].each { |helper| @controller.add_helper(helper) } if options[:helpers]
+        end
+
+        # Renders a template for a View Spec, which then provides access to the result
+        # through the +response+. Also supports render with :inline, which you can
+        # use to spec custom form builders, helpers, etc, in the context of a view.
+        #
+        # == Examples
+        #
+        #   render('/people/list')
+        #   render('/people/list', :helper => MyHelper)
+        #   render('/people/list', :helpers => [MyHelper, MyOtherHelper])
+        #   render(:partial => '/people/_address')
+        #   render(:inline => "<% custom_helper 'argument', 'another argument' %>")
+        #
+        # See Spec::Rails::Example::ViewExampleGroup for more information.
+        def render(*args)
+          options = Hash === args.last ? args.pop : {}
+          
+          if args.empty? 
+            unless [:partial, :inline, :file, :template, :xml, :json, :update].any? {|k| options.has_key? k} 
+              args << self.class.description_parts.first
+            end
+          end
+          
+          options[:template] = args.first.to_s.sub(/^\//,'') unless args.empty?
+          
+          set_base_view_path(options)
+          add_helpers(options)
+
+          assigns[:action_name] = @action_name
+          
+          @request.path_parameters = @request.path_parameters.merge(
+            :controller => derived_controller_name(options),
+            :action => derived_action_name(options)
+          ).merge(options[:path_parameters] || {})
+
+          defaults = { :layout => false }
+          options = defaults.merge options
+
+          @controller.__send__(:params).reverse_merge! @request.parameters
+
+          @controller.class.instance_eval %{
+            def controller_path
+              "#{derived_controller_name(options)}"
+            end
+
+            def controller_name
+              "#{derived_controller_name(options).split('/').last}"
+            end
+          }
+
+          @controller.__send__ :forget_variables_added_to_assigns
+          @controller.__send__ :render, options
+          @controller.__send__ :process_cleanup
+        end
+
+        # This provides the template. Use this to set mock
+        # expectations for dealing with partials
+        #
+        # == Example
+        #
+        #   describe "/person/new" do
+        #     it "should use the form partial" do
+        #       template.should_receive(:render).with(:partial => 'form')
+        #       render "/person/new"
+        #     end
+        #   end
+        def template
+          @controller.template
+        end
+
+        Spec::Example::ExampleGroupFactory.register(:view, self)
+
+      protected
+        def _assigns_hash_proxy
+          @_assigns_hash_proxy ||= AssignsHashProxy.new(self) {@response.template}
+        end
+      end
+
+    end
+  end
+end

data/lib/spec/rails/example.rb

@@ -0,0 +1,48 @@
+dir = File.dirname(__FILE__)
+
+require 'spec/rails/example/routing_helpers'
+require 'spec/rails/example/assigns_hash_proxy'
+require "spec/rails/example/render_observer"
+require "spec/rails/example/model_example_group"
+require "spec/rails/example/functional_example_group"
+require "spec/rails/example/controller_example_group"
+require "spec/rails/example/helper_example_group"
+require "spec/rails/example/view_example_group"
+require "spec/rails/example/routing_example_group"
+require "spec/rails/example/integration_example_group"
+require "spec/rails/example/cookies_proxy"
+
+module Spec
+  module Rails
+    # Spec::Rails::Example extends Spec::Example (RSpec's core Example module) to provide
+    # Rails-specific contexts for describing Rails Models, Views, Controllers and Helpers.
+    #
+    # == Model Examples
+    #
+    # These are the equivalent of unit tests in Rails' built in testing. Ironically (for the traditional TDD'er) these are the only specs that we feel should actually interact with the database.
+    #
+    # See Spec::Rails::Example::ModelExampleGroup
+    #
+    # == Controller Examples
+    #
+    # These align somewhat with functional tests in rails, except that they do not actually render views (though you can force rendering of views if you prefer). Instead of setting expectations about what goes on a page, you set expectations about what templates get rendered.
+    #
+    # See Spec::Rails::Example::ControllerExampleGroup
+    #
+    # == View Examples
+    #
+    # This is the other half of Rails functional testing. View specs allow you to set up assigns and render
+    # a template. By assigning mock model data, you can specify view behaviour with no dependency on a database
+    # or your real models.
+    #
+    # See Spec::Rails::Example::ViewExampleGroup
+    #
+    # == Helper Examples
+    #
+    # These let you specify directly methods that live in your helpers.
+    #
+    # See Spec::Rails::Example::HelperExampleGroup
+    module Example
+    end
+  end
+end

data/lib/spec/rails/extensions/action_controller/rescue.rb

@@ -0,0 +1,42 @@
+module ActionController
+  module Rescue
+    def use_rails_error_handling!
+      Kernel.warn <<-WARNING
+DEPRECATION NOTICE: controller.use_rails_error_handling! is
+deprecated and will be removed from a future version of
+rspec-rails.
+
+Use rescue_action_in_public!, which is defined directly in
+rails' testing framework, instead.
+WARNING
+      if ::Rails::VERSION::STRING =~ /^2\.0/
+        @use_rails_error_handling = true
+      else
+        # anything but 0.0.0.0 - borrowed from rails own rescue_action_in_public!
+        request.remote_addr = '208.77.188.166'
+      end
+    end
+    
+    def use_rails_error_handling?
+      @use_rails_error_handling ||= false
+    end
+
+  protected
+  
+    if ::Rails::VERSION::STRING =~ /^2\.0/
+      def rescue_action_in_public?
+        request.respond_to?(:rescue_action_in_public?) and request.rescue_action_in_public?
+      end
+      
+      def rescue_action_with_handler_with_fast_errors(exception)
+        if (use_rails_error_handling? || rescue_action_in_public?) & !handler_for_rescue(exception)
+          rescue_action_in_public(exception)
+        else
+          rescue_action_with_handler_without_fast_errors(exception)
+        end
+      end
+      alias_method_chain :rescue_action_with_handler, :fast_errors
+    end
+
+  end
+end

data/lib/spec/rails/extensions/action_controller/test_case.rb

@@ -0,0 +1,16 @@
+module ActionController
+  class TestCase
+    include ::Spec::Rails::Example::RoutingHelpers
+
+    if ::Rails::VERSION::STRING =~ /2\.0/
+      # Introduced in Rails 2.1, but we need it for 2.0
+      def rescue_action_in_public!
+        # See rescue.rb in this same directory
+        def request.rescue_action_in_public?
+          true
+        end
+      end
+      
+    end
+  end
+end

data/lib/spec/rails/extensions/action_controller/test_response.rb

@@ -0,0 +1,21 @@
+module ActionController #:nodoc:
+  class TestResponse #:nodoc:
+    attr_writer :controller_path
+
+    def capture(name)
+      template.instance_variable_get "@content_for_#{name.to_s}"
+    end
+    
+    if ::Rails::VERSION::STRING < "2.3"
+      def [](name)
+        Kernel.warn <<-WARNING
+DEPRECATION NOTICE: [](name) as an alias for capture(name) (TestResponse
+extension in rspec-rails) is deprecated and will not be defined by rspec-rails
+when working with rails >= 2.3.0. It will also be removed entirely from
+a future version of rspec-rails.
+WARNING
+        capture(name)
+      end
+    end
+  end
+end

data/lib/spec/rails/extensions/action_view/base.rb

@@ -0,0 +1,35 @@
+module ActionView #:nodoc:
+  class Base #:nodoc:
+    include Spec::Rails::Example::RenderObserver
+    cattr_accessor :base_view_path
+
+    def render_partial_with_base_view_path_handling(partial_path, local_assigns = nil, deprecated_local_assigns = nil) #:nodoc:
+      if partial_path.is_a?(String)
+        unless partial_path.include?("/")
+          unless self.class.base_view_path.nil?
+            partial_path = "#{self.class.base_view_path}/#{partial_path}"
+          end
+        end
+      end
+      begin
+        render_partial_without_base_view_path_handling(partial_path, local_assigns, deprecated_local_assigns)
+      rescue ArgumentError # edge rails > 2.1 changed render_partial to accept only one arg
+        render_partial_without_base_view_path_handling(partial_path)
+      end
+    end
+    alias_method_chain :render_partial, :base_view_path_handling
+
+    def render_with_mock_proxy(options = {}, old_local_assigns = {}, &block)
+      if render_proxy.__send__(:__mock_proxy).__send__(:find_matching_expectation, :render, options, old_local_assigns)
+        render_proxy.render(options, old_local_assigns)
+      elsif render_proxy.__send__(:__mock_proxy).__send__(:find_matching_expectation, :render, options)
+        render_proxy.render(options)
+      else
+        unless render_proxy.__send__(:__mock_proxy).__send__(:find_matching_method_stub, :render, options)
+          render_without_mock_proxy(options, old_local_assigns, &block)
+        end
+      end
+    end
+    alias_method_chain :render, :mock_proxy
+  end
+end

data/lib/spec/rails/extensions/active_record/base.rb

@@ -0,0 +1,45 @@
+if defined?(ActiveRecord::Base)
+  module Spec
+    module Rails
+      module Extensions
+        module ActiveRecord
+          module ClassMethods
+            # :call-seq:
+            #   ModelClass.should have(:no).records
+            #   ModelClass.should have(1).record
+            #   ModelClass.should have(n).records
+            #
+            # Extension to enhance <tt>should have</tt> on AR Model classes
+            def records
+              find(:all)
+            end
+            alias :record :records
+          end
+
+          module InstanceMethods
+            # :call-seq:
+            #   model.should have(:no).errors_on(:attribute)
+            #   model.should have(1).error_on(:attribute)
+            #   model.should have(n).errors_on(:attribute)
+            #
+            # Extension to enhance <tt>should have</tt> on AR Model instances.
+            # Calls model.valid? in order to prepare the object's errors
+            # object.
+            def errors_on(attribute)
+              self.valid?
+              [self.errors.on(attribute)].flatten.compact
+            end
+            alias :error_on :errors_on
+          end
+        end
+      end
+    end
+  end
+  
+  module ActiveRecord #:nodoc:
+    class Base
+      extend  Spec::Rails::Extensions::ActiveRecord::ClassMethods
+      include Spec::Rails::Extensions::ActiveRecord::InstanceMethods
+    end
+  end
+end

data/lib/spec/rails/extensions/active_support/test_case.rb

@@ -0,0 +1,7 @@
+module ActiveSupport
+  class TestCase
+    include ::Spec::Rails::Matchers
+    include ::Spec::Rails::Mocks
+  end
+end
+

data/lib/spec/rails/extensions/spec/matchers/have.rb

@@ -0,0 +1,23 @@
+require 'spec/matchers/have'
+
+module Spec #:nodoc:
+  module Matchers #:nodoc:
+    class Have #:nodoc:
+
+      def failure_message_for_should_with_errors_on_extensions
+        return "expected #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}, got #{@actual}" if @collection_name == :errors_on
+        return "expected #{relativities[@relativity]}#{@expected} error on :#{@args[0]}, got #{@actual}"  if @collection_name == :error_on
+        return failure_message_for_should_without_errors_on_extensions
+      end
+      alias_method_chain :failure_message_for_should, :errors_on_extensions
+      
+      def description_with_errors_on_extensions
+        return "have #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}" if @collection_name == :errors_on
+        return "have #{relativities[@relativity]}#{@expected} error on :#{@args[0]}"  if @collection_name == :error_on
+        return description_without_errors_on_extensions
+      end
+      alias_method_chain :description, :errors_on_extensions
+
+    end
+  end
+end

data/lib/spec/rails/extensions/spec/runner/configuration.rb

@@ -0,0 +1,44 @@
+require 'spec/runner/configuration'
+require 'test_help'
+
+if defined?(ActiveRecord::Base)
+  module Spec
+    module Runner
+      class Configuration
+      
+        def initialize
+          super
+          self.fixture_path = RAILS_ROOT + '/spec/fixtures'
+        end
+
+        def use_transactional_fixtures
+          ActiveSupport::TestCase.use_transactional_fixtures
+        end
+        def use_transactional_fixtures=(value)
+          ActiveSupport::TestCase.use_transactional_fixtures = value
+        end
+
+        def use_instantiated_fixtures
+          ActiveSupport::TestCase.use_instantiated_fixtures
+        end
+        def use_instantiated_fixtures=(value)
+          ActiveSupport::TestCase.use_instantiated_fixtures = value
+        end
+
+        def fixture_path
+          ActiveSupport::TestCase.fixture_path
+        end
+        def fixture_path=(path)
+          ActiveSupport::TestCase.fixture_path = path
+        end
+
+        def global_fixtures
+          ActiveSupport::TestCase.fixture_table_names
+        end
+        def global_fixtures=(fixtures)
+          ActiveSupport::TestCase.fixtures(*fixtures)
+        end
+      end
+    end
+  end
+end

data/lib/spec/rails/extensions.rb

@@ -0,0 +1,11 @@
+require 'spec'
+
+require 'spec/rails/extensions/spec/runner/configuration'
+require 'spec/rails/extensions/spec/matchers/have'
+
+require 'spec/rails/extensions/active_support/test_case'
+require 'spec/rails/extensions/active_record/base'
+require 'spec/rails/extensions/action_controller/rescue'
+require 'spec/rails/extensions/action_controller/test_case'
+require 'spec/rails/extensions/action_controller/test_response'
+require 'spec/rails/extensions/action_view/base'

data/lib/spec/rails/interop/testcase.rb

@@ -0,0 +1,14 @@
+module Test
+  module Unit
+    class TestCase
+      # Edge rails (r8664) introduces class-wide setup & teardown callbacks for Test::Unit::TestCase.
+      # Make sure these still get run when running TestCases under rspec:
+      prepend_before(:each) do
+        run_callbacks :setup if respond_to?(:run_callbacks)
+      end
+      append_after(:each) do
+        run_callbacks :teardown if respond_to?(:run_callbacks)
+      end
+    end
+  end
+end

data/lib/spec/rails/matchers/ar_be_valid.rb

@@ -0,0 +1,27 @@
+if defined?(ActiveRecord::Base)
+  module Spec
+    module Rails
+      module Matchers
+        # :call-seq:
+        #   response.should be_valid
+        #   response.should_not be_valid
+        def be_valid
+          ::Spec::Matchers::Matcher.new :be_valid do
+            match do |actual|
+              actual.valid?
+            end
+
+            failure_message_for_should do |actual|
+              if actual.respond_to?(:errors) && ActiveRecord::Errors === actual.errors
+                "Expected #{actual.inspect} to be valid, but it was not\nErrors: " + actual.errors.full_messages.join(", ")            
+              else
+                "Expected #{actual.inspect} to be valid"
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end