rcarvalho-capybara 0.4.1.1

data/spec/capybara_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Capybara do
+
+  describe 'default_wait_time' do
+    after do
+      Capybara.default_wait_time = @previous_default_time
+    end
+
+    it "should be changeable" do
+      @previous_default_time = Capybara.default_wait_time
+      Capybara.default_wait_time = 5
+      Capybara.default_wait_time.should == 5
+    end
+  end
+
+  describe '.register_driver' do
+    it "should add a new driver" do
+      Capybara.register_driver :schmoo do |app|
+        Capybara::Driver::RackTest.new(app)
+      end
+      session = Capybara::Session.new(:schmoo, TestApp)
+      session.visit('/')
+      session.body.should include("Hello world!")
+    end
+  end
+
+  describe ".server" do
+    after do
+      Capybara.server {|app, port| Capybara.run_default_server(app, port)}
+    end
+
+    it "should default to a proc that calls run_default_server" do
+      mock_app = mock('app')
+      Capybara.should_receive(:run_default_server).with(mock_app, 8000)
+      Capybara.server.call(mock_app, 8000)
+    end
+
+    it "should return a custom server proc" do
+      server = lambda {|app, port|}
+      Capybara.server(&server)
+      Capybara.server.should == server
+    end
+  end
+
+end

data/spec/driver/celerity_driver_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Capybara::Driver::Celerity, :jruby => :platform do
+  before(:all) do
+    @driver = TestSessions::Celerity.driver
+  end
+
+  it_should_behave_like "driver"
+  it_should_behave_like "driver with javascript support"
+  it_should_behave_like "driver with header support"
+  it_should_behave_like "driver with status code support"
+  it_should_behave_like "driver with cookies support"
+end

data/spec/driver/culerity_driver_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Capybara::Driver::Culerity, :jruby => :installed do
+
+  before(:all) do
+    @driver = TestSessions::Culerity.driver
+  end
+
+  it_should_behave_like "driver"
+  it_should_behave_like "driver with javascript support"
+  it_should_behave_like "driver with header support"
+  it_should_behave_like "driver with status code support"
+  it_should_behave_like "driver with cookies support"
+end

data/spec/driver/rack_test_driver_spec.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'stringio'
+
+def capture(*streams)
+  streams.map! { |stream| stream.to_s }
+  begin
+    result = StringIO.new
+    streams.each { |stream| eval "$#{stream} = result" }
+    yield
+  ensure
+    streams.each { |stream| eval("$#{stream} = #{stream.upcase}") }
+  end
+  result.string
+end
+
+describe Capybara::Driver::RackTest do
+  before do
+    @driver = TestSessions::RackTest.driver
+  end
+
+  it "should throw an error when no rack app is given" do
+    running do
+      Capybara::Driver::RackTest.new(nil)
+    end.should raise_error(ArgumentError)
+  end
+
+  if '1.9'.respond_to?(:encode)
+    describe "with non-binary parameters" do
+
+      it "should convert attribute values to binary" do
+        output = capture(:stderr) {
+          @driver.visit('/mypage', :param => 'µ')
+        }.should_not =~ %r{warning: regexp match /.../n against to UTF-8 string}
+      end
+
+      it "should convert attribute with Array to binary" do
+        output = capture(:stderr) {
+          @driver.visit('/mypage', :param => ['µ'])
+        }.should_not =~ %r{warning: regexp match /.../n against to UTF-8 string}
+      end
+
+      it "should convert path to binary" do
+        output = capture(:stderr) {
+          @driver.visit('/mypage'.encode('utf-8'))
+        }.should_not =~ %r{warning: regexp match /.../n against to UTF-8 string}
+      end
+    end
+  end
+
+  it_should_behave_like "driver"
+  it_should_behave_like "driver with header support"
+  it_should_behave_like "driver with status code support"
+  it_should_behave_like "driver with cookies support"
+  it_should_behave_like "driver with infinite redirect detection"
+
+  describe '#reset!' do
+    it { @driver.visit('/foo'); lambda { @driver.reset! }.should change(@driver, :current_url).to('') }
+
+    it 'should reset headers' do
+      @driver.header('FOO', 'BAR')
+      @driver.visit('/get_header')
+      @driver.body.should include('BAR')
+
+      @driver.reset!
+      @driver.visit('/get_header')
+      @driver.body.should_not include('BAR')
+    end
+
+    it 'should reset response' do
+      @driver.visit('/foo')
+      lambda { @driver.response }.should_not raise_error
+      @driver.reset!
+      lambda { @driver.response }.should raise_error
+    end
+
+    it 'should request response' do
+      @driver.visit('/foo')
+      lambda { @driver.request }.should_not raise_error
+      @driver.reset!
+      lambda { @driver.request }.should raise_error
+    end
+  end
+end

