http_wrapper 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 425cf2e9d257f1b5fa7740175a8f73cb016c3a30
+  data.tar.gz: ac5befa4cc51dd8ea3370a6ab86bbcb145c37a54
+SHA512:
+  metadata.gz: 5d7ea56a231b668b36017f6f0b12aeab2c76ad83fad1618e6e25736f394445c6537cef1f19d96611408bec41acff5883189308dd93477cd5322e40e9bf6519b2
+  data.tar.gz: 9b5d9c375e60c37f658a33b54eb4ef4cec6892ce50e36e5399c93bcf7d397f2f3f536e192c2e9189ce35be7ecc0984c6b866c21b65e2815426756c9abbfacbd3

data/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+## v2.0.0
+
+* Gem rewritten completely and renamed to 'http_wrapper'
+* `#get_response` now simply `#get`
+* `#get_ajax_response` now `#get_ajax`
+* `#get_soap_response` now `#get_soap`
+* `#get_json_response` now `#get_json`
+* `#get_cookie` now `#post_and_get_cookie`
+* new methods `#post`, `#put`, `#delete`,
+* new methods `#get_ajax_json`, `#post_ajax_json`, `#put_ajax_json`, `#delete_ajax_json`
+* new methods `#post_[ajax|soap|json]`, `#put_[ajax|soap|json]`, `#delete_[ajax|soap|json]`
+* class constructor now use options hash as a parameter instead of separate parameters
+
+    ```ruby
+    # was
+    accessor = ResourceAccessor.new(5000, '/path/to/ca_file', true)
+    # now
+    http = HTTWrapper.new(timeout: 5000, ca_file: '/path/to/ca_file', validate_ssl_cert: true)
+    ```
+
+* methods signature changed to `method(url, params)`
+* development gem dependencies reduced
+* tests rewritten completely using `webmock` gem
+* changelog order reversed
+* changelog file renamed to `CHANGELOG.md`
+
+## v1.1.1
+
+* Adding query parameter
+* Adding specs
+
+## v1.1.0
+
+* Write documentation
+* API change
+
+## v1.0.1
+
+* Bug fix
+
+## v1.0.0
+
+* Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2013 Leonid Svyatov
+Copyright (c) 2012 Alexander Shvets
+
+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,217 @@
+# http_wrapper
+
+Simple wrapper around standard Net::HTTP library to simplify common http[s] tasks usage
+
+## Installation
+
+Add this line to your Gemfile:
+
+    gem 'http_wrapper', '~> 2.0.0'
+
+And then execute:
+
+    $ bundle
+
+Or install it manually:
+
+    $ gem install http_wrapper
+
+And require it in you code:
+
+```ruby
+require 'http_wrapper'
+```
+
+## Usage
+
+Create wrapper object:
+
+```ruby
+http = HTTPWrapper.new
+```
+
+### Access unprotected resource located at **some_url**:
+
+Resource is redirecting? No problem! `http_wrapper` follows up to 10 sequential redirects (you cannot change that limit yet).
+
+```ruby
+response = http.get some_url
+```
+
+### Access resource protected by form-based authentication:
+
+1. Post your credentials and get authentication cookie
+
+    ```ruby
+    # 'username' and 'password' fields are examples, it's just query parameters
+
+    # credentials as body params
+    cookie = http.post_and_get_cookie some_url, body: { username: 'iamjohn', password: '$uperS1kret' }
+    # - or - credentials as GET query params
+    cookie = http.post_and_get_cookie some_url, params: { username: 'iamjohn', password: '$uperS1kret' }
+    ```
+
+2. Get protected resource with provided cookie
+
+    ```ruby
+    response = http.get some_url, cookie: cookie
+    ```
+
+### Access resource protected by basic access authentication:
+
+```ruby
+response = http.get 'http://example.com', auth: { login: 'iamjohn', password: 'iamnotjohn' }
+# => http://iamjohn:iamnotjohn@example.com
+```
+
+### Access resource mimicing AJAX
+
+Add special header or use special method:
+
+```ruby
+response = http.get some_url, headers: {'X-Requested-With' => 'XMLHttpRequest'}
+# - or -
+response = http.get_ajax some_url
+```
+
+### Access SOAP resource
+
+Same as before, add special header or use special method:
+
+```ruby
+response = http.get some_url, headers: {'SOAPAction' => 'someSoapOperation', 'Content-Type' => 'text/xml; charset=UTF-8'}
+# - or -
+response = http.get_soap some_url
+```
+
+### Access JSON resource
+
+Same as before :)
+
+```ruby
+response = http.get some_url, headers: {'Content-Type' => 'application/json; charset=UTF-8'}
+# - or -
+response = http.get_json some_url
+```
+
+### Access JSON resource mimicing AJAX
+
+Just use special method :) (which sets `X-Requested-With` and `Content-Type` headers for you)
+
+```ruby
+response = http.get_ajax_json some_url, some_params
+```
+
+Difficult to remember what goes after what: `get_ajax_json` or `get_json_ajax`?
+`http_wrapper` got you covered. They both work, use whatever variant you like better.
+
+```ruby
+# the same as above
+response = http.get_json_ajax some_url, some_params
+```
+
+### Provide additional query parameters
+
+Don't worry about escaping, `http_wrapper` got you covered here either.
+
+```ruby
+response = http.get 'http://www.google.com', params: {message: 'Hi! M&Ms!', user: 'iamjohn'}
+# => http://www.google.com/?message=Hi!%20M%26Ms!&user=iamjohn
+```
+
+Don't worry about parameters that already in URL, they'll be merged.
+
+```ruby
+response = http.get 'http://www.google.com/?q=test', params: {user: 'iamjohn'}
+# => http://www.google.com/?q=test&user=iamjohn
+```
+
+### Set timeout for wrapper:
+
+```ruby
+http.timeout = 10000 # in milliseconds
+# - or - on instantiation
+http = HTTPWrapper.new timeout: 10000
+```
+
+### Work over SSL
+
+To work over SSL enable certificate validation before any calls:
+
+```ruby
+http.validate_ssl_cert = true
+http.ca_file = '/path/to/your/ca_file'
+# - or - on instantiation
+http = HTTPWrapper.new ca_file: '/path/to/your/ca_file', validate_ssl_cert: true
+```
+
+### POST, PUT and DELETE requests
+
+On each `get` method there are `post`, `put` and `delete` methods. Examples:
+
+```ruby
+http.post some_url, body: {user: 'iamjohn', password: 'secret'}
+# - or -
+http.put some_url, body: {user: 'iamjohn', password: 'secret'}
+# - or -
+http.delete some_url, params: {user: 'iamjohn'}
+```
+
+Default content type header for these requests is `application/x-www-form-urlencoded; charset=UTF-8`.
+
+So for `get_ajax` there are `post_ajax`, `put_ajax` and `delete_ajax`.
+
+For `get_soap` there are `post_soap`, `put_soap` and `delete_soap`.
+
+For `get_json` there are `post_json`, `put_json` and `delete_json`.
+
+And for `get_ajax_json`, there are `post_ajax_json`, `put_ajax_json` and `delete_ajax_json`.
+
+### Full params hash example
+
+```ruby
+{
+  # Request Headers
+  headers: {
+    'Content-Type' => 'text/html',
+    'X-Requested-With' => 'XMLHttpRequest',
+    'User-Agent' => 'Chrome v123'
+  },
+
+  # Query Parameters
+  params: {
+    user: 'iamjohn',
+    'user-stuff' => '123abc'
+  },
+
+  # Cookie
+  cookie: 'all cookies in one string',
+
+  # Basic authentication credentials
+  auth: {
+    login: 'iamjohn',
+    password: 'secret'
+  },
+
+  # Request body
+  body: 'as a string',
+  # - or -
+  body: {
+    as: 'a hash'
+  },
+
+  # Request method - :get, :post, :put, :delete
+  :method => :get
+}
+```
+
+Don't worry if you mistype root parameters key. `http_wrapper` checks root params keys and instantiation options keys.
+If any unknown options or parameters found, they raise the `UnknownParameterError` exception.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift File.expand_path('lib', File.dirname(__FILE__))
+
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new do |task|
+  task.pattern = 'spec/**/*_spec.rb'
+  task.verbose = false
+end
+

