rspec-rails 1.3.2 → 6.1.2

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

@@ -1,149 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

data/spec/resources/controllers/application.rb

@@ -1,9 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

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

data/spec/resources/controllers/redirect_spec_controller.rb

@@ -1,70 +0,0 @@
-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
-