data/spec/driver/remote_culerity_driver_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Capybara::Driver::Culerity, :jruby => :installed do
+  before(:all) do
+    Capybara.app_host = "http://capybara-testapp.heroku.com"
+    @driver = TestSessions::Culerity.driver
+  end
+
+  after(:all) do
+    Capybara.app_host = nil
+  end
+
+  it "should navigate to a fully qualified remote page" do
+    @driver.visit('http://capybara-testapp.heroku.com/foo')
+    @driver.body.should include('Another World')
+  end
+
+  it_should_behave_like "driver"
+  it_should_behave_like "driver with javascript support"
+  it_should_behave_like "driver with header support"
+  it_should_behave_like "driver with status code support"
+end

data/spec/driver/remote_selenium_driver_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Capybara::Driver::Selenium do
+  before do
+    #Capybara.app_host = "http://capybara-testapp.heroku.com"
+    @driver = TestSessions::Selenium.driver
+  end
+
+  after do
+    Capybara.app_host = nil
+  end
+
+  it_should_behave_like "driver"
+  it_should_behave_like "driver with javascript support"
+  it_should_behave_like "driver without status code support"
+end

data/spec/driver/selenium_driver_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Capybara::Driver::Selenium do
+  before do
+    @driver = TestSessions::Selenium.driver
+  end
+
+  it_should_behave_like "driver"
+  it_should_behave_like "driver with javascript support"
+  it_should_behave_like "driver with frame support"
+  it_should_behave_like "driver with support for window switching"
+  it_should_behave_like "driver without status code support"
+  it_should_behave_like "driver with cookies support"
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+require 'capybara/dsl'
+
+describe Capybara do
+
+  before do
+    Capybara.app = TestApp
+  end
+
+  after do
+    Capybara.default_driver = nil
+    Capybara.use_default_driver
+  end
+
+  describe '#default_driver' do
+    it "should default to rack_test" do
+      Capybara.default_driver.should == :rack_test
+    end
+
+    it "should be changeable" do
+      Capybara.default_driver = :culerity
+      Capybara.default_driver.should == :culerity
+    end
+  end
+
+  describe '#current_driver' do
+    it "should default to the default driver" do
+      Capybara.current_driver.should == :rack_test
+      Capybara.default_driver = :culerity
+      Capybara.current_driver.should == :culerity
+    end
+
+    it "should be changeable" do
+      Capybara.current_driver = :culerity
+      Capybara.current_driver.should == :culerity
+    end
+  end
+
+  describe '#javascript_driver' do
+    it "should default to selenium" do
+      Capybara.javascript_driver.should == :selenium
+    end
+
+    it "should be changeable" do
+      Capybara.javascript_driver = :culerity
+      Capybara.javascript_driver.should == :culerity
+    end
+  end
+
+  describe '#use_default_driver' do
+    it "should restore the default driver" do
+      Capybara.current_driver = :culerity
+      Capybara.use_default_driver
+      Capybara.current_driver.should == :rack_test
+    end
+  end
+
+  describe '#using_driver' do
+    before do
+      Capybara.current_driver.should_not == :selenium
+    end
+
+    it 'should set the driver using Capybara.current_driver=' do
+      driver = nil
+      Capybara.using_driver(:selenium) { driver = Capybara.current_driver }
+      driver.should == :selenium
+    end
+
+    it 'should reset the driver using Capybara.use_default_driver, even if an exception occurs' do
+      begin
+        Capybara.using_driver(:selenium) { raise "ohnoes!" }
+      rescue Exception
+      end
+      Capybara.current_driver.should == Capybara.default_driver
+    end
+
+    it 'should yield the passed block' do
+      called = false
+      Capybara.using_driver(:selenium) { called = true }
+      called.should == true
+    end
+  end
+
+  describe '#app' do
+    it "should be changeable" do
+      Capybara.app = "foobar"
+      Capybara.app.should == 'foobar'
+    end
+  end
+
+  describe '#current_session' do
+    it "should choose a session object of the current driver type" do
+      Capybara.current_session.should be_a(Capybara::Session)
+    end
+
+    it "should use #app as the application" do
+      Capybara.app = proc {}
+      Capybara.current_session.app.should == Capybara.app
+    end
+
+    it "should change with the current driver" do
+      Capybara.current_session.mode.should == :rack_test
+      Capybara.current_driver = :selenium
+      Capybara.current_session.mode.should == :selenium
+    end
+
+    it "should be persistent even across driver changes" do
+      object_id = Capybara.current_session.object_id
+      Capybara.current_session.object_id.should == object_id
+      Capybara.current_driver = :selenium
+      Capybara.current_session.mode.should == :selenium
+      Capybara.current_session.object_id.should_not == object_id
+
+      Capybara.current_driver = :rack_test
+      Capybara.current_session.object_id.should == object_id
+    end
+
+    it "should change when changing application" do
+      object_id = Capybara.current_session.object_id
+      Capybara.current_session.object_id.should == object_id
+      Capybara.app = proc {}
+      Capybara.current_session.object_id.should_not == object_id
+      Capybara.current_session.app.should == Capybara.app
+    end
+  end
+
+  describe 'the DSL' do
+    before do
+      @session = Capybara
+    end
+
+    it_should_behave_like "session"
+    it_should_behave_like "session without javascript support"
+
+    it "should be possible to include it in another class" do
+      klass = Class.new do
+        include Capybara
+      end
+      foo = klass.new
+      foo.visit('/with_html')
+      foo.click_link('ullamco')
+      foo.body.should include('Another World')
+    end
+
+    it "should provide a 'page' shortcut for more expressive tests" do
+      klass = Class.new do
+        include Capybara
+      end
+      foo = klass.new
+      foo.page.visit('/with_html')
+      foo.page.click_link('ullamco')
+      foo.page.body.should include('Another World')
+    end
+  end
+
+end

