RubyGems - capybara-webkit - Versions diffs - 1.5.2 → 1.6.0 - Mend

capybara-webkit 1.5.2 → 1.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

checksums.yaml +4 -4
data/.travis.yml +1 -0
data/CONTRIBUTING.md +4 -1
data/Gemfile.lock +1 -1
data/NEWS.md +12 -0
data/README.md +54 -12
data/lib/capybara/webkit.rb +9 -4
data/lib/capybara/webkit/browser.rb +18 -2
data/lib/capybara/webkit/configuration.rb +98 -0
data/lib/capybara/webkit/connection.rb +13 -1
data/lib/capybara/webkit/driver.rb +133 -52
data/lib/capybara/webkit/errors.rb +3 -0
data/lib/capybara/webkit/node.rb +9 -8
data/lib/capybara/webkit/version.rb +1 -1
data/spec/browser_spec.rb +0 -229
data/spec/configuration_spec.rb +16 -0
data/spec/connection_spec.rb +15 -2
data/spec/driver_spec.rb +343 -53
data/spec/selenium_compatibility_spec.rb +88 -9
data/spec/spec_helper.rb +7 -2
data/spec/support/app_runner.rb +13 -3
data/src/Authenticate.cpp +4 -0
data/src/Headers.cpp +4 -1
data/src/Server.cpp +7 -0
data/src/WebPage.cpp +11 -9
data/src/WebPage.h +1 -1
data/src/WebPageManager.cpp +0 -3
data/src/capybara.js +20 -3
metadata +5 -3
data/lib/capybara/webkit/socket_debugger.rb +0 -46

data/lib/capybara/webkit/errors.rb CHANGED

@@ -23,6 +23,9 @@ module Capybara::Webkit
   class ModalNotFound < StandardError
   end
+  class CrashError < StandardError
+  end
   class JsonError
     def initialize(response)
       error = JSON.parse response

data/lib/capybara/webkit/node.rb CHANGED

@@ -1,5 +1,10 @@
 module Capybara::Webkit
   class Node < Capybara::Driver::Node
+    def initialize(session, base, browser)
+      super(session, base)
+      @browser = browser
+    end
     def visible_text
       Capybara::Helpers.normalize_whitespace(invoke("text"))
     end
@@ -113,7 +118,7 @@ module Capybara::Webkit
     def find_xpath(xpath)
       invoke("findXpathWithin", xpath).split(',').map do |native|
-        self.class.new(driver, native)
+        self.class.new(driver, native, @browser)
       end
     end
@@ -121,12 +126,12 @@ module Capybara::Webkit
     def find_css(selector)
       invoke("findCssWithin", selector).split(',').map do |native|
-        self.class.new(driver, native)
+        self.class.new(driver, native, @browser)
       end
     end
     def invoke(name, *args)
-      browser.command "Node", name, allow_unattached_nodes?, native, *args
+      @browser.command "Node", name, allow_unattached_nodes?, native, *args
     end
     def allow_unattached_nodes?
@@ -138,11 +143,7 @@ module Capybara::Webkit
     end
     def attached?
-      browser.command("Node", "isAttached", native) == "true"
-    end
-    def browser
-      driver.browser
+      @browser.command("Node", "isAttached", native) == "true"
     end
     def multiple_select?

data/lib/capybara/webkit/version.rb CHANGED

@@ -1,7 +1,7 @@
 module Capybara
   module Driver
     class Webkit
-      VERSION = '1.5.2'.freeze
+      VERSION = "1.6.0".freeze
     end
   end
 end

data/spec/browser_spec.rb CHANGED

@@ -9,144 +9,6 @@ describe Capybara::Webkit::Browser do
   let(:connection) { Capybara::Webkit::Connection.new }
   let(:browser) { Capybara::Webkit::Browser.new(connection) }
