dchelimsky-rspec-rails 1.1.12 → 1.1.99.1

data/spec/spec/rails/example/cookies_proxy_spec.rb

@@ -16,29 +16,27 @@ module Spec
         describe "with a String key" do
         
           it "should accept a String value" do
-            cookies = CookiesProxy.new(self)
-            cookies['key'] = 'value'
+            proxy = CookiesProxy.new(self)
+            proxy['key'] = 'value'
             get :index
             if ::Rails::VERSION::STRING >= "2.3"
-              cookies['key'].should == 'value'
+              proxy['key'].should == 'value'
             else
-              cookies['key'].should == ['value']
+              proxy['key'].should == ['value']
             end
           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
-              if ::Rails::VERSION::STRING >= "2.3"
-                cookies['key'].should == 'value'
-              else
-                cookies['key'].should == ['value']
-                cookies['key'].value.should == ['value']
-                cookies['key'].expires.should == expiration
-                cookies['key'].path.should == path
-              end
+          it "should accept a Hash value" do
+            proxy = CookiesProxy.new(self)
+            proxy['key'] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
+            get :index
+            if ::Rails::VERSION::STRING >= "2.3"
+              proxy['key'].should == 'value'
+            else
+              proxy['key'].should == ['value']
+              proxy['key'].value.should == ['value']
+              proxy['key'].expires.should == expiration
+              proxy['key'].path.should == path
             end
           end
             
@@ -47,29 +45,27 @@ module Spec
         describe "with a Symbol key" do
         
           it "should accept a String value" do
-            example_cookies = CookiesProxy.new(self)
-            example_cookies[:key] = 'value'
+            proxy = CookiesProxy.new(self)
+            proxy[:key] = 'value'
             get :index
             if ::Rails::VERSION::STRING >= "2.3"
-              example_cookies[:key].should == 'value'
+              proxy[:key].should == 'value'
             else
-              example_cookies[:key].should == ['value']
+              proxy[:key].should == ['value']
             end
           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
-              if ::Rails::VERSION::STRING >= "2.3"
-                example_cookies[:key].should == 'value'
-              else
-                example_cookies[:key].should == ['value']
-                example_cookies[:key].value.should == ['value']
-                example_cookies[:key].expires.should == expiration
-                example_cookies[:key].path.should == path
-              end
+          it "should accept a Hash value" do
+            proxy = CookiesProxy.new(self)
+            proxy[:key] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
+            get :index
+            if ::Rails::VERSION::STRING >= "2.3"
+              proxy[:key].should == 'value'
+            else
+              proxy[:key].should == ['value']
+              proxy[:key].value.should == ['value']
+              proxy[:key].expires.should == expiration
+              proxy[:key].path.should == path
             end
           end
 
@@ -77,11 +73,11 @@ module Spec
     
         describe "#delete" do
           it "should delete from the response cookies" do
-            example_cookies = CookiesProxy.new(self)
+            proxy = 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
+            proxy.delete :key
           end
         end
       end

data/spec/spec/rails/example/example_group_factory_spec.rb

@@ -24,21 +24,21 @@ module Spec
         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
+      it "should return an ActiveSupport::TestCase 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
+        example_group.superclass.should == ActiveSupport::TestCase
       end
 
-      it "should return a RailsExampleGroup when given :spec_path => '\\blah\\spec\\foo\\' (windows format)  (anything other than controllers, views and helpers)" do
+      it "should return an ActiveSupport::TestCase 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
+        example_group.superclass.should == ActiveSupport::TestCase
       end
 
-      it "should return a ViewExampleGroup when given :type => :model" do
+      it "should return a ViewExampleGroup when given :type => :view" do
         example_group = Spec::Example::ExampleGroupFactory.create_example_group(
           "name", :type => :view
         ) {}

data/spec/spec/rails/example/{helper_spec_spec.rb → helper_example_group_spec.rb}

@@ -16,6 +16,8 @@ module Spec
       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
@@ -112,8 +114,6 @@ module Spec
           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)
@@ -146,6 +146,12 @@ module Spec
       
       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.1"
+            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

data/spec/spec/rails/example/{model_spec_spec.rb → model_example_group_spec.rb}

@@ -4,7 +4,9 @@ module Spec
   module Rails
     module Example
       describe ModelExampleGroup do
-        it "should clear its name from the description" do
+        accesses_configured_helper_methods
+        
+        it "clears its name from the description" do
           group = describe("foo", :type => :model) do
             $nested_group = describe("bar") do
             end

data/spec/spec/rails/example/{view_spec_spec.rb → view_example_group_spec.rb}

