rspec-rails-w-factory_girl 1.3.2

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

@@ -0,0 +1,149 @@
+require 'rack/utils'
+
+module Spec
+  module Rails
+    module Matchers
+      USAGE = ArgumentError.new( 'usage: { :method => "path" }.should route_to( :controller => "controller", :action => "action", [ args ] )' )
+
+      class PathDecomposer
+        def self.decompose_path(path)
+          method, path = if Hash === path
+                           raise USAGE if path.keys.size > 1
+                           path.entries.first
+                         else
+                           [:get, path]
+                         end
+          path, querystring = path.split('?')
+          return method, path, querystring
+        end
+      end
+
+      class RouteTo #:nodoc:
+        def initialize(expected, example)
+          @route, @example = expected,example
+        end
+
+        def matches?(path)
+          begin
+            @actual = path
+            method, path, querystring = PathDecomposer.decompose_path(path)
+            params = querystring.blank? ? {} : Rack::Utils.parse_query(querystring).symbolize_keys!
+            @example.assert_routing({ :method => method, :path => path }, @route, {}, params)
+            true
+          rescue ActionController::RoutingError, ::Test::Unit::AssertionFailedError, ActionController::MethodNotAllowed => e
+            raise e.class, "#{e}\nIf you're expecting this failure, we suggest { :#{method} => \"#{path}\" }.should_not be_routable"
+          rescue Exception => e
+            raise e.class, "#{e}\n#{e.backtrace.join( "\n" )}"
+          end
+        end
+
+        def does_not_match(path)
+          raise ArgumentError, "Don't test a negative route like this."
+        end
+
+        def failure_message_for_should
+          "Expected #{@expected.inspect} to route to #{@actual.inspect}, but it didn't.\n"+
+          "In this case, we expected you to get an exception.  So this message probably means something weird happened."
+        end
+
+        def failure_message_for_should_not
+          "Expected a routing error, but the route passed instead.  \nNote, when expecting routes to fail, you should use 'should_not be_routable' instead."
+        end
+
+        def description
+          "route to #{@expected.inspect}"
+        end
+
+        private
+          attr_reader :expected
+          attr_reader :actual
+
+      end
+
+      # :call-seq:
+      #   "path".should route_to(expected)  # assumes GET
+      #   { :get => "path" }.should route_to(expected)
+      #   { :put => "path" }.should route_to(expected)
+      #
+      # Uses ActionController::Routing::Routes to verify that
+      # the path-and-method routes to a given set of options.
+      # Also verifies route-generation, so that the expected options
+      # do generate a pathname consisten with the indicated path/method.
+      #
+      # For negative tests, only the route recognition failure can be
+      # tested; since route generation via path_to() will always generate
+      # a path as requested.  Use .should_not be_routable() in this case.
+      #
+      # == Examples
+      # { :get => '/registrations/1/edit' }.
+      #   should route_to(:controller => 'registrations', :action => 'edit', :id => '1')
+      # { :put => "/registrations/1" }.should
+      #   route_to(:controller => 'registrations', :action => 'update', :id => 1)
+      # { :post => "/registrations/" }.should
+      #   route_to(:controller => 'registrations', :action => 'create')
+
+      def route_to(expected)
+        RouteTo.new(expected, self)
+      end
+
+      class BeRoutable
+        def initialize(example)
+          @example = example
+        end
+
+        def matches?(path)
+          begin
+            @actual = path
+            method, path = PathDecomposer.decompose_path(path)
+            @example.assert_recognizes({}, { :method => method, :path => path }, {} )
+            true
+          rescue ActionController::RoutingError, ActionController::MethodNotAllowed
+            false
+          rescue ::Test::Unit::AssertionFailedError => e
+            # the second thingy will always be "<{}>" becaues of the way we called assert_recognizes({}...) above.
+            e.to_s =~ /<(.*)> did not match <\{\}>/ and @actual_place = $1 or raise
+            true
+          end
+        end
+        def failure_message_for_should
+          "Expected '#{@actual.keys.first.to_s.upcase} #{@actual.values.first}' to be routable, but it wasn't.\n"+
+          "To really test routability, we recommend #{@actual.inspect}.\n"+
+          "  should route_to( :action => 'action', :controller => 'controller' )\n\n"+
+
+          "That way, you'll verify where your route goes to.  Plus, we'll verify\n"+
+          "the generation of the expected path from the action/controller, as in\n"+
+          "the url_for() helper."
+        end
+
+        def failure_message_for_should_not
+          "Expected '#{@actual.keys.first.to_s.upcase} #{@actual.values.first}' to fail, but it routed to #{@actual_place} instead"
+        end
+
+      end
+      # :call-seq:
+      #   { "path" }.should_not be_routable # assumes GET
+      #   { :get => "path" }.should_not be_routable
+      #   { :put => "path" }.should_not be_routable
+      #
+      # Uses ActionController::Routing::Routes to verify that
+      # the path-and-method cannot be routed to a controller.
+      # Since url_for() will always generate a path, even if that
+      # path is not routable, the negative test only needs to be
+      # performed on the route recognition.
+      #
+      # Don't use this matcher for testing expected routability -
+      # use .should route_to( :controller => "controller", :action => "action" ) instead
+      #
+      # == Examples
+      # { :get => '/registrations/1/attendees/3/edit' }.should_not be_routable
+      # { :get => '/attendees/3/edit' }.should route_to( ...<controller/action>... )
+
+      def be_routable
+        BeRoutable.new(self)
+      end
+
+      alias_method :be_routeable, :be_routable
+    end
+  end
+end
+

