persistent_httparty 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0 - 2012-09-09
+
+* initial release

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Matt Campbell
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+[![Build Status](https://secure.travis-ci.org/soupmatt/persistent_httparty.png?branch=master)](http://travis-ci.org/soupmatt/persistent_httparty)
+
+# persistent_httparty
+
+Persistent HTTP connections for HTTParty!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'persistent_httparty'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install persistent_httparty
+
+## Requirements
+
+* [httparty](/jnunemaker/httparty) and [persistent_http](/bpardee/persistent_http)
+* You like to `Keep-Alive` the party!
+
+## Usage
+
+Just call `persistent_connection_adapter` and then use HTTParty as
+normal.
+
+```ruby
+class Twitter
+  include HTTParty
+  persistent_connection_adapter
+end
+```
+
+You can also pass in parameters to the `persistent_http` gem. The
+regular HTTParty config will be passed through as applicable.
+
+```ruby
+class MyCoolRestClient
+  include HTTParty
+  persistent_connection_adapter { :name => 'my_cool_rest_client',
+                                  :pool_size => 2,
+                                  :idle_timeout => 10,
+                                  :keep-alive => 30 }
+end
+```
+
+## License
+
+Distributed under the [MIT License](/soupmatt/persistent_httparty/blob/master/LICENSE)
+
+## Special Thanks
+
+* To @jnunemaker for maintaining a tight ship on the extremely useful
+[httparty](/jnunemaker/httparty)
+* To @bpardee for writing the best persistent http connection library
+  for ruby I've found in [persistent_http](/bpardee/persistent_http)
+* To @vibes for letting me open source as much of the work I do there
+  as possible.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/features/persistent_http_connections.feature

@@ -0,0 +1,13 @@
+Feature: Persistent HTTP Connections
+
+  Scenario:
+    Given I have an http end point "http://www.example.com/api/thing.json"
+    And I perform a "get" against that end point
+    And The end point returns "application/json"
+    """
+    {"name":"foo", "type":"thing"}
+    """
+    When I visit that end point with HTTParty
+    Then the parsed_response contains
+      | name | foo   |
+      | type | thing |

data/features/step_definitions/persistent_http_connections_steps.rb

@@ -0,0 +1,22 @@
+Given /^I have an http end point "(.*?)"$/ do |uri|
+  @web_request = WebRequest.new
+  @web_request.uri = uri
+end
+
+Given /^I perform a "(.*?)" against that end point$/ do |verb|
+  @web_request.verb = verb
+end
+
+Given /^The end point returns "(.*?)"$/ do |content_type, body|
+  @web_request.content_type = content_type
+  @web_request.response_body = body
+end
+
+When /^I visit that end point with HTTParty$/ do
+  @web_request.mock
+  @response = @web_request.perform
+end
+
+Then /^the parsed_response contains$/ do |table|
+  @response.parsed_response.should == table.rows_hash
+end

data/features/step_definitions/support/env.rb

@@ -0,0 +1 @@
+require 'persistent_httparty'

data/features/step_definitions/support/web_request.rb

@@ -0,0 +1,40 @@
+class TestHTTPartyClient
+  include HTTParty
+  persistent_connection_adapter
+end
+
+class WebRequest
+  include WebMock::API
+
+  attr_accessor :uri, :verb, :content_type, :request_body, :response_body
+
+  def initialize
+    @uri = 'http://www.example.com/'
+    @verb = :get
+    @content_type = 'text/plain'
+    @response_body = 'Hello!'
+  end
+
+  def verb=(arg)
+    unless arg.is_a? Symbol
+      @verb = arg.to_s.downcase.to_sym
+    else
+      @verb = arg
+    end
+  end
+
+  VALID_VERBS = %w(get head post put delete patch options).collect { |v| v.to_sym }
+
+  def mock
+    stub_request(verb, uri).to_return(:body => response_body, :headers => {:content_type => content_type})
+  end
+
+  def perform
+    case verb
+    when :get
+      TestHTTPartyClient.get(uri)
+    else
+      raise "#{verb} is not a supported HTTP verb"
+    end
+  end
+end

data/features/support/env.rb

@@ -0,0 +1 @@
+require 'webmock/cucumber'

data/lib/httparty/persistent.rb

@@ -0,0 +1,15 @@
+require 'httparty'
+
+module HTTParty::Persistent
+  module ClassMethods
+    def persistent_connection_adapter(opts={})
+      connection_adapter(HTTParty::Persistent::ConnectionAdapter.new, opts)
+    end
+  end
+end
+
+HTTParty::ClassMethods.module_exec do
+  include HTTParty::Persistent::ClassMethods
+end
+
+require 'httparty/persistent/connection_adapter'

data/lib/httparty/persistent/connection_adapter.rb

@@ -0,0 +1,34 @@
+require 'persistent_http'
+
+module HTTParty::Persistent
+  class ConnectionAdapter
+
+    attr_accessor :persistent_http
+
+    def call(uri, options)
+      if @persistent_http.nil?
+        @persistent_http = build_persistent_http(uri, options)
+      end
+      @persistent_http
+    end
+
+    def build_persistent_http(uri, options)
+      opts = {:url => uri}
+      opts.merge!(options[:connection_adapter_options]) if options[:connection_adapter_options]
+      if options[:timeout] && (options[:timeout].is_a?(Integer) || options[:timeout].is_a?(Float))
+        opts.merge!(:read_timeout => options[:timeout], :open_timeout => options[:timeout])
+      end
+      opts.merge!(:debug_output => options[:debug_output]) if options[:debug_output]
+
+      if options[:http_proxyaddr]
+        proxy_opts = {:host => options[:http_proxyaddr]}
+        proxy_opts[:port] = options[:http_proxyport] if options[:http_proxyport]
+        opts[:proxy] = URI::HTTP.build(proxy_opts)
+        opts[:proxy].user = options[:http_proxyuser] if options[:http_proxyuser]
+        opts[:proxy].password = options[:http_proxypass] if options[:http_proxypass]
+      end
+
+      PersistentHTTP.new(opts)
+    end
+  end
+end

data/lib/persistent_httparty.rb

@@ -0,0 +1,2 @@
+require "persistent_httparty/version"
+require "httparty/persistent"

data/lib/persistent_httparty/version.rb

@@ -0,0 +1,3 @@
+module PersistentHttparty
+  VERSION = "0.1.0"
+end

data/spec/lib/httparty/persistent/connection_adapter_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe HTTParty::Persistent::ConnectionAdapter do
+  let(:uri) { URI 'http://foo.com:8085' }
+  let(:connection_adapter_options) { {} }
+  let(:options) { {:connection_adapter_options => connection_adapter_options} }
+  let!(:adapter) { HTTParty::Persistent::ConnectionAdapter.new }
+  subject { adapter }
+
+  describe "#call" do
+    subject { adapter.call(uri, options) }
+
+    it "returns a PersistentHTTP" do
+      subject.should be_a PersistentHTTP
+    end
+
+    it "returns the same PersistentHTTP across calls" do
+      adapter.call(uri, options).should be subject
+    end
+
+    describe "the resulting PersistentHTTP" do
+      subject { adapter.call(uri, options) }
+
+      it { should_not be_nil }
+      it { should be_instance_of PersistentHTTP }
+      its(:host) { should == uri.host }
+      its(:port) { should == uri.port }
+
+      it "is the same across multiple calls" do
+        adapter.call(uri, options).should be subject
+        adapter.call(uri, options).should be subject
+      end
+
+      context "when dealing with ssl" do
+        Spec::Matchers.define :use_ssl do
+          match do |connection|
+            connection.use_ssl
+          end
+        end
+
+        context "using port 443 for ssl" do
+          let(:uri) { URI 'https://api.foo.com/v1:443' }
+          it { should use_ssl }
+        end
+
+        context "using port 80" do
+          let(:uri) { URI 'http://foobar.com' }
+          it { should_not use_ssl }
+        end
+
+        context "https scheme with default port" do
+          let(:uri) { URI 'https://foobar.com' }
+          it { should use_ssl }
+        end
+
+        context "https scheme with non-standard port" do
+          let(:uri) { URI 'https://foobar.com:123456' }
+          it { should use_ssl }
+        end
+      end
+
+      context "when setting timeout" do
+        context "to 5 seconds" do
+          let(:options) { {:timeout => 5} }
+
+          its(:open_timeout) { should == 5 }
+          its(:read_timeout) { should == 5 }
+        end
+
+        context "and timeout is a string" do
+          let(:options) { {:timeout => "five seconds"} }
+
+          it "doesn't set the timeout" do
+            subject.open_timeout.should be_nil
+            subject.read_timeout.should be_nil
+          end
+        end
+      end
+
+      context "when debug_output" do
+        context "is set to $stderr" do
+          let(:options) { {:debug_output => $stderr} }
+          it "has debug output set" do
+            subject.debug_output.should == $stderr
+          end
+        end
+
+        context "is not provided" do
+          let(:options) { {} }
+          it "does not set_debug_output" do
+            subject.debug_output.should be_nil
+          end
+        end
+      end
+
+      context 'when providing proxy address and port' do
+        let(:options) { {:http_proxyaddr => '1.2.3.4', :http_proxyport => 8080} }
+
+        its(:proxy_uri) { should == URI.parse('http://1.2.3.4:8080') }
+
+        context 'as well as proxy user and password' do
+          let(:options) do
+            {:http_proxyaddr => '1.2.3.4', :http_proxyport => 8080,
+             :http_proxyuser => 'user', :http_proxypass => 'pass'}
+          end
+          its(:proxy_uri) do
+            uri = URI.parse('http://1.2.3.4:8080')
+            uri.user = 'user'
+            uri.password = 'pass'
+            should == uri
+          end
+        end
+      end
+
+      context "when providing PEM certificates", :pending => true do
+        let(:pem) { :pem_contents }
+        let(:options) { {:pem => pem, :pem_password => "password"} }
+
+        context "when scheme is https" do
+          let(:uri) { URI 'https://google.com' }
+          let(:cert) { mock("OpenSSL::X509::Certificate") }
+          let(:key) { mock("OpenSSL::PKey::RSA") }
+
+          before do
+            OpenSSL::X509::Certificate.should_receive(:new).with(pem).and_return(cert)
+            OpenSSL::PKey::RSA.should_receive(:new).with(pem, "password").and_return(key)
+          end
+
+          it "uses the provided PEM certificate " do
+            subject.cert.should == cert
+            subject.key.should == key
+          end
+
+          it "will verify the certificate" do
+            subject.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+          end
+        end
+
+        context "when scheme is not https" do
+          let(:uri) { URI 'http://google.com' }
+          let(:http) { Net::HTTP.new(uri) }
+
+          before do
+            Net::HTTP.stub(:new => http)
+            OpenSSL::X509::Certificate.should_not_receive(:new).with(pem)
+            OpenSSL::PKey::RSA.should_not_receive(:new).with(pem, "password")
+            http.should_not_receive(:cert=)
+            http.should_not_receive(:key=)
+          end
+
+          it "has no PEM certificate " do
+            subject.cert.should be_nil
+            subject.key.should be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/httparty/persistent_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe HTTParty::Persistent do
+  let!(:klass) { Class.new }
+  before(:each) do
+    klass.instance_eval { include HTTParty }
+  end
+
+  describe HTTParty do
+    it "includes HTTParty::Persistent" do
+      HTTParty::ClassMethods.should include_module(HTTParty::Persistent::ClassMethods)
+    end
+
+    context "across multiple requests" do
+      let(:base_uri) { URI 'http://example.com' }
+
+      it "reuses the same http connection" do
+        http = Net::HTTP.new(base_uri.host, base_uri.port)
+        Net::HTTP.should_receive(:new).once().and_return(http)
+
+        stub_request(:get, "#{base_uri.to_s}/status").
+          to_return(:status => 200, :body => "", :headers => {})
+
+        stub_request(:get, "#{base_uri.to_s}/info").
+          to_return(:status => 200, :body => "", :headers => {})
+
+        klass.base_uri base_uri.to_s
+        klass.persistent_connection_adapter
+
+        klass.get('/status')
+        klass.get('/info')
+      end
+    end
+  end
+
+  describe "#persistent_connection_adapter" do
+    before(:each) { klass.persistent_connection_adapter }
+
+    it "sets the connection_adapter to HTTParty::Persistent::ConnectionAdapter" do
+      klass.connection_adapter.should be_a HTTParty::Persistent::ConnectionAdapter
+    end
+
+    context "with connection_adapter_options" do
+      let(:connection_adapter_options) { {:foo => :bar} }
+      before(:each) { klass.persistent_connection_adapter(connection_adapter_options) }
+
+      it "sets the connection_adapter_options that are passed to it" do
+        klass.default_options[:connection_adapter_options].should == connection_adapter_options
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'persistent_httparty'
+require 'webmock/rspec'
+
+app_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+Dir[File.join(app_root, "spec/support/**/*.rb")].each {|f| require f}
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/matchers.rb

@@ -0,0 +1,11 @@
+RSpec::Matchers.define :include_module do |module_to_include|
+  match do |subject|
+    subject.include? module_to_include
+  end
+end
+
+RSpec::Matchers.define :define_instance_variable do |instance_variable|
+  match do |subject|
+    subject.instance_variable_defined? instance_variable
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: persistent_httparty
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Matt Campbell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: persistent_http
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Persistent HTTP connections for HTTParty using the persistent_http gem.
+  Keep the party alive!
+email:
+- persistent_httparty@soupmatt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/httparty/persistent.rb
+- lib/httparty/persistent/connection_adapter.rb
+- lib/persistent_httparty.rb
+- lib/persistent_httparty/version.rb
+- README.md
+- LICENSE
+- CHANGELOG.md
+- features/persistent_http_connections.feature
+- features/step_definitions/persistent_http_connections_steps.rb
+- features/step_definitions/support/env.rb
+- features/step_definitions/support/web_request.rb
+- features/support/env.rb
+- spec/lib/httparty/persistent/connection_adapter_spec.rb
+- spec/lib/httparty/persistent_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers.rb
+homepage: https://github.com/soupmatt/persistent_httparty
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -710231127126955515
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -710231127126955515
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Persistent HTTP connections for HTTParty
+test_files:
+- features/persistent_http_connections.feature
+- features/step_definitions/persistent_http_connections_steps.rb
+- features/step_definitions/support/env.rb
+- features/step_definitions/support/web_request.rb
+- features/support/env.rb
+- spec/lib/httparty/persistent/connection_adapter_spec.rb
+- spec/lib/httparty/persistent_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers.rb