-  let(:browser_ignore_ssl_err) do
-    Capybara::Webkit::Browser.new(Capybara::Webkit::Connection.new).tap do |browser|
-      browser.ignore_ssl_errors
-    end
-  end
-  let(:browser_skip_images) do
-    Capybara::Webkit::Browser.new(Capybara::Webkit::Connection.new).tap do |browser|
-      browser.set_skip_image_loading(true)
-    end
-  end
-  context 'handling of SSL validation errors' do
-    before do
-      # set up minimal HTTPS server
-      @host = "127.0.0.1"
-      @server = TCPServer.new(@host, 0)
-      @port = @server.addr[1]
-      # set up SSL layer
-      ssl_serv = OpenSSL::SSL::SSLServer.new(@server, $openssl_self_signed_ctx)
-      @server_thread = Thread.new(ssl_serv) do |serv|
-        while conn = serv.accept do
-          # read request
-          request = []
-          until (line = conn.readline.strip).empty?
-            request << line
-          end
-          # write response
-          html = "<html><body>D'oh!</body></html>"
-          conn.write "HTTP/1.1 200 OK\r\n"
-          conn.write "Content-Type:text/html\r\n"
-          conn.write "Content-Length: %i\r\n" % html.size
-          conn.write "\r\n"
-          conn.write html
-          conn.close
-        end
-      end
-    end
-    after do
-      @server_thread.kill
-      @server.close
-    end
-    it "doesn't accept a self-signed certificate by default" do
-      lambda { browser.visit "https://#{@host}:#{@port}/" }.should raise_error
-    end
-    it 'accepts a self-signed certificate if configured to do so' do
-      browser_ignore_ssl_err.visit "https://#{@host}:#{@port}/"
-    end
-    it "doesn't accept a self-signed certificate in a new window by default" do
-      browser.execute_script("window.open('about:blank')")
-      browser.window_focus(browser.get_window_handles.last)
-      lambda { browser.visit "https://#{@host}:#{@port}/" }.should raise_error
-    end
-    it 'accepts a self-signed certificate in a new window if configured to do so' do
-      browser_ignore_ssl_err.execute_script("window.open('about:blank')")
-      browser_ignore_ssl_err.window_focus(browser_ignore_ssl_err.get_window_handles.last)
-      browser_ignore_ssl_err.visit "https://#{@host}:#{@port}/"
-    end
-  end
-  context "skip image loading" do
-    before(:each) do
-      # set up minimal HTTP server
-      @host = "127.0.0.1"
-      @server = TCPServer.new(@host, 0)
-      @port = @server.addr[1]
-      @received_requests = []
-      @server_thread = Thread.new do
-        while conn = @server.accept
-          Thread.new(conn) do |thread_conn|
-            # read request
-            request = []
-            until (line = thread_conn.readline.strip).empty?
-              request << line
-            end
-            @received_requests << request.join("\n")
-            # write response
-            html = <<-HTML
-            <html>
-              <head>
-                <style>
-                  body {
-                    background-image: url(/path/to/bgimage);
-                  }
-                </style>
-              </head>
-              <body>
-                <img src="/path/to/image"/>
-              </body>
-            </html>
-            HTML
-            thread_conn.write "HTTP/1.1 200 OK\r\n"
-            thread_conn.write "Content-Type:text/html\r\n"
-            thread_conn.write "Content-Length: %i\r\n" % html.size
-            thread_conn.write "\r\n"
-            thread_conn.write html
-            thread_conn.write("\r\n\r\n")
-            thread_conn.close
-          end
-        end
-      end
-    end
-    after(:each) do
-      @server_thread.kill
-      @server.close
-    end
-    it "should load images in image tags by default" do
-      browser.visit("http://#{@host}:#{@port}/")
-      @received_requests.find {|r| r =~ %r{/path/to/image}   }.should_not be_nil
-    end
-    it "should load images in css by default" do
-      browser.visit("http://#{@host}:#{@port}/")
-      @received_requests.find {|r| r =~ %r{/path/to/image}   }.should_not be_nil
-    end
-    it "should not load images in image tags when skip_image_loading is true" do
-      browser_skip_images.visit("http://#{@host}:#{@port}/")
-      @received_requests.find {|r| r =~ %r{/path/to/image} }.should be_nil
-    end
-    it "should not load images in css when skip_image_loading is true" do
-      browser_skip_images.visit("http://#{@host}:#{@port}/")
-      @received_requests.find {|r| r =~ %r{/path/to/bgimage} }.should be_nil
-    end
-  end
   describe "forking", skip_on_windows: true, skip_on_jruby: true do
     it "only shuts down the server from the main process" do
@@ -157,97 +19,6 @@ describe Capybara::Webkit::Browser do
     end
   end
