simple-client 0.0.2

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/curb/curb_spec_helper.rb

@@ -0,0 +1,144 @@
+require 'ostruct'
+
+module CurbSpecHelper
+  def http_request(method, uri, options = {}, &block)
+    uri = Addressable::URI.heuristic_parse(uri)
+    body = options[:body]
+
+    curl = curb_http_request(uri, method, body, options)
+
+    status, response_headers =
+     WebMock::HttpLibAdapters::CurbAdapter.parse_header_string(curl.header_str)
+
+    # Deal with the fact that the HTTP spec allows multi-values headers
+    # to either be a single entry with a comma-separated listed of
+    # values, or multiple separate entries
+    response_headers.keys.each do |k|
+      v = response_headers[k]
+      if v.is_a?(Array)
+        response_headers[k] = v.join(', ')
+      end
+    end
+
+    OpenStruct.new(
+      :body => curl.body_str,
+      :headers => WebMock::Util::Headers.normalize_headers(response_headers),
+      :status => curl.response_code.to_s,
+      :message => status
+    )
+  end
+
+  def setup_request(uri, curl, options={})
+    curl          ||= Curl::Easy.new
+    curl.url      = uri.omit(:userinfo).to_s
+    curl.username = uri.user
+    curl.password = uri.password
+    curl.timeout  = 30
+    curl.connect_timeout = 30
+
+    if headers = options[:headers]
+      headers.each {|k,v| curl.headers[k] = v }
+    end
+
+    curl
+  end
+
+  def client_timeout_exception_class
+    Curl::Err::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    Curl::Err::ConnectionFailedError
+  end
+
+  def http_library
+    :curb
+  end
+
+  module DynamicHttp
+    def curb_http_request(uri, method, body, options)
+      curl = setup_request(uri, nil, options)
+
+      case method
+      when :post
+        curl.post_body = body
+      when :put
+        curl.put_data = body
+      end
+
+      curl.http(method)
+      curl
+    end
+  end
+
+  module NamedHttp
+    def curb_http_request(uri, method, body, options)
+      curl = setup_request(uri, nil, options)
+
+      case method
+      when :put, :post
+        curl.send( "http_#{method}", body )
+      else
+        curl.send( "http_#{method}" )
+      end
+      curl
+    end
+  end
+
+  module Perform
+    def curb_http_request(uri, method, body, options)
+      curl = setup_request(uri, nil, options)
+
+      case method
+      when :post
+        curl.post_body = body
+      when :put
+        curl.put_data = body
+      when :head
+        curl.head = true
+      when :delete
+        curl.delete = true
+      end
+
+      curl.perform
+      curl
+    end
+  end
+
+  module ClassNamedHttp
+    def curb_http_request(uri, method, body, options)
+      args = ["http_#{method}", uri]
+      args << body if method == :post || method == :put
+
+      c = Curl::Easy.send(*args) do |curl|
+        setup_request(uri, curl, options)
+      end
+
+      c
+    end
+  end
+
+  module ClassPerform
+    def curb_http_request(uri, method, body, options)
+      args = ["http_#{method}", uri]
+      args << body if method == :post || method == :put
+
+      c = Curl::Easy.send(*args) do |curl|
+        setup_request(uri, curl, options)
+
+        case method
+        when :post
+          curl.post_body = body
+        when :put
+          curl.put_data = body
+        when :head
+          curl.head = true
+        when :delete
+          curl.delete = true
+        end
+      end
+
+      c
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/em_http_request/em_http_request_spec.rb

