simple-client 0.0.2

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

@@ -0,0 +1,255 @@
+require 'spec_helper'
+require 'ostruct'
+require 'acceptance/webmock_shared'
+require 'acceptance/net_http/net_http_spec_helper'
+require 'acceptance/net_http/net_http_shared'
+
+include NetHTTPSpecHelper
+
+describe "Net:HTTP" do
+  include_examples "with WebMock"
+
+  let(:port){ WebMockServer.instance.port }
+
+  describe "marshalling" do
+    class TestMarshalingInWebMockNetHTTP
+      attr_accessor :r
+    end
+    before(:each) do
+      @b = TestMarshalingInWebMockNetHTTP.new
+    end
+    after(:each) do
+      WebMock.enable!
+    end
+    it "should be possible to load object marshalled when webmock was disabled" do
+      WebMock.disable!
+      original_constants = [
+        Net::HTTP::Get,
+        Net::HTTP::Post,
+        Net::HTTP::Put,
+        Net::HTTP::Delete,
+        Net::HTTP::Head,
+        Net::HTTP::Options
+      ]
+      @b.r = original_constants
+      original_serialized = Marshal.dump(@b)
+      Marshal.load(original_serialized)
+      WebMock.enable!
+      Marshal.load(original_serialized)
+    end
+
+    it "should be possible to load object marshalled when webmock was enabled"  do
+      WebMock.enable!
+      new_constants = [
+        Net::HTTP::Get,
+        Net::HTTP::Post,
+        Net::HTTP::Put,
+        Net::HTTP::Delete,
+        Net::HTTP::Head,
+        Net::HTTP::Options
+      ]
+      @b.r = new_constants
+      new_serialized = Marshal.dump(@b)
+      Marshal.load(new_serialized)
+      WebMock.disable!
+      Marshal.load(new_serialized)
+    end
+  end
+
+  describe "constants" do
+    it "should still have const Get defined on replaced Net::HTTP" do
+      Object.const_get("Net").const_get("HTTP").const_defined?("Get").should be_true
+    end
+
+    it "should still have const Get within constants on replaced Net::HTTP" do
+      Object.const_get("Net").const_get("HTTP").constants.map(&:to_s).should include("Get")
+    end
+
+    it "should still have const Get within constants on replaced Net::HTTP" do
+      Object.const_get("Net").const_get("HTTP").const_get("Get").should_not be_nil
+    end
+
+    if Module.method(:const_defined?).arity != 1
+      it "should still have const Get defined (and not inherited) on replaced Net::HTTP" do
+        Object.const_get("Net").const_get("HTTP").const_defined?("Get", false).should be_true
+      end
+    end
+
+    if Module.method(:const_get).arity != 1
+      it "should still be able to get non inherited constant Get on replaced Net::HTTP" do
+        Object.const_get("Net").const_get("HTTP").const_get("Get", false).should_not be_nil
+      end
+    end
+
+    if Module.method(:constants).arity != 0
+      it "should still Get within non inherited constants on replaced Net::HTTP" do
+        Object.const_get("Net").const_get("HTTP").constants(false).map(&:to_s).should include("Get")
+      end
+    end
+  end
+
+  it "should work with block provided" do
+    stub_http_request(:get, "www.example.com").to_return(:body => "abc"*100000)
+    Net::HTTP.start("www.example.com") { |query| query.get("/") }.body.should == "abc"*100000
+  end
+
+  it "should handle multiple values for the same response header" do
+    stub_http_request(:get, "www.example.com").to_return(:headers => { 'Set-Cookie' => ['foo=bar', 'bar=bazz'] })
+    response = Net::HTTP.get_response(URI.parse("http://www.example.com/"))
+    response.get_fields('Set-Cookie').should == ['bar=bazz', 'foo=bar']
+  end
+
+  it "should yield block on response" do
+    stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+    response_body = ""
+    http_request(:get, "http://www.example.com/") do |response|
+      response_body = response.body
+    end
+    response_body.should == "abc"
+  end
+
+  it "should handle Net::HTTP::Post#body" do
+    stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
+    req = Net::HTTP::Post.new("/")
+    req.body = "my_params"
+    Net::HTTP.start("www.example.com") { |http| http.request(req)}.body.should == "abc"
+  end
+
+  it "should handle Net::HTTP::Post#body_stream" do
+    stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
+    req = Net::HTTP::Post.new("/")
+    req.body_stream = StringIO.new("my_params")
+    Net::HTTP.start("www.example.com") { |http| http.request(req)}.body.should == "abc"
+  end
+
+  it "should behave like Net::HTTP and raise error if both request body and body argument are set" do
+    stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
+    req = Net::HTTP::Post.new("/")
+    req.body = "my_params"
+    lambda {
+      Net::HTTP.start("www.example.com") { |http| http.request(req, "my_params")}
+    }.should raise_error("both of body argument and HTTPRequest#body set")
+  end
+
+  it "should return a Net::ReadAdapter from response.body when a stubbed request is made with a block and #read_body" do
+    WebMock.stub_request(:get, 'http://example.com/').to_return(:body => "the body")
+    response = Net::HTTP.new('example.com', 80).request_get('/') { |r| r.read_body { } }
+    response.body.should be_a(Net::ReadAdapter)
+  end
+
+  it "should have request 1 time executed in registry after 1 real request", :net_connect => true do
+    WebMock.allow_net_connect!
+    http = Net::HTTP.new('localhost', port)
+    http.get('/') {}
+    WebMock::RequestRegistry.instance.requested_signatures.hash.size.should == 1
+    WebMock::RequestRegistry.instance.requested_signatures.hash.values.first.should == 1
+  end
+
+  describe "connecting on Net::HTTP.start" do
+    before(:each) do
+      @http = Net::HTTP.new('www.google.com', 443)
+      @http.use_ssl = true
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+    describe "when net http is allowed" do
+      it "should not connect to the server until the request", :net_connect => true do
+        WebMock.allow_net_connect!
+        @http.start {|conn|
+          conn.peer_cert.should be_nil
+        }
+      end
+
+      it "should connect to the server on start", :net_connect => true do
+        WebMock.allow_net_connect!(:net_http_connect_on_start => true)
+        @http.start {|conn|
+          cert = OpenSSL::X509::Certificate.new conn.peer_cert
+          cert.should be_a(OpenSSL::X509::Certificate)
+        }
+      end
+
+    end
+
+    describe "when net http is disabled and allowed only for some hosts" do
+      it "should not connect to the server until the request", :net_connect => true do
+        WebMock.disable_net_connect!(:allow => "www.google.com")
+        @http.start {|conn|
+          conn.peer_cert.should be_nil
+        }
+      end
+
+      it "should connect to the server on start", :net_connect => true do
+        WebMock.disable_net_connect!(:allow => "www.google.com", :net_http_connect_on_start => true)
+        @http.start {|conn|
+          cert = OpenSSL::X509::Certificate.new conn.peer_cert
+          cert.should be_a(OpenSSL::X509::Certificate)
+        }
+      end
+
+      it "should connect to the server if the URI matches an regex", :net_connect => true do
+        WebMock.disable_net_connect!(:allow => /google.com/)
+        response = Net::HTTP.get('www.google.com','/')
+      end
+
+    end
+
+  end
+
+  describe "when net_http_connect_on_start is true" do
+    before(:each) do
+      WebMock.allow_net_connect!(:net_http_connect_on_start => true)
+    end
+    it_should_behave_like "Net::HTTP"
+  end
+
+  describe "when net_http_connect_on_start is false" do
+    before(:each) do
+      WebMock.allow_net_connect!(:net_http_connect_on_start => false)
+    end
+    it_should_behave_like "Net::HTTP"
+  end
+
+  describe 'after_request callback support', :net_connect => true do
+    let(:expected_body_regex) { /hello world/ }
+
+    before(:each) do
+      WebMock.allow_net_connect!
+      @callback_invocation_count = 0
+      WebMock.after_request do |_, response|
+        @callback_invocation_count += 1
+        @callback_response = response
+      end
+    end
+
+    after(:each) do
+      WebMock.reset_callbacks
+    end
+
+    def perform_get_with_returning_block
+      http_request(:get, "http://localhost:#{port}/") do |response|
+        return response.body
+      end
+    end
+
+    it "should support the after_request callback on an request with block and read_body" do
+      response_body = ''
+      http_request(:get, "http://localhost:#{port}/") do |response|
+        response.read_body { |fragment| response_body << fragment }
+      end
+      response_body.should =~ expected_body_regex
+
+      @callback_response.body.should == response_body
+    end
+
+    it "should support the after_request callback on a request with a returning block" do
+      response_body = perform_get_with_returning_block
+      response_body.should =~ expected_body_regex
+      @callback_response.should be_instance_of(WebMock::Response)
+      @callback_response.body.should == response_body
+    end
+
+    it "should only invoke the after_request callback once, even for a recursive post request" do
+      Net::HTTP.new('localhost', port).post('/', nil)
+      @callback_invocation_count.should == 1
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module NetHTTPSpecHelper
+  def http_request(method, uri, options = {}, &block)
+    begin
+      uri = URI.parse(uri)
+    rescue
+      uri = Addressable::URI.heuristic_parse(uri)
+    end
+    response = nil
+    clazz = Net::HTTP.const_get("#{method.to_s.capitalize}")
+    req = clazz.new("#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", nil)
+    options[:headers].each do |k,v|
+      if v.is_a?(Array)
+        v.each_with_index do |v,i|
+          i == 0 ? (req[k] = v) : req.add_field(k, v)
+        end
+      else
+        req[k] = v
+      end
+    end if options[:headers]
+
+    req.basic_auth uri.user, uri.password if uri.user
+    http = Net::HTTP.new(uri.host, uri.port)
+    if uri.scheme == "https"
+      http.use_ssl = true
+      #1.9.1 has a bug with ssl_timeout
+      http.ssl_timeout = 20 unless RUBY_PLATFORM =~ /java/
+      http.open_timeout = 60
+      http.read_timeout = 60
+    end
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    response = http.start {|http|
+      http.request(req, options[:body], &block)
+    }
+    headers = {}
+    response.each_header {|name, value| headers[name] = value}
+    OpenStruct.new({
+      :body => response.body,
+      :headers => WebMock::Util::Headers.normalize_headers(headers),
+      :status => response.code,
+      :message => response.message
+    })
+  end
+
+  def client_timeout_exception_class
+    Timeout::Error
+  end
+
+  def connection_refused_exception_class
+    Errno::ECONNREFUSED
+  end
+
+  def http_library
+    :net_http
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'rspec'
+require 'net/http'
+require 'net/https'
+require 'stringio'
+require 'acceptance/net_http/net_http_shared'
+require 'support/webmock_server'
+
+describe "Real Net:HTTP without webmock", :without_webmock => true do
+  before(:all) do
+    raise "WebMock has no access here!!!" if defined?(WebMock::NetHTTPUtility)
+    WebMockServer.instance.start
+  end
+
+  after(:all) do
+    WebMockServer.instance.stop
+  end
+
+  it_should_behave_like "Net::HTTP"
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/patron/patron_spec.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+
+unless RUBY_PLATFORM =~ /java/
+  require 'acceptance/patron/patron_spec_helper'
+  require 'tmpdir'
+  require 'fileutils'
+
+  describe "Patron" do
+    include PatronSpecHelper
+
+    include_examples "with WebMock"
+
+    describe "when custom functionality is used" do
+      before(:each) do
+        @sess = Patron::Session.new
+        @sess.base_url = "http://www.example.com"
+      end
+
+      describe "file requests" do
+
+        before(:each) do
+          @dir_path = Dir.mktmpdir('webmock-')
+          @file_path = File.join(@dir_path, "webmock_temp_test_file")
+          FileUtils.rm_rf(@file_path) if File.exists?(@file_path)
+        end
+
+        after(:each) do
+          FileUtils.rm_rf(@dir_path) if File.exist?(@dir_path)
+        end
+
+
+        it "should work with get_file" do
+          stub_request(:get, "www.example.com").to_return(:body => "abc")
+          @sess.get_file("/", @file_path)
+          File.read(@file_path).should == "abc"
+        end
+
+        it "should raise same error as Patron if file is not readable for get request" do
+          stub_request(:get, "www.example.com")
+          File.open("/tmp/read_only_file", "w") do |tmpfile|
+            tmpfile.chmod(0400)
+          end
+          begin
+            lambda {
+              @sess.get_file("/", "/tmp/read_only_file")
+            }.should raise_error(ArgumentError, "Unable to open specified file.")
+          ensure
+            File.unlink("/tmp/read_only_file")
+          end
+        end
+
+        it "should work with put_file" do
+          File.open(@file_path, "w") {|f| f.write "abc"}
+          stub_request(:put, "www.example.com").with(:body => "abc")
+          @sess.put_file("/", @file_path)
+        end
+
+        it "should work with post_file" do
+          File.open(@file_path, "w") {|f| f.write "abc"}
+          stub_request(:post, "www.example.com").with(:body => "abc")
+          @sess.post_file("/", @file_path)
+        end
+
+        it "should raise same error as Patron if file is not readable for post request" do
+          stub_request(:post, "www.example.com").with(:body => "abc")
+          lambda {
+            @sess.post_file("/", "/path/to/non/existing/file")
+          }.should raise_error(ArgumentError, "Unable to open specified file.")
+        end
+
+      end
+
+      describe "handling errors same way as patron" do
+        it "should raise error if put request has neither upload_data nor file_name" do
+          stub_request(:post, "www.example.com")
+          lambda {
+            @sess.post("/", nil)
+          }.should raise_error(ArgumentError, "Must provide either data or a filename when doing a PUT or POST")
+        end
+      end
+
+      it "should work with WebDAV copy request" do
+        stub_request(:copy, "www.example.com/abc").with(:headers => {'Destination' => "/def"})
+        @sess.copy("/abc", "/def")
+      end
+
+      if /^1\.9/ === RUBY_VERSION
+        describe "handling encoding same way as patron" do
+          around(:each) do |example|
+            @encoding = Encoding.default_internal
+            Encoding.default_internal = "UTF-8"
+            example.run
+            Encoding.default_internal = @encoding
+          end
+
+          it "should encode body with default encoding" do
+            stub_request(:get, "www.example.com").
+              to_return(:body => "Øl")
+
+            @sess.get("").body.encoding.should == Encoding::UTF_8
+          end
+
+          it "should encode body to default internal" do
+            stub_request(:get, "www.example.com").
+              to_return(:headers => {'Content-Type' => 'text/html; charset=iso-8859-1'},
+                        :body => "Øl".encode("iso-8859-1"))
+
+            @sess.get("").body.encoding.should == Encoding.default_internal
+          end
+
+          it "should encode body based on encoding-attribute in body" do
+            stub_request(:get, "www.example.com").
+              to_return(:body => "<?xml encoding=\"iso-8859-1\">Øl</xml>".encode("iso-8859-1"))
+
+
+            @sess.get("").body.encoding.should == Encoding::ISO_8859_1
+          end
+
+
+          it "should encode body based on Session#default_response_charset" do
+            stub_request(:get, "www.example.com").
+              to_return(:body => "Øl".encode("iso-8859-1"))
+
+            @sess.default_response_charset = "iso-8859-1"
+
+            @sess.get("").body.encoding.should == Encoding::ISO_8859_1
+          end
+
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/patron/patron_spec_helper.rb