-  describe '#set_proxy' do
-    before do
-      @host = '127.0.0.1'
-      @user = 'user'
-      @pass = 'secret'
-      @url  = "http://example.org/"
-      @server = TCPServer.new(@host, 0)
-      @port = @server.addr[1]
-      @proxy_requests = []
-      @proxy = Thread.new(@server, @proxy_requests) do |serv, proxy_requests|
-        while conn = serv.accept do
-          # read request
-          request = []
-          until (line = conn.readline.strip).empty?
-            request << line
-          end
-          # send response
-          auth_header = request.find { |h| h =~ /Authorization:/i }
-          if auth_header || request[0].split(/\s+/)[1] =~ /^\//
-            html = "<html><body>D'oh!</body></html>"
-            conn.write "HTTP/1.1 200 OK\r\n"
-            conn.write "Content-Type:text/html\r\n"
-            conn.write "Content-Length: %i\r\n" % html.size
-            conn.write "\r\n"
-            conn.write html
-            conn.close
-            proxy_requests << request if auth_header
-          else
-            conn.write "HTTP/1.1 407 Proxy Auth Required\r\n"
-            conn.write "Proxy-Authenticate: Basic realm=\"Proxy\"\r\n"
-            conn.write "\r\n"
-            conn.close
-            proxy_requests << request
-          end
-        end
-      end
-      browser.set_proxy(:host => @host,
-                        :port => @port,
-                        :user => @user,
-                        :pass => @pass)
-      browser.visit @url
-      @proxy_requests.size.should eq 2
-      @request = @proxy_requests[-1]
-    end
-    after do
-      @proxy.kill
-      @server.close
-    end
-    it 'uses the HTTP proxy correctly' do
-      @request[0].should match(/^GET\s+http:\/\/example.org\/\s+HTTP/i)
-      @request.find { |header|
-        header =~ /^Host:\s+example.org$/i }.should_not be nil
-    end
-    it 'sends correct proxy authentication' do
-      auth_header = @request.find { |header|
-        header =~ /^Proxy-Authorization:\s+/i }
-      auth_header.should_not be nil
-      user, pass = Base64.decode64(auth_header.split(/\s+/)[-1]).split(":")
-      user.should eq @user
-      pass.should eq @pass
-    end
-    it "uses the proxies' response" do
-      browser.body.should include "D'oh!"
-    end
-    it 'uses original URL' do
-      browser.current_url.should eq @url
-    end
-    it 'uses URLs changed by javascript' do
-      browser.execute_script "window.history.pushState('', '', '/blah')"
-      browser.current_url.should eq 'http://example.org/blah'
-    end
-    it 'is possible to disable proxy again' do
-      @proxy_requests.clear
-      browser.clear_proxy
-      browser.visit "http://#{@host}:#{@port}/"
-      @proxy_requests.size.should eq 0
-    end
-  end
   it "doesn't try to read an empty response" do
     connection = double("connection")
     connection.stub(:puts)

data/spec/configuration_spec.rb ADDED

@@ -0,0 +1,16 @@
+require "spec_helper"
+describe Capybara::Webkit::Configuration do
+  it "returns a hash and then prevents future modification" do
+    Capybara::Webkit.configure do |config|
+      config.debug = true
+    end
+    result = Capybara::Webkit::Configuration.to_hash
+    expect(result).to include(debug: true)
+    expect { Capybara::Webkit.configure {} }.to raise_error(
+      "All configuration must take place before the driver starts"
+    )
+  end
+end

data/spec/connection_spec.rb CHANGED

@@ -19,8 +19,21 @@ describe Capybara::Webkit::Connection do
     webkit_pid.should be > 1
     read_io.close
     Process.kill(9, fork_pid)
-    sleep 1
-    expect { Process.getpgid(webkit_pid) }.to raise_error Errno::ESRCH
+    eventually { expect { Process.getpgid(webkit_pid) }.to raise_error Errno::ESRCH }
+  end
+  def eventually
+    polling_interval = 0.1
+    time_limit = Time.now + 3
+    loop do
+      begin
+        yield
+        return
+      rescue RSpec::Expectations::ExpectationNotMetError => error
+        raise error if Time.now >= time_limit
+        sleep polling_interval
+      end
+    end
   end
   it "raises an error if the server has stopped", skip_on_windows: true do

data/spec/driver_spec.rb CHANGED

