has_finder 0.1.3 → 0.1.4

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/helper_spec_spec.rb

@@ -1,62 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-Spec::Runner.configuration.global_fixtures = :people
-
-describe "HelperBehaviour", :behaviour_type => :helper do
-  helper_name :explicit
-  
-  it "should have direct access to methods defined in helpers" do
-    method_in_explicit_helper.should =~ /text from a method/
-  end
-end
-
-
-describe "HelperBehaviour#eval_erb", :behaviour_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 "HelperBehaviour.fixtures", :behaviour_type => :helper do
-  helper_name :explicit
-  fixtures :animals
-
-  it "loads fixtures" do
-    pig = animals(:pig)
-    pig.class.should == Animal
-  end
-
-  it "loads global fixtures" do
-    lachie = people(:lachie)
-    lachie.class.should == Person
-  end  
-end
-
-describe ExplicitHelper, :behaviour_type => :helper do
-  it "should not require naming the helper if describe is passed a type" do
-    method_in_explicit_helper.should match(/text from a method/)
-  end
-end
-
-module Spec
-  module Rails
-    module DSL
-      describe HelperBehaviour do
-        it "should tell you its behaviour_type is :helper" do
-          behaviour = HelperBehaviour.new("") {}
-          behaviour.behaviour_type.should == :helper
-        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', :behaviour_type => :helper do
-    it 'should not raise an error' do
-      lambda { flash['test'] }.should_not raise_error
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/ivar_proxy_spec.rb

@@ -1,64 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "IvarProxy setup", :shared => true do
-  before do
-    @object = Object.new
-    @proxy = Spec::Rails::DSL::IvarProxy.new(@object)
-  end  
-end
-
-describe "IvarProxy" do
-  it_should_behave_like "IvarProxy setup"
-  
-  it "has [] accessor" do
-    @proxy['foo'] = 'bar'
-    @object.instance_variable_get(:@foo).should == 'bar'
-    @proxy['foo'].should == 'bar'
-  end
-
-  it "iterates through each element like a Hash" do
-    values = {
-      'foo' => 1,
-      'bar' => 2,
-      'baz' => 3
-    }
-    @proxy['foo'] = values['foo']
-    @proxy['bar'] = values['bar']
-    @proxy['baz'] = values['baz']
-
-    @proxy.each do |key, value|
-      key.should == key
-      value.should == values[key]
-    end
-  end
-
-  it "detects the presence of a key" do
-    @proxy['foo'] = 'bar'
-    @proxy.has_key?('foo').should == true
-    @proxy.has_key?('bar').should == false
-  end
-end
-
-describe "IvarProxy", "#delete" do
-  it_should_behave_like "IvarProxy setup"
-  
-  it "deletes the element with key" do
-    @proxy['foo'] = 'bar'
-    @proxy.delete('foo').should == 'bar'
-    @proxy['foo'].should be_nil
-  end
-
-  it "deletes nil instance variables" do
-    @proxy['foo'] = nil
-    @object.instance_variables.should include("@foo")
-    @proxy.delete('foo').should == nil
-    @proxy['foo'].should be_nil
-    @object.instance_variables.should_not include("@foo")
-  end
-
-  it "returns nil when key does not exist" do
-    @proxy['foo'].should be_nil
-    @proxy.delete('foo').should == nil
-    @proxy['foo'].should be_nil
-  end
-end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/model_spec_spec.rb

@@ -1,14 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module Rails
-    module DSL
-      describe ModelBehaviour do
-        it "should tell you its behaviour_type is :model" do
-          behaviour = ModelBehaviour.new("") {}
-          behaviour.behaviour_type.should == :model
-        end
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/shared_behaviour_spec.rb

@@ -1,16 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "A shared view behaviour", :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 behaviour", :behaviour_type => :view do
-  it_should_behave_like "A shared view behaviour"
-  
-  before(:each) do
-    render "view_spec/show"
-  end
-end
-  

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/test_unit_assertion_accessibility_spec.rb