@@ -0,0 +1,183 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+require 'ostruct'
+
+unless RUBY_PLATFORM =~ /java/
+  require 'acceptance/em_http_request/em_http_request_spec_helper'
+
+  describe "EM::HttpRequest" do
+    include EMHttpRequestSpecHelper
+
+    include_context "with WebMock", :no_status_message
+
+    #functionality only supported for em-http-request 1.x
+    if defined?(EventMachine::HttpConnection)
+      describe "with middleware" do
+
+        it "should work with request middleware" do
+          stub_request(:get, "www.example.com").with(:body => 'bar')
+
+          middleware = Class.new do
+            def request(client, head, body)
+              [{}, 'bar']
+            end
+          end
+
+          EM.run do
+            conn = EventMachine::HttpRequest.new('http://www.example.com/')
+
+            conn.use middleware
+
+            http = conn.get(:body => 'foo')
+
+            http.callback do
+              WebMock.should have_requested(:get, "www.example.com").with(:body => 'bar')
+              EM.stop
+            end
+          end
+        end
+
+        it "should work with response middleware" do
+          stub_request(:get, "www.example.com").to_return(:body => 'foo')
+
+          middleware = Class.new do
+            def response(resp)
+              resp.response = 'bar'
+            end
+          end
+
+          EM.run do
+            conn = EventMachine::HttpRequest.new('http://www.example.com/')
+
+            conn.use middleware
+
+            http = conn.get
+
+            http.callback do
+              http.response.should be == 'bar'
+              EM.stop
+            end
+          end
+        end
+      end
+
+      # not pretty, but it works
+      if defined?(EventMachine::Synchrony)
+        describe "with synchrony" do
+          let(:webmock_em_http) { File.expand_path(File.join(File.dirname(__FILE__), "../lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb")) }
+
+          before(:each) do
+            # need to reload the webmock em-http adapter after we require synchrony
+            WebMock::HttpLibAdapters::EmHttpRequestAdapter.disable!
+            $".delete webmock_em_http
+            $".delete File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
+            require 'em-synchrony'
+            require 'em-synchrony/em-http'
+            require File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
+          end
+
+          it "should work" do
+            stub_request(:post, /.*.testserver.com*/).to_return(:status => 200, :body => 'ok')
+            lambda {
+              EM.run do
+                fiber = Fiber.new do
+                  http = EM::HttpRequest.new("http://www.testserver.com").post :body => "foo=bar&baz=bang", :timeout => 60
+                  EM.stop
+                end
+                fiber.resume
+              end
+            }.should_not raise_error
+          end
+
+          after(:each) do
+            EM.send(:remove_const, :Synchrony)
+            EM.send(:remove_const, :HTTPMethods)
+            WebMock::HttpLibAdapters::EmHttpRequestAdapter.disable!
+            $".reject! {|path| path.include? "em-http-request"}
+            $".delete webmock_em_http
+            $".delete File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
+            require 'em-http-request'
+            require File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
+          end
+        end
+      end
+    end
+
+    it "should work with streaming" do
+      stub_request(:get, "www.example.com").to_return(:body => "abc")
+      response = ""
+      EM.run {
+        http = EventMachine::HttpRequest.new('http://www.example.com/').get
+        http.stream { |chunk| response = chunk; EM.stop  }
+      }
+      response.should == "abc"
+    end
+
+    it "should work with responses that use chunked transfer encoding" do
+      stub_request(:get, "www.example.com").to_return(:body => "abc", :headers => { 'Transfer-Encoding' => 'chunked' })
+      http_request(:get, "http://www.example.com").body.should == "abc"
+    end
+
+    it "should work with optional query params" do
+      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
+      http_request(:get, "http://www.example.com/?x=3", :query => {"a" => ["b", "c"]}).body.should == "abc"
+    end
+
+    it "should work with optional query params declared as string" do
+      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
+      http_request(:get, "http://www.example.com/?x=3", :query => "a[]=b&a[]=c").body.should == "abc"
+    end
+
+    it "should work when the body is passed as a Hash" do
+      stub_request(:post, "www.example.com").with(:body => {:a => "1", :b => "2"}).to_return(:body => "ok")
+      http_request(:post, "http://www.example.com", :body => {:a => "1", :b => "2"}).body.should == "ok"
+    end
+
+    it "should work with UTF-8 strings" do
+      body = "Привет, Мир!"
+      stub_request(:post, "www.example.com").to_return(:body => body)
+      http_request(:post, "http://www.example.com").body.bytesize.should == body.bytesize
+    end
+
+    describe "mocking EM::HttpClient API" do
+      let(:uri) { "http://www.example.com/" }
+
+      before do
+        stub_request(:get, uri)
+        WebMock::HttpLibAdapters::EmHttpRequestAdapter.enable!
+      end
+
+      def client(uri, options = {})
+        client = nil
+        EM.run do
+          client = EventMachine::HttpRequest.new(uri).get(options)
+          client.callback { EM.stop }
+          client.errback { failed }
+        end
+        client
+      end
+
+      subject { client(uri) }
+
+      it 'should support #uri' do
+        subject.uri.should == Addressable::URI.parse(uri)
+      end
+
+      it 'should support #last_effective_url' do
+        subject.last_effective_url.should == Addressable::URI.parse(uri)
+      end
+
+      context "with a query" do
+        let(:uri) { "http://www.example.com/?a=1&b=2" }
+        subject { client("http://www.example.com/?a=1", :query => { 'b' => 2 }) }
+
+        it "#request_signature doesn't mutate the original uri" do
+          subject.uri.should == Addressable::URI.parse("http://www.example.com/?a=1")
+          subject.request_signature.uri.should == Addressable::URI.parse(uri)
+        end
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/em_http_request/em_http_request_spec_helper.rb