data/lib/spec/rails/matchers.rb

@@ -0,0 +1,32 @@
+module Spec
+  module Rails
+    # Spec::Rails::Expectations::Matchers provides several expectation matchers
+    # intended to work with Rails components like models and responses. For example:
+    #
+    #   response.should redirect_to("some/url") #redirect_to(url) is the matcher.
+    #
+    # In addition to those you see below, the arbitrary predicate feature of RSpec
+    # makes the following available as well:
+    #
+    #   response.should be_success #passes if response.success?
+    #   response.should be_redirect #passes if response.redirect?
+    #
+    # Note that many of these matchers are part of a wrapper of <tt>assert_select</tt>, so
+    # the documentation comes straight from that with some slight modifications.
+    # <tt>assert_select</tt> is a Test::Unit extension originally contributed to the
+    # Rails community as a plugin by Assaf Arkin and eventually shipped as part of Rails.
+    #
+    # For more info on <tt>assert_select</tt>, see the relevant Rails documentation.
+    module Matchers
+    end
+  end
+end
+
+require 'spec/rails/matchers/ar_be_valid'
+require 'spec/rails/matchers/assert_select'
+require 'spec/rails/matchers/change'
+require 'spec/rails/matchers/have_text'
+require 'spec/rails/matchers/include_text'
+require 'spec/rails/matchers/redirect_to'
+require 'spec/rails/matchers/route_to'
+require 'spec/rails/matchers/render_template'

data/lib/spec/rails/mocks.rb

