rspec-rails 1.3.4 → 2.0.0.a2

data/spec/spec/rails/example/model_example_group_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Rails
-    module Example
-      describe ModelExampleGroup do
-        accesses_configured_helper_methods
-        
-        if defined?(ActiveRecord::TestCase)
-          it "derives from ActiveRecord::TestCase" do
-            group = describe("foo", :type => :model) do; end
-            group.ancestors.should include(ActiveRecord::TestCase)
-          end
-        else
-          it "derives from ActiveSupport::TestCase" do
-            group = describe("foo", :type => :model) do; end
-            group.ancestors.should include(ActiveSupport::TestCase)
-          end
-        end
-        
-        it "clears its name from the description" do
-          group = describe("foo", :type => :model) do
-            $nested_group = describe("bar") do
-            end
-          end
-          group.description.to_s.should == "foo"
-          $nested_group.description.to_s.should == "foo bar"
-        end
-      end
-    end
-  end
-end

data/spec/spec/rails/example/routing_example_group_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-require 'controller_spec_controller'
-require File.join(File.dirname(__FILE__), "/shared_routing_example_group_examples.rb")
-
-describe "Routing Examples", :type => :routing do
-  it_should_behave_like "a routing example"
-  it_should_behave_like "a be routable spec"
-  it_should_behave_like "a route to spec"
-end

data/spec/spec/rails/example/shared_routing_example_group_examples.rb