@@ -0,0 +1,72 @@
+module EMHttpRequestSpecHelper
+
+  def failed
+    EventMachine.stop
+    fail
+  end
+
+  def http_request(method, uri, options = {}, &block)
+    @http = nil
+    head = options[:headers] || {}
+    response = nil
+    error = nil
+    error_set = false
+    uri = Addressable::URI.heuristic_parse(uri)
+    EventMachine.run {
+      request = EventMachine::HttpRequest.new("#{uri.normalize.to_s}")
+      http = request.send(method, {
+        :timeout => 30,
+        :body => options[:body],
+        :query => options[:query],
+        :head => head.merge('authorization' => [uri.user, uri.password])
+      }, &block)
+      http.errback {
+        error_set = true
+        error = if http.respond_to?(:errors)
+          http.errors
+        else
+          http.error
+        end
+        failed
+      }
+      http.callback {
+        response = OpenStruct.new({
+          :body => http.response,
+          :headers => WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),
+          :message => http.response_header.http_reason,
+          :status => http.response_header.status.to_s
+        })
+        EventMachine.stop
+      }
+      @http = http
+    }
+    raise error.to_s if error_set
+    response
+  end
+
+  def client_timeout_exception_class
+    "WebMock timeout error"
+  end
+
+  def connection_refused_exception_class
+    RuntimeError
+  end
+
+  def http_library
+    :em_http_request
+  end
+
+  private
+
+  def extract_response_headers(http)
+    headers = {}
+    if http.response_header
+      http.response_header.each do |k,v|
+        v = v.join(", ") if v.is_a?(Array)
+        headers[k] = v
+      end
+    end
+    headers
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/excon/excon_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+require 'acceptance/excon/excon_spec_helper'
+
+describe "Excon" do
+  include ExconSpecHelper
+  include_context "with WebMock", :no_status_message, :no_url_auth
+
+  it 'should allow Excon requests to use query hash paramters' do
+    stub_request(:get, "http://example.com/resource/?a=1&b=2").to_return(:body => "abc")
+    Excon.get('http://example.com', :path => "resource/", :query => {:a => 1, :b => 2}).body.should == "abc"
+  end
+
+end
+

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/excon/excon_spec_helper.rb