@@ -0,0 +1,136 @@
+module Spec
+  module Rails
+
+    class IllegalDataAccessException < StandardError; end
+
+    module Mocks
+      
+      # Creates a mock object instance for a +model_class+ with common
+      # methods stubbed out. Additional methods may be easily stubbed (via
+      # add_stubs) if +stubs+ is passed.
+      def mock_model(model_class, options_and_stubs = {})
+        id = options_and_stubs[:id] || next_id
+        options_and_stubs = options_and_stubs.reverse_merge({
+          :id => id,
+          :to_param => id.to_s,
+          :new_record? => false,
+          :destroyed? => false,
+          :errors => stub("errors", :count => 0)
+        })
+        m = mock("#{model_class.name}_#{id}", options_and_stubs)
+        m.__send__(:__mock_proxy).instance_eval <<-CODE
+          def @target.as_new_record
+            self.stub!(:id).and_return nil
+            self.stub!(:to_param).and_return nil
+            self.stub!(:new_record?).and_return true
+            self
+          end
+          def @target.is_a?(other)
+            #{model_class}.ancestors.include?(other)
+          end
+          def @target.kind_of?(other)
+            #{model_class}.ancestors.include?(other)
+          end
+          def @target.instance_of?(other)
+            other == #{model_class}
+          end
+          def @target.class
+            #{model_class}
+          end
+        CODE
+        yield m if block_given?
+        m
+      end
+      
+      module ModelStubber
+        def connection
+          raise Spec::Rails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+        end
+        def new_record?
+          id.nil?
+        end
+        def as_new_record
+          self.id = nil
+          self
+        end
+      end
+
+      # :call-seq:
+      #   stub_model(Model)
+      #   stub_model(Model).as_new_record
+      #   stub_model(Model, hash_of_stubs)
+      #   stub_model(Model, instance_variable_name, hash_of_stubs)
+      #
+      # Creates an instance of +Model+ that is prohibited from accessing the
+      # database*. For each key in +hash_of_stubs+, if the model has a
+      # matching attribute (determined by asking it) are simply assigned the
+      # submitted values. If the model does not have a matching attribute, the
+      # key/value pair is assigned as a stub return value using RSpec's
+      # mocking/stubbing framework.
+      #
+      # <tt>new_record?</tt> is overridden to return the result of id.nil?
+      # This means that by default new_record? will return false. If  you want
+      # the object to behave as a new record, sending it +as_new_record+ will
+      # set the id to nil. You can also explicitly set :id => nil, in which
+      # case new_record? will return true, but using +as_new_record+ makes the
+      # example a bit more descriptive.
+      #
+      # While you can use stub_model in any example (model, view, controller,
+      # helper), it is especially useful in view examples, which are
+      # inherently more state-based than interaction-based.
+      #
+      # == Database Independence
+      #
+      # +stub_model+ does not make your examples entirely
+      # database-independent. It does not stop the model class itself from
+      # loading up its columns from the database. It just prevents data access
+      # from the object itself. To completely decouple from the database, take
+      # a look at libraries like unit_record or NullDB.
+      #
+      # == Examples
+      #
+      #   stub_model(Person)
+      #   stub_model(Person).as_new_record
+      #   stub_model(Person, :id => 37)
+      #   stub_model(Person) do |person|
+      #     person.first_name = "David"
+      #   end
+      def stub_model(model_class, stubs={})
+        stubs = {:id => next_id}.merge(stubs)
+        returning model_class.new do |model|
+          model.id = stubs.delete(:id)
+          model.extend ModelStubber
+          stubs.each do |k,v|
+            if model.has_attribute?(k)
+              model[k] = stubs.delete(k)
+            end
+          end
+          model.stub!(stubs)
+          yield model if block_given?
+        end
+      end
+      
+      # DEPRECATED - use object.stub!(:method => value, :method2 => value)
+      #
+      # Stubs methods on +object+ (if +object+ is a symbol or string a new mock
+      # with that name will be created). +stubs+ is a Hash of +method=>value+
+      def add_stubs(object, stubs = {}) #:nodoc:
+        Kernel.warn <<-WARNING
+DEPRECATION NOTICE: add_stubs is deprecated and will be removed
+from a future version of rspec-rails. Use this instead:
+  
+  object.stub!(:method => value, :method2 => value)
+  
+WARNING
+        object.stub!(stubs)
+      end
+
+      private
+        @@model_id = 1000
+        def next_id
+          @@model_id += 1
+        end
+
+    end
+  end
+end

data/lib/spec/rails/version.rb

@@ -0,0 +1,16 @@
+module Spec # :nodoc:
+  module Rails # :nodoc:
+    module VERSION # :nodoc:
+      unless defined? MAJOR
+        MAJOR  = 1
+        MINOR  = 3
+        TINY   = 2
+        PRE    = nil
+      
+        STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+
+        SUMMARY = "rspec-rails #{STRING}"
+      end
+    end
+  end
+end

data/lib/spec/rails.rb

@@ -0,0 +1,26 @@
+begin
+  require_dependency 'application_controller'
+rescue MissingSourceFile
+  require_dependency 'application'
+end
+require 'rack/utils'
+
+require 'action_controller/test_process'
+require 'action_controller/integration'
+require 'active_support/test_case'
+require 'active_record/fixtures' if defined?(ActiveRecord::Base)
+
+require 'spec/test/unit'
+
+require 'spec/rails/matchers'
+require 'spec/rails/mocks'
+require 'spec/rails/example'
+require 'spec/rails/extensions'
+require 'spec/rails/interop/testcase'
+
+Spec::Example::ExampleGroupFactory.default(ActiveSupport::TestCase)
+
+if ActionView::Base.respond_to?(:cache_template_extensions)
+  ActionView::Base.cache_template_extensions = false
+end
+