data/spec/rspec_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'capybara/rspec'
+
+Capybara.app = TestApp
+
+describe 'capybara/rspec', :type => :acceptance do
+  it "should include Capybara in rpsec" do
+    visit('/foo')
+    page.body.should include('Another World')
+  end
+
+  context "resetting session" do
+    it "sets a cookie in one example..." do
+      visit('/set_cookie')
+      page.body.should include('Cookie set to test_cookie')
+    end
+
+    it "...then it is not availbable in the next" do
+      visit('/get_cookie')
+      page.body.should_not include('test_cookie')
+    end
+  end
+
+  context "setting the current driver" do
+    it "sets the current driver in one example..." do
+      Capybara.current_driver = :selenium
+    end
+
+    it "...then it has returned to the default in the next example" do
+      Capybara.current_driver.should == :rack_test
+    end
+  end
+
+  it "switches to the javascript driver when giving it as metadata", :js => true do
+    Capybara.current_driver.should == Capybara.javascript_driver
+  end
+
+  it "switches to the given driver when giving it as metadata", :driver => :culerity do
+    Capybara.current_driver.should == :culerity
+  end
+end
+
+describe 'capybara/rspec', :type => :other do
+  it "should not include Capybara" do
+    expect { visit('/') }.to raise_error(NoMethodError)
+  end
+end

