raptor-io 0.0.1

data/spec/raptor-io/protocol/http/request/manipulators/authenticators/negotiate_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe 'RaptorIO::Protocol::HTTP::Request::Manipulators::Authenticators::Negotiate' do
+  before :all do
+    WebServers.start :basic
+    @url = "http://#{ENV['IIS']}/negotiate/"
+  end
+
+  before( :each ) do
+    RaptorIO::Protocol::HTTP::Request::Manipulators.reset
+  end
+
+  let(:client) { RaptorIO::Protocol::HTTP::Client.new }
+
+  it 'provides Negotiate authentication' do
+    pending if !ENV['IIS']
+
+    opts = {
+        mode: :sync, manipulators: {
+            'authenticators/negotiate' =>
+                {
+                    username: 'msfadmin',
+                    password: 'msfadmin'
+                }
+        }
+    }
+
+    2.times do
+      client.get( @url, opts ).code.should == 200
+    end
+  end
+
+  context 'on wrong credentials' do
+    it 'returns a 401' do
+      pending if !ENV['IIS']
+
+      opts = {
+          mode: :sync, manipulators: {
+              'authenticators/negotiate' =>
+                  {
+                      username: 'blah',
+                      password: 'blah'
+                  }
+          }
+      }
+
+      2.times do
+        client.get( @url, opts ).code.should == 401
+      end
+    end
+  end
+end

data/spec/raptor-io/protocol/http/request/manipulators/authenticators/ntlm_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'RaptorIO::Protocol::HTTP::Request::Manipulators::Authenticators::NTLM' do
+  before :all do
+    WebServers.start :basic
+    @url = "http://#{ENV['IIS']}/ntlm/"
+  end
+
+  before( :each ) do
+    RaptorIO::Protocol::HTTP::Request::Manipulators.reset
+  end
+
+  let(:client) { RaptorIO::Protocol::HTTP::Client.new }
+
+  it 'provides NTLM authentication' do
+    pending if !ENV['IIS']
+
+    response = client.get( @url, mode: :sync )
+    response.code.should == 401
+
+    opts = {
+        mode: :sync, manipulators: {
+            'authenticators/ntlm' =>
+                {
+                    username: 'msfadmin',
+                    password: 'msfadmin',
+                    response: response
+                }
+        }
+    }
+
+    2.times do
+      client.get( @url, opts ).code.should == 200
+    end
+
+  end
+end

data/spec/raptor-io/protocol/http/request/manipulators/redirect_follower_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'RaptorIO::Protocol::HTTP::Request::Manipulators::RedirectFollower' do
+  before :all do
+    WebServers.start :redirect_follower
+    @url = WebServers.url_for( :redirect_follower )
+  end
+
+  before( :each ) do
+    RaptorIO::Protocol::HTTP::Request::Manipulators.reset
+  end
+
+  subject(:client) do
+    RaptorIO::Protocol::HTTP::Client.new(
+      {
+        switch_board: RaptorIO::Socket::SwitchBoard.new
+      }.merge(options)
+    )
+  end
+  let(:options) do
+    {
+      manipulators: {
+        redirect_follower: { max: 6 }
+      }
+    }
+  end
+
+  it 'sets the limit on how many stacked redirections to follow' do
+    response = client.get( "#{@url}/10", mode: :sync )
+    response.redirections.size.should == 6
+    response.headers['Location'].should == "#{@url}/3"
+  end
+
+  context 'without a :max' do
+    let(:options) do
+      {
+        manipulators: {
+          redirect_follower: {}
+        }
+      }
+    end
+    it 'defaults to 5' do
+
+      response = client.get( "#{@url}/10", mode: :sync )
+      response.redirections.size.should == 5
+      response.headers['Location'].should == "#{@url}/4"
+    end
+
+  end
+
+end