data/lib/http_wrapper/constants.rb

@@ -0,0 +1,16 @@
+class HTTPWrapper
+  KNOWN_OPTIONS_KEYS   = [:timeout, :ca_file, :validate_ssl_cert].freeze
+  KNOWN_PARAMS_KEYS    = [:headers, :params, :cookie, :auth, :body, :method].freeze
+
+  HEADER_CONTENT_TYPE  = 'Content-Type'.freeze
+
+  DEFAULT_CONTENT_TYPE = 'text/xml; charset=UTF-8'.freeze
+  JSON_CONTENT_TYPE    = 'application/json; charset=UTF-8'.freeze
+  POST_CONTENT_TYPE    = 'application/x-www-form-urlencoded; charset=UTF-8'.freeze
+
+  HEADER_USER_AGENT    = 'User-Agent'.freeze
+  HEADER_COOKIE        = 'Cookie'.freeze
+
+  HEADER_AJAX          = 'X-Requested-With'.freeze
+  HEADER_AJAX_VALUE    = 'XMLHttpRequest'.freeze
+end

data/lib/http_wrapper/errors.rb

@@ -0,0 +1,5 @@
+class HTTPWrapper
+  HTTPWrapperError      = Class.new StandardError
+  TooManyRedirectsError = Class.new HTTPWrapperError
+  UnknownParameterError = Class.new HTTPWrapperError
+end