@@ -3,6 +3,7 @@
 require 'spec_helper'
 require 'capybara/webkit/driver'
 require 'base64'
+require 'self_signed_ssl_cert'
 describe Capybara::Webkit::Driver do
   include AppRunner
@@ -1808,7 +1809,7 @@ describe Capybara::Webkit::Driver do
   context "no response app" do
     let(:driver) do
-      driver_for_html(<<-HTML)
+      driver_for_html(<<-HTML, browser: browser)
         <html><body>
           <form action="/error"><input type="submit"/></form>
         </body></html>
@@ -1827,16 +1828,19 @@ describe Capybara::Webkit::Driver do
     end
     def make_the_server_come_back
-      driver.browser.instance_variable_get(:@connection).unstub(:gets)
-      driver.browser.instance_variable_get(:@connection).unstub(:puts)
-      driver.browser.instance_variable_get(:@connection).unstub(:print)
+      connection.unstub(:gets)
+      connection.unstub(:puts)
+      connection.unstub(:print)
     end
     def make_the_server_go_away
-      driver.browser.instance_variable_get(:@connection).stub(:gets).and_return(nil)
-      driver.browser.instance_variable_get(:@connection).stub(:puts)
-      driver.browser.instance_variable_get(:@connection).stub(:print)
+      connection.stub(:gets).and_return(nil)
+      connection.stub(:puts)
+      connection.stub(:print)
     end
+    let(:browser) { Capybara::Webkit::Browser.new(connection) }
+    let(:connection) { Capybara::Webkit::Connection.new }
   end
   context "custom font app" do
@@ -1906,30 +1910,21 @@ describe Capybara::Webkit::Driver do
     end
     it "uses a custom cookie" do
-      driver.browser.set_cookie 'cookie=abc; domain=127.0.0.1; path=/'
+      driver.set_cookie 'cookie=abc; domain=127.0.0.1; path=/'
       visit "/"
       echoed_cookie.should eq "abc"
     end
     it "clears cookies" do
-      driver.browser.clear_cookies
+      driver.clear_cookies
       visit "/"
       echoed_cookie.should eq ""
     end
-    it "allows enumeration of cookies" do
-      cookies = driver.browser.get_cookies
-      cookies.size.should eq 1
-      cookie = Hash[cookies[0].split(/\s*;\s*/).map { |x| x.split("=", 2) }]
-      cookie["cookie"].should eq "abc"
-      cookie["domain"].should include "127.0.0.1"
-      cookie["path"].should eq "/"
-    end
-    it "allows reading access to cookies using a nice syntax" do
+    it "allows reading cookies" do
       driver.cookies["cookie"].should eq "abc"
+      driver.cookies.find("cookie").path.should eq "/"
+      driver.cookies.find("cookie").domain.should include "127.0.0.1"
     end
   end
@@ -2120,14 +2115,23 @@ describe Capybara::Webkit::Driver do
       driver_for_app do
         get '/' do
           etag etag_value
+          <<-HTML
+            <html>
+              <body>
+                Expected body
+              </body>
+            </html>
+          HTML
         end
       end
     end
-    it "does not cache responses" do
+    it "returns a body for cached responses" do
       visit '/'
+      first = driver.html
       visit '/'
-      expect(driver.status_code).to eq(200)
+      second = driver.html
+      expect(second).to eq(first)
     end
   end
@@ -2592,20 +2596,27 @@ CACHE MANIFEST
     end
     it "can authenticate a request" do
-      driver.browser.authenticate('user', 'password')
+      driver.authenticate('user', 'password')
       visit("/")
       driver.html.should include("Basic "+Base64.encode64("user:password").strip)
     end
     it "returns 401 for incorrectly authenticated request" do
-      driver.browser.authenticate('user1', 'password1')
-      driver.browser.timeout = 2
+      driver.authenticate('user1', 'password1')
       lambda { visit("/") }.should_not raise_error
       driver.status_code.should eq 401
     end
     it "returns 401 for unauthenticated request" do
-      driver.browser.timeout = 2
+      lambda { visit("/") }.should_not raise_error
+      driver.status_code.should eq 401
+    end
+    it "can be reset with subsequent authenticate call", skip_on_qt4: true do
+      driver.authenticate('user', 'password')
+      visit("/")
+      driver.html.should include("Basic "+Base64.encode64("user:password").strip)
+      driver.authenticate('user1', 'password1')
       lambda { visit("/") }.should_not raise_error
       driver.status_code.should eq 401
     end
