typo 5.2 → 5.2.98

data/vendor/plugins/rspec-rails/spec/rails/example/cookies_proxy_spec.rb

@@ -1,74 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-class CookiesProxyExamplesController < ActionController::Base
-  def index
-    cookies[:key] = cookies[:key]
-  end
-end
-
-module Spec
-  module Rails
-    module Example
-      describe CookiesProxy, :type => :controller do
-        controller_name :cookies_proxy_examples
-      
-        describe "with a String key" do
-        
-          it "should accept a String value" do
-            cookies = CookiesProxy.new(self)
-            cookies['key'] = 'value'
-            get :index
-            cookies['key'].should == ['value']
-          end
-          
-          if Rails::VERSION::STRING >= "2.0.0"
-            it "should accept a Hash value" do
-              cookies = CookiesProxy.new(self)
-              cookies['key'] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
-              get :index
-              cookies['key'].should == ['value']
-              cookies['key'].value.should == ['value']
-              cookies['key'].expires.should == expiration
-              cookies['key'].path.should == path
-            end
-          end
-            
-        end
-      
-        describe "with a Symbol key" do
-        
-          it "should accept a String value" do
-            example_cookies = CookiesProxy.new(self)
-            example_cookies[:key] = 'value'
-            get :index
-            example_cookies[:key].should == ['value']
-          end
-
-          if Rails::VERSION::STRING >= "2.0.0"
-            it "should accept a Hash value" do
-              example_cookies = CookiesProxy.new(self)
-              example_cookies[:key] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
-              get :index
-              example_cookies[:key].should == ['value']
-              example_cookies[:key].value.should == ['value']
-              example_cookies[:key].expires.should == expiration
-              example_cookies[:key].path.should == path
-            end
-          end
-
-        end
-    
-        describe "#delete" do
-          it "should delete from the response cookies" do
-            example_cookies = CookiesProxy.new(self)
-            response_cookies = mock('cookies')
-            response.should_receive(:cookies).and_return(response_cookies)
-            response_cookies.should_receive(:delete).with('key')
-            example_cookies.delete :key
-          end
-        end
-      end
-    
-    end
-  end
-end

data/vendor/plugins/rspec-rails/spec/rails/example/example_group_factory_spec.rb

@@ -1,112 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module Example
-    describe ExampleGroupFactory do
-      it "should return a ModelExampleGroup when given :type => :model" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :type => :model
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '/blah/spec/models/'" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/models/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\models\\' (windows format)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\models\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
-      end
-
-      it "should return a RailsExampleGroup when given :spec_path => '/blah/spec/foo/' (anything other than controllers, views and helpers)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/foo/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::RailsExampleGroup
-      end
-
-      it "should return a RailsExampleGroup when given :spec_path => '\\blah\\spec\\foo\\' (windows format)  (anything other than controllers, views and helpers)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\foo\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::RailsExampleGroup
-      end
-
-      it "should return a ViewExampleGroup when given :type => :model" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :type => :view
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
-      end
-
-      it "should return a ViewExampleGroup when given :spec_path => '/blah/spec/views/'" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/views/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\views\\' (windows format)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\views\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
-      end
-
-      it "should return a HelperExampleGroup when given :type => :helper" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :type => :helper
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
-      end
-
-      it "should return a HelperExampleGroup when given :spec_path => '/blah/spec/helpers/'" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/helpers/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\helpers\\' (windows format)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\helpers\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
-      end
-
-      it "should return a ControllerExampleGroup when given :type => :controller" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :type => :controller
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
-      end
-
-      it "should return a ControllerExampleGroup when given :spec_path => '/blah/spec/controllers/'" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/controllers/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\controllers\\' (windows format)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\controllers\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
-      end
-
-      it "should favor the :type over the :spec_path" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/models/blah.rb', :type => :controller
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
-      end
-    end
-  end
-end

data/vendor/plugins/rspec-rails/spec/rails/example/helper_spec_spec.rb

@@ -1,174 +0,0 @@
-require File.dirname(__FILE__) + '/../../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
-
-        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 << ActionView::Helpers::PaginationHelper rescue nil       #removed for 2.0
-        helpers << ActionView::Helpers::JavaScriptMacrosHelper rescue nil #removed for 2.0
-        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
-    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

data/vendor/plugins/rspec-rails/spec/rails/example/model_spec_spec.rb

@@ -1,18 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module Rails
-    module Example
-      describe ModelExampleGroup do
-        it "should clear 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/vendor/plugins/rspec-rails/spec/rails/example/shared_behaviour_spec.rb

@@ -1,16 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "A shared view example_group", :shared => true do
-  it "should have some tag with some text" do
-    response.should have_tag('div', 'This is text from a method in the ViewSpecHelper')
-  end
-end
-
-describe "A view example_group", :type => :view do
-  it_should_behave_like "A shared view example_group"
-  
-  before(:each) do
-    render "view_spec/implicit_helper"
-  end
-end
-  

data/vendor/plugins/rspec-rails/spec/rails/example/test_unit_assertion_accessibility_spec.rb

@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + '/../../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/vendor/plugins/rspec-rails/spec/rails/example/view_spec_spec.rb

@@ -1,287 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "A template with an implicit helper", :type => :view do
-  before(:each) do
-    render "view_spec/implicit_helper"
-  end
-
-  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 =~ /view_spec_spec\.rb\:92/}.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 =~ /view_spec_spec\.rb\:109/}.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
-
-if Rails::VERSION::MAJOR >= 2
-  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
-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"
-    render "view_spec/accessor"
-  end
-
-  it "should have access to session data" do
-    response.should have_tag("div#session", "session")
-  end
-
-  specify "should have access to params data" do
-    response.should have_tag("div#params", "params")
-  end
-
-  it "should have access to flash data" do
-    response.should have_tag("div#flash", "flash")
-  end
-
-  it "should have a controller param" do
-    response.should have_tag("div#controller", "view_spec")
-  end
-  
-  it "should have 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.rhtml'", :type => :view do
-  it "should derive action name using the first part of the template name" do
-    render 'view_spec/foo/show.rhtml'
-    request.path_parameters[:action].should == 'show'
-  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.it{}
-          
-          ActionView::Base.should_receive(:base_view_path=).with(nil)
-          group.run_after_each(example)
-        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