data/lib/http_wrapper/http_wrapper.rb

@@ -0,0 +1,201 @@
+require 'uri/common'
+require 'net/https'
+require_relative 'constants'
+require_relative 'errors'
+require_relative 'version'
+
+class HTTPWrapper
+  attr_accessor :timeout, :ca_file, :validate_ssl_cert
+
+  def initialize(options = {})
+    unknown_options = options.keys - KNOWN_OPTIONS_KEYS
+
+    if unknown_options.length > 0
+      raise UnknownParameterError.new "Unknown options: #{unknown_options.join(', ')}"
+    end
+
+    @timeout           = options.fetch(:timeout) { 10000 }
+    @ca_file           = options.fetch(:ca_file) { nil }
+    @validate_ssl_cert = options.fetch(:validate_ssl_cert) { false }
+  end
+
+  def self.default_user_agent
+    "HTTPWrapper/#{VERSION}; Ruby/#{RUBY_VERSION}"
+  end
+
+  def get(url, params = {})
+    params = validate_parameters_and_init_headers params
+    locate_response url, params
+  end
+
+  [:post, :put, :delete].each do |method|
+    define_method method do |url, params = {}|
+      params = validate_parameters_and_init_headers params
+      params[:headers][HEADER_CONTENT_TYPE] ||= POST_CONTENT_TYPE
+      params[:method] = method
+      locate_response url, params
+    end
+  end
+
+  def get_soap(url, params = {})
+    params = validate_parameters_and_init_headers params
+    params[:headers]['SOAPAction'] ||= ''
+    params[:headers][HEADER_CONTENT_TYPE] ||= DEFAULT_CONTENT_TYPE
+    locate_response url, params
+  end
+
+  [:post, :put, :delete].each do |method|
+    define_method "#{method.to_s}_soap" do |url, params = {}|
+      params[:method] = method
+      get_soap url, params
+    end
+  end
+
+  def get_ajax(url, params = {})
+    params = validate_parameters_and_init_headers params
+    params[:headers][HEADER_AJAX] = HEADER_AJAX_VALUE
+    locate_response url, params
+  end
+
+  [:post, :put, :delete].each do |method|
+    define_method "#{method.to_s}_ajax" do |url, params = {}|
+      params[:method] = method
+      get_ajax url, params
+    end
+  end
+
+  def get_json(url, params = {})
+    params = validate_parameters_and_init_headers params
+    params[:headers][HEADER_CONTENT_TYPE] = JSON_CONTENT_TYPE
+    locate_response url, params
+  end
+
+  [:post, :put, :delete].each do |method|
+    define_method "#{method.to_s}_json" do |url, params = {}|
+      params[:method] = method
+      get_json url, params
+    end
+  end
+
+  def get_ajax_json(url, params = {})
+    params = validate_parameters_and_init_headers params
+    params[:headers][HEADER_CONTENT_TYPE] = JSON_CONTENT_TYPE
+    get_ajax url, params
+  end
+
+  [:post, :put, :delete].each do |method|
+    define_method "#{method.to_s}_ajax_json" do |url, params = {}|
+      params[:method] = method
+      get_ajax_json url, params
+    end
+  end
+
+  %w(get post put delete).each do |method|
+    alias_method "#{method}_json_ajax", "#{method}_ajax_json"
+  end
+
+  def post_and_get_cookie(url, params = {})
+    response = post url, params
+    response.response['set-cookie']
+  end
+
+  private
+
+  def validate_parameters_and_init_headers(params)
+    params[:headers] ||= {}
+    unknown_params = params.keys - KNOWN_PARAMS_KEYS
+
+    if unknown_params.length > 0
+      raise UnknownParameterError.new "Unknown parameters: #{unknown_params.join(', ')}"
+    end
+
+    params
+  end
+
+  def locate_response(url, params, redirects_limit = 10)
+    raise TooManyRedirectsError.new 'Too many redirects!' if redirects_limit == 0
+
+    response = execute_request url, params
+
+    if response.kind_of? Net::HTTPRedirection
+      response = locate_response response['location'], params, redirects_limit - 1
+    end
+
+    response
+  end
+
+  def execute_request(url, params)
+    params[:headers] ||= {}
+    params[:headers][HEADER_USER_AGENT]   ||= self.class.default_user_agent
+    params[:headers][HEADER_CONTENT_TYPE] ||= DEFAULT_CONTENT_TYPE
+    params[:headers][HEADER_COOKIE] = params[:cookie] if params[:cookie]
+
+    uri = build_uri url, params[:params]
+    connection = create_connection uri
+    request = create_request uri, params
+
+    Timeout.timeout(timeout) do
+      connection.request(request)
+    end
+  end
+
+  def build_uri(url, query_params)
+    uri = URI url
+
+    if query_params
+      if uri.query && !uri.query.empty?
+        new_query = Hash[URI.decode_www_form(uri.query)].merge(query_params)
+      else
+        new_query = query_params
+      end
+      uri.query = URI.encode_www_form new_query
+    end
+
+    uri
+  end
+
+  def create_connection(uri)
+    connection = Net::HTTP.new uri.host, uri.port
+    connection.read_timeout = timeout
+    connection.open_timeout = timeout
+
+    if uri.scheme == 'https'
+      connection.use_ssl = true
+
+      if validate_ssl_cert
+        connection.ca_file = ca_file
+        connection.verify_mode = OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+      else
+        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+
+    connection
+  end
+
+  def create_request(uri, params)
+    case params[:method]
+      when :get
+        request = Net::HTTP::Get.new    uri.request_uri, params[:headers]
+      when :post
+        request = Net::HTTP::Post.new   uri.request_uri, params[:headers]
+      when :put
+        request = Net::HTTP::Put.new    uri.request_uri, params[:headers]
+      when :delete
+        request = Net::HTTP::Delete.new uri.request_uri, params[:headers]
+      else
+        request = Net::HTTP::Get.new    uri.request_uri, params[:headers]
+    end
+
+    if [:post, :put, :delete].include? params[:method]
+      request.body = params[:body] if params[:body].kind_of? String
+      request.set_form_data(params[:body]) if params[:body].kind_of? Hash
+    end
+
+    if params[:auth]
+      request.basic_auth params[:auth].fetch(:login), params[:auth].fetch(:password)
+    end
+
+    request
+  end
+end