@@ -2647,10 +2658,12 @@ CACHE MANIFEST
     end
     before do
-      driver.block_url "http://example.org/path/to/file"
-      driver.block_url "http://example.*/foo/*"
-      driver.block_url "http://example.com"
-      driver.block_url "#{AppRunner.app_host}/script"
+      configure do |config|
+        config.block_url "http://example.org/path/to/file"
+        config.block_url "http://example.*/foo/*"
+        config.block_url "http://example.com"
+        config.block_url "#{AppRunner.app_host}/script"
+      end
     end
     it "should not fetch urls blocked by host" do
@@ -2697,7 +2710,7 @@ CACHE MANIFEST
   describe "url whitelisting", skip_if_offline: true do
     it_behaves_like "output writer" do
       let(:driver) do
-        driver_for_html(<<-HTML, browser)
+        driver_for_html(<<-HTML, browser: browser)
           <<-HTML
             <html>
               <body>
@@ -2717,8 +2730,22 @@ CACHE MANIFEST
       end
       it "can allow specific hosts" do
-        driver.allow_url("example.com")
-        driver.allow_url("www.example.com")
+        configure do |config|
+          config.allow_url("example.com")
+          config.allow_url("www.example.com")
+        end
+        visit("/")
+        expect(stderr).not_to include("http://example.com/path")
+        expect(stderr).not_to include(driver.current_url)
+        driver.within_frame("frame") do
+          expect(driver.find("//body").first.text).not_to be_empty
+        end
+      end
+      it "can allow all hosts" do
+        configure(&:allow_unknown_urls)
         visit("/")
         expect(stderr).not_to include("http://example.com/path")
@@ -2728,8 +2755,17 @@ CACHE MANIFEST
         end
       end
+      it "resets allowed hosts on reset" do
+        driver.allow_unknown_urls
+        driver.reset!
+        visit("/")
+        expect(stderr).to include("http://example.com/path")
+        expect(stderr).not_to include(driver.current_url)
+      end
       it "can block unknown hosts" do
-        driver.block_unknown_urls
+        configure(&:block_unknown_urls)
         visit("/")
         expect(stderr).not_to include("http://example.com/path")
@@ -2740,7 +2776,7 @@ CACHE MANIFEST
       end
       it "can allow urls with wildcards" do
-        driver.allow_url("*/path")
+        configure { |config| config.allow_url("*/path") }
         visit("/")
         expect(stderr).to include("www.example.com")
@@ -2790,65 +2826,64 @@ CACHE MANIFEST
     end
     it "should not raise a timeout error when zero" do
-      driver.browser.timeout = 0
+      configure { |config| config.timeout = 0 }
       lambda { visit("/") }.should_not raise_error
     end
     it "should raise a timeout error" do
-      driver.browser.timeout = 1
+      configure { |config| config.timeout = 1 }
       lambda { visit("/") }.should raise_error(Timeout::Error, "Request timed out after 1 second(s)")
     end
     it "should not raise an error when the timeout is high enough" do
-      driver.browser.timeout = 10
+      configure { |config| config.timeout = 10 }
       lambda { visit("/") }.should_not raise_error
     end
     it "should set the timeout for each request" do
-      driver.browser.timeout = 10
+      configure { |config| config.timeout = 10 }
       lambda { visit("/") }.should_not raise_error
-      driver.browser.timeout = 1
+      driver.timeout = 1
       lambda { visit("/") }.should raise_error(Timeout::Error)
     end
     it "should set the timeout for each request" do
-      driver.browser.timeout = 1
+      configure { |config| config.timeout = 1 }
       lambda { visit("/") }.should raise_error(Timeout::Error)
       driver.reset!
-      driver.browser.timeout = 10
+      driver.timeout = 10
       lambda { visit("/") }.should_not raise_error
     end
     it "should raise a timeout on a slow form" do
-      driver.browser.timeout = 3
+      configure { |config| config.timeout = 3 }
       visit("/")
       driver.status_code.should eq 200
-      driver.browser.timeout = 1
+      driver.timeout = 1
       driver.find_xpath("//input").first.click
       lambda { driver.status_code }.should raise_error(Timeout::Error)
     end
     it "get timeout" do