@@ -1,28 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-['model','view','helper'].each do |context|
-  describe "A #{context} spec should be able to access 'test/unit' assertions", :behaviour_type => context.to_sym do
-
-    it "like assert_equal" do
-      assert_equal 1, 1
-      lambda {
-        assert_equal 1, 2
-      }.should raise_error(Test::Unit::AssertionFailedError)
-    end
-
-  end
-end
-
-['integration', 'isolation'].each do |mode|
-  describe "A controller spec in #{mode} mode should be able to access 'test/unit' assertions", :behaviour_type => :controller do
-    controller_name :controller_spec
-    integrate_views if mode == 'integration'
-
-    it "like assert_equal" do
-      assert_equal 1, 1
-      lambda {
-        assert_equal 1, 2
-      }.should raise_error(Test::Unit::AssertionFailedError)
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/view_spec_spec.rb

@@ -1,165 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "A view with an implicit helper", :behaviour_type => :view do
-  before(:each) do
-    render "view_spec/show"
-  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
-end
-
-describe "A view requiring an explicit helper", :behaviour_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 view requiring multiple explicit helpers", :behaviour_type => :view do
-  before(:each) do
-    render "view_spec/multiple_helpers", :helpers => ['explicit', 'more_explicit']
-  end
-
-  it "should included 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 "A view that includes a partial", :behaviour_type => :view do
-  def render!
-    render "view_spec/partial_including_template"
-  end
-
-  it "should render the enclosing template" do
-    render!
-    response.should have_tag('div', "method_in_included_partial in ViewSpecHelper")
-  end
-
-  it "should render the partial" do
-    render!
-    response.should have_tag('div', "method_in_partial_including_template 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 support mocking the render call" do
-    template.should_receive(:render).with(:partial => 'included_partial')
-    render!
-  end
-end
-
-describe "A view that includes a partial using :collection and :spacer_template", :behaviour_type => :view  do
-  before(:each) do
-    render "view_spec/partial_collection_including_template"
-  end
-
-  it "should render the partial w/ spacer_tamplate" do
-    response.should have_tag('div', :content => 'Alice')
-    response.should have_tag('hr', :attributes =>{:id => "spacer"})
-    response.should have_tag('div', :content => 'Bob')
-  end
-
-end
-
-describe "A view that includes a partial using an array as partial_path", :behaviour_type => :view do
-  before(:each) do
-    module ActionView::Partials
-      def render_partial_with_array_support(partial_path, local_assigns = nil, deprecated_local_assigns = nil)
-        if partial_path.is_a?(Array)
-          "Array Partial"
-        else
-          render_partial_without_array_support(partial_path, local_assigns, deprecated_local_assigns)
-        end
-      end
-
-      alias :render_partial_without_array_support :render_partial
-      alias :render_partial :render_partial_with_array_support
-    end
-
-    @array = ['Alice', 'Bob']
-    assigns[:array] = @array
-  end
-
-  after(:each) do
-    module ActionView::Partials
-      alias :render_partial_with_array_support :render_partial
-      alias :render_partial :render_partial_without_array_support
-      undef render_partial_with_array_support
-    end
-  end
-
-  it "should render have the array passed through to render_partial without modification" do
-    render "view_spec/partial_with_array" 
-    response.body.should match(/^Array Partial$/)
-  end
-end
-
-describe "Different types of renders (not :template)", :behaviour_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", :behaviour_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
-    puts response.body
-    response.should have_tag("div#params", "params")
-  end
-
-  it "should have access to flash data" do
-    response.should have_tag("div#flash", "flash")
-  end
-end
-
-describe "A view with a form_tag", :behaviour_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
-
-module Spec
-  module Rails
-    module DSL
-      describe ViewBehaviour do
-        it "should tell you its behaviour_type is :view" do
-          behaviour = ViewBehaviour.new("") {}
-          behaviour.behaviour_type.should == :view
-        end
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/extensions/active_record_spec.rb

@@ -1,17 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-class Thing < ActiveRecord::Base
-  validates_presence_of :name
-end
-
-describe "A model" do
-  it "should tell you its required fields" do
-    Thing.new.should have(1).error_on(:name)
-  end
-  
-  it "should tell you how many records it has" do
-    Thing.should have(:no).records
-    Thing.create(:name => "THE THING")
-    Thing.should have(1).record
-  end
-end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/matchers/assert_select_spec.rb

@@ -1,718 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-# assert_select plugins for Rails
-#
-# Copyright (c) 2006 Assaf Arkin, under Creative Commons Attribution and/or MIT License
-# Developed for http://co.mments.com
-# Code and documention: http://labnotes.org
-
-class AssertSelectController < ActionController::Base
-
-  def response=(content)
-    @content = content
-  end
-
-  #NOTE - this is commented because response is implemented in lib/spec/rails/context/controller
-  # def response(&block)
-  #   @update = block
-  # end
-  # 
-  def html()
-    render :text=>@content, :layout=>false, :content_type=>Mime::HTML
-    @content = nil
-  end
-
-  def rjs()
-    update = @update
-    render :update do |page|
-      update.call page
-    end
-    @update = nil
-  end
-
-  def xml()
-    render :text=>@content, :layout=>false, :content_type=>Mime::XML
-    @content = nil
-  end
-
-  def rescue_action(e)
-    raise e
-  end
-
-end
-
-class AssertSelectMailer < ActionMailer::Base
-
-  def test(html)
-    recipients "test <test@test.host>"
-    from "test@test.host"
-    subject "Test e-mail"
-    part :content_type=>"text/html", :body=>html
-  end
-
-end
-
-module AssertSelectSpecHelpers
-  def render_html(html)
-    @controller.response = html
-    get :html
-  end
-
-  def render_rjs(&block)
-    clear_response
-    @controller.response &block
-    get :rjs
-  end
-
-  def render_xml(xml)
-    @controller.response = xml
-    get :xml
-  end
-  
-  private
-    # necessary for 1.2.1
-    def clear_response
-      render_html("")
-    end
-end
-
-unless defined?(SpecFailed)
-  SpecFailed = Spec::Expectations::ExpectationNotMetError 
-end
-
-describe "should have_tag", :behaviour_type => :controller do
-  include AssertSelectSpecHelpers
-  controller_name :assert_select
-  integrate_views
-
-  it "should find specific numbers of elements" do
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    response.should have_tag( "div" )
-    response.should have_tag("div", 2)
-    lambda { response.should_not have_tag("div") }.should raise_error(SpecFailed, "should not have tag(\"div\"), but did")
-
-    lambda { response.should have_tag("div", 3) }.should raise_error(SpecFailed)
-    lambda { response.should have_tag("p") }.should raise_error(SpecFailed)
-  end
-
-  it "should expect to find elements when using true" do
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    response.should have_tag( "div", true )
-    lambda { response.should have_tag( "p", true )}.should raise_error(SpecFailed)
-  end
-
-  it "should expect to not find elements when using false" do
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    response.should have_tag( "p", false )
-    lambda { response.should have_tag( "div", false )}.should raise_error(SpecFailed)
-  end
-
-
-  it "should match submitted text using text or regexp" do
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    response.should have_tag("div", "foo")
-    response.should have_tag("div", /(foo|bar)/)
-    response.should have_tag("div", :text=>"foo")
-    response.should have_tag("div", :text=>/(foo|bar)/)
-
-    lambda { response.should have_tag("div", "bar") }.should raise_error(SpecFailed)
-    lambda { response.should have_tag("div", :text=>"bar") }.should raise_error(SpecFailed)
-    lambda { response.should have_tag("p", :text=>"foo") }.should raise_error(SpecFailed)
-
-    lambda { response.should have_tag("div", /foobar/) }.should raise_error(SpecFailed)
-    lambda { response.should have_tag("div", :text=>/foobar/) }.should raise_error(SpecFailed)
-    lambda { response.should have_tag("p", :text=>/foo/) }.should raise_error(SpecFailed)
-  end
-  
-  it "should use submitted message" do
-    render_html %Q{nothing here}
-    lambda {
-      response.should have_tag("div", {}, "custom message")
-    }.should raise_error(SpecFailed, /custom message/)
-  end
-
-  it "should match submitted html" do
-    render_html %Q{<p>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</p>}
-    text = "\"This is not a big problem,\" he said."
-    html = "<em>\"This is <strong>not</strong> a big problem,\"</em> he said."
-    response.should have_tag("p", text)
-    lambda { response.should have_tag("p", html) }.should raise_error(SpecFailed)
-    response.should have_tag("p", :html=>html)
-    lambda { response.should have_tag("p", :html=>text) }.should raise_error(SpecFailed)
-
-    # # No stripping for pre.
-    render_html %Q{<pre>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</pre>}
-    text = "\n\"This is not a big problem,\" he said.\n"
-    html = "\n<em>\"This is <strong>not</strong> a big problem,\"</em> he said.\n"
-    response.should have_tag("pre", text)
-    lambda { response.should have_tag("pre", html) }.should raise_error(SpecFailed)
-    response.should have_tag("pre", :html=>html)
-    lambda { response.should have_tag("pre", :html=>text) }.should raise_error(SpecFailed)
-  end
-
-  it "should match number of instances" do
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    response.should have_tag("div", 2)
-    lambda { response.should have_tag("div", 3) }.should raise_error(SpecFailed)
-    response.should have_tag("div", 1..2)
-    lambda { response.should have_tag("div", 3..4) }.should raise_error(SpecFailed)
-    response.should have_tag("div", :count=>2)
-    lambda { response.should have_tag("div", :count=>3) }.should raise_error(SpecFailed)
-    response.should have_tag("div", :minimum=>1)
-    response.should have_tag("div", :minimum=>2)
-    lambda { response.should have_tag("div", :minimum=>3) }.should raise_error(SpecFailed)
-    response.should have_tag("div", :maximum=>2)
-    response.should have_tag("div", :maximum=>3)
-    lambda { response.should have_tag("div", :maximum=>1) }.should raise_error(SpecFailed)
-    response.should have_tag("div", :minimum=>1, :maximum=>2)
-    lambda { response.should have_tag("div", :minimum=>3, :maximum=>4) }.should raise_error(SpecFailed)
-  end
-
-  it "substitution values" do
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div><span id="3"></span>}
-    response.should have_tag("div#?", /\d+/) do |elements| #using do/end
-      elements.size.should == 2
-    end
-    response.should have_tag("div#?", /\d+/) { |elements| #using {}
-      elements.size.should == 2
-    }
-    lambda {
-      response.should have_tag("div#?", /\d+/) do |elements|
-        elements.size.should == 3
-      end
-    }.should raise_error(SpecFailed, "expected 3, got 2 (using ==)")
-    
-    lambda {
-      response.should have_tag("div#?", /\d+/) { |elements|
-        elements.size.should == 3
-      }
-    }.should raise_error(SpecFailed, "expected 3, got 2 (using ==)")
-
-    response.should have_tag("div#?", /\d+/) do |elements|
-      elements.size.should == 2
-      with_tag("#1")
-      with_tag("#2")
-      without_tag("#3")
-    end 
-  end
-  
-  #added for RSpec
-  it "nested tags in form" do
-    render_html %Q{
-      <form action="test">
-        <input type="text" name="email">
-      </form>
-      <form action="other">
-        <input type="text" name="other_input">
-      </form>
-    }
-    response.should have_tag("form[action=test]") { |form|
-      with_tag("input[type=text][name=email]")
-    }
-    response.should have_tag("form[action=test]") { |form|
-      with_tag("input[type=text][name=email]")
-    }
-    
-    lambda {
-      response.should have_tag("form[action=test]") { |form|
-        with_tag("input[type=text][name=other_input]")
-      }
-    }.should raise_error(SpecFailed)
-    
-    lambda {
-      response.should have_tag("form[action=test]") {
-        with_tag("input[type=text][name=other_input]")
-      }
-    }.should raise_error(SpecFailed)
-  end
-  
-  it "beatles" do
-    unless defined?(BEATLES)
-      BEATLES = [
-        ["John", "Guitar"],
-        ["George", "Guitar"],
-        ["Paul", "Bass"],
-        ["Ringo", "Drums"]
-      ]
-    end
-
-    render_html %Q{
-      <div id="beatles">
-        <div class="beatle">
-          <h2>John</h2><p>Guitar</p>
-        </div>
-        <div class="beatle">
-          <h2>George</h2><p>Guitar</p>
-        </div>
-        <div class="beatle">
-          <h2>Paul</h2><p>Bass</p>
-        </div>
-        <div class="beatle">
-          <h2>Ringo</h2><p>Drums</p>
-        </div>
-      </div>          
-    }
-    response.should have_tag("div#beatles>div[class=\"beatle\"]", 4)
-
-    response.should have_tag("div#beatles>div.beatle") {
-      BEATLES.each { |name, instrument|
-        with_tag("div.beatle>h2", name)
-        with_tag("div.beatle>p", instrument)
-        without_tag("div.beatle>span")
-      }
-    }
-  end
-
-  it "assert_select_text_match" do
-    render_html %Q{<div id="1"><span>foo</span></div><div id="2"><span>bar</span></div>}
-    response.should have_tag("div") do |divs|
-      with_tag("div", "foo")
-      with_tag("div", "bar")
-      with_tag("div", /\w*/)
-      with_tag("div", /\w*/, :count=>2)
-      without_tag("div", :text=>"foo", :count=>2)
-      with_tag("div", :html=>"<span>bar</span>")
-      with_tag("div", :html=>"<span>bar</span>")
-      with_tag("div", :html=>/\w*/)
-      with_tag("div", :html=>/\w*/, :count=>2)
-      without_tag("div", :html=>"<span>foo</span>", :count=>2)
-    end
-  end
-
-
-  it "assert_select_from_rjs with one item" do
-    render_rjs do |page|
-      page.replace_html "test", "<div id=\"1\">foo</div>\n<div id=\"2\">foo</div>"
-    end
-    response.should have_tag("div") { |elements|
-      elements.size.should == 2
-      with_tag("#1")
-      with_tag("#2")
-    }
-    
-    lambda {
-      response.should have_tag("div") { |elements|
-        elements.size.should == 2
-        with_tag("#1")
-        with_tag("#3")
-      }
-    }.should raise_error(SpecFailed)
-
-    lambda {
-      response.should have_tag("div") { |elements|
-        elements.size.should == 2
-        with_tag("#1")
-        without_tag("#2")
-      }
-    }.should raise_error(SpecFailed, "should not have tag(\"#2\"), but did")
-
-    lambda {
-      response.should have_tag("div") { |elements|
-        elements.size.should == 3
-        with_tag("#1")
-        with_tag("#2")
-      }
-    }.should raise_error(SpecFailed)
-
-
-    response.should have_tag("div#?", /\d+/) { |elements|
-      with_tag("#1")
-      with_tag("#2")
-    }
-  end
-  
-  it "assert_select_from_rjs with multiple items" do
-    render_rjs do |page|
-      page.replace_html "test", "<div id=\"1\">foo</div>"
-      page.replace_html "test2", "<div id=\"2\">foo</div>"
-    end
-    response.should have_tag("div")
-    response.should have_tag("div") { |elements|
-      elements.size.should == 2
-      with_tag("#1")
-      with_tag("#2")
-    }
-
-    lambda {
-      response.should have_tag("div") { |elements|
-        with_tag("#3")
-      }
-    }.should raise_error(SpecFailed)
-  end
-end
-
-describe "css_select", :behaviour_type => :controller do
-  include AssertSelectSpecHelpers
-  controller_name :assert_select
-  integrate_views
-
-  it "can select tags from html" do
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    css_select("div").size.should == 2
-    css_select("p").size.should == 0
-  end
-
-
-  it "can select nested tags from html" do
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    response.should have_tag("div#?", /\d+/) { |elements|
-      css_select(elements[0], "div").should have(1).element
-      css_select(elements[1], "div").should have(1).element
-    }
-    response.should have_tag("div") {
-      css_select("div").should have(2).elements
-      css_select("div").each { |element|
-        # Testing as a group is one thing
-        css_select("#1,#2").should have(2).elements
-        # Testing individually is another
-        css_select("#1").should have(1).element
-        css_select("#2").should have(1).element
-      }
-    }
-  end
-
-  it "can select nested tags from rjs (one result)" do
-    render_rjs do |page|
-      page.replace_html "test", "<div id=\"1\">foo</div>\n<div id=\"2\">foo</div>"
-    end
-    css_select("div").should have(2).elements
-    css_select("#1").should have(1).element
-    css_select("#2").should have(1).element
-  end
-
-  it "can select nested tags from rjs (two results)" do
-    render_rjs do |page|
-      page.replace_html "test", "<div id=\"1\">foo</div>"
-      page.replace_html "test2", "<div id=\"2\">foo</div>"
-    end
-    css_select("div").should have(2).elements
-    css_select("#1").should have(1).element
-    css_select("#2").should have(1).element
-  end
-  
-end
-
-describe "have_rjs behaviour", :behaviour_type => :controller do
-  include AssertSelectSpecHelpers
-  controller_name :assert_select
-  integrate_views
-
-  before(:each) do
-    render_rjs do |page|
-      page.replace "test1", "<div id=\"1\">foo</div>"
-      page.replace_html "test2", "<div id=\"2\">bar</div><div id=\"3\">none</div>"
-      page.insert_html :top, "test3", "<div id=\"4\">loopy</div>"
-      page.hide "test4"
-      page["test5"].hide
-    end
-  end
-  
-  it "should pass if any rjs exists" do
-    response.should have_rjs
-  end
-  
-  it "should fail if no rjs exists" do
-    render_rjs do |page|
-    end
-    lambda do
-      response.should have_rjs
-    end.should raise_error(SpecFailed)
-  end
-  
-  it "should find all rjs from multiple statements" do
-    response.should have_rjs do
-      with_tag("#1")
-      with_tag("#2")
-      with_tag("#3")
-      # with_tag("#4")
-      # with_tag("#5")
-    end
-  end
-
-  it "should find by id" do
-    response.should have_rjs("test1") { |rjs|
-      rjs.size.should == 1
-      with_tag("div", 1)
-      with_tag("div#1", "foo")
-    }
-    
-    lambda do
-      response.should have_rjs("test1") { |rjs|
-        rjs.size.should == 1
-        without_tag("div#1", "foo")
-      }
-    end.should raise_error(SpecFailed, "should not have tag(\"div#1\", \"foo\"), but did")
-
-    response.should have_rjs("test2") { |rjs|
-      rjs.size.should == 2
-      with_tag("div", 2)
-      with_tag("div#2", "bar")
-      with_tag("div#3", "none")
-    }
-    # response.should have_rjs("test4")
-    # response.should have_rjs("test5")
-  end
-  
-  # specify "should find rjs using :hide" do
-  #   response.should have_rjs(:hide)
-  #   response.should have_rjs(:hide, "test4")
-  #   response.should have_rjs(:hide, "test5")
-  #   lambda do
-  #     response.should have_rjs(:hide, "test3")
-  #   end.should raise_error(SpecFailed)
-  # end
-
-  it "should find rjs using :replace" do
-    response.should have_rjs(:replace) { |rjs|
-      with_tag("div", 1)
-      with_tag("div#1", "foo")
-    }
-    response.should have_rjs(:replace, "test1") { |rjs|
-      with_tag("div", 1)
-      with_tag("div#1", "foo")
-    }
-    lambda {
-      response.should have_rjs(:replace, "test2")
-    }.should raise_error(SpecFailed)
-
-    lambda {
-      response.should have_rjs(:replace, "test3")
-    }.should raise_error(SpecFailed)
-  end
-
-  it "should find rjs using :replace_html" do
-    response.should have_rjs(:replace_html) { |rjs|
-      with_tag("div", 2)
-      with_tag("div#2", "bar")
-      with_tag("div#3", "none")
-    }
-
-    response.should have_rjs(:replace_html, "test2") { |rjs|
-      with_tag("div", 2)
-      with_tag("div#2", "bar")
-      with_tag("div#3", "none")
-    }
-
-    lambda {
-      response.should have_rjs(:replace_html, "test1")
-    }.should raise_error(SpecFailed)
-
-    lambda {
-      response.should have_rjs(:replace_html, "test3")
-    }.should raise_error(SpecFailed)
-  end
-    
-  it "should find rjs using :insert_html (non-positioned)" do
-    response.should have_rjs(:insert_html) { |rjs|
-      with_tag("div", 1)
-      with_tag("div#4", "loopy")
-    }
-
-    response.should have_rjs(:insert_html, "test3") { |rjs|
-      with_tag("div", 1)
-      with_tag("div#4", "loopy")
-    }
-
-    lambda {
-      response.should have_rjs(:insert_html, "test1")
-    }.should raise_error(SpecFailed)
-
-    lambda {
-      response.should have_rjs(:insert_html, "test2")
-    }.should raise_error(SpecFailed)
-  end
-
-  it "should find rjs using :insert (positioned)" do
-    render_rjs do |page|
-      page.insert_html :top, "test1", "<div id=\"1\">foo</div>"
-      page.insert_html :bottom, "test2", "<div id=\"2\">bar</div>"
-      page.insert_html :before, "test3", "<div id=\"3\">none</div>"
-      page.insert_html :after, "test4", "<div id=\"4\">loopy</div>"
-    end
-    response.should have_rjs(:insert, :top) do
-      with_tag("div", 1)
-      with_tag("#1")
-    end
-    response.should have_rjs(:insert, :top, "test1") do
-      with_tag("div", 1)
-      with_tag("#1")
-    end
-    lambda {
-      response.should have_rjs(:insert, :top, "test2")
-    }.should raise_error(SpecFailed)
-    response.should have_rjs(:insert, :bottom) {|rjs|
-      with_tag("div", 1)
-      with_tag("#2")
-    }
-    response.should have_rjs(:insert, :bottom, "test2") {|rjs|
-      with_tag("div", 1)
-      with_tag("#2")
-    }
-    response.should have_rjs(:insert, :before) {|rjs|
-      with_tag("div", 1)
-      with_tag("#3")
-    }
-    response.should have_rjs(:insert, :before, "test3") {|rjs|
-      with_tag("div", 1)
-      with_tag("#3")
-    }
-    response.should have_rjs(:insert, :after) {|rjs|
-      with_tag("div", 1)
-      with_tag("#4")
-    }
-    response.should have_rjs(:insert, :after, "test4") {|rjs|
-      with_tag("div", 1)
-      with_tag("#4")
-    }
-  end
-end
-
-describe "send_email behaviour", :behaviour_type => :controller do
-  include AssertSelectSpecHelpers
-  controller_name :assert_select
-  integrate_views
-
-  before(:each) do
-    ActionMailer::Base.delivery_method = :test
-    ActionMailer::Base.perform_deliveries = true
-    ActionMailer::Base.deliveries = []
-  end
-
-  after(:each) do
-    ActionMailer::Base.deliveries.clear
-  end
-
-  it "should fail with nothing sent" do
-    response.should_not send_email
-    lambda {
-      response.should send_email{}
-    }.should raise_error(SpecFailed, /No e-mail in delivery list./)
-  end
-  
-  it "should pass otherwise" do
-    AssertSelectMailer.deliver_test "<div><p>foo</p><p>bar</p></div>"
-    response.should send_email
-    lambda {
-      response.should_not send_email
-    }.should raise_error(SpecFailed)
-    response.should send_email{}
-    response.should send_email {
-      with_tag("div:root") {
-        with_tag("p:first-child", "foo")
-        with_tag("p:last-child", "bar")
-      }
-    }
-    
-    lambda {
-      response.should_not send_email
-    }.should raise_error(SpecFailed, "should not send email, but did")
-  end
-
-end
-
-# describe "An rjs call to :visual_effect, a 'should have_rjs' spec with",
-#   :behaviour_type => :view do
-#     
-#   before do
-#     render 'rjs_spec/visual_effect'
-#   end
-# 
-#   it "should pass with the correct element name" do
-#     response.should have_rjs(:effect, :fade, 'mydiv')
-#   end
-#   
-#   it "should fail the wrong element name" do
-#     lambda {
-#       response.should have_rjs(:effect, :fade, 'wrongname')
-#     }.should raise_error(SpecFailed)
-#   end
-#   
-#   it "should fail with the correct element but the wrong command" do
-#     lambda {
-#       response.should have_rjs(:effect, :puff, 'mydiv')
-#     }.should raise_error(SpecFailed)
-#   end
-#   
-# end
-#   
-# describe "An rjs call to :visual_effect for a toggle, a 'should have_rjs' spec with",
-#   :behaviour_type => :view do
-#     
-#   before do
-#     render 'rjs_spec/visual_toggle_effect'
-#   end
-#   
-#   it "should pass with the correct element name" do
-#     response.should have_rjs(:effect, :toggle_blind, 'mydiv')
-#   end
-#   
-#   it "should fail with the wrong element name" do
-#     lambda {
-#       response.should have_rjs(:effect, :toggle_blind, 'wrongname')
-#     }.should raise_error(SpecFailed)
-#   end
-#   
-#   it "should fail the correct element but the wrong command" do
-#     lambda {
-#       response.should have_rjs(:effect, :puff, 'mydiv')
-#     }.should raise_error(SpecFailed)
-#   end
-#   
-# end
-
-describe "string.should have_tag", :behaviour_type => :helper do
-  include AssertSelectSpecHelpers
-
-  it "should find root element" do
-    "<p>a paragraph</p>".should have_tag("p", "a paragraph")
-  end
-
-  it "should not find non-existent element" do
-    lambda do
-      "<p>a paragraph</p>".should have_tag("p", "wrong text")
-    end.should raise_error(SpecFailed)
-  end
-
-  it "should find child element" do
-    "<div><p>a paragraph</p></div>".should have_tag("p", "a paragraph")
-  end
-
-  it "should find nested element" do
-    "<div><p>a paragraph</p></div>".should have_tag("div") do
-      with_tag("p", "a paragraph")
-    end
-  end
-
-  it "should not find wrong nested element" do
-    lambda do
-      "<div><p>a paragraph</p></div>".should have_tag("div") do
-        with_tag("p", "wrong text")
-      end
-    end.should raise_error(SpecFailed)
-  end
-end
-
-describe "have_tag", :behaviour_type => :controller do
-  include AssertSelectSpecHelpers
-  controller_name :assert_select
-  integrate_views
-
-  it "should work exactly the same as assert_select" do
-    render_html %Q{
-      <div id="wrapper">foo
-        <div class="piece">
-          <h3>Text</h3>
-        </div>
-        <div class="piece">
-          <h3>Another</h3>
-        </div>      
-      </div>
-    }
-
-    assert_select "#wrapper .piece h3", :text => "Text"
-    assert_select "#wrapper .piece h3", :text => "Another"
-
-    response.should have_tag("#wrapper .piece h3", :text => "Text")
-    response.should have_tag("#wrapper .piece h3", :text => "Another")
-  end
-end