rspec-rails 1.3.4 → 2.0.0.a2

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

@@ -1,129 +0,0 @@
-module Spec
-  module Rails
-    module Matchers
-    
-      class RenderTemplate #:nodoc:
-    
-        def initialize(expected, controller)
-          @controller = controller
-          @expected = expected
-        end
-      
-        def matches?(response_or_controller)
-          response  = response_or_controller.respond_to?(:response) ?
-                      response_or_controller.response :
-                      response_or_controller
-
-          if response.respond_to?(:redirect?) && response.redirect?
-            @redirect_url = response.redirect_url
-          elsif response.respond_to?(:rendered_file)
-            @actual = response.rendered_file
-          elsif response.respond_to?(:rendered)
-            case template = response.rendered[:template]
-            when nil
-              unless response.rendered[:partials].empty?
-                @actual = path_and_file(response.rendered[:partials].keys.first).join("/_")
-              end
-            when ActionView::Template
-              @actual = template.path
-            when String
-              @actual = template
-            end
-          else
-            @actual = response.rendered_template.to_s
-          end
-          return false if @actual.blank?
-          given_controller_path, given_file = path_and_file(@actual)
-          expected_controller_path, expected_file = path_and_file(@expected)
-          given_controller_path == expected_controller_path && match_files(given_file, expected_file)
-        end
-        
-        def match_files(actual, expected)
-          actual_parts = actual.split('.')
-          expected_parts = expected.split('.')
-          expected_parts.each_with_index do |expected_part, index|
-            return false unless expected_part == actual_parts[index]
-          end
-          true
-        end
-        
-        def failure_message_for_should
-          if @redirect_url
-            "expected #{@expected.inspect}, got redirected to #{@redirect_url.inspect}"
-          else
-            "expected #{@expected.inspect}, got #{@actual.inspect}"
-          end
-        end
-        
-        def failure_message_for_should_not
-          "expected not to render #{@expected.inspect}, but did"
-        end
-        
-        def description
-          "render template #{@expected.inspect}"
-        end
-      
-        private
-          def path_and_file(path)
-            parts = path.split('/')
-            file = parts.pop
-            controller = parts.empty? ? current_controller_path : parts.join('/')
-            return controller, file
-          end
-        
-          def controller_path_from(path)
-            parts = path.split('/')
-            parts.pop
-            parts.join('/')
-          end
-
-          def current_controller_path
-            @controller.class.to_s.underscore.gsub(/_controller$/,'')
-          end
-        
-      end
-      
-      # :call-seq:
-      #   response.should render_template(template)
-      #   response.should_not render_template(template)
-      #
-      # For use in controller code examples (integration or isolation mode).
-      #
-      # Passes if the specified template (view file) is rendered by the
-      # response. This file can be any view file, including a partial. However
-      # if it is a partial it must be rendered directly i.e. you can't detect
-      # that a partial has been rendered as part of a view using
-      # render_template. For that you should use a message expectation
-      # (mock) instead:
-      #
-      #   controller.should_receive(:render).with(:partial => 'path/to/partial')
-      #
-      # <code>template</code> can include the controller path. It can also
-      # include an optional extension, which you only need to use when there
-      # is ambiguity.
-      #
-      # Note that partials must be spelled with the preceding underscore.
-      #
-      # == Examples
-      #
-      #   response.should render_template('list')
-      #   response.should render_template('same_controller/list')
-      #   response.should render_template('other_controller/list')
-      #
-      #   # with extensions
-      #   response.should render_template('list.rjs')
-      #   response.should render_template('list.haml')
-      #   response.should render_template('same_controller/list.rjs')
-      #   response.should render_template('other_controller/list.rjs')
-      #
-      #   # partials
-      #   response.should render_template('_a_partial')
-      #   response.should render_template('same_controller/_a_partial')
-      #   response.should render_template('other_controller/_a_partial')
-      def render_template(path)
-        RenderTemplate.new(path.to_s, @controller)
-      end
-
-    end
-  end
-end

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/mocks.rb

@@ -1,140 +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,
-          :marked_for_destruction? => 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.to_str
-            self.to_s
-          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)
-        model_class.new.tap 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   = 4
-        PRE    = nil
-      
-        STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
-
-        SUMMARY = "rspec-rails #{STRING}"
-      end
-    end
-  end
-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