@@ -0,0 +1,38 @@
+require 'ostruct'
+
+module ExconSpecHelper
+
+  def http_request(method, uri, options = {}, &block)
+    Excon.defaults[:ssl_verify_peer] = false
+    uri      = Addressable::URI.heuristic_parse(uri)
+    uri      = uri.omit(:userinfo).to_s.gsub(' ', '+')
+
+    options  = options.merge(:method => method) # Dup and merge
+    response = Excon.new(uri).request(options, &block)
+
+    headers  = WebMock::Util::Headers.normalize_headers(response.headers)
+    headers  = headers.inject({}) do |res, (name, value)|
+      res[name] = value.is_a?(Array) ? value.flatten.join(', ') : value
+      res
+    end
+
+    OpenStruct.new \
+      :body => response.body,
+      :headers => headers,
+      :status  => response.status.to_s,
+      :message => ""
+  end
+
+  def client_timeout_exception_class
+    Excon::Errors::Timeout
+  end
+
+  def connection_refused_exception_class
+    Excon::Errors::SocketError
+  end
+
+  def http_library
+    :excon
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/httpclient/httpclient_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+require 'ostruct'
+
+require 'acceptance/httpclient/httpclient_spec_helper'
+
+describe "HTTPClient" do
+  include HTTPClientSpecHelper
+
+  before(:each) do
+    HTTPClientSpecHelper.async_mode = false
+  end
+
+  include_examples "with WebMock"
+
+  it "should yield block on response if block provided" do
+    stub_request(:get, "www.example.com").to_return(:body => "abc")
+    response_body = ""
+    http_request(:get, "http://www.example.com/") do |body|
+      response_body = body
+    end
+    response_body.should == "abc"
+  end
+
+  it "should match requests if headers are the same  but in different order" do
+    stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]} )
+    http_request(
+      :get, "http://www.example.com/",
+    :headers => {"a" => ["c", "b"]}).status.should == "200"
+  end
+
+  describe "when using async requests" do
+    before(:each) do
+      HTTPClientSpecHelper.async_mode = true
+    end
+
+    include_examples "with WebMock"
+  end
+
+  it "should work with get_content" do
+    stub_request(:get, 'www.example.com').to_return(:status => 200, :body => 'test', :headers => {})
+    str = ''
+    HTTPClient.get_content('www.example.com') do |content|
+      str << content
+    end
+    str.should == 'test'
+  end
+
+  context "Filters" do
+    class Filter
+      def filter_request(request)
+        request.header["Authorization"] = "Bearer 0123456789"
+      end
+
+      def filter_response(request, response)
+        response.header.set('X-Powered-By', 'webmock')
+      end
+    end
+
+    before do
+      @client = HTTPClient.new
+      @client.request_filter << Filter.new
+      stub_request(:get, 'www.example.com').with(:headers => {'Authorization' => 'Bearer 0123456789'})
+    end
+
+    it "supports request filters" do
+      @client.request(:get, 'http://www.example.com/').status.should == 200
+    end
+
+    it "supports response filters" do
+      res = @client.request(:get, 'http://www.example.com/')
+      res.header['X-Powered-By'].first.should == 'webmock'
+    end
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/httpclient/httpclient_spec_helper.rb

@@ -0,0 +1,48 @@
+module HTTPClientSpecHelper
+  class << self
+    attr_accessor :async_mode
+  end
+
+  def http_request(method, uri, options = {}, &block)
+    uri = Addressable::URI.heuristic_parse(uri)
+    c = HTTPClient.new
+    c.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    c.set_basic_auth(nil, uri.user, uri.password) if uri.user
+    params = [method, "#{uri.omit(:userinfo, :query).normalize.to_s}",
+      uri.query_values, options[:body], options[:headers] || {}]
+    if HTTPClientSpecHelper.async_mode
+      connection = c.request_async(*params)
+      connection.join
+      response = connection.pop
+    else
+      response = c.request(*params, &block)
+    end
+    headers = response.header.all.inject({}) do |headers, header|
+      if !headers.has_key?(header[0])
+        headers[header[0]] = header[1]
+      else
+        headers[header[0]] = [headers[header[0]], header[1]].join(', ')
+      end
+      headers
+    end
+    OpenStruct.new({
+      :body => HTTPClientSpecHelper.async_mode ? response.content.read : response.content,
+      :headers => headers,
+      :status => response.code.to_s,
+      :message => response.reason
+    })
+  end
+
+  def client_timeout_exception_class
+    HTTPClient::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    Errno::ECONNREFUSED
+  end
+
+  def http_library
+    :httpclient
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/net_http/net_http_shared.rb