@@ -1,237 +0,0 @@
-class CustomRouteSpecController < ActionController::Base; end
-class RspecOnRailsSpecsController < ActionController::Base; end
-
-shared_examples_for "a routing example" do
-  describe "using backward compatible route_for()" do
-    it "translates GET-only paths to be explicit" do
-      self.should_receive(:assert_routing).with(hash_including(:method => :get), anything, {}, anything)
-      route_for(:controller => "controller_spec", :action => "some_action").
-        should == "/controller_spec/some_action"
-    end
-
-    it "uses assert_routing to specify that the :controller and :action are involved" do
-      @route = { :controller => "controller_spec", :action => "some_action" }
-      self.should_receive(:assert_routing).with(anything, @route, {}, anything)
-      route_for(@route).
-        should == "/controller_spec/some_action"
-    end
-
-    it "passes extra args through to assert_routing" do
-      @route = { :controller => "controller_spec", :action => "some_action" }
-      self.should_receive(:assert_routing).with(anything, anything, {}, { :a => "1", :b => "2" } )
-      route_for(@route).
-        should == "/controller_spec/some_action?a=1&b=2"
-    end
-
-    it "passes with an existing route" do
-      route_for(:controller => "controller_spec", :action => "some_action").
-        should == "/controller_spec/some_action"
-    end
-
-    it "passes with an existing route with additional parameters" do
-      route_for(:controller => "controller_spec", :action => "some_action", :param => '1').
-        should == "/controller_spec/some_action?param=1"
-    end
-
-    it "recognizes routes with methods besides :get" do
-      should_receive(:assert_routing).with(hash_including(:method => :put), anything, {},  anything)
-
-      route_for(:controller => "rspec_on_rails_specs", :action => "update", :id => "37").
-        should == {:path => "/rspec_on_rails_specs/37", :method => :put}
-    end
-    
-    describe "failing due to bad path:" do
-      it "raises routing error and suggests should_not be_routeable()" do
-        lambda {
-          route_for(:controller => "rspec_on_rails_specs", :action => "nonexistent", :id => "37") ==
-            {:path => "/rspec_on_rails_specs/bad_route/37", :method => :put}
-        }.should raise_error( ActionController::RoutingError, /suggest.*should_not be_routable/ )
-      end
-    end
-
-    describe "failing due to params mismatch:" do
-      it "re-raises assertion and suggests should_not be_routeable()" do
-        lambda {
-          route_for(:controller => "rspec_on_rails_specs", :action => "nonexistent", :id => "37") ==
-            {:path => "/rspec_on_rails_specs/37", :method => :put}
-        }.should raise_error( ::Test::Unit::AssertionFailedError, /suggest.*should_not be_routable/ )
-      end
-    end
-
-    describe "failing due to wrong HTTP method" do
-      it "raises method error and suggest should_not be_routable()" do
-        lambda {
-          route_for(:controller => "rspec_on_rails_specs", :action => "update", :id => "37").
-            should == {:path => "/rspec_on_rails_specs/37", :method => :post}
-        }.should raise_error(ActionController::MethodNotAllowed) { |error| error.should_not =~ /should_not be_routable/ }
-      end
-    end
-
-    it "generates params for custom routes" do
-      # redundant, deprecated
-      params_from(:get, '/custom_route').
-        should == {:controller => "custom_route_spec", :action => "custom_route"}
-    end
-
-    it "generates params for existing routes" do
-      # redundant, deprecated
-      params_from(:get, '/controller_spec/some_action').
-        should == {:controller => "controller_spec", :action => "some_action"}
-    end
-
-    it "generates params for existing routes with a query parameters" do
-      # redundant, deprecated
-      params_from(:get, '/controller_spec/some_action?param=1').
-        should == {:controller => "controller_spec", :action => "some_action", :param => '1'}
-    end
-
-    it "generates params for existing routes with multiple query parameters" do
-      # redundant, deprecated
-      params_from(:get, '/controller_spec/some_action?param1=1&param2=2').
-        should == {:controller => "controller_spec", :action => "some_action", :param1 => '1', :param2 => '2' }
-    end
-  end
-end
-
-shared_examples_for "a be routable spec" do
-  describe "using should_not be_routable()" do
-    it "passes for a bad route" do
-      { :put => "/rspec_on_rails_specs/bad_route/37" }.
-        should_not be_routable
-    end
-    it "passes for a bad route having an arg" do
-      { :put => "/rspec_on_rails_specs/bad_route/37?some_arg=1" }.
-        should_not be_routable
-    end
-    describe "when assert_recognizes throws exceptions:" do
-      [ ActionController::RoutingError, ActionController::MethodNotAllowed ].each do |e|
-        it "passes on #{e}" do
-          self.stub!( :assert_recognizes ).and_return { raise e, "stubbed exception" }
-          { :get => "/rspec_on_rails_spec/bad_route/37" }.should_not be_routable
-        end
-        it "should be_routable on usual Test::Unit::AssertionFailedError" do
-          # <{}> is predictable because of the way we call assert_recognizes during be_routable().
-          self.stub!( :assert_recognizes ).and_return { raise ::Test::Unit::AssertionFailedError, "<{a}> did not match <{}>" }
-          { :get => "/rspec_on_rails_spec/arguably_bad_route" }.should be_routable
-        end
-        it "should re-raise on unusual Test::Unit::AssertionFailedError" do
-          self.stub!( :assert_recognizes ).and_return { raise ::Test::Unit::AssertionFailedError, "some other message" }
-          expect { { :get => "/rspec_on_rails_spec/weird_case_route/" }.should be_routable }.
-            to raise_error
-        end
-      end
-    end
-    it "test should be_routable" do
-      { :get => "/custom_route" }.
-        should be_routable
-    end
-
-    it "recommends route_to() on failure with should()" do
-      lambda {
-        { :get => "/nonexisting_route" }.
-          should be_routable
-      }.should raise_error( /route_to\(/)
-    end
-
-    it "shows actual route that was generated on failure with should_not()" do
-      begin
-        { :get => "/custom_route" }.should_not be_routable
-      rescue Exception => e
-      ensure
-        # Different versions of ruby order these differently
-        e.message.should =~ /"action"=>"custom_route"/
-        e.message.should =~ /"controller"=>"custom_route_spec"/
-      end
-    end
-
-    it "works with routeable (alternate spelling)" do
-      { :put => "/nonexisting_route" }.
-        should_not be_routeable
-    end
-  end
-end
-
-shared_examples_for "a route to spec" do
-  describe "using should[_not] route_to()" do
-    it "supports existing routes" do
-      { :get => "/controller_spec/some_action" }.
-        should route_to( :controller => "controller_spec", :action => "some_action" )
-    end
-
-    it "translates GET-only paths to be explicit, when matching against a string (for parity with route_for().should == '/path')" do
-      self.should_receive(:assert_routing).with(hash_including(:method => :get), anything, {}, anything)
-      "/controller_spec/some_action".
-        should route_to({})
-    end
-
-    it "asserts, using assert_routing, that the :controller and :action are involved" do
-      @route = { :controller => "controller_spec", :action => "some_action" }
-      self.should_receive(:assert_routing).with(anything, @route, {}, anything)
-      "/controller_spec/some_action".
-        should route_to(@route)
-    end
-    
-    it "sends extra args through" do
-      @route = { :controller => "controller_spec", :action => "some_action" }
-      self.should_receive(:assert_routing).with(anything, anything, {}, { :a => "1", :b => "2" } )
-      "/controller_spec/some_action?a=1&b=2".
-        should route_to( @route )
-    end
-
-    it "supports routes with additional parameters" do
-      { :get => "/controller_spec/some_action?param=1" }.
-        should route_to( :controller => "controller_spec", :action => "some_action", :param => '1' )
-    end
-
-    it "recognizes routes with methods besides :get" do
-      self.should_receive(:assert_routing).with(hash_including(:method => :put), anything, {}, anything)
-      { :put => "/rspec_on_rails_specs/37" }.
-        should route_to(:controller => "rspec_on_rails_specs", :action => "update", :id => "37")
-    end
-
-    it "allows only one key/value in the path - :method => path" do
-      lambda {
-        { :a => "b" ,:c => "d" }.
-          should route_to("anything")
-      }.should raise_error( ArgumentError, /usage/ )
-    end
-
-    describe "failing due to bad path" do
-      it "raises routing error, and suggests should_not be_routeable()" do
-        lambda {
-          { :put => "/rspec_on_rails_specs/nonexistent/37" }.
-            should route_to(:controller => "rspec_on_rails_specs", :action => "nonexistent", :id => "37")
-        }.should raise_error( ActionController::RoutingError, /suggest.*nonexistent.*should_not be_routable/ )
-      end
-    end
-    
-    describe "failing due to params mismatch" do
-      it "raises assertion, and suggests should_not be_routeable()" do
-        lambda {
-          { :put => "/rspec_on_rails_specs/37" }.
-            should route_to(:controller => "rspec_on_rails_specs", :action => "nonexistent", :id => "37")
-        }.should raise_error( ::Test::Unit::AssertionFailedError, /suggest.*rspec_on_rails_specs\/37.*should_not be_routable/ )
-      end
-    end
-    
-    describe "passing when expected failure" do
-      it "suggests should_not be_routable()" do
-        self.stub!(:assert_routing).and_return true
-        lambda {
-          { :put => "/rspec_on_rails_specs/37" }.
-            should_not route_to(:controller => "rspec_on_rails_specs", :action => "update", :id => "37")
-        }.should raise_error( /expected a routing error.*be_routable/im )
-      end
-    end
-
-    describe "failing due to wrong HTTP method" do
-      it "raises method error and suggests should_not be_routable()" do
-        self.stub!(:assert_routing) { raise ActionController::MethodNotAllowed }
-        lambda {
-          { :post => "/rspec_on_rails_specs/37" }.
-            should route_to(:controller => "rspec_on_rails_specs", :action => "update", :id => "37" )
-        }.should raise_error(ActionController::MethodNotAllowed, /rspec_on_rails_specs\/37.*should_not be_routable/ )
-      end
-    end
-  end
-end

data/spec/spec/rails/example/test_unit_assertion_accessibility_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe "assert_equal", :shared => true do
-  it "like assert_equal" do
-    assert_equal 1, 1
-    lambda {
-      assert_equal 1, 2
-    }.should raise_error(::Test::Unit::AssertionFailedError)
-  end
-end
-
-describe "A model spec should be able to access 'test/unit' assertions", :type => :model do
-  it_should_behave_like "assert_equal"
-end
-
-describe "A view spec should be able to access 'test/unit' assertions", :type => :view do
-  it_should_behave_like "assert_equal"
-end
-
-describe "A helper spec should be able to access 'test/unit' assertions", :type => :helper do
-  it_should_behave_like "assert_equal"
-end
-
-describe "A controller spec with integrated views should be able to access 'test/unit' assertions", :type => :controller do
-  controller_name :controller_spec
-  integrate_views
-  it_should_behave_like "assert_equal"
-end
-
-describe "A controller spec should be able to access 'test/unit' assertions", :type => :controller do
-  controller_name :controller_spec
-  it_should_behave_like "assert_equal"
-end

data/spec/spec/rails/example/view_example_group_spec.rb

@@ -1,346 +0,0 @@
-require 'spec_helper'
-
-describe "A template with an implicit helper", :type => :view do
-  before(:each) do
-    render "view_spec/implicit_helper"
-  end
-  
-  accesses_configured_helper_methods
-
-  it "should include the helper" do
-    response.should have_tag('div', :content => "This is text from a method in the ViewSpecHelper")
-  end
-
-  it "should include the application helper" do
-    response.should have_tag('div', :content => "This is text from a method in the ApplicationHelper")
-  end
-
-  it "should have access to named routes" do
-    rspec_on_rails_specs_url.should == "http://test.host/rspec_on_rails_specs"
-    rspec_on_rails_specs_path.should == "/rspec_on_rails_specs"
-  end
-end
-
-describe "A template requiring an explicit helper", :type => :view do
-  before(:each) do
-    render "view_spec/explicit_helper", :helper => 'explicit'
-  end
-
-  it "should include the helper if specified" do
-    response.should have_tag('div', :content => "This is text from a method in the ExplicitHelper")
-  end
-
-  it "should include the application helper" do
-    response.should have_tag('div', :content => "This is text from a method in the ApplicationHelper")
-  end
-end
-
-describe "A template requiring multiple explicit helpers", :type => :view do
-  before(:each) do
-    render "view_spec/multiple_helpers", :helpers => ['explicit', 'more_explicit']
-  end
-
-  it "should include all specified helpers" do
-    response.should have_tag('div', :content => "This is text from a method in the ExplicitHelper")
-    response.should have_tag('div', :content => "This is text from a method in the MoreExplicitHelper")
-  end
-
-  it "should include the application helper" do
-    response.should have_tag('div', :content => "This is text from a method in the ApplicationHelper")
-  end
-end
-
-describe "Message Expectations on helper methods", :type => :view do
-  it "should work" do
-    template.should_receive(:method_in_plugin_application_helper).and_return('alternate message 1')
-    render "view_spec/implicit_helper"
-    response.body.should =~ /alternate message 1/
-  end
-
-  it "should work twice" do
-    template.should_receive(:method_in_plugin_application_helper).and_return('alternate message 2')
-    render "view_spec/implicit_helper"
-    response.body.should =~ /alternate message 2/
-  end
-end
-
-describe "A template that includes a partial", :type => :view do
-  def render!
-    render "view_spec/template_with_partial"
-  end
-
-  it "should render the enclosing template" do
-    render!
-    response.should have_tag('div', "method_in_partial in ViewSpecHelper")
-  end
-
-  it "should render the partial" do
-    render!
-    response.should have_tag('div', "method_in_template_with_partial in ViewSpecHelper")
-  end
-
-  it "should include the application helper" do
-    render!
-    response.should have_tag('div', "This is text from a method in the ApplicationHelper")
-  end
-  
-  it "should pass should_receive(:render) with the right partial" do
-    template.should_receive(:render).with(:partial => 'partial')
-    render!
-    template.verify_rendered
-  end
-  
-  it "should fail should_receive(:render) with the wrong partial" do
-    template.should_receive(:render).with(:partial => 'non_existent')
-    render!
-    begin
-      template.verify_rendered
-    rescue Spec::Mocks::MockExpectationError => e
-    ensure
-      e.backtrace.find{|line| line =~ /#{__FILE__}\:#{__LINE__ - 6}/}.should_not be_nil
-    end
-  end
-  
-  it "should pass should_receive(:render) when a partial is expected twice and happens twice" do
-    template.should_receive(:render).with(:partial => 'partial_used_twice').twice
-    render!
-    template.verify_rendered
-  end
-  
-  it "should pass should_receive(:render) when a partial is expected once and happens twice" do
-    template.should_receive(:render).with(:partial => 'partial_used_twice')
-    render!
-    begin
-      template.verify_rendered
-    rescue Spec::Mocks::MockExpectationError => e
-    ensure
-      e.backtrace.find{|line| line =~ /#{__FILE__}\:#{__LINE__ - 6}/}.should_not be_nil
-    end
-  end
-  
-  it "should fail should_receive(:render) with the right partial but wrong options" do
-    template.should_receive(:render).with(:partial => 'partial', :locals => {:thing => Object.new})
-    render!
-    lambda {template.verify_rendered}.should raise_error(Spec::Mocks::MockExpectationError)
-  end
-end
-
-describe "A partial that includes a partial", :type => :view do
-  it "should support should_receive(:render) with nested partial" do
-    obj = Object.new
-    template.should_receive(:render).with(:partial => 'partial', :object => obj)
-    render :partial => "view_spec/partial_with_sub_partial", :locals => { :partial => obj }
-  end
-end
-
-describe "A view that includes a partial using :collection and :spacer_template", :type => :view  do
-  it "should render the partial w/ spacer_tamplate" do
-    render "view_spec/template_with_partial_using_collection"
-    response.should have_tag('div',/method_in_partial/)
-    response.should have_tag('div',/ApplicationHelper/)
-    response.should have_tag('div',/ViewSpecHelper/)
-    response.should have_tag('hr#spacer')
-  end
-
-  it "should render the partial" do
-    template.should_receive(:render).with(:partial => 'partial',
-               :collection => ['Alice', 'Bob'],
-               :spacer_template => 'spacer')
-    render "view_spec/template_with_partial_using_collection"
-  end
-
-end
-
-describe "A view that includes a partial using an array as partial_path", :type => :view do
-  before(:each) do
-    renderable_object = Object.new
-    renderable_object.stub!(:name).and_return("Renderable Object")
-    assigns[:array] = [renderable_object]
-  end
-
-  it "should render the array passed through to render_partial without modification" do
-    render "view_spec/template_with_partial_with_array" 
-    response.body.should match(/^Renderable Object$/)
-  end
-end
-
-describe "Different types of renders (not :template)", :type => :view do
-  it "should render partial with local" do
-    render :partial => "view_spec/partial_with_local_variable", :locals => {:x => "Ender"}
-    response.should have_tag('div', :content => "Ender")
-  end
-end
-
-describe "A view", :type => :view do
-  before(:each) do
-    session[:key] = "session"
-    params[:key] = "params"
-    flash[:key] = "flash"
-    flash.now[:now_key] = "flash.now"
-    render "view_spec/accessor"
-  end
-
-  it "uses the template as the implicit subject" do
-    subject.should == template
-  end
-
-  it "has access to session data" do
-    response.should have_tag("div#session", "session")
-  end
-
-  it "has access to params data" do
-    response.should have_tag("div#params", "params")
-  end
-
-  it "has access to flash" do
-    response.should have_tag("div#flash", "flash")
-  end
-
-  it "has access to flash.now" do
-    response.should have_tag("div#flash_now", "flash.now")
-  end
-
-  it "has a controller param" do
-    response.should have_tag("div#controller", "view_spec")
-  end
-  
-  it "has an action param" do
-    response.should have_tag("div#action", "accessor")
-  end
-end
-
-describe "A view with a form_tag", :type => :view do
-  it "should render the right action" do
-    render "view_spec/entry_form"
-    response.should have_tag("form[action=?]","/view_spec/entry_form")
-  end
-end
-
-describe "An instantiated ViewExampleGroupController", :type => :view do
-  before do
-    render "view_spec/foo/show"
-  end
-  
-  it "should return the name of the real controller that it replaces" do
-    @controller.controller_name.should == 'foo'
-  end
-  
-  it "should return the path of the real controller that it replaces" do
-    @controller.controller_path.should == 'view_spec/foo'
-  end
-end
-
-describe "a block helper", :type => :view do
-  it "should not yield when not told to in the example" do
-    template.should_receive(:if_allowed)
-    render "view_spec/block_helper"
-    response.should_not have_tag("div","block helper was rendered")
-  end
-
-  it "should yield when told to in the example" do
-    template.should_receive(:if_allowed).and_yield
-    render "view_spec/block_helper"
-    response.should have_tag("div","block helper was rendered")
-  end
-end
-
-describe "render :inline => ...", :type => :view do
-  it "should render ERB right in the spec" do
-    render :inline => %|<%= text_field_tag('field_name', 'Value') %>|
-    response.should have_tag("input[type=?][name=?][value=?]","text","field_name","Value")
-  end
-end
-
-describe "render 'view_spec/foo/show'", :type => :view do
-  it "should derive action name using the first part of the template name" do
-    render 'view_spec/foo/show'
-    request.path_parameters[:action].should == 'show'
-  end
-end
-
-describe "view_spec/foo/show", :type => :view do
-  context "rendered with no args" do
-    it "renders just fine" do
-      render
-      request.path_parameters[:action].should == 'show'
-    end
-  end
-end
-
-describe "setting path parameters", :type => :view do
-  describe "(controller)" do
-    it "should supercede the default path parameters" do
-      render "view_spec/entry_form", :path_parameters => {:controller => 'foo'}
-      request.path_parameters[:controller].should == 'foo'
-    end
-  end
-  describe "(action)" do
-    it "should supercede the default path parameters" do
-      render "view_spec/entry_form", :path_parameters => {:action => 'foo'}
-      request.path_parameters[:action].should == 'foo'
-    end
-  end
-  describe "(something arbitrary)" do
-    it "should supercede the default path parameters" do
-      render "view_spec/entry_form", :path_parameters => {:foo => 'bar'}
-      request.path_parameters[:foo].should == 'bar'
-    end
-  end
-end
-
-describe "route helpers", :type => :view do
-  it "should be available before render is called" do
-    custom_route_path.should == '/custom_route'
-  end
-end
-
-module Spec
-  module Rails
-    module Example
-      describe ViewExampleGroup do
-        it "should clear its name from the description" do
-          group = describe("foo", :type => :view) do
-            $nested_group = describe("bar") do
-            end
-          end
-          group.description.to_s.should == "foo"
-          $nested_group.description.to_s.should == "foo bar"
-        end
-
-        it "should clear ActionView::Base.base_view_path on teardown" do
-          group = describe("base_view_path_cleared flag", :type => :view) {}
-          example = group.new(Spec::Example::ExampleProxy.new) {}
-          
-          ActionView::Base.should_receive(:base_view_path=).with(nil)
-          example.run_after_each
-        end
-      end
-    end
-  end
-end
-
-describe "bug http://rspec.lighthouseapp.com/projects/5645/tickets/510", :type => :view do
-  describe "a view example with should_not_receive" do
-    it "should render the view" do
-      obj = mock('model')
-      obj.should_receive(:render_partial?).and_return false
-      assigns[:obj] = obj
-      template.should_not_receive(:render).with(:partial => 'some_partial')
-      render "view_spec/should_not_receive"
-    end
-  end
-end
-
-describe "bug https://rspec.lighthouseapp.com/projects/5645/tickets/787", :type => :view do
-  describe "a view example checking a link" do
-    it "should have access to link_to" do
-      render "view_spec/view_helpers"
-      response.body.should include(link_to("edit", "this_is_the_link"))
-    end
-
-    it "should use link_to within have_tag" do
-      render "view_spec/view_helpers"
-      response.body.should have_tag("span", :html => link_to("edit", "this_is_the_link"))
-    end
-  end
-end