data/spec/autotest/mappings_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../lib/autotest/rails_rspec'
+require File.dirname(__FILE__) + '/../../../rspec/spec/autotest/autotest_matchers'
+
+describe Autotest::RailsRspec, "file mapping" do
+  before(:each) do
+    @autotest = Autotest::RailsRspec.new
+    @autotest.hook :initialize
+  end
+  
+  it "should map model example to model" do
+    @autotest.should map_specs(['spec/models/thing_spec.rb']).
+                            to('app/models/thing.rb')
+  end
+  
+  it "should map controller example to controller" do
+    @autotest.should map_specs(['spec/controllers/things_controller_spec.rb']).
+                            to('app/controllers/things_controller.rb')
+  end
+  
+  it "should map view.rhtml" do
+    @autotest.should map_specs(['spec/views/things/index.rhtml_spec.rb']).
+                            to('app/views/things/index.rhtml')
+  end
+  
+  it "should map view.rhtml with underscores in example filename" do
+    @autotest.should map_specs(['spec/views/things/index_rhtml_spec.rb']).
+                            to('app/views/things/index.rhtml')
+  end
+  
+  it "should map view.html.erb" do
+    @autotest.should map_specs(['spec/views/things/index.html.erb_spec.rb']).
+                            to('app/views/things/index.html.erb')
+  end
+  
+  describe "between routes.rb and things which depend on routes" do
+    it "should map routes.rb to controllers" do
+      @autotest.should map_specs(['spec/controllers/things_controller_spec.rb']).
+                              to('config/routes.rb')
+    end
+    
+    it "should map routes.rb to views" do
+      @autotest.should map_specs(['spec/views/things/action.html.erb_spec.rb']).
+                              to('config/routes.rb')
+    end
+    
+    it "should map routes.rb to helpers" do
+      @autotest.should map_specs(['spec/helpers/things_helper_spec.rb']).
+                              to('config/routes.rb')
+    end
+    
+    it "should map routing example to routes" do
+      @autotest.should map_specs(['spec/routing/thing_spec.rb']).
+                              to('config/routes.rb')
+    end
+  end  
+  
+  describe "between the config and specs" do
+    ['spec/controllers/things_controller_spec.rb', 
+     'spec/views/things/action.html.erb_spec.rb', 
+     'spec/helpers/things_helper_spec.rb', 
+     'spec/routing/thing_spec.rb', 
+     'spec/models/thing_spec.rb'].each do |file_path|
+    
+      it "should map environment.rb to #{file_path}" do
+        @autotest.should map_specs([file_path]).
+                                to('config/environment.rb')
+      end
+      
+      it "should map environments/test.rb to #{file_path}" do
+        @autotest.should map_specs([file_path]).
+                                to('config/environments/test.rb')
+      end
+      
+      it "should map boot.rb to #{file_path}" do
+        @autotest.should map_specs([file_path]).
+                                to('config/boot.rb')
+      end
+      
+      it "should map spec_helper.rb to #{file_path}" do
+        @autotest.should map_specs([file_path]).
+                                to('spec/spec_helper.rb')
+      end
+    end
+  end
+end

data/spec/rails_suite.rb

@@ -0,0 +1,7 @@
+dir = File.dirname(__FILE__)
+Dir["#{dir}/**/*_example.rb"].each do |file|
+  require file
+end
+Dir["#{dir}/**/*_spec.rb"].each do |file|
+  require file
+end

data/spec/resources/controllers/action_view_base_spec_controller.rb

@@ -0,0 +1,2 @@
+class ActionViewBaseSpecController < ActionController::Base
+end

data/spec/resources/controllers/application.rb

@@ -0,0 +1,9 @@
+class ApplicationController < ActionController::Base
+  before_filter :i_should_only_be_run_once, 
+                :only => 'action_with_inherited_before_filter'
+  
+  def i_should_only_be_run_once
+    true
+  end
+  private :i_should_only_be_run_once
+end

data/spec/resources/controllers/controller_spec_controller.rb