data/spec/save_and_open_page_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+require 'capybara/util/save_and_open_page'
+require 'launchy'
+describe Capybara do
+  describe ".save_and_open_page" do
+    before do
+      @time = Time.new.strftime("%Y%m%d%H%M%S")
+
+      @temp_file = mock("FILE")
+      @temp_file.stub!(:write)
+      @temp_file.stub!(:close)
+
+      @html = <<-HTML
+        <html>
+          <head>
+            <script type="text/javascript" src="/javascripts/prototype.js?123"/>
+          </head>
+          <body>
+            <h1>test</h1>
+            <p>
+              Some images (note differing whitespace closing tag):
+              <img src="/images/image1.jpeg" />
+              <img src="/images/image2.jpeg"/>
+            </p>
+            <p>
+              Some more in a non-existent directory:
+              <img src="/img/image3.jpeg" />
+              <img src="/img/image4.jpeg"/>
+            </p>
+            <p>
+              <a href="/not-here/foo.html">
+                A link to a file in a non-existent directory.
+              </a>
+            </p>
+          </body>
+        <html>
+      HTML
+
+      Launchy::Browser.stub(:run)
+    end
+
+    def default_file_expectations
+      @name = "capybara-#{@time}.html"
+
+      @temp_file.stub!(:path).and_return(@name)
+
+      File.should_receive(:exist?).and_return true
+      File.should_receive(:new).and_return @temp_file
+    end
+
+    describe "defaults" do
+      before do
+        default_file_expectations
+      end
+
+      it "should create a new temporary file" do
+        @temp_file.should_receive(:write).with @html
+        Capybara.save_and_open_page @html
+      end
+
+      it "should open the file in the browser" do
+        Capybara.should_receive(:open_in_browser).with(@name)
+        Capybara.save_and_open_page @html
+      end
+    end
+
+    describe "custom output path" do
+      before do
+        @custom_path = File.join('tmp', 'capybara')
+        @custom_name = File.join(@custom_path, "capybara-#{@time}.html")
+
+        @temp_file.stub!(:path).and_return(@custom_name)
+
+        Capybara.should_receive(:save_and_open_page_path).at_least(:once).and_return(@custom_path)
+      end
+
+      it "should create a new temporary file in the custom path" do
+        File.should_receive(:directory?).and_return true
+        File.should_receive(:exist?).and_return true
+        File.should_receive(:new).and_return @temp_file
+
+        @temp_file.should_receive(:write).with @html
+        Capybara.save_and_open_page @html
+      end
+
+      it "should open the file - in the custom path - in the browser" do
+        Capybara.should_receive(:open_in_browser).with(@custom_name)
+        Capybara.save_and_open_page @html
+      end
+
+      it "should be possible to configure output path" do
+        Capybara.should respond_to(:save_and_open_page_path)
+        default_setting = Capybara.save_and_open_page_path
+        lambda {
+            Capybara.save_and_open_page_path = File.join('tmp', 'capybara')
+            Capybara.save_and_open_page_path.should == File.join('tmp', 'capybara')
+          }.should_not raise_error
+        Capybara.save_and_open_page_path = default_setting
+      end
+    end
+
+    describe "rewrite_css_and_image_references" do
+      before do
+        default_file_expectations
+        @asset_root_dir = "/path/to/rails/public"
+      end
+
+      def mock_asset_root_with(directories)
+        @asset_root = Pathname.new(@asset_root_dir)
+        Capybara.should_receive(:asset_root).and_return @asset_root
+
+        dir = mock('asset_root mock dir')
+        Dir.should_receive(:new).with(@asset_root).and_return dir
+
+        dirents = [ '.', '..', 'file.html' ] + directories
+        dir.should_receive(:entries).and_return dirents
+
+        directories_regexp = directories.join('|')
+        FileTest.should_receive(:directory?) \
+                .at_least(dirents.size - 2).times \
+                .and_return { |dir|
+          dir =~ %r!#{@asset_root_dir}/(#{directories_regexp})$!
+        }
+      end
+
+      def expected_html_for_asset_root_with(directories)
+        mock_asset_root_with(directories)
+
+        expected_html = @html.clone
+        if not directories.empty?
+          directories_regexp = directories.join('|')
+          expected_html.gsub!(/"(\/(#{directories_regexp})\/)/,
+                              '"%s\1' % @asset_root_dir)
+        end
+
+        return expected_html
+      end
+
+      def test_with_directories(directories)
+        @temp_file.should_receive(:write) \
+          .with expected_html_for_asset_root_with(directories)
+        Capybara.save_and_open_page @html
+      end
+
+      context "asset_root contains some directories" do
+        it "should rewrite relative paths to absolute local paths" do
+          test_with_directories([ 'javascripts', 'images' ])
+        end
+      end
+
+      context "asset_root path contains no directories" do
+        it "should not rewrite any relative paths" do
+          test_with_directories([ ])
+        end
+      end
+    end
+  end
+end