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

capybara-webkit 1.5.2 → 1.6.0

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