@@ -0,0 +1,127 @@
+class ControllerSpecController < ActionController::Base
+  before_filter :raise_error, :only => :action_with_skipped_before_filter
+  
+  def raise_error
+    raise "from a before filter"
+  end
+  
+  skip_before_filter :raise_error
+
+  prepend_view_path File.join(File.dirname(__FILE__), "..", "views")
+  
+  def some_action
+    render :template => "template/that/does/not/actually/exist"
+  end
+  
+  def some_action_with_implied_template
+  end
+  
+  def action_with_template
+    render :template => "controller_spec/action_with_template"
+  end
+  
+  def action_which_sets_flash
+    flash[:flash_key] = "flash value"
+    render :text => ""
+  end
+  
+  def action_which_gets_session
+    raise "expected #{params[:session_key].inspect}\ngot #{session[:session_key].inspect}" unless (session[:session_key] == params[:expected])
+    render :text => ""
+  end
+  
+  def action_which_sets_session
+    session[:session_key] = "session value"
+  end
+      
+  def action_which_gets_cookie
+    raise "expected #{params[:expected].inspect}, got #{cookies[:cookie_key].inspect}" unless (cookies[:cookie_key] == params[:expected])
+    render :text => ""
+  end
+      
+  def action_which_sets_cookie
+    cookies['cookie_key'] = params[:value]
+    render :text => ""
+  end
+      
+  def action_with_partial
+    render :partial => "controller_spec/partial"
+  end
+  
+  def action_with_partial_with_object
+    render :partial => "controller_spec/partial", :object => params[:thing]
+  end
+  
+  def action_with_partial_with_locals
+    render :partial => "controller_spec/partial", :locals => {:thing => params[:thing]}
+  end
+  
+  def action_with_errors_in_template
+    render :template => "controller_spec/action_with_errors_in_template"
+  end
+
+  def action_setting_the_assigns_hash
+    @indirect_assigns_key = :indirect_assigns_key_value
+  end
+  
+  def action_setting_flash_after_session_reset
+    reset_session
+    flash[:after_reset] = "available"
+  end
+  
+  def action_setting_flash_before_session_reset
+    flash[:before_reset] = 'available'
+    reset_session
+  end
+  
+  def action_with_render_update
+    render :update do |page|
+      page.replace :bottom, 'replace_me',
+                            :partial => 'non_existent_partial'
+    end
+  end
+  
+  def action_with_skipped_before_filter
+    render :text => ""
+  end
+  
+  def action_that_renders_inline
+    render :inline => "<%= 'inline code' %>"
+  end
+  
+  def action_that_assigns_false_to_a_variable
+    @a_variable = false
+    render :text => ""
+  end
+  
+  def action_with_two_arg_render
+    render :update, :status => 404 do |page|
+      page.visual_effect :highlight, 'user_list'
+    end
+  end
+  
+  class RescuedError < Exception; end
+  class UnRescuedError < Exception; end
+  
+  rescue_from RescuedError do |e|
+    render :text => 'Rescued!'
+  end
+
+  def rescued_error_action
+    raise ControllerSpecController::RescuedError
+  end
+
+  def un_rescued_error_action
+    raise ControllerSpecController::UnRescuedError
+  end
+  
+  def action_that_returns_headers
+    render :text => request.headers[params[:header]]
+  end
+end
+
+class ControllerInheritingFromApplicationControllerController < ApplicationController
+  def action_with_inherited_before_filter
+    render :text => ""
+  end
+end

data/spec/resources/controllers/example.txt

@@ -0,0 +1 @@
+This is an example file to download.

data/spec/resources/controllers/redirect_spec_controller.rb

@@ -0,0 +1,70 @@
+class RedirectSpecController < ApplicationController
+
+  def action_with_no_redirect
+    render :text => "this is just here to keep this from causing a MissingTemplate error"
+  end
+  
+  def action_with_redirect_to_somewhere
+    redirect_to :action => 'somewhere'
+  end
+  
+  def action_with_redirect_to_other_somewhere
+    redirect_to :controller => 'render_spec', :action => 'text_action'
+  end
+  
+  def action_with_redirect_to_somewhere_and_return
+    redirect_to :action => 'somewhere' and return
+    render :text => "this is after the return"
+  end
+  
+  def somewhere
+    render :text => "this is just here to keep this from causing a MissingTemplate error"
+  end
+  
+  def action_with_redirect_to_rspec_site
+    redirect_to "http://rspec.rubyforge.org"
+  end
+  
+  def action_with_redirect_back
+    redirect_to :back
+  end
+  
+  def action_with_redirect_in_respond_to
+    respond_to do |wants|
+      wants.html { redirect_to :action => 'somewhere' }
+    end
+  end
+
+  def action_with_redirect_which_creates_query_string
+    redirect_to :action => "somewhere", :id => 1111, :param1 => "value1", :param2 => "value2"
+  end
+
+  # note: sometimes this is the URL which rails will generate from the hash in
+  # action_with_redirect_which_creates_query_string
+  def action_with_redirect_with_query_string_order1
+    redirect_to "http://test.host/redirect_spec/somewhere/1111?param1=value1&param2=value2"
+  end
+
+  # note: sometimes this is the URL which rails will generate from the hash in
+  # action_with_redirect_which_creates_query_string
+  def action_with_redirect_with_query_string_order2
+    redirect_to "http://test.host/redirect_spec/somewhere/1111?param2=value2&param1=value1"
+  end
+
+  def action_with_redirect_to_unroutable_url_inside_app
+    redirect_to :controller => "nonexistant", :action => "none"
+  end
+
+  def action_with_method_restriction
+    render :text => ''
+  end
+
+  def action_to_redirect_to_action_with_method_restriction
+    redirect_to :action => 'action_with_method_restriction'
+  end
+
+  def action_with_redirect_to_somewhere_with_status
+    redirect_to :action => 'somewhere', :status => 301
+  end
+end
+