-      driver.browser.timeout = 10
+      configure { |config| config.timeout = 10 }
       driver.browser.timeout.should eq 10
-      driver.browser.timeout = 3
-      driver.browser.timeout.should eq 3
     end
   end
   describe "logger app" do
     it_behaves_like "output writer" do
       let(:driver) do
-        driver_for_html("<html><body>Hello</body></html>", browser)
+        driver_for_html("<html><body>Hello</body></html>", browser: browser)
       end
-      it "logs nothing before turning on the logger" do
+      it "logs nothing in normal mode" do
+        configure { |config| config.debug = false }
         visit("/")
         stderr.should_not include logging_message
       end
-      it "logs its commands after turning on the logger" do
-        driver.enable_logging
+      it "logs its commands in debug mode" do
+        configure { |config| config.debug = true }
         visit("/")
         stderr.should include logging_message
       end
@@ -2997,11 +3032,29 @@ CACHE MANIFEST
     end
   end
+  context "response header contains colon" do
+    let(:driver) do
+      driver_for_app do
+        get "/" do
+          headers "Content-Disposition" => 'filename="File: name.txt"'
+        end
+      end
+    end
+    it "sets the response header" do
+      visit("/")
+      expect(
+        driver.response_headers["Content-Disposition"]
+      ).to eq 'filename="File: name.txt"'
+    end
+  end
   context "with unfinished responses" do
     it_behaves_like "output writer" do
       let(:driver) do
         count = 0
-        driver_for_app browser do
+        driver_for_app browser: browser do
           get "/" do
             count += 1
             <<-HTML
@@ -3044,6 +3097,243 @@ CACHE MANIFEST
     end
   end