@@ -0,0 +1,50 @@
+require 'ostruct'
+
+module PatronSpecHelper
+  def http_request(method, uri, options = {}, &block)
+    uri = Addressable::URI.heuristic_parse(uri)
+    sess = Patron::Session.new
+    sess.base_url = "#{uri.omit(:userinfo, :path, :query).normalize.to_s}".gsub(/\/$/,"")
+    sess.username = uri.user
+    sess.password = uri.password
+
+    sess.connect_timeout = 30
+    sess.timeout = 30
+    sess.max_redirects = 0
+    uri = "#{uri.path}#{uri.query ? '?' : ''}#{uri.query}"
+    uri.gsub!(' ','+')
+    response = sess.request(method, uri, options[:headers] || {}, {
+      :data => options[:body]
+    })
+    headers = {}
+    if response.headers
+      response.headers.each do |k,v|
+        v = v.join(", ") if v.is_a?(Array)
+        headers[k] = v
+      end
+    end
+
+    status_line_pattern = %r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?)
+    message = response.status_line.match(status_line_pattern)[3] || ""
+
+    OpenStruct.new({
+      :body => response.body,
+      :headers => WebMock::Util::Headers.normalize_headers(headers),
+      :status => response.status.to_s,
+      :message => message
+    })
+  end
+
+  def client_timeout_exception_class
+    Patron::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    Patron::ConnectionFailed
+  end
+
+  def http_library
+    :patron
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/shared/allowing_and_disabling_net_connect.rb

