bbc-capybara 1.1.2

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::RackTest::Driver.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/rack_test_driver_spec.rb

@@ -0,0 +1,90 @@
+# 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::RackTest::Driver do
+  before do
+    @driver = TestSessions::RackTest.driver
+  end
+
+  it "should throw an error when no rack app is given" do
+    running do
+      Capybara::RackTest::Driver.new(nil)
+    end.should raise_error(ArgumentError)
+  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"
+  it_should_behave_like "driver with referer support"
+
+  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
+
+  describe ':headers option' do
+    it 'should always set headers' do
+      @driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      @driver.visit('/get_header')
+      @driver.body.should include('foobar')
+    end
+
+    it 'should keep headers on link clicks' do
+      @driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      @driver.visit('/header_links')
+      @driver.find('.//a').first.click
+      @driver.body.should include('foobar')
+    end
+
+    it 'should keep headers on form submit' do
+      @driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      @driver.visit('/header_links')
+      @driver.find('.//input').first.click
+      @driver.body.should include('foobar')
+    end
+
+    it 'should keep headers on redirects' do
+      @driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      @driver.visit('/get_header_via_redirect')
+      @driver.body.should include('foobar')
+    end
+  end
+end

data/spec/driver/selenium_driver_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'rbconfig'
+
+describe Capybara::Selenium::Driver 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 resynchronization 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"
+  it_should_behave_like "driver with referer support"
+
+  unless Config::CONFIG['host_os'] =~ /mswin|mingw/
+    it "should not interfere with forking child processes" do
+      # Launch a browser, which registers the at_exit hook
+      browser = Capybara::Selenium::Driver.new(TestApp).browser
+
+      # Fork an unrelated child process. This should not run the code in the at_exit hook.
+      begin
+        pid = fork { "child" }
+        Process.wait2(pid)[1].exitstatus.should == 0
+      rescue NotImplementedError
+        # Fork unsupported (e.g. on JRuby)
+      end
+
+      browser.quit
+    end
+  end
+
+  describe "exit codes" do
+    before do
+      @current_dir = Dir.getwd
+      Dir.chdir(File.join(File.dirname(__FILE__), '..', '..'))
+    end
+
+    after do
+      Dir.chdir(@current_dir)
+    end
+
+    it "should have return code 1 when running selenium_driver_rspec_failure.rb" do
+      `rspec spec/fixtures/selenium_driver_rspec_failure.rb`
+      $?.exitstatus.should be 1
+    end
+
+    it "should have return code 0 when running selenium_driver_rspec_success.rb" do
+      `rspec spec/fixtures/selenium_driver_rspec_success.rb`
+      $?.exitstatus.should be 0
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,255 @@
+require 'spec_helper'
+require 'capybara/dsl'
+
+describe Capybara::DSL do
+  after do
+    Capybara.session_name = nil
+    Capybara.default_driver = nil
+    Capybara.use_default_driver
+    Capybara.app = TestApp
+  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 return the driver to default if it has not been changed' do
+      Capybara.using_driver(:selenium) do
+        Capybara.current_driver.should == :selenium
+      end
+      Capybara.current_driver.should == Capybara.default_driver
+    end
+
+    it 'should reset the driver even if an exception occurs' do
+      driver_before_block = Capybara.current_driver
+      begin
+        Capybara.using_driver(:selenium) { raise "ohnoes!" }
+      rescue Exception
+      end
+      Capybara.current_driver.should == driver_before_block
+    end
+
+    it 'should return the driver to what it was previously' do
+      Capybara.current_driver = :selenium
+      Capybara.using_driver(:culerity) do
+        Capybara.using_driver(:rack_test) do
+          Capybara.current_driver.should == :rack_test
+        end
+        Capybara.current_driver.should == :culerity
+      end
+      Capybara.current_driver.should == :selenium
+    end
+
+    it 'should yield the passed block' do
+      called = false
+      Capybara.using_driver(:selenium) { called = true }
+      called.should == true
+    end
+  end
+
+  describe '#using_wait_time' do
+    it "should switch the wait time and switch it back" do
+      in_block = nil
+      Capybara.using_wait_time 6 do
+        in_block = Capybara.default_wait_time
+      end
+      in_block.should == 6
+      Capybara.default_wait_time.should == 0
+    end
+
+    it "should ensure wait time is reset" do
+      expect do
+        Capybara.using_wait_time 6 do
+          raise "hell"
+        end
+      end.to raise_error
+      Capybara.default_wait_time.should == 0
+    end
+
+    after do
+      Capybara.default_wait_time = 0
+    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
+
+    it "should change when the session name changes" do
+      object_id = Capybara.current_session.object_id
+      Capybara.session_name = :administrator
+      Capybara.session_name.should == :administrator
+      Capybara.current_session.object_id.should_not == object_id
+      Capybara.session_name = :default
+      Capybara.session_name.should == :default
+      Capybara.current_session.object_id.should == object_id
+    end
+  end
+
+  describe "#using_session" do
+    it "should change the session name for the duration of the block" do
+      Capybara.session_name.should == :default
+      Capybara.using_session(:administrator) do
+        Capybara.session_name.should == :administrator
+      end
+      Capybara.session_name.should == :default
+    end
+
+    it "should reset the session to the default, even if an exception occurs" do
+      begin
+        Capybara.using_session(:raise) do
+          raise
+        end
+      rescue Exception
+      end
+      Capybara.session_name.should == :default
+    end
+
+    it "should yield the passed block" do
+      called = false
+      Capybara.using_session(:administrator) { called = true }
+      called.should == true
+    end
+  end
+
+  describe "#session_name" do
+    it "should default to :default" do
+      Capybara.session_name.should == :default
+    end
+  end
+
+  describe 'the DSL' do
+    before do
+      @session = Class.new { include Capybara::DSL }.new
+    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::DSL
+      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::DSL
+      end
+      foo = klass.new
+      foo.page.visit('/with_html')
+      foo.page.click_link('ullamco')
+      foo.page.body.should include('Another World')
+    end
+
+    it "should provide an 'using_session' shortcut" do
+      klass = Class.new do
+        include Capybara::DSL
+      end
+      Capybara.should_receive(:using_session).with(:name)
+      foo = klass.new
+      foo.using_session(:name)
+    end
+
+    it "should provide a 'using_wait_time' shortcut" do
+      klass = Class.new do
+        include Capybara::DSL
+      end
+      Capybara.should_receive(:using_wait_time).with(6)
+      foo = klass.new
+      foo.using_wait_time(6)
+    end
+  end
+end

data/spec/fixtures/selenium_driver_rspec_failure.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Capybara::Selenium::Driver do
+  it "should exit with a non-zero exit status" do
+    browser = Capybara::Selenium::Driver.new(TestApp).browser
+    true.should == false
+  end
+end