data/lib/http_wrapper/version.rb

@@ -0,0 +1,3 @@
+class HTTPWrapper
+  VERSION = '2.0.0'.freeze
+end

data/lib/http_wrapper.rb

@@ -0,0 +1 @@
+require 'http_wrapper/http_wrapper'

data/spec/http_wrapper_spec.rb

@@ -0,0 +1,163 @@
+require_relative 'spec_helper'
+
+require 'http_wrapper'
+
+describe HTTPWrapper do
+  let(:basic_auth_login) { 'balogin' }
+  let(:basic_auth_password) { 'bapassword' }
+
+  it 'should define all dynamic methods' do
+    [:get,           :post,           :put,           :delete,
+     :get_soap,      :post_soap,      :put_soap,      :delete_soap,
+     :get_json,      :post_json,      :put_json,      :delete_json,
+     :get_ajax,      :post_ajax,      :put_ajax,      :delete_ajax,
+     :get_ajax_json, :post_ajax_json, :put_ajax_json, :delete_ajax_json,
+     :get_json_ajax, :post_json_ajax, :put_json_ajax, :delete_json_ajax].each do |method|
+      subject.should be_respond_to method
+    end
+  end
+
+  context 'HTTP' do
+    let(:sample_url) { 'http://example.com' }
+    let(:sample_url_with_basic_auth) { "http://#{basic_auth_login}:#{basic_auth_password}@example.com" }
+
+    it 'should raise UnknownParameterError if initial options key is unknown' do
+      expect do
+        HTTPWrapper.new unknown_option: 'test', maybe_this_known: '?'
+      end.to raise_error HTTPWrapper::UnknownParameterError, 'Unknown options: unknown_option, maybe_this_known'
+    end
+
+    it 'should raise UnknownParameterError if params key is unknown' do
+      expect do
+        subject.get sample_url, unknown_param_key: 'test', another_param_key: 'wow'
+      end.to raise_error HTTPWrapper::UnknownParameterError, 'Unknown parameters: unknown_param_key, another_param_key'
+    end
+
+    context 'GET' do
+      it 'should hit provided url with default content type' do
+        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::DEFAULT_CONTENT_TYPE} }
+        stub_get sample_url, params
+        subject.get sample_url
+      end
+
+      it 'should set content type if provided' do
+        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => 'Custom Content Type'} }
+        stub_get sample_url, params
+        subject.get sample_url, params
+      end
+
+      it 'should set proper header for JSON requests' do
+        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::JSON_CONTENT_TYPE} }
+        stub_get sample_url, params
+        subject.get_json sample_url
+      end
+
+      it 'should set proper header for AJAX requests' do
+        params = { headers: {HTTPWrapper::HEADER_AJAX => HTTPWrapper::HEADER_AJAX_VALUE,
+                             HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::DEFAULT_CONTENT_TYPE } }
+        stub_get sample_url, params
+        subject.get_ajax sample_url
+      end
+
+      it 'should set proper headers for AJAX-JSON requests' do
+        params = { headers: {HTTPWrapper::HEADER_AJAX => HTTPWrapper::HEADER_AJAX_VALUE,
+                             HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::JSON_CONTENT_TYPE } }
+        stub_get sample_url, params
+        subject.get_ajax_json sample_url
+      end
+
+      it 'should correctly escape query parameters' do
+        stub_get sample_url + '/?param1=&param2=A%26B&param3=C%20%26%20D'
+        subject.get sample_url, params: {param1: '', param2: 'A&B', param3: 'C & D'}
+      end
+
+      it 'should set default user agent' do
+        params = { headers: {HTTPWrapper::HEADER_USER_AGENT => HTTPWrapper.default_user_agent} }
+        stub_get sample_url, params
+        subject.get sample_url
+      end
+
+      it 'should change user agent if provided' do
+        custom_user_agent = 'Mozilla v1.2.3'
+        params = { headers: {HTTPWrapper::HEADER_USER_AGENT => custom_user_agent} }
+        stub_get sample_url, params
+        subject.get sample_url, params
+      end
+
+      it 'should send cookie if provided' do
+        cookie_value = 'some cookie'
+        params = { headers: {'Cookie' => cookie_value} }
+        stub_get sample_url, params
+        subject.get sample_url, cookie: cookie_value
+        subject.get sample_url, params
+      end
+
+      it 'should hit provided url with basic auth' do
+        stub_get sample_url_with_basic_auth
+        subject.get sample_url, auth: {login: basic_auth_login, password: basic_auth_password}
+      end
+
+      it 'should follow redirects no more then 10 times' do
+        stub_redirects sample_url, 9
+        response = subject.get sample_url
+        response.code.should eql '200'
+
+        stub_redirects sample_url, 10
+        expect { subject.get sample_url }.to raise_error HTTPWrapper::TooManyRedirectsError, 'Too many redirects!'
+      end
+
+      it 'should merge query parameters and params should take precedence' do
+        stub_get sample_url + '/?text=edf&time=16:44&user=test'
+        subject.get(sample_url + '/?user=test&text=abc', params: {time: '16:44', text: 'edf'})
+      end
+    end
+
+    context 'POST' do
+      it 'should set content type if provided' do
+        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => 'Custom Content Type'} }
+        stub_post sample_url, params
+        subject.post sample_url, params
+      end
+
+      it 'should return cookies after post' do
+        cookie_value = 'some cookie'
+        params = { body: {username: 'test', password: 'test'} }
+        stub_post(sample_url, params).to_return({headers: {'Set-Cookie' => cookie_value}})
+        cookie = subject.post_and_get_cookie sample_url, params
+        cookie.should eql cookie_value
+      end
+
+      it 'should hit provided url with default content type' do
+        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::POST_CONTENT_TYPE } }
+        stub_post sample_url, params
+        subject.post sample_url
+      end
+    end
+
+    context 'PUT' do
+      it 'should hit provided url with default content type' do
+        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::POST_CONTENT_TYPE } }
+        stub_put sample_url, params
+        subject.put sample_url
+      end
+    end
+
+    context 'DELETE' do
+      it 'should hit provided url with default content type' do
+        params = { headers: {HTTPWrapper::HEADER_CONTENT_TYPE => HTTPWrapper::POST_CONTENT_TYPE } }
+        stub_delete sample_url, params
+        subject.delete sample_url
+      end
+    end
+  end
+
+  context 'HTTPS' do
+    let(:sample_url) { 'https://example.com' }
+
+    it 'should hit provided url with HTTPS protocol' do
+      stub_get sample_url
+      subject.get sample_url
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rspec'
+require 'webmock/rspec'
+
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+module HTTPWrapperSpecHelpers
+  [:get, :post, :put, :delete].each do |type|
+    define_method("stub_#{type.to_s}") do |url, params = nil|
+      if params
+        stub_request(type, url).with(params)
+      else
+        stub_request(type, url)
+      end
+    end
+  end
+
+  def stub_redirects(url, amount_of_redirects)
+    stub_get(url).to_return(status: 301, headers: {'Location' => url})
+                 .times(amount_of_redirects)
+                 .then
+                 .to_return(status: 200)
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.include HTTPWrapperSpecHelpers
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: http_wrapper
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Leonid Svyatov
+- Alexander Shvets
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+description: Simple wrapper around standard Net::HTTP library to simplify common http[s]
+  tasks usage
+email: leonid@svyatov.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- CHANGELOG.md
+- Rakefile
+- lib/http_wrapper/constants.rb
+- lib/http_wrapper/errors.rb
+- lib/http_wrapper/http_wrapper.rb
+- lib/http_wrapper/version.rb
+- lib/http_wrapper.rb
+- spec/http_wrapper_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/Svyatov/http_wrapper
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Simple wrapper around standard Net::HTTP library
+test_files:
+- spec/http_wrapper_spec.rb
+- spec/spec_helper.rb