data/spec/raptor-io/protocol/http/request/manipulators_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe RaptorIO::Protocol::HTTP::Request::Manipulators do
+  before( :each ) do
+    described_class.reset
+    described_class.library = manipulator_fixtures_path
+  end
+
+  it 'is Enumerable' do
+    described_class.should be_kind_of Enumerable
+  end
+
+  describe '.class_to_name' do
+    it 'returns the name of a loaded manipulator based on its class' do
+      described_class.load_all
+      described_class.class_to_name( RaptorIO::Protocol::HTTP::Request::Manipulators::NiccoloMachiavelli ).should ==
+          'niccolo_machiavelli'
+    end
+  end
+
+  describe '.process' do
+    let(:client) do
+      RaptorIO::Protocol::HTTP::Client.new(switch_board:RaptorIO::Socket::SwitchBoard.new)
+    end
+    it 'processes the given request and client with the given manipulator' do
+      request = RaptorIO::Protocol::HTTP::Request.new( url: 'http://test/' )
+      options = { stuff: 1 }
+
+      datastore = client.datastore['niccolo_machiavelli']
+      datastore['stuff'] = 'blah'
+
+      described_class.process( :niccolo_machiavelli, client, request, options ).should ==
+          [client, request, options, datastore]
+    end
+
+    context 'when given a non-existent manipulator' do
+      it 'raises LoadError' do
+        request = RaptorIO::Protocol::HTTP::Request.new( url: 'http://test/' )
+
+        expect do
+          described_class.process( :huaa!, client, request )
+        end.to raise_error LoadError
+      end
+    end
+  end
+
+  describe '.validate_options' do
+    context 'when the options are invalid' do
+      it 'returns a Hash with errors' do
+        described_class.validate_options(
+            :options_validator,
+            { mandatory_string: 12 },
+            nil
+        ).should eq({
+            mandatory_string: 'Must be string.'
+        })
+      end
+    end
+
+    context 'when the options are valid' do
+      it 'returns an empty Hash' do
+        described_class.validate_options(
+            :options_validator,
+            { mandatory_string: 'Stuff' },
+            nil
+        ).should be_empty
+      end
+    end
+  end
+
+  describe '.validate_batch_options' do
+    context 'when the options are invalid' do
+      it 'returns a Hash with errors' do
+        described_class.validate_batch_options(
+            { options_validator: { mandatory_string: 12 } },
+            nil
+        ).should eq({
+          options_validator: { mandatory_string: 'Must be string.' }
+        })
+      end
+    end
+
+    context 'when the options are valid' do
+      it 'returns an empty Hash' do
+        described_class.validate_batch_options(
+            { options_validator: { mandatory_string: 'Stuff' } },
+            nil
+        ).should be_empty
+      end
+    end
+  end
+
+  describe '.library' do
+    it 'returns the directory of the manipulators\' library' do
+      File.directory?( described_class.library ).should be_true
+    end
+  end
+
+  describe '.library=' do
+    it 'sets the manipulators\' library directory' do
+      described_class.library = '/tmp/'
+      File.directory?( described_class.library ).should be_true
+    end
+  end
+
+  describe '.paths' do
+    it 'returns paths of all manipulators' do
+      described_class.paths.each do |path|
+        path.should start_with described_class.library
+        File.exist?( path ).should be_true
+      end
+    end
+  end
+
+  describe '.exist?' do
+    context 'when a manipulator exists' do
+      it 'returns true' do
+        described_class.exist?( 'niccolo_machiavelli' ).should be_true
+      end
+    end
+
+    context 'when a manipulator does not exist' do
+      it 'returns false' do
+        described_class.exist?( 'stuffer_stufferson' ).should be_false
+      end
+    end
+  end
+
+  describe '.available' do
+    it 'returns the names of all available manipulators' do
+      described_class.available.sort.should eq [ 'niccolo_machiavelli', 'manifoolators/fooer', 'options_validator' ].sort
+    end
+  end
+
+  describe '.load' do
+    it 'loads a manipulator by filename' do
+      described_class.load( :niccolo_machiavelli )
+      described_class.loaded['niccolo_machiavelli'].should ==
+          RaptorIO::Protocol::HTTP::Request::Manipulators::NiccoloMachiavelli
+    end
+    it 'returns the loaded manipulator' do
+      described_class.load( :niccolo_machiavelli ).should ==
+          RaptorIO::Protocol::HTTP::Request::Manipulators::NiccoloMachiavelli
+    end
+
+    context 'when given a non-existent manipulator' do
+      it 'raises LoadError' do
+        expect{ described_class.load( :huaa! ) }.to raise_error LoadError
+      end
+    end
+  end
+
+  describe '.load_all' do
+    it 'loads all manipulators' do
+      described_class.load_all
+      described_class.loaded['niccolo_machiavelli'].should ==
+          RaptorIO::Protocol::HTTP::Request::Manipulators::NiccoloMachiavelli
+    end
+    it 'returns the loaded manipulators' do
+      described_class.load_all.should eq ({
+        'manifoolators/fooer' => RaptorIO::Protocol::HTTP::Request::Manipulators::Manifoolators::Fooer,
+        'niccolo_machiavelli' => RaptorIO::Protocol::HTTP::Request::Manipulators::NiccoloMachiavelli,
+        'options_validator' => RaptorIO::Protocol::HTTP::Request::Manipulators::OptionsValidator
+      })
+    end
+  end
+
+  describe '.unload' do
+    it 'unload a manipulator' do
+      described_class.load( :niccolo_machiavelli )
+      described_class.unload( :niccolo_machiavelli )
+      described_class.loaded.should_not include :niccolo_machiavelli
+
+      expect do
+        RaptorIO::Protocol::HTTP::Request::Manipulators::NiccoloMachiavelli
+      end.to raise_error NameError
+    end
+  end
+
+  describe '.unload_all' do
+    it 'unloads all manipulators' do
+      described_class.load_all
+      described_class.constants.size.should >= 1
+
+      described_class.unload_all
+      described_class.loaded.should be_empty
+      described_class.constants.should be_empty
+    end
+  end
+
+  describe '.each' do
+    it 'returns each loaded manipulator' do
+      described_class.load_all
+      described_class.loaded.should be_any
+
+      described_class.each do |name, klass|
+        described_class.loaded[name].should == klass
+      end
+    end
+  end
+
+end