+  context "when the driver process crashes" do
+    let(:driver) do
+      driver_for_app browser: browser do
+        get "/" do
+          "<html><body>Relaunched</body></html>"
+        end
+      end
+    end
+    let(:browser) { Capybara::Webkit::Browser.new(connection) }
+    let(:connection) { Capybara::Webkit::Connection.new }
+    it "reports and relaunches on reset" do
+      Process.kill "KILL", connection.pid
+      expect { driver.reset! }.to raise_error(Capybara::Webkit::CrashError)
+      visit "/"
+      expect(driver.html).to include("Relaunched")
+    end
+  end
+  context "handling of SSL validation errors" do
+    before do
+      # set up minimal HTTPS server
+      @host = "127.0.0.1"
+      @server = TCPServer.new(@host, 0)
+      @port = @server.addr[1]
+      # set up SSL layer
+      ssl_serv = OpenSSL::SSL::SSLServer.new(@server, $openssl_self_signed_ctx)
+      @server_thread = Thread.new(ssl_serv) do |serv|
+        while conn = serv.accept do
+          # read request
+          request = []
+          until (line = conn.readline.strip).empty?
+            request << line
+          end
+          # write response
+          html = "<html><body>D'oh!</body></html>"
+          conn.write "HTTP/1.1 200 OK\r\n"
+          conn.write "Content-Type:text/html\r\n"
+          conn.write "Content-Length: %i\r\n" % html.size
+          conn.write "\r\n"
+          conn.write html
+          conn.close
+        end
+      end
+    end
+    after do
+      @server_thread.kill
+      @server.close
+    end
+    context "with default settings" do
+      it "doesn't accept a self-signed certificate" do
+        lambda { driver.visit "https://#{@host}:#{@port}/" }.should raise_error
+      end
+      it "doesn't accept a self-signed certificate in a new window" do
+        driver.execute_script("window.open('about:blank')")
+        driver.switch_to_window(driver.window_handles.last)
+        lambda { driver.visit "https://#{@host}:#{@port}/" }.should raise_error
+      end
+    end
+    context "ignoring SSL errors" do
+      it "accepts a self-signed certificate if configured to do so" do
+        configure(&:ignore_ssl_errors)
+        driver.visit "https://#{@host}:#{@port}/"
+      end
+      it "accepts a self-signed certificate in a new window when configured" do
+        configure(&:ignore_ssl_errors)
+        driver.execute_script("window.open('about:blank')")
+        driver.switch_to_window(driver.window_handles.last)
+        driver.visit "https://#{@host}:#{@port}/"
+      end
+    end
+    let(:driver) { driver_for_html("", browser: browser) }
+    let(:browser) { Capybara::Webkit::Browser.new(connection) }
+    let(:connection) { Capybara::Webkit::Connection.new }
+  end
+  context "skip image loading" do
+    let(:driver) do
+      driver_for_app do
+        requests = []
+        get "/" do
+          <<-HTML
+            <html>
+              <head>
+                <style>
+                  body {
+                    background-image: url(/path/to/bgimage);
+                  }
+                </style>
+              </head>
+              <body>
+                <img src="/path/to/image"/>
+              </body>
+            </html>
+          HTML
+        end
+        get "/requests" do
+          <<-HTML
+            <html>
+              <body>
+                #{requests.map { |path| "<p>#{path}</p>" }.join}
+              </body>
+            </html>
+          HTML
+        end
+        get %r{/path/to/(.*)} do |path|
+          requests << path
+        end
+      end
+    end
+    it "should load images by default" do
+      visit("/")
+      requests.should match_array %w(image bgimage)
+    end
+    it "should not load images when disabled" do
+      configure(&:skip_image_loading)
+      visit("/")
+      requests.should eq []
+    end
+    let(:requests) do
+      visit "/requests"
+      driver.find("//p").map(&:text)
+    end
+  end
+  describe "#set_proxy" do
+    before do
+      @host = "127.0.0.1"
+      @user = "user"
+      @pass = "secret"
+      @url  = "http://example.org/"
+      @server = TCPServer.new(@host, 0)
+      @port = @server.addr[1]
+      @proxy_requests = []
+      @proxy = Thread.new(@server, @proxy_requests) do |serv, proxy_requests|
+        while conn = serv.accept do
+          # read request
+          request = []
+          until (line = conn.readline.strip).empty?
+            request << line
+          end
+          # send response
+          auth_header = request.find { |h| h =~ /Authorization:/i }
+          if auth_header || request[0].split(/\s+/)[1] =~ /^\//
+            html = "<html><body>D'oh!</body></html>"
+            conn.write "HTTP/1.1 200 OK\r\n"
+            conn.write "Content-Type:text/html\r\n"
+            conn.write "Content-Length: %i\r\n" % html.size
+            conn.write "\r\n"
+            conn.write html
+            conn.close
+            proxy_requests << request if auth_header
+          else
+            conn.write "HTTP/1.1 407 Proxy Auth Required\r\n"
+            conn.write "Proxy-Authenticate: Basic realm=\"Proxy\"\r\n"
+            conn.write "\r\n"
+            conn.close
+            proxy_requests << request
+          end
+        end
+      end
+      configure do |config|
+        config.allow_url("example.org")
+        config.use_proxy host: @host, port: @port, user: @user, pass: @pass
+      end
+      driver.visit @url
+      @proxy_requests.size.should eq 2
+      @request = @proxy_requests[-1]
+    end
+    after do
+      @proxy.kill
+      @server.close
+    end
+    let(:driver) do
+      driver_for_html("", browser: nil)
+    end
+    it "uses the HTTP proxy correctly" do
+      @request[0].should match(/^GET\s+http:\/\/example.org\/\s+HTTP/i)
+      @request.find { |header|
+        header =~ /^Host:\s+example.org$/i }.should_not be nil
+    end
+    it "sends correct proxy authentication" do
+      auth_header = @request.find { |header|
+        header =~ /^Proxy-Authorization:\s+/i }
+      auth_header.should_not be nil
+      user, pass = Base64.decode64(auth_header.split(/\s+/)[-1]).split(":")
+      user.should eq @user
+      pass.should eq @pass
+    end
+    it "uses the proxy's response" do
+      driver.html.should include "D'oh!"
+    end
+    it "uses original URL" do
+      driver.current_url.should eq @url
+    end
+    it "uses URLs changed by javascript" do
+      driver.execute_script %{window.history.pushState("", "", "/blah")}
+      driver.current_url.should eq "http://example.org/blah"
+    end
+    it "is possible to disable proxy again" do
+      @proxy_requests.clear
+      driver.browser.clear_proxy
+      driver.visit "http://#{@host}:#{@port}/"
+      @proxy_requests.size.should eq 0
+    end
+  end
   def driver_url(driver, path)
     URI.parse(driver.current_url).merge(path).to_s
   end