@@ -0,0 +1,125 @@
+shared_examples_for "Net::HTTP" do
+  describe "when making real requests", :net_connect => true do
+    let(:port){ WebMockServer.instance.port }
+
+    before(:each) do
+      @http = Net::HTTP.new("localhost", port)
+    end
+
+    it "should return a Net::ReadAdapter from response.body when a real request is made with a block and #read_body", :net_connect => true do
+      response = Net::HTTP.new("localhost", port).request_get('/') { |r| r.read_body { } }
+      response.body.should be_a(Net::ReadAdapter)
+    end
+
+    it "should handle requests with block passed to read_body", :net_connect => true do
+      body = ""
+      req = Net::HTTP::Get.new("/")
+      Net::HTTP.start("localhost", port) do |http|
+        http.request(req) do |res|
+          res.read_body do |str|
+            body << str
+          end
+        end
+      end
+      body.should =~ /hello world/
+    end
+
+    it "should connect only once when connected on start", :net_connect => true do
+      @http = Net::HTTP.new('localhost', port)
+      socket_id_before_request = socket_id_after_request = nil
+      @http.start {|conn|
+        socket_id_before_request = conn.instance_variable_get(:@socket).object_id
+        conn.request(Net::HTTP::Get.new("/"))
+        socket_id_after_request = conn.instance_variable_get(:@socket).object_id
+      }
+      socket_id_after_request.should_not be_nil
+      socket_id_after_request.should == socket_id_before_request
+    end
+
+    describe "without start" do
+      it "should close connection after a real request" do
+        @http.get('/') { }
+        @http.should_not be_started
+      end
+
+      it "should execute block exactly once" do
+        times = 0
+        @http.get('/') { times += 1 }
+        times.should == 1
+      end
+
+      it "should have socket open during a real request" do
+        socket_id = nil
+        @http.get('/') {
+          socket_id = @http.instance_variable_get(:@socket).object_id
+        }
+        socket_id.should_not be_nil
+      end
+
+      it "should be started during a real request" do
+        started = nil
+        @http.get('/') {
+          started = @http.started?
+        }
+        started.should == true
+        @http.started?.should == false
+      end
+    end
+
+    describe "with start" do
+      it "should close connection after a real request" do
+        @http.start {|conn| conn.get('/') { } }
+        @http.should_not be_started
+      end
+
+      it "should execute block exactly once" do
+        times = 0
+        @http.start {|conn| conn.get('/') { times += 1 }}
+        times.should == 1
+      end
+
+      it "should have socket open during a real request" do
+        socket_id = nil
+        @http.start {|conn| conn.get('/') {
+            socket_id = conn.instance_variable_get(:@socket).object_id
+          }
+        }
+        socket_id.should_not be_nil
+      end
+
+      it "should be started during a real request" do
+        started = nil
+        @http.start {|conn| conn.get('/') {
+            started = conn.started?
+          }
+        }
+        started.should == true
+        @http.started?.should == false
+      end
+    end
+
+    describe "with start without request block" do
+      it "should close connection after a real request" do
+        @http.start {|conn| conn.get('/') }
+        @http.should_not be_started
+      end
+
+      it "should have socket open during a real request" do
+        socket_id = nil
+        @http.start {|conn|
+          socket_id = conn.instance_variable_get(:@socket).object_id
+        }
+        socket_id.should_not be_nil
+      end
+
+      it "should be started during a real request" do
+        started = nil
+        @http.start {|conn|
+          started = conn.started?
+        }
+        started.should == true
+        @http.started?.should == false
+      end
+    end
+  end
+end