httparty 0.16.2 → 0.20.0

data/spec/spec_helper.rb

@@ -1,51 +0,0 @@
-require "simplecov"
-SimpleCov.start
-
-require "httparty"
-require 'webmock/rspec'
-
-def file_fixture(filename)
-  open(File.join(File.dirname(__FILE__), 'fixtures', "#{filename}")).read
-end
-
-Dir[File.expand_path(File.join(File.dirname(__FILE__), 'support', '**', '*.rb'))].each {|f| require f}
-
-RSpec.configure do |config|
-  config.include HTTParty::StubResponse
-  config.include HTTParty::SSLTestHelper
-
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = false
-  end
-
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  config.disable_monkey_patching!
-
-  config.warnings = true
-
-  if config.files_to_run.one?
-    config.default_formatter = 'doc'
-  end
-
-  config.profile_examples = 10
-
-  config.order = :random
-
-  Kernel.srand config.seed
-end
-
-RSpec::Matchers.define :use_ssl do
-  match(&:use_ssl?)
-end
-
-RSpec::Matchers.define :use_cert_store do |cert_store|
-  match do |connection|
-    connection.cert_store == cert_store
-  end
-end

data/spec/support/ssl_test_helper.rb

@@ -1,47 +0,0 @@
-require 'pathname'
-
-module HTTParty
-  module SSLTestHelper
-    def ssl_verify_test(mode, ca_basename, server_cert_filename, options = {})
-      options = {
-        format:  :json,
-        timeout: 30
-      }.merge(options)
-
-      if mode
-        ca_path = File.expand_path("../../fixtures/ssl/generated/#{ca_basename}", __FILE__)
-        raise ArgumentError.new("#{ca_path} does not exist") unless File.exist?(ca_path)
-        options[mode] = ca_path
-      end
-
-      begin
-        test_server = SSLTestServer.new(
-            rsa_key: File.read(File.expand_path("../../fixtures/ssl/generated/server.key", __FILE__)),
-            cert:    File.read(File.expand_path("../../fixtures/ssl/generated/#{server_cert_filename}", __FILE__)))
-
-        test_server.start
-
-        if mode
-          ca_path = File.expand_path("../../fixtures/ssl/generated/#{ca_basename}", __FILE__)
-          raise ArgumentError.new("#{ca_path} does not exist") unless File.exist?(ca_path)
-          return HTTParty.get("https://localhost:#{test_server.port}/", options)
-        else
-          return HTTParty.get("https://localhost:#{test_server.port}/", options)
-        end
-      ensure
-        test_server.stop if test_server
-      end
-
-      test_server = SSLTestServer.new({
-        rsa_key: path.join('server.key').read,
-        cert:    path.join(server_cert_filename).read
-      })
-
-      test_server.start
-
-      HTTParty.get("https://localhost:#{test_server.port}/", options)
-    ensure
-      test_server.stop if test_server
-    end
-  end
-end

data/spec/support/ssl_test_server.rb

@@ -1,80 +0,0 @@
-require 'openssl'
-require 'socket'
-require 'thread'
-
-# NOTE: This code is garbage.  It probably has deadlocks, it might leak
-# threads, and otherwise cause problems in a real system.  It's really only
-# intended for testing HTTParty.
-class SSLTestServer
-  attr_accessor :ctx    # SSLContext object
-  attr_reader :port
-
-  def initialize(options = {})
-    @ctx             = OpenSSL::SSL::SSLContext.new
-    @ctx.cert        = OpenSSL::X509::Certificate.new(options[:cert])
-    @ctx.key         = OpenSSL::PKey::RSA.new(options[:rsa_key])
-    @ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE   # Don't verify client certificate
-    @port            = options[:port] || 0
-    @thread          = nil
-    @stopping_mutex  = Mutex.new
-    @stopping        = false
-  end
-
-  def start
-    @raw_server = TCPServer.new(@port)
-
-    if @port == 0
-      @port = Socket.getnameinfo(@raw_server.getsockname, Socket::NI_NUMERICHOST | Socket::NI_NUMERICSERV)[1].to_i
-    end
-
-    @ssl_server = OpenSSL::SSL::SSLServer.new(@raw_server, @ctx)
-
-    @stopping_mutex.synchronize {
-      return if @stopping
-      @thread = Thread.new { thread_main }
-    }
-
-    nil
-  end
-
-  def stop
-    @stopping_mutex.synchronize {
-      return if @stopping
-      @stopping = true
-    }
-    @thread.join
-  end
-
-  private
-
-  def thread_main
-    until @stopping_mutex.synchronize { @stopping }
-      (rr, _, _) = select([@ssl_server.to_io], nil, nil, 0.1)
-
-      next unless rr && rr.include?(@ssl_server.to_io)
-
-      socket = @ssl_server.accept
-
-      Thread.new {
-        header = []
-
-        until (line = socket.readline).rstrip.empty?
-          header << line
-        end
-
-        response = <<EOF
-HTTP/1.1 200 OK
-Connection: close
-Content-Type: application/json; charset=UTF-8
-
-{"success":true}
-EOF
-
-        socket.write(response.gsub(/\r\n/n, "\n").gsub(/\n/n, "\r\n"))
-        socket.close
-      }
-    end
-
-    @ssl_server.close
-  end
-end

data/spec/support/stub_response.rb

@@ -1,49 +0,0 @@
-module HTTParty
-  module StubResponse
-    def stub_http_response_with(filename)
-      format = filename.split('.').last.intern
-      data = file_fixture(filename)
-
-      response = Net::HTTPOK.new("1.1", 200, "Content for you")
-      allow(response).to receive(:body).and_return(data)
-
-      http_request = HTTParty::Request.new(Net::HTTP::Get, 'http://localhost', format: format)
-      allow(http_request).to receive_message_chain(:http, :request).and_return(response)
-
-      expect(HTTParty::Request).to receive(:new).and_return(http_request)
-    end
-
-    def stub_chunked_http_response_with(chunks, options = {format: "html"})
-      response = Net::HTTPResponse.new("1.1", 200, nil)
-      allow(response).to receive(:chunked_data).and_return(chunks)
-      def response.read_body(&block)
-        @body || chunked_data.each(&block)
-      end
-
-      http_request = HTTParty::Request.new(Net::HTTP::Get, 'http://localhost', options)
-      allow(http_request).to receive_message_chain(:http, :request).and_yield(response).and_return(response)
-
-      expect(HTTParty::Request).to receive(:new).and_return(http_request)
-    end
-
-    def stub_response(body, code = '200')
-      code = code.to_s
-      @request.options[:base_uri] ||= 'http://localhost'
-      unless defined?(@http) && @http
-        @http = Net::HTTP.new('localhost', 80)
-        allow(@request).to receive(:http).and_return(@http)
-      end
-
-      # CODE_TO_OBJ currently missing 308
-      if code == '308'
-        response = Net::HTTPRedirection.new("1.1", code, body)
-      else
-        response = Net::HTTPResponse::CODE_TO_OBJ[code].new("1.1", code, body)
-      end
-      allow(response).to receive(:body).and_return(body)
-
-      allow(@http).to receive(:request).and_return(response)
-      response
-    end
-  end
-end