@@ -4,6 +4,8 @@ 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")
@@ -95,7 +97,7 @@ describe "A template that includes a partial", :type => :view do
       template.verify_rendered
     rescue Spec::Mocks::MockExpectationError => e
     ensure
-      e.backtrace.find{|line| line =~ /view_spec_spec\.rb\:92/}.should_not be_nil
+      e.backtrace.find{|line| line =~ /#{__FILE__}\:#{__LINE__ - 6}/}.should_not be_nil
     end
   end
   
@@ -112,7 +114,7 @@ describe "A template that includes a partial", :type => :view do
       template.verify_rendered
     rescue Spec::Mocks::MockExpectationError => e
     ensure
-      e.backtrace.find{|line| line =~ /view_spec_spec\.rb\:109/}.should_not be_nil
+      e.backtrace.find{|line| line =~ /#{__FILE__}\:#{__LINE__ - 6}/}.should_not be_nil
     end
   end
   
@@ -149,18 +151,16 @@ describe "A view that includes a partial using :collection and :spacer_template"
 
 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
+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
+  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
 
@@ -179,6 +179,18 @@ describe "A view", :type => :view do
     render "view_spec/accessor"
   end
 
+  it "should use the template as the implicit subject" do
+    subject.should == template
+  end
+
+  describe "with a specified subject" do
+    subject { 'specified' }
+
+    it "should use the specified subject" do
+      subject.should == 'specified'
+    end
+  end
+
   it "should have access to session data" do
     response.should have_tag("div#session", "session")
   end
@@ -270,6 +282,12 @@ describe "setting path parameters", :type => :view do
   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
@@ -285,10 +303,10 @@ module Spec
 
         it "should clear ActionView::Base.base_view_path on teardown" do
           group = describe("base_view_path_cleared flag", :type => :view) {}
-          example = group.it{}
+          example = group.new("example",{}) {}
           
           ActionView::Base.should_receive(:base_view_path=).with(nil)
-          group.run_after_each(example)
+          example.run_after_each
         end
       end
     end

data/spec/spec/rails/matchers/ar_be_valid_spec.rb

@@ -13,6 +13,16 @@ describe "be_valid" do
     CanBeValid.new(false).should_not be_valid
   end
 
+  describe CanBeValid do
+    subject { CanBeValid.new(true) }
+    it { subject.should be_valid }
+  end
+
+  describe CanBeValid do
+    subject { CanBeValid.new(false) }
+    it { subject.should_not be_valid }
+  end
+
   class CanHaveErrors
     def initialize(errors)
       @valid = !errors

data/spec/spec/rails/matchers/assert_select_spec.rb

@@ -786,6 +786,7 @@ describe "have_tag", :type => :controller do
 end
 
 describe 'selecting in HTML that contains a mock with null_object' do
+  include ActionController::Assertions::SelectorAssertions
   module HTML
     class Document
       def initialize_with_strict_error_checking(text, strict=false, xml=false)

data/spec/spec/rails/matchers/have_text_spec.rb

@@ -2,17 +2,25 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe "have_text" do
   
+
+  it "should have a helpful description" do
+    matcher = have_text("foo bar")
+    matcher.description.should == 'have text "foo bar"'
+  end
+
   describe "where target is a Regexp" do
     it 'should should match submitted text using a regexp' do
-      string = 'foo'
-      string.should have_text(/fo*/)
+      matcher = have_text(/fo*/)
+      matcher.matches?('foo').should be_true
+      matcher.matches?('bar').should be_nil
     end
   end
   
   describe "where target is a String" do
     it 'should match submitted text using a string' do
-      string = 'foo'
-      string.should have_text('foo')
+      matcher = have_text('foo')
+      matcher.matches?('foo').should be_true
+      matcher.matches?('foo bar').should be_false
     end
   end
   

data/spec/spec/rails/matchers/include_text_spec.rb

@@ -2,21 +2,19 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe "include_text" do
 
-  describe "where target is a String" do
-    it 'should match submitted text using a string' do
-      string = 'foo'
-      string.should include_text('foo')
-    end
+  it "should have a helpful description" do
+    matcher = include_text("foo bar")
+    matcher.description.should == 'include text "foo bar"'
+  end
 
-    it 'should match if the text is contained' do
-      string = 'I am a big piece of text'
-      string.should include_text('big piece')
-    end
+  it 'should match if the text is contained' do
+    matcher = include_text('big piece')
+    matcher.matches?('I am a big piece of text').should be_true
+  end
 
-    it 'should not match if text is not contained' do
-      string = 'I am a big piece of text'
-      string.should_not include_text('corey')
-    end
+  it 'should not match if text is not contained' do
+    matcher = include_text('foo bar')
+    matcher.matches?('hello world').should be_false
   end
 
 end