data/spec/raptor-io/protocol/http/request_spec.rb

@@ -0,0 +1,965 @@
+# coding: utf-8
+require 'spec_helper'
+require 'ostruct'
+
+describe RaptorIO::Protocol::HTTP::Request do
+  it_should_behave_like 'RaptorIO::Protocol::HTTP::Message'
+
+  let(:url) { 'http://test.com' }
+  let(:parsed_url) { URI(url) }
+  let(:url_with_query) { 'http://test.com/?id=1&stuff=blah' }
+
+  describe '#initialize' do
+    it 'sets the instance attributes by the options' do
+      options = {
+          url: url,
+          http_method: :get,
+          parameters: { 'test' => 'blah' },
+          timeout: 10,
+          continue: false,
+          raw: true
+      }
+      r = described_class.new( options )
+      r.url.should          == url
+      r.http_method.should  == options[:http_method]
+      r.parameters.should   == options[:parameters]
+      r.timeout.should      == options[:timeout]
+      r.continue.should     == options[:continue]
+      r.raw.should          == options[:raw]
+    end
+
+    it 'uses the setter methods when configuring' do
+      options = { url: url, http_method: 'gEt', parameters: { 'test' => 'blah' } }
+      described_class.new( options ).http_method.should == :get
+    end
+
+    context 'when no :url option has been provided' do
+      it 'raises ArgumentError' do
+        raised = false
+        begin
+          described_class.new
+        rescue ArgumentError
+          raised = true
+        end
+        raised.should be_true
+      end
+    end
+  end
+
+  describe '#connection_id' do
+    it 'returns an ID for the given host:port' do
+      described_class.new( url: 'http://stuff' ).connection_id.should ==
+        described_class.new( url: 'http://stuff:80' ).connection_id
+
+      described_class.new( url: 'http://stuff' ).connection_id.should_not ==
+          described_class.new( url: 'http://stuff:81' ).connection_id
+
+      described_class.new( url: 'http://stuff.com' ).connection_id.should ==
+          described_class.new( url: 'http://stuff.com' ).connection_id
+    end
+  end
+
+  describe '#continue?' do
+    context 'default' do
+      it 'returns true' do
+        described_class.new( url: url ).continue?.should be_true
+      end
+    end
+
+    context 'when the continue option has been set to' do
+      context true do
+        it 'returns false' do
+          described_class.new( url: url, continue: true ).continue?.should be_true
+        end
+      end
+
+      context false do
+        it 'returns false' do
+          described_class.new( url: url, continue: false ).continue?.should be_false
+        end
+      end
+    end
+  end
+
+
+  describe '#url' do
+    it 'returns the configured value' do
+      described_class.new( url: url ).url.should == url
+    end
+  end
+
+  describe '#parsed_url' do
+    it 'returns the configured URL as a parsed object' do
+      described_class.new( url: url ).parsed_url.should == URI(url)
+    end
+  end
+
+  describe '#http_method' do
+    it 'defaults to :get' do
+      described_class.new( url: url ).http_method.should == :get
+    end
+  end
+
+  describe '#http_method=' do
+    it 'normalizes the HTTP method to a downcase symbol' do
+      request = described_class.new( url: url )
+      request.http_method = 'pOsT'
+      request.http_method.should == :post
+    end
+  end
+
+  describe '#idempotent?' do
+    context 'when http_method is post' do
+      it 'returns false' do
+        described_class.new( url: url, http_method: :post ).idempotent?.should be_false
+      end
+    end
+
+    context 'when http_method is not post' do
+      it 'returns true' do
+        described_class.new( url: url ).idempotent?.should be_true
+      end
+    end
+  end
+
+  describe '#parameters' do
+    it 'defaults to an empty Hash' do
+      described_class.new( url: url ).parameters.should == {}
+    end
+
+    it 'recursively forces converts keys and values to strings' do
+      with_symbols = {
+          test:         'blah',
+          another_hash: {
+              stuff: 'test'
+          }
+      }
+      with_strings = {
+          'test'         => 'blah',
+          'another_hash' => {
+              'stuff' => 'test'
+          }
+      }
+
+      request = described_class.new( url: url )
+      request.parameters = with_symbols
+      request.parameters.should == with_strings
+    end
+  end
+
+  describe '#query_parameters' do
+    context 'when :raw option is' do
+      context true do
+        it 'does not decode the URL query parameters' do
+          weird_url = 'http://test.com/?first=test%3Fblah%2F&second%2F%26=blah'
+          r = described_class.new( raw: true, url: weird_url, http_method: :other )
+          r.query_parameters.should == { 'first' => 'test%3Fblah%2F', 'second%2F%26' => 'blah' }
+        end
+      end
+
+      context false do
+        it 'decodes the URL query parameters' do
+          weird_url = 'http://test.com/?first=test%3Fblah%2F&second%2F%26=blah'
+          r = described_class.new( raw: false, url: weird_url, http_method: :other )
+          r.query_parameters.should == { 'first' => 'test?blah/', 'second/&' => 'blah' }
+        end
+      end
+
+      context 'default' do
+        it 'decodes the URL query parameters' do
+          weird_url = 'http://test.com/?first=test%3Fblah%2F&second%2F%26=blah'
+          r = described_class.new( url: weird_url, http_method: :other )
+          r.query_parameters.should == { 'first' => 'test?blah/', 'second/&' => 'blah' }
+        end
+      end
+    end
+
+    context 'when the request method is' do
+      context 'GET' do
+        context 'when no parameters have been provided as options' do
+          it 'returns the query parameters as a Hash' do
+            r = described_class.new( url: url_with_query, http_method: :get )
+            r.query_parameters.should == { 'id' => '1', 'stuff' => 'blah' }
+          end
+        end
+        context 'when there are parameters as options' do
+          let(:parameters) { { 'id' => '2', 'stuff' => 'blah' } }
+
+          context 'and the URL has no query parameters' do
+            it 'returns the parameters from options' do
+              r = described_class.new( url: url, http_method: :get, parameters: parameters )
+              r.query_parameters.should == parameters
+            end
+          end
+          context 'and the URL has query parameters' do
+            it 'returns the query parameters merged with the options parameters' do
+              r = described_class.new( url: url_with_query, http_method: :get, parameters: parameters )
+              r.query_parameters.should == { 'id' => '1', 'stuff' => 'blah' }.merge(parameters)
+            end
+          end
+        end
+      end
+      context 'other' do
+        it 'returns the query parameters as a Hash' do
+          r = described_class.new( url: url_with_query, http_method: :other )
+          r.query_parameters.should == { 'id' => '1', 'stuff' => 'blah' }
+        end
+      end
+    end
+  end
+
+  describe '#resource' do
+    it 'returns the resource to be requested' do
+      r = described_class.new( url: url, parameters: { 'first' => 'test?blah/', 'second/&' => 'blah' } )
+      r.resource.to_s.should == '/?first=test%3Fblah%2F&second%2F%26=blah'
+    end
+  end
+
+  describe '#effective_url' do
+    context 'when :raw option is' do
+      context true do
+        it 'does not encode the URL query parameters' do
+          r = described_class.new( raw: true, url: url, parameters: { 'first' => 'test?blah/', 'second/&' => 'blah' } )
+          r.effective_url.to_s.should == 'http://test.com/?first=test?blah/&second/&=blah'
+        end
+      end
+
+      context false do
+        it 'encodes the URL query parameters' do
+          r = described_class.new( raw: false, url: url, parameters: { 'first' => 'test?blah/', 'second/&' => 'blah' } )
+          r.effective_url.to_s.should == 'http://test.com/?first=test%3Fblah%2F&second%2F%26=blah'
+        end
+      end
+
+      context 'default' do
+        it 'encodes the URL query parameters' do
+          r = described_class.new( url: url, parameters: { 'first' => 'test?blah/', 'second/&' => 'blah' } )
+          r.effective_url.to_s.should == 'http://test.com/?first=test%3Fblah%2F&second%2F%26=blah'
+        end
+      end
+    end
+
+    it 'has UTF8 support' do
+      options = {
+          url: url_with_query,
+          parameters: {
+              'test' => 'τεστ'
+          }
+      }
+      described_class.new( options ).effective_url.to_s.should ==
+          "http://test.com/?id=1&stuff=blah&test=%CF%84%CE%B5%CF%83%CF%84"
+    end
+
+    context 'when the request method is' do
+      context 'GET' do
+        context 'when no parameters have been provided as options' do
+          it 'returns the original URL' do
+            r = described_class.new( url: url_with_query, http_method: :get )
+            r.effective_url.to_s.should == url_with_query
+          end
+        end
+        context 'when there are parameters as options' do
+          let(:parameters) { { 'id' => '2', 'stuff' => 'blah' } }
+
+          context 'and the URL has no query parameters' do
+            it 'returns a URL with the option parameters' do
+              r = described_class.new( url: url, http_method: :get, parameters: parameters )
+              r.effective_url.to_s.should == "#{url}/?id=2&stuff=blah"
+            end
+          end
+          context 'and the URL has query parameters' do
+            it 'returns the query parameters merged with the options parameters' do
+              r = described_class.new( url: url_with_query, http_method: :get, parameters: parameters )
+              r.effective_url.to_s.should == "#{url}/?id=2&stuff=blah"
+            end
+          end
+        end
+      end
+      context 'other' do
+        it 'returns the original URL' do
+          r = described_class.new( url: url_with_query, http_method: :other )
+          r.effective_url.to_s.should == url_with_query
+        end
+      end
+    end
+  end
+
+  describe '#effective_body' do
+    context 'when the Expect header field has been set' do
+      it 'returns an empty string' do
+        described_class.new( url: url,
+                             body: 'stuff',
+                             headers: { 'Expect' => '100-continue' }
+        ).effective_body.should == ''
+      end
+    end
+
+    context 'when no body has been provided' do
+      it 'returns an empty string' do
+        described_class.new( url: url ).effective_body.should == ''
+      end
+    end
+
+    context 'when there is a body' do
+      context 'when :raw option is' do
+        context true do
+          it 'does not encode it' do
+            options = {
+                raw:  true,
+                url:  url,
+                body: "fds g45\#$ 6@ %y @^2\r\n"
+            }
+            described_class.new( options ).effective_body.should ==
+                options[:body]
+          end
+        end
+
+        context false do
+          it 'encodes it' do
+            options = {
+                raw:  false,
+                url:  url,
+                body: "fds g45\#$ 6@ %y @^2\r\n"
+            }
+            described_class.new( options ).effective_body.should ==
+                'fds+g45%23%24+6%40+%25y+%40%5E2%0D%0A'
+          end
+        end
+
+        context 'default' do
+          it 'encodes it' do
+            options = {
+                url:  url,
+                body: "fds g45\#$ 6@ %y @^2\r\n"
+            }
+            described_class.new( options ).effective_body.should ==
+                'fds+g45%23%24+6%40+%25y+%40%5E2%0D%0A'
+          end
+        end
+      end
+
+      it 'has UTF8 support' do
+        described_class.new( url: 'http://stuff', body: 'τεστ' ).effective_body.should == '%CF%84%CE%B5%CF%83%CF%84'
+      end
+    end
+
+    context 'when the request method is' do
+      context 'POST' do
+        context 'when no parameters have been provided as options' do
+          context 'when :raw option is' do
+            context true do
+              it 'returns the original body' do
+                options = {
+                    raw: true,
+                    url: url_with_query,
+                    http_method: :post,
+                    body: 'stuff=/1&blah=/test'
+                }
+                described_class.new( options ).effective_body.should == options[:body]
+              end
+            end
+
+            context false do
+              it 'escapes and returns the body' do
+                options = {
+                    raw: false,
+                    url: url_with_query,
+                    http_method: :post,
+                    body: 'stuff=/1&blah=/test'
+                }
+                described_class.new( options ).effective_body.should == 'stuff=%2F1&blah=%2Ftest'
+              end
+            end
+
+            context 'default' do
+              it 'escapes and returns the body' do
+                options = {
+                    raw: false,
+                    url: url_with_query,
+                    http_method: :post,
+                    body: 'stuff=/1&blah=/test'
+                }
+                described_class.new( options ).effective_body.should == 'stuff=%2F1&blah=%2Ftest'
+              end
+            end
+          end
+        end
+
+        context 'when there are parameters as options' do
+          let(:parameters) { { 'id/' => '2', 'stuff' => 'blah/' } }
+
+          context 'and there is no body configured' do
+            context 'when :raw option is' do
+              context true do
+                it 'returns the option parameters' do
+                  options = {
+                      raw: true,
+                      url: url_with_query,
+                      http_method: :post,
+                      parameters: parameters
+                  }
+                  described_class.new( options ).effective_body.to_s.should ==
+                      "id/=2&stuff=blah/"
+                end
+              end
+
+              context false do
+                it 'returns the escaped option parameters' do
+                  options = {
+                      raw: false,
+                      url: url_with_query,
+                      http_method: :post,
+                      parameters: parameters
+                  }
+                  described_class.new( options ).effective_body.to_s.should ==
+                      "id%2F=2&stuff=blah%2F"
+                end
+              end
+
+              context 'default' do
+                it 'returns the escaped option parameters' do
+                  options = {
+                      raw: false,
+                      url: url_with_query,
+                      http_method: :post,
+                      parameters: parameters
+                  }
+                  described_class.new( options ).effective_body.to_s.should ==
+                      "id%2F=2&stuff=blah%2F"
+                end
+              end
+            end
+
+          end
+
+          it 'has UTF8 support' do
+            options = {
+                url: url_with_query,
+                http_method: :post,
+                parameters: {
+                    'test' => 'τεστ'
+                }
+            }
+            described_class.new( options ).effective_body.to_s.should ==
+                "test=%CF%84%CE%B5%CF%83%CF%84"
+          end
+
+          context 'and there is a body' do
+            it 'returns the body parameters merged with the options parameters' do
+              options = {
+                  url: url_with_query,
+                  http_method: :post,
+                  body: 'stuff 4354%$43=$#535!35VWE g4 %yt5&stuff=1',
+                  parameters: parameters
+              }
+              described_class.new( options ).effective_body.to_s.should ==
+                  "stuff+4354%25%2443=%24%23535%2135VWE+g4+%25yt5&stuff=blah%2F&id%2F=2"
+            end
+          end
+        end
+      end
+
+      context 'other' do
+        context 'when :raw option is' do
+          context true do
+            it 'returns the original body' do
+              options = {
+                  raw: true,
+                  url: url_with_query,
+                  http_method: :other,
+                  body: 'stuff here #$^#46 %H# '
+              }
+              described_class.new( options ).effective_body.should == options[:body]
+            end
+          end
+
+          context false do
+            it 'escapes and returns the original body' do
+              options = {
+                  raw: false,
+                  url: url_with_query,
+                  http_method: :other,
+                  body: 'stuff here #$^#46 %H# '
+              }
+              described_class.new( options ).effective_body.should ==
+                  'stuff+here+%23%24%5E%2346+%25H%23+'
+            end
+          end
+
+          context 'default' do
+            it 'escapes and returns the original body' do
+              options = {
+                  url: url_with_query,
+                  http_method: :other,
+                  body: 'stuff here #$^#46 %H# '
+              }
+              described_class.new( options ).effective_body.should ==
+                  'stuff+here+%23%24%5E%2346+%25H%23+'
+            end
+          end
+        end
+
+      end
+    end
+  end
+
+  describe '#clear_callbacks' do
+    it 'clears all callbacks' do
+      request = described_class.new( url: url )
+
+      request.on_complete { |res| res }
+      request.on_complete.size.should == 1
+
+      request.on_success { |res| res }
+      request.on_success.size.should == 1
+
+      request.on_failure { |res| res }
+      request.on_failure.size.should == 1
+
+      request.clear_callbacks
+
+      request.on_complete.should be_empty
+      request.on_success.should be_empty
+      request.on_failure.should be_empty
+    end
+  end
+
+  describe '#on_complete' do
+    context 'when passed a block' do
+      it 'adds it as a callback to be passed the response' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_complete { |res| passed_response = res }
+
+        response = RaptorIO::Protocol::HTTP::Response.new( url: url )
+        request.handle_response( response )
+
+        passed_response.should == response
+      end
+
+      it 'can add multiple callbacks' do
+        request = described_class.new( url: url )
+
+        passed_responses = []
+
+        2.times do
+          request.on_complete { |res| passed_responses << res }
+        end
+
+        response = RaptorIO::Protocol::HTTP::Response.new( url: url )
+        request.handle_response( response )
+
+        passed_responses.size.should == 2
+        passed_responses.uniq.size.should == 1
+        passed_responses.uniq.first.should == response
+      end
+    end
+
+    it 'returns all relevant callbacks' do
+      request = described_class.new( url: url )
+      2.times do
+        request.on_complete { |res| res }
+      end
+      request.on_complete.size.should == 2
+    end
+  end
+
+  describe '#on_success' do
+    context 'when passed a block' do
+      it 'adds it as a callback to be called on a successful request' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_success { |res| passed_response = res }
+
+        response = RaptorIO::Protocol::HTTP::Response.new( url: url, code: 200 )
+        request.handle_response( response )
+
+        passed_response.should == response
+      end
+
+      it 'can add multiple callbacks' do
+        request = described_class.new( url: url )
+
+        passed_responses = []
+
+        2.times do
+          request.on_success { |res| passed_responses << res }
+        end
+
+        response = RaptorIO::Protocol::HTTP::Response.new( url: url, code: 200 )
+        request.handle_response( response )
+
+        passed_responses.size.should == 2
+        passed_responses.uniq.size.should == 1
+        passed_responses.uniq.first.should == response
+      end
+    end
+
+    it 'returns all relevant callbacks' do
+      request = described_class.new( url: url )
+      2.times do
+        request.on_success { |res| res }
+      end
+      request.on_success.size.should == 2
+    end
+  end
+
+  describe '#on_failure' do
+    context 'when passed a block' do
+      it 'adds a callback block to be called on a failed request' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_failure { |res| passed_response = res }
+
+        response = RaptorIO::Protocol::HTTP::Response.new( url: url, code: 0 )
+        request.handle_response( response )
+
+        passed_response.should == response
+      end
+
+      it 'can add multiple callbacks' do
+        request = described_class.new( url: url )
+
+        passed_responses = []
+
+        2.times do
+          request.on_failure { |res| passed_responses << res }
+        end
+
+        response = RaptorIO::Protocol::HTTP::Response.new( url: url, code: 0 )
+        request.handle_response( response )
+
+        passed_responses.size.should == 2
+        passed_responses.uniq.size.should == 1
+        passed_responses.uniq.first.should == response
+      end
+    end
+
+    it 'returns all relevant callbacks' do
+      request = described_class.new( url: url )
+      2.times do
+        request.on_failure { |res| res }
+      end
+      request.on_failure.size.should == 2
+    end
+  end
+
+  describe '#handle_response' do
+    it 'assigns self as the #request attribute of the response' do
+      request = described_class.new( url: url )
+
+      passed_response = nil
+      request.on_complete { |res| passed_response = res }
+
+      response = RaptorIO::Protocol::HTTP::Response.new( url: url )
+      request.handle_response( response )
+
+      passed_response.request.should == request
+    end
+
+    context 'when a response is successful' do
+      let(:response) { RaptorIO::Protocol::HTTP::Response.new( url: url, code: 200 ) }
+
+      it 'calls #on_complete callbacks' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_complete { |res| passed_response = res }
+        request.handle_response( response )
+
+        passed_response.should == response
+      end
+      it 'calls #on_success callbacks' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_success { |res| passed_response = res }
+        request.handle_response( response )
+
+        passed_response.should == response
+      end
+      it 'does not call #on_failure callbacks' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_failure { |res| passed_response = res }
+        request.handle_response( response )
+
+        passed_response.should be_nil
+      end
+    end
+    context 'when a request fails' do
+      let(:response) { RaptorIO::Protocol::HTTP::Response.new( url: url, code: 0 ) }
+
+      it 'calls #on_complete callbacks' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_complete { |res| passed_response = res }
+        request.handle_response( response )
+
+        passed_response.should == response
+      end
+      it 'does not call #on_success callbacks' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_success { |res| passed_response = res }
+        request.handle_response( response )
+
+        passed_response.should be_nil
+      end
+      it 'calls #on_failure callbacks' do
+        request = described_class.new( url: url )
+
+        passed_response = nil
+        request.on_failure { |res| passed_response = res }
+        request.handle_response( response )
+
+        passed_response.should == response
+      end
+    end
+  end
+
+  describe '#to_s' do
+    it 'includes a Host header' do
+      described_class.new( url: url ).to_s.should ==
+          "GET / HTTP/1.1\r\n" +
+              "Host: #{parsed_url.host}:#{parsed_url.port}\r\n\r\n"
+    end
+
+    context 'when the request method is' do
+      context 'GET' do
+        context 'when no parameters have been provided as options' do
+          it 'uses the original URL' do
+            r = described_class.new( url: url_with_query, http_method: :get )
+            r.to_s.lines.first.should == "GET /?id=1&stuff=blah HTTP/1.1\r\n"
+          end
+        end
+        context 'when there are parameters as options' do
+          let(:parameters) { { 'id' => '2', 'stuff' => 'blah' } }
+
+          context 'and the URL has no query parameters' do
+            it 'uses the URL with the option parameters' do
+              r = described_class.new( url: url, http_method: :get, parameters: parameters )
+              r.to_s.lines.first.should == "GET /?id=2&stuff=blah HTTP/1.1\r\n"
+            end
+          end
+          context 'and the URL has query parameters' do
+            it 'uses the query parameters merged with the options parameters' do
+              r = described_class.new( url: url_with_query, http_method: :get, parameters: parameters )
+              r.to_s.lines.first.should == "GET /?id=2&stuff=blah HTTP/1.1\r\n"
+            end
+          end
+        end
+      end
+
+      context 'POST' do
+        context 'when no parameters have been provided as options' do
+          it 'uses the original body' do
+            options = {
+                url: url_with_query,
+                http_method: :post,
+                body: 'stuff=1&blah=test'
+            }
+            described_class.new( options ).to_s.split( /[\n\r]+/ ).last.should ==
+                options[:body]
+          end
+        end
+        context 'when there are parameters as options' do
+          let(:parameters) { { 'id $#^3 4q%$#' => '2 dfgr ', 'stuff' => 'blah' } }
+
+          context 'and there is no body configured' do
+            it 'uses the escaped option parameters' do
+              options = {
+                  url: url_with_query,
+                  http_method: :post,
+                  parameters: parameters
+              }
+              described_class.new( options ).to_s.split( /[\n\r]+/ ).last.should ==
+                  "id+%24%23%5E3+4q%25%24%23=2+dfgr+&stuff=blah"
+            end
+          end
+          context 'and there is a body' do
+            it 'uses the body parameters merged with the options parameters' do
+              options = {
+                  url: url_with_query,
+                  http_method: :post,
+                  body: 'stuff 4354%$43=$#535!35VWE g4 %yt5&stuff=1',
+                  parameters: parameters
+              }
+              described_class.new( options ).to_s.split( /[\n\r]+/ ).last.should ==
+                  "stuff+4354%25%2443=%24%23535%2135VWE+g4+%25yt5&stuff=blah&id+%24%23%5E3+4q%25%24%23=2+dfgr+"
+            end
+          end
+        end
+      end
+
+      context 'other' do
+        it 'returns the original body' do
+          options = {
+              url: url_with_query,
+              http_method: :other,
+              body: 'stuff'
+          }
+          described_class.new( options ).to_s.split( /[\n\r]+/ ).last.should ==
+              options[:body]
+        end
+
+        it 'escapes the original body' do
+          options = {
+              url: url_with_query,
+              http_method: :other,
+              body: 'stuff here #$^#46 %H# '
+          }
+          described_class.new( options ).to_s.split( /[\n\r]+/ ).last.should ==
+              'stuff+here+%23%24%5E%2346+%25H%23+'
+        end
+
+        it 'returns the original URL' do
+          options = {
+              url: url_with_query,
+              http_method: :other
+          }
+          described_class.new( options ).to_s.lines.first.should ==
+              "OTHER /?id=1&stuff=blah HTTP/1.1\r\n"
+        end
+      end
+    end
+
+    context 'when headers' do
+      context 'have been provided' do
+        it 'escapes and includes them in the request' do
+          options = {
+              url:     url,
+              headers: {
+                  'X-Stuff' => "blah"
+              }
+          }
+          described_class.new( options ).to_s.should ==
+              "GET / HTTP/1.1\r\n" +
+                "Host: #{parsed_url.host}:#{parsed_url.port}\r\n" +
+                "X-Stuff: blah\r\n\r\n"
+        end
+      end
+    end
+
+    context 'when an HTTP method' do
+      context 'has been provided' do
+        it 'includes it the request' do
+          options = {
+              url:         url,
+              http_method: :stuff
+          }
+          described_class.new( options ).to_s.lines.first.should == "STUFF / HTTP/1.1\r\n"
+        end
+      end
+      context 'has not been provided' do
+        it 'defaults to GET' do
+          described_class.new( url: url ).to_s.lines.first.should == "GET / HTTP/1.1\r\n"
+        end
+      end
+    end
+
+    context 'when an HTTP version' do
+      context 'has been provided' do
+        it 'includes it the request' do
+          options = {
+              url:     url,
+              version: '2'
+          }
+          described_class.new( options ).to_s.lines.first.should == "GET / HTTP/2\r\n"
+        end
+      end
+
+      context 'has not been provided' do
+        it 'defaults to 1.1' do
+          described_class.new( url: url ).to_s.lines.first.should == "GET / HTTP/1.1\r\n"
+        end
+      end
+    end
+
+    context 'when there is a body' do
+      it 'encodes it' do
+        options = {
+            url:  url,
+            body: "fds g45\#$ 6@ %y @^2\r\n"
+        }
+        described_class.new( options ).to_s.split( /[\n\r]+/ ).last.should ==
+                "fds+g45%23%24+6%40+%25y+%40%5E2%0D%0A"
+      end
+      it 'sets the Content-Length header' do
+        options = {
+            url:  url,
+            body: "fds g45\#$ 6@ %y @^2\r\n"
+        }
+        described_class.new( options ).to_s.should ==
+            "GET / HTTP/1.1\r\n" +
+                "Host: #{parsed_url.host}:#{parsed_url.port}\r\n" +
+                "Content-Length: 37\r\n\r\n" +
+                "fds+g45%23%24+6%40+%25y+%40%5E2%0D%0A"
+      end
+    end
+
+  end
+
+  describe '.parse' do
+    it 'parses a request string into a Request object' do
+      request = <<EOTXT
+GET /stuff?pname=pvalue HTTP/1.1
+Host: localhost:88
+User-Agent: Stuff agent
+Cookie: cname=cvalue; c2name=c2value
+
+body+here
+EOTXT
+
+      request = described_class.parse( request )
+      request.url.should             == '/stuff?pname=pvalue'
+      request.parsed_url.to_s.should == '/stuff?pname=pvalue'
+      request.version.should         == '1.1'
+      request.http_method.should     == :get
+      request.body.should            == "body+here\n"
+      request.headers.should         eq({
+        'Host'       => 'localhost:88',
+        'User-Agent' => 'Stuff agent',
+        'Cookie'     => 'cname=cvalue; c2name=c2value'
+      })
+
+      request.headers.cookies.should == [
+        {
+            name: 'cname',
+            value: 'cvalue',
+            version: 0,
+            port: nil,
+            discard: nil,
+            comment_url: nil,
+            expires: nil,
+            max_age: nil,
+            comment: nil,
+            secure: nil,
+            path: nil,
+            domain: nil
+        },
+        {
+            name: 'c2name',
+            value: 'c2value',
+            version: 0,
+            port: nil,
+            discard: nil,
+            comment_url: nil,
+            expires: nil,
+            max_age: nil,
+            comment: nil,
+            secure: nil,
+            path: nil,
+            domain: nil
+        }
+      ]
+    end
+  end
+
+end