rspec-rails 1.3.2 → 7.0.2

data/spec/spec/rails/example/helper_example_group_spec.rb

@@ -1,233 +0,0 @@
-require 'spec_helper'
-Spec::Runner.configuration.global_fixtures = :people
-
-describe ExplicitHelper, :type => :helper do
-  include ExplicitHelper
-  
-  it "should not require naming the helper if describe is passed a type" do
-    method_in_explicit_helper.should match(/text from a method/)
-    helper.method_in_explicit_helper.should match(/text from a method/)
-  end
-end
-
-module Spec
-  module Rails
-    module Example
-      describe HelperExampleGroup, :type => :helper do
-        helper_name :explicit
-
-        accesses_configured_helper_methods
-
-        it "DEPRECATED should have direct access to methods defined in helpers" do
-          method_in_explicit_helper.should =~ /text from a method/
-        end
-
-        it "should expose the helper with the #helper method" do
-          helper.method_in_explicit_helper.should =~ /text from a method/
-        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"
-
-          helper.named_url.should == "http://test.host/rspec_on_rails_specs"
-          helper.named_path.should == "/rspec_on_rails_specs"
-        end
-
-        it "should fail if the helper method deson't exist" do
-          lambda { non_existent_helper_method }.should raise_error(NameError)
-          lambda { helper.non_existent_helper_method }.should raise_error(NameError)
-        end
-
-        it "should have access to session" do
-          session[:foo] = 'bar'
-          session_foo.should == 'bar'
-          helper.session_foo.should == 'bar'
-        end
-        
-        it "should have access to params" do
-          params[:foo] = 'bar'
-          params_foo.should == 'bar'
-          helper.params_foo.should == 'bar'
-        end
-        
-        it "should have access to request" do
-          request.stub!(:thing).and_return('bar')
-          request_thing.should == 'bar'
-          helper.request_thing.should == 'bar'
-        end
-        
-        it "should have access to flash" do
-          flash[:thing] = 'camera'
-          flash_thing.should == 'camera'
-          helper.flash_thing.should == 'camera'
-        end
-      end
-
-      describe HelperExampleGroup, "#eval_erb", :type => :helper do
-        helper_name :explicit
-
-        it "should support methods that accept blocks" do
-          eval_erb("<% prepend 'foo' do %>bar<% end %>").should == "foobar"
-        end
-      end
-
-      describe HelperExampleGroup, ".fixtures", :type => :helper do
-        helper_name :explicit
-        fixtures :animals
-
-        it "should load fixtures" do
-          pig = animals(:pig)
-          pig.class.should == Animal
-        end
-
-        it "should load global fixtures" do
-          lachie = people(:lachie)
-          lachie.class.should == Person
-        end
-      end
-      
-      describe "methods from standard helpers", :type => :helper do
-        helper_name :explicit
-        it "should be exposed to the helper" do
-          helper.link_to("Foo","http://bar").should have_tag("a")
-        end
-      end
-
-      describe HelperExampleGroup, "included modules", :type => :helper do
-        helpers = [
-          ActionView::Helpers::ActiveRecordHelper,
-          ActionView::Helpers::AssetTagHelper,
-          ActionView::Helpers::BenchmarkHelper,
-          ActionView::Helpers::CacheHelper,
-          ActionView::Helpers::CaptureHelper,
-          ActionView::Helpers::DateHelper,
-          ActionView::Helpers::DebugHelper,
-          ActionView::Helpers::FormHelper,
-          ActionView::Helpers::FormOptionsHelper,
-          ActionView::Helpers::FormTagHelper,
-          ActionView::Helpers::JavaScriptHelper,
-          ActionView::Helpers::NumberHelper,
-          ActionView::Helpers::PrototypeHelper,
-          ActionView::Helpers::ScriptaculousHelper,
-          ActionView::Helpers::TagHelper,
-          ActionView::Helpers::TextHelper,
-          ActionView::Helpers::UrlHelper
-        ]
-        helpers.each do |helper_module|
-          it "should include #{helper_module}" do
-            self.class.ancestors.should include(helper_module)
-            helper.class.ancestors.should include(helper_module)
-          end
-        end
-      end
-      
-      # TODO: BT - Helper Examples should proxy method_missing to a Rails View instance.
-      # When that is done, remove this method
-      describe HelperExampleGroup, "#protect_against_forgery?", :type => :helper do
-        it "should return false" do
-          protect_against_forgery?.should be_false
-          helper.protect_against_forgery?.should be_false
-        end
-      end
-      
-      describe HelperExampleGroup, "#assigns", :type => :helper do
-        helper_name :addition
-        it "should expose variables to helper" do
-          assigns[:addend] = 3
-          helper.plus(4).should == 7
-        end
-
-        it "should make helper ivars available in example" do
-          assigns[:addend] = 3
-          assigns[:addend].should == 3
-        end
-      end
-      
-      describe HelperExampleGroup, "using a helper that uses output_buffer inside helper", :type => :helper do
-        helper_name :explicit
-        
-        before(:each) do
-          if ::Rails::VERSION::STRING < "2.2"
-            pending("need to get this new feature working against pre 2.2 versions of rails")
-          end
-        end
-
-        it "should not raise an error" do
-          lambda { method_using_output_buffer }.should_not raise_error
-        end
-
-        it "should put the output in the output_buffer" do
-          method_using_output_buffer
-          output_buffer.should == "the_text_from_concat"
-        end
-      end
-
-      describe HelperExampleGroup, "using a helper that tries to access @template", :type => :helper do
-        helper_name :explicit
-
-        it "should not raise an error" do
-          lambda { method_using_template }.should_not raise_error
-        end
-
-        it "should have the correct output" do
-          method_using_template.should have_text(/#some_id/)
-        end
-      end
-
-    end
-  end
-end
-
-module Bug11223
-  # see http://rubyforge.org/tracker/index.php?func=detail&aid=11223&group_id=797&atid=3149
-  describe 'Accessing flash from helper spec', :type => :helper do
-    it 'should not raise an error' do
-      lambda { flash['test'] }.should_not raise_error
-    end
-  end
-end
-
-module Spec
-  module Rails
-    module Example
-      describe HelperExampleGroup do
-        it "should clear its name from the description" do
-          group = describe("foo", :type => :helper) 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
-
-module Bug719
-  # see http://rspec.lighthouseapp.com/projects/5645/tickets/719
-  # FIXME - helper and example provided in ticket. The example did
-  # fail initially, so running it now shows that the bug is fixed,
-  # but this doesn't serve as a good internal example.
-  module ImagesHelper
-    def hide_images_button
-      content_tag :div, :class => :hide_images_button do
-        button_to_function "Hide Images", :id => :hide_images_button do |page|
-          page[:more_images_button].toggle
-          page[:image_browser].toggle
-        end
-      end
-    end
-  end
-  
-  describe ImagesHelper, :type => :helper do
-    it "should render a hide_images_button" do
-      helper.hide_images_button.should have_tag('div[class=?]','hide_images_button') do
-        with_tag('input[id=?][type=?][value=?][onclick^=?]',
-                 'hide_images_button', 'button', 'Hide Images',
-                 "$(&quot;more_images_button&quot;).toggle();\n$(&quot;image_browser&quot;).toggle();;")
-        end
-     end
-  end
-end

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,10 +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
-  
-  include RoutingExampleGroupSpec
-  include RouteToExampleGroupSpec
-  include BeRoutableExampleGroupSpec
-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
-
-share_as :RoutingExampleGroupSpec 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
-
-share_as :BeRoutableExampleGroupSpec 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
-
-share_as :RouteToExampleGroupSpec 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