@@ -0,0 +1,142 @@
+shared_context "allowing and disabling net connect" do |*adapter_info|
+  describe "when net connect" do
+    describe "is allowed", :net_connect => true do
+      before(:each) do
+        WebMock.allow_net_connect!
+      end
+
+      it "should make a real web request if request is not stubbed" do
+        http_request(:get, webmock_server_url).status.should == "200"
+      end
+
+      it "should make a real https request if request is not stubbed" do
+        unless http_library == :httpclient
+          http_request(:get, "https://www.google.com/").
+            body.should =~ /.*google.*/
+        end
+      end
+
+      it "should return stubbed response if request was stubbed" do
+        stub_request(:get, "www.example.com").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/").body.should == "abc"
+      end
+    end
+
+    describe "is not allowed" do
+      before(:each) do
+        WebMock.disable_net_connect!
+      end
+
+      it "should return stubbed response if request was stubbed" do
+        stub_request(:get, "www.example.com").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/").body.should == "abc"
+      end
+
+      it "should return stubbed response if request with path was stubbed" do
+        stub_request(:get, "www.example.com/hello_world").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/hello_world").body.should == "abc"
+      end
+
+      it "should raise exception if request was not stubbed" do
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+      end
+    end
+
+    describe "is not allowed with exception for localhost" do
+      before(:each) do
+        WebMock.disable_net_connect!(:allow_localhost => true)
+      end
+
+      it "should return stubbed response if request was stubbed" do
+        stub_request(:get, "www.example.com").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/").body.should == "abc"
+      end
+
+      it "should raise exception if request was not stubbed" do
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+      end
+
+      it "should make a real request to localhost" do
+        lambda {
+          http_request(:get, "http://localhost:12345/")
+        }.should raise_error(connection_refused_exception_class)
+      end
+
+      it "should make a real request to 127.0.0.1" do
+        lambda {
+          http_request(:get, "http://127.0.0.1:12345/")
+        }.should raise_error(connection_refused_exception_class)
+      end
+
+      it "should make a real request to 0.0.0.0" do
+        lambda {
+          http_request(:get, "http://0.0.0.0:12345/")
+        }.should raise_error(connection_refused_exception_class)
+      end
+    end
+
+    describe "is not allowed with exception for allowed domains" do
+      let(:host_with_port){ WebMockServer.instance.host_with_port }
+
+      before(:each) do
+        WebMock.disable_net_connect!(:allow => ["www.example.org", host_with_port])
+      end
+
+      context "when the host is not allowed" do
+        it "should return stubbed response if request was stubbed" do
+          stub_request(:get, "www.example.com").to_return(:body => "abc")
+          http_request(:get, "http://www.example.com/").body.should == "abc"
+        end
+
+        it "should raise exception if request was not stubbed" do
+          lambda {
+            http_request(:get, "http://www.example.com/")
+          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+        end
+      end
+
+      context "when the host with port is not allowed" do
+        it "should return stubbed response if request was stubbed" do
+          stub_request(:get, "http://localhost:2345").to_return(:body => "abc")
+          http_request(:get, "http://localhost:2345/").body.should == "abc"
+        end
+
+        it "should raise exception if request was not stubbed" do
+          lambda {
+            http_request(:get, "http://localhost:2345/")
+          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:2345/))
+        end
+      end
+
+      context "when the host is allowed" do
+        it "should raise exception if request was not stubbed" do
+          lambda {
+            http_request(:get, "http://www.example.com/")
+          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+        end
+
+        it "should make a real request to allowed host", :net_connect => true do
+          http_request(:get, "http://www.example.org/").status.should == "302"
+        end
+      end
+
+      context "when the host with port is allowed" do
+        it "should make a real request to allowed host", :net_connect => true do
+          http_request(:get, "http://#{host_with_port}/").status.should == "200"
+        end
+      end
+
+      context "when the host is allowed but not port" do
+        it "should make a real request to allowed host", :net_connect => true do
+          lambda {
+            http_request(:get, "http://localhost:123/")
+          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:123/))
+        end
+      end
+    end
+  end
+end