restful_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fdf61437db7d8ba44585cc4b91bcb2362227c068
+  data.tar.gz: 7d9fc6320b56785f07249b3146b15a04af2693b6
+SHA512:
+  metadata.gz: 508b11c0cae03e2a895305162b92737e26e78e8e2f186d0a2b4edf454da5607eb624659022b606ec43eacec0685ea7a8f9e82de241cc3690470a85a766c3e7cb
+  data.tar.gz: c2f023f3df2c3bcedfe4916ddbb5c0597979e8cf310f0f763da9fde6470a31cd86b8c0b5fb9ccbae7b38fdabd5f74da4e26e5e049d107923c34e98711233d744

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--drb
+--format documentation
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+restful_client

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.2

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'thin', '~> 1.6'
+
+gem 'pry-byebug', '~> 3.2.0', {}.merge(ENV['RM_INFO'] ? {require: false} : {})
+gem 'rspec', '~> 3.1'
+gem 'rspec-its', '~> 1.1'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Avner Cohen
+
+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,135 @@
+# RestfulClient
+
+An HTTP framework for micro-services based environment, build on top of [typhoeus](https://github.com/typhoeus/typhoeus) and [servicejynx](https://github.com/AvnerCohen/service-jynx)
+
+[![Build status](https://travis-ci.org/AvnerCohen/restful-client.png)](https://travis-ci.org/AvnerCohen/restful-client)
+
+## Installation
+
+    gem 'restful_client'
+
+## Features
+
+* Clean restful api supporting http verbs (GET/PUT/POST/DELETE)
+* Manage Failures -  set stubs for case of errors and SERVICE_DOWN event from [Jynx](https://github.com/AvnerCohen/service-jynx)
+* Strcutured and configurable YAML for multiple service end points
+* Build using Typheous, a fast and robuts http client, built on top of libcurl
+* Configurable timeouts for http request
+
+## Configuration
+
+Create the "restful_services.yml" file in your config folder.
+Configuration for the various service is based on top of YAML that configures the http service endpoints and ServiceJynx setup:
+
+<pre>
+development: &development
+  users:
+    url: http://1.2.3.4:7711/api/v1/
+    time_window_in_seconds: 20
+    max_errors: 10
+    grace_period: 60    
+
+production: &production
+  users:
+    url: http://1.2.3.4:7711/api/v0/
+    time_window_in_seconds: 20
+    max_errors: 10
+    grace_period: 60    
+
+</pre>
+
+### Possible flags
+
+* use_jynx - Remove the integrated jynx-service protection (default: false)
+* report_method - proc to be executed in the case of error
+* env_name - environment name (production|staging|development etc..)
+* config_folder - path to the configuration folder of the restful_services.yml file.
+* user_agent - user agent... duh! (users_service|mobile_service|etc..)
+* legacy_postfix - Legacy version accessed the restful_services.yml with an additional postfix in the yaml.
+
+## Usage
+
+In your environment initializer:
+
+<pre>
+      RestfulClient.configure do |config|
+        config.env_name = Rails.env
+        config.config_folder = "config"
+      end
+</pre>
+
+When an error occurs, restful client will report it, as part of the configuration, you an provide it with a reporting hook service, such as graylog or airbrake or whatever you want.
+
+Data from the report_method will be reported as ```func(klass_name, message, Exception)```
+
+Consider the following example:
+
+<pre>
+      #reporting method
+      def report_to_graylog(klass, message, e)
+        Logger.warn "#{klass}::#{message}"
+        $gelf_notifier.send_to_graylog2(e)
+      end
+
+      RestfulClient.configure do |config|
+        config.env_name = ENV['RACK_ENV']
+        config.config_folder = "config"
+        config.user_agent = "my_service"
+        #proc hock to the reporting method
+        config.report_method = proc {|*args| report_to_graylog(*args) }
+      end
+</pre>
+
+
+Default timeout for a call is set to 10 seconds, if you want to configure anything different:
+<pre>
+
+      RestfulClient.configure do |config|
+        config.env_name = Rails.env
+        config.config_folder = "#{Rails.root}/config"
+        config.timeout = 5
+      end  
+
+</pre>
+
+Than use the service:
+
+<pre>
+RestfulClient.get("posts", "/comments/#{user.id}") do
+ [] #default value to be returned on failure
+end
+
+#or
+RestfulClient.delete("posts", {comments: [1,2,4]}, "/comments/#{some_id}") do
+ "ok" #default value to be returned on failure
+end
+</pre>
+
+## Forward IP of client
+In a complex micro services environment, when services are chained together, you might need to pass along the original IP of the client.
+Implementation is based on a global $client_ip that can be set and will be assigned to the "X-Forwarded-For" http header.
+So yeah, no JRuby support at this time.
+
+
+## Reusing configuration
+In some cases you might need to use, join or read the base URL of a given service:
+
+
+Given:
+
+````
+  users:
+    url: http://1.2.3.4:8383/api/v0/
+````
+<pre>
+
+  RestfulClient.srv_url('posts') # ==> http://1.2.3.4:8383/api/v0/
+</pre>
+
+## 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/lib/restful_client/version.rb

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

data/lib/restful_client.rb

@@ -0,0 +1,211 @@
+require 'yaml'
+require 'typhoeus'
+require 'service_jynx'
+require 'json'
+require_relative './restful_client_configuration.rb'
+require_relative './restful_client_logger.rb'
+require_relative './restful_client_uri.rb'
+
+module RestfulClient
+  module_function
+
+  class RestError < StandardError; end
+
+  @@configuration  = nil
+  @@logger = nil
+  @@timeout_occured_count = 0
+
+  SERVER_SIDE_ERRORS_RANGE = 500
+
+  def self.configure
+    @@configuration ||= RestfulClientConfiguration.new
+    yield(configuration)
+    @@configuration.run!
+    @@logger = RestfulClientLogger.logger
+  end
+
+  def configuration
+    @@configuration
+  end
+
+  def logger
+    @@logger
+  end
+
+  def srv_url(caller)
+    callerr_config(caller)["url"]
+  end
+
+  def get(caller, path, params = {}, extra_options = {}, &on_error_block)
+    url = RestfulClientUri.uri_join(callerr_config(caller)["url"], path)
+    headers = { "Accept" => "text/json" }
+    headers.merge!(extra_options.fetch("headers", {}))
+    request = Typhoeus::Request.new(url, headers: headers, method: 'GET', timeout: timeout, params: params)
+    run_safe_request(caller, request, true, &on_error_block)
+  end
+
+  def post(caller, path, payload, extra_options = {}, &on_error_block)
+    url = RestfulClientUri.uri_join(callerr_config(caller)["url"], path)
+    headers, payload_as_str = prepare_payload_with_headers(payload, extra_options.fetch("headers", {}))
+    request = Typhoeus::Request.new(url, headers: headers, method: 'POST', body: payload_as_str, timeout: timeout)
+    run_safe_request(caller, request, false, &on_error_block)
+  end
+
+  def post_raw(caller, path, payload, custom_timeout = timeout, &on_error_block)
+    url = RestfulClientUri.uri_join(callerr_config(caller)["url"], path)
+    request = Typhoeus::Request.new(url, method: 'POST', body: payload, timeout: custom_timeout)
+    run_safe_request(caller, request, false, &on_error_block)
+  end
+
+  def delete(caller, path, payload = {}, extra_options = {}, &on_error_block)
+    url = RestfulClientUri.uri_join(callerr_config(caller)["url"], path)
+    headers, payload_as_str = prepare_payload_with_headers(payload, extra_options.fetch("headers", {}))
+    request = Typhoeus::Request.new(url, headers: headers, method: 'DELETE', body: payload_as_str, timeout: timeout)
+    run_safe_request(caller, request, true, &on_error_block)
+  end
+
+  def put(caller, path, payload, extra_options = {}, &on_error_block)
+    url = RestfulClientUri.uri_join(callerr_config(caller)["url"], path)
+    headers, payload_as_str = prepare_payload_with_headers(payload, extra_options.fetch("headers", {}))
+    request = Typhoeus::Request.new(url, headers: headers, method: 'PUT', body: payload_as_str, timeout: timeout)
+    run_safe_request(caller, request, false, &on_error_block)
+  end
+
+  def callerr_config(caller)
+    caller_setup = configuration.data["#{caller}#{legacy_postfix}"]
+    raise "Couldn't find ['#{caller}#{legacy_postfix}'] in the configuration YAML !!" unless caller_setup
+    caller_setup
+  end
+
+  def run_safe_request(caller, request, retry_if_needed, &on_error_block)
+
+    @@timeout_occured_count = 0
+    if !use_jynx?
+      response = run_request(request.dup, __method__, false)
+    elsif ServiceJynx.alive?(caller)
+      begin
+        response = run_request(request.dup, __method__, retry_if_needed)
+      end while response.is_a?(Typhoeus::Response)
+
+      response
+    else
+      response = on_error_block.call("#{caller} set as down.") if on_error_block
+    end
+    response
+  rescue => e
+    res = ServiceJynx.failure!(caller) if use_jynx?
+    report_method.call("ServiceJynx", "Service #{caller} was taken down as a result of exception", e) if res == :WENT_DOWN
+    on_error_block.call("Exception in #{caller} execution - #{e.message}") if on_error_block
+  end
+
+  def run_request(request, method, retry_if_needed)
+    logger.debug { "#{__method__} :: Request :: #{request.inspect}" }
+    request.options[:headers].merge!({'X-Forwarded-For' => $client_ip}) if $client_ip
+    request.options[:headers].merge!({'User-Agent' => user_agent})
+    request.on_complete do |response|
+      #200, OK
+      if response.success?
+        logger.debug { "Success in #{method} :: Code: #{response.response_code}, #{response.body}" }
+        return "" if response.body.empty?
+        begin
+          return JSON.parse(response.body)
+        rescue => e
+          logger.error { "Response from #{response.effective_url} is not a valid json  - [#{response.body}]"}
+          raise e
+        end
+        #Timeout occured
+      elsif response.timed_out?
+        @@timeout_occured_count = @@timeout_occured_count + 1
+        skip_raise = (retry_if_needed && @@timeout_occured_count <= retries)
+
+        error_type = "TimeoutOccured"
+        error_description = prettify_logger(error_type, request, response)
+        logger.error { "Time out in #{method} for: #{error_description}" }
+
+        exception = RuntimeError.new(error_description)
+        exception.set_backtrace(caller)
+        report_method.call("RestError", error_description, exception)
+
+        raise RestError.new(response.return_code.to_sym) unless skip_raise
+        # Could not get an http response, something's wrong.
+      elsif response.code == 0
+
+        error_type = :HttpError
+        error_description = prettify_logger(error_type, request, response)
+        logger.error { "HttpError Error #{response.code}/#{response.return_code} for: #{error_description}" }
+
+        exception = RuntimeError.new(error_description)
+        exception.set_backtrace(caller)
+        report_method.call("RestError", error_description, exception)
+        raise RestError.new(error_type)
+        # Received a non-successful http response.
+      elsif response.code >= SERVER_SIDE_ERRORS_RANGE
+
+        error_type = :BadReturnCode
+        error_description = prettify_logger(error_type, request, response)
+        logger.error { "#{error_type} #{response.code}/#{response.return_code} for: #{error_description}" }
+
+        report_method.call("RestError", error_description, exception)
+        exception = RuntimeError.new(error_description)
+
+        exception.set_backtrace(caller)
+
+        raise RestError.new(error_type)
+      else
+
+        raise RestError.new(:BadReturnCode)
+
+      end
+    end
+    request.run
+  end
+
+  def prepare_payload_with_headers(payload, custom_headers)
+    headers = {}
+    if payload.is_a?(Hash)
+      payload_as_str = payload.to_json(root: false)
+      headers.merge!({ "Content-Type" => "application/json" })
+    else
+      payload_as_str = payload
+    end
+
+    headers.merge!(custom_headers)
+
+    [headers, payload_as_str]
+  end
+
+  def fake(caller, path, options = {}, &block)
+    url = RestfulClientUri.uri_join(callerr_config(caller)["url"], path)
+    Typhoeus.stub(url, options = {}, &block)
+  end
+
+  def timeout
+    configuration.timeout
+  end
+
+  def user_agent
+    configuration.user_agent
+  end
+
+  def use_jynx?
+    configuration.use_jynx
+  end
+
+  def legacy_postfix
+    configuration.legacy_postfix
+  end
+
+  def retries
+    configuration.retries
+  end
+
+  def report_method
+    configuration.report_method
+  end
+
+  def prettify_logger(type, request, response)
+    return "#{type} with no request or response." unless request || response
+    "#{type} #{response.code}/#{response.return_code} for: #{request.options.fetch(:method)} #{request.base_url}, Total time: #{response.total_time} seconds"
+  end
+
+end

data/lib/restful_client_configuration.rb

@@ -0,0 +1,55 @@
+require 'erb'
+
+class RestfulClientConfiguration
+  attr_accessor :config_folder, :report_method, :data, :env_name, :timeout, :user_agent, :retries, :use_jynx, :legacy_postfix
+  DEFAULT_TIMEOUT = 10
+  DEFAULT_RETRIES = 2
+  DEFAULT_USER_AGENT = 'RestfulClient - https://github.com/AvnerCohen/restful-client'
+
+  def run!
+    raise "Configuration directory name must be provided" unless config_folder.class.to_s == "String"
+    file_name = ["restful_services.yml", "rest_api.yml"].each do |name|
+      locale_name = File.join(config_folder, name)
+      break locale_name if File.file?(locale_name)
+    end
+
+    ## Set Default Values
+    @report_method  ||=     proc {|*args| nil }
+    @timeout        ||=     DEFAULT_TIMEOUT
+    @user_agent     ||=     DEFAULT_USER_AGENT
+    @retries        ||=     DEFAULT_RETRIES
+    @legacy_postfix ||=     ""
+    @use_jynx         =     true if @use_jynx.nil?
+
+    @data = YAML.load(ERB.new(File.read(file_name)).result)[env].each do |name, entry|
+      next unless entry.has_key?("url")
+      opts = {
+        time_window_in_seconds: entry.fetch(:time_window_in_seconds, 20),
+        max_errors: entry.fetch(:max_errors, 10),
+        grace_period: entry.fetch(:grace_period, 120)
+      }
+
+      ServiceJynx.register!(name.gsub(@legacy_postfix, ""), opts) if @use_jynx
+    end
+
+  end
+
+  def reset
+    @report_method  =    nil
+    @timeout        =    nil
+    @user_agent     =    nil
+    @retries        =    nil
+    @use_jynx       =    nil
+    @legacy_postfix =    nil
+  end
+
+  ## Dummy method to test reporting phase
+  def report_on
+    @report_method.call("RestfulClientConfiguration", "Initialized at: #{Time.now}.")
+  end
+
+  def env
+    @env_name || "default"
+  end
+
+end

data/lib/restful_client_logger.rb

@@ -0,0 +1,23 @@
+module RestfulClientLogger
+  module_function
+
+  def logger
+    @logger ||= (rails_logger || $log || default_logger)
+  end
+
+  def rails_logger
+    (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
+    (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
+  end
+
+  def default_logger
+    require 'logger'
+    l = Logger.new(STDOUT)
+    l.level = Logger::INFO
+    l
+  end
+
+  def logger=(logger)
+    @logger = logger
+  end
+end

data/lib/restful_client_uri.rb

@@ -0,0 +1,11 @@
+require 'uri'
+
+module RestfulClientUri
+  module_function
+
+  ## This is totally wierd, but File.join just does what you need while URI.join as much too strict.
+  def uri_join(url, path)
+    File.join(url, path).to_s
+  end
+
+end

data/restful_client.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'restful_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'restful_client'
+  spec.version       = RestfulClient::VERSION
+  spec.authors       = ['Avner Cohen']
+  spec.email         = ['israbirding@gmail.com']
+  spec.description   = %q{An HTTP framework for micro-services based environment, build on top of Typheous and Service Jynx}
+  spec.summary       = %q{An HTTP framework for micro-services based environment}
+  spec.homepage      = 'https://github.com/AvnerCohen/restful_client'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+
+  spec.add_runtime_dependency 'service_jynx'
+  spec.add_runtime_dependency 'typhoeus'
+end
+

data/spec/config/restful_services.yml

@@ -0,0 +1,22 @@
+default: &default
+  users:
+    url: http://1.2.3.4:7711/api/v1/
+  posts:
+    url: http://1.2.3.4:8383/api/v1/
+  locally:
+    url: http://127.0.0.1:8383/api/v1/
+  pompa_service:
+    url: http://127.0.0.1:8383/api/v1/
+
+
+development: &development
+<<: *default
+
+production: &production
+  <<: *default
+  users:
+    url: http://1.2.3.4:7711/api/v0/
+  posts:
+    url: http://1.2.3.4:8383/api/v0/
+  locally:
+    url: http://127.0.0.1:8383/api/v0/

data/spec/restful_client_spec.rb

@@ -0,0 +1,394 @@
+require 'spec_helper'
+
+require 'pry'
+
+def set_global(class_name)
+  $some_global = class_name
+end
+
+describe :RestfulClient do
+
+  before(:all) do
+    # Start a local rack server to serve up test pages.
+    server_thread = Thread.new do
+      Rack::Handler::Thin.run MyApp::Test::Server.new, :Port => 8383
+    end
+    sleep(3) # wait a sec for the server to be booted
+  end
+
+  before(:each) do
+    $some_global = nil
+    Typhoeus::Expectation.clear
+    RestfulClient.configuration.reset if RestfulClient.configuration
+  end
+
+  describe "Configuration" do
+
+    it "raise when file_name not sent in" do
+      expect { RestfulClient.configure { } }.to raise_error
+    end
+
+    it "correctly read configuration files" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.configuration.data).to_not eq(nil)
+    end
+
+    it "allow accesing url configuration" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.configuration.data["posts"]["url"]).to eq("http://1.2.3.4:8383/api/v1/")
+    end
+
+    it "allow accesing url configuration by environment" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.configuration.data["posts"]["url"]).to eq("http://1.2.3.4:8383/api/v0/")
+    end
+
+    it "allow should access with legacy configuration as well" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+        config.legacy_postfix = "_service"
+      end
+
+      expect(RestfulClient.callerr_config("pompa")["url"]).to_not eq(nil)
+    end
+
+    it "should register jynx with correct name in case of legacy" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+        config.legacy_postfix = "_service"
+      end
+
+
+      expect(ServiceJynx.alive?("pompa")).to eq(true)
+    end
+
+
+    it "have a logger" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.logger).to respond_to :info
+    end
+
+    it "correctly read the configuration from the registry" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.callerr_config("posts")["url"]).to eq("http://1.2.3.4:8383/api/v0/")
+    end
+
+    it "have a timeout defined for the service by default" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.timeout).to eq(10)
+    end
+
+    it "have a timeout defined for the service by default" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+        config.timeout = 2
+      end
+
+      expect(RestfulClient.timeout).to eq(2)
+    end
+
+    it "have a user agent defined for the service by default" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.user_agent).to eq(RestfulClientConfiguration::DEFAULT_USER_AGENT)
+    end
+
+    it "have a user agent defined for the service" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+        config.user_agent = "users_service"
+      end
+
+      expect(RestfulClient.user_agent).to eq("users_service")
+    end
+
+    it "have a retries defined for the service by default" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.retries).to eq(2)
+    end
+
+    it "have a retries defined for the service by default" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+        config.retries = 15
+      end
+
+      expect(RestfulClient.retries).to eq(15)
+    end
+
+  end
+
+  describe "toJson" do
+
+    it "automatically run to_json on an object" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      some_object = {"moshe" => "test"}
+      res = RestfulClient.post("locally", "/bounce", some_object) { |m| m }
+
+      expect(res).to eq(some_object)
+    end
+
+    it "doesn't re-run json on data that was already a json object" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      some_object = {"moshe" => "test"}.to_json
+      res = RestfulClient.post("locally", "/bounce", some_object) { |m| m }
+
+      expect(res).to eq(JSON.parse(some_object))
+    end
+
+  end
+
+  describe "Restful Client Calls" do
+
+    it "allow sending in a reporting method (such as graylog/ airbrake instrumentiation)" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+        config.report_method = proc do |*args|
+          klass, message = *args
+          set_global(klass)
+        end
+      end
+      RestfulClient.configuration.report_on
+
+      expect($some_global).to eq("RestfulClientConfiguration")
+    end
+
+    it "report on a server error (end-2-end ish test)" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+        config.timeout = 1
+        config.report_method = proc do |*args|
+          klass, message = *args
+          set_global(klass)
+        end
+      end
+      RestfulClient.get("posts", "/a/a/a/a") { nil }
+
+      expect($some_global).to eq("RestError")
+    end
+
+    it "do not report on a client side error (http_code < 500)" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+        config.report_method = proc do |*args|
+          klass, message = *args
+          set_global(klass)
+        end
+      end
+      RestfulClient.get("locally", "/client_error") { nil }
+
+      expect($some_global).to be_nil
+    end
+
+    it "do not report on a missing resource (http_code == 404)" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+        config.report_method = proc do |*args|
+          klass, message = *args
+          set_global(klass)
+        end
+      end
+
+      RestfulClient.get("locally", "/non_existing") { nil }
+
+      expect($some_global).to be_nil
+    end
+
+  end
+
+  describe "Retry call count" do
+
+    it "repeat the call if retry is set " do
+
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+        config.retries = 3
+        config.timeout = 2
+        config.report_method = proc do |*args|
+          klass, message = *args
+          set_global(klass)
+        end
+      end
+
+      # flow is a little wierdish
+      ##Run something that hard codedly, in the test_server, increments the counter
+      RestfulClient.get("locally", "a/a/a/b") { |m| nil }
+      # Now checksomething that returns "200", put also the global server counter
+      # And asset the number of retries. 
+      res = RestfulClient.get("locally", "a") { "good" }
+
+      expect(res["counter"]).to eq(4)
+    end
+
+  end
+
+  describe "Default Value if no block is given" do
+
+    it "should return nil when no value is given" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+        config.timeout = 1
+      end
+      res = RestfulClient.get("posts", "/a")
+      expect(res).to eq(nil)
+    end
+
+    it "should allow skiping jynx completly" do
+      RestfulClient.configure do |config|
+        config.config_folder = "spec/config"
+        config.use_jynx = false
+        config.timeout = 1
+      end
+      res = RestfulClient.get("posts", "/a")
+      expect(res).to eq(nil)
+    end
+
+  end
+
+  describe "Uri Joining" do
+
+    it "correct join two paths leading slash defined as [WithSlash : NoSlash]" do
+      path = RestfulClientUri.uri_join("http://load-balancer-int01:9999/api/v1/", "proposals/sent/count/123")
+      expect(path).to eq("http://load-balancer-int01:9999/api/v1/proposals/sent/count/123")
+    end
+
+    it "correct join two paths leading slash defined as [WithSlash : WithSlash]" do
+      path = RestfulClientUri.uri_join("http://load-balancer-int01:9999/api/v1/", "/proposals/sent/count/123")
+      expect(path).to eq("http://load-balancer-int01:9999/api/v1/proposals/sent/count/123")
+    end
+
+    it "correct join two paths leading slash defined as [NoSlash : WithSlash]" do
+      path = RestfulClientUri.uri_join("http://load-balancer-int01:9999/api/v1", "/proposals/sent/count/123")
+      expect(path).to eq("http://load-balancer-int01:9999/api/v1/proposals/sent/count/123")
+    end
+
+    it "correct join two paths leading slash defined as [NoSlash : NowSlash]" do
+      path = RestfulClientUri.uri_join("http://load-balancer-int01:9999/api/v1", "proposals/sent/count/123")
+      expect(path).to eq("http://load-balancer-int01:9999/api/v1/proposals/sent/count/123")
+    end
+
+  end
+
+  describe "Fake response" do
+
+    it "should return fake response" do
+      RestfulClient.configure { |config| config.config_folder = "spec/config" }
+
+      RestfulClient.fake('locally', 'fake/me') do
+        Typhoeus::Response.new(
+          code: 200,
+          headers: {'Content-Type' => 'application/json'},
+          body: { 'fake' => true }.to_json)
+      end
+
+      res = RestfulClient.get('locally', 'fake/me') { nil }
+      expect(res).to eq({ 'fake' => true })
+    end
+
+  end
+
+  describe "custom headers" do
+    it "should allow sending custom headers to a single post request" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      custom_headers = {"moshe" => "OH MY GOD ~!!"}
+      res = RestfulClient.post("locally", "/bounce_headers/moshe", {}, {"headers" => custom_headers})
+      expect(res).to eq(custom_headers)
+
+    end
+
+    it "should allow sending custom headers to a single get request" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      custom_headers = {"moshe" => "OH MY GOD ~!!"}
+      res = RestfulClient.get("locally", "/bounce_headers/moshe", nil, {"headers" => custom_headers})
+      expect(res).to eq(custom_headers)
+
+    end
+
+    it "should allow sending custom headers to a single delete request" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      custom_headers = {"moshe" => "OH MY GOD ~!!"}
+      res = RestfulClient.delete("locally", "/bounce_headers/moshe", {}, {"headers" => custom_headers})
+      expect(res).to eq(custom_headers)
+
+    end
+
+    it "should allow sending custom headers to a single put request" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      custom_headers = {"moshe" => "OH MY GOD ~!!"}
+      res = RestfulClient.put("locally", "/bounce_headers/moshe", {}, {"headers" => custom_headers})
+      expect(res).to eq(custom_headers)
+
+    end
+
+
+  end
+
+  describe :PlainURL do
+    it "should be possible to get url from yml for custom calls" do
+      RestfulClient.configure do |config|
+        config.env_name = "production"
+        config.config_folder = "spec/config"
+      end
+
+      expect(RestfulClient.srv_url('posts')).to eq("http://1.2.3.4:8383/api/v0/")
+    end
+  end
+
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler.require
+
+require 'rspec'
+
+Dir["./spec/support/**/*.rb"].each {|f| load(f)}
+load("#{File.dirname(__FILE__)}/../lib/restful_client.rb")

data/spec/support/test_server.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'rack'
+require 'json'
+
+module MyApp
+  module Test
+    class Server
+      @@counter = 0
+      def call(env)
+        path = Rack::Utils.unescape(env['PATH_INFO'])
+        ### Hacky just to allow sending a global counter
+        if path == "/api/v0/a/a/a/b"
+          @@counter = @@counter+1
+          sleep 3
+          [ 500, {"Content-Type" => "application/json"}, {counter: @@counter}.to_json ]
+        elsif path == "/api/v0/bounce"
+          [ 200, {'Content-Type' => 'text/plain'}, env['rack.input'].gets ]
+        elsif path == "/api/v0/non_existing"
+          [ 404, {'Content-Type' => 'text/plain'}, {}.to_json ]
+        elsif path == "/api/v0/client_error"
+          [ 400, {'Content-Type' => 'text/plain'}, {}.to_json ]
+        elsif path =~ /\/api\/v0\/bounce_headers/
+            ## this is what rack request is doing to custom headers
+            base_name = path.split("/").last
+            header_name = "HTTP_#{base_name.upcase}"
+          [ 200, {'Content-Type' => 'text/plain'}, {"#{base_name}" => env[header_name]}.to_json ]
+        else
+          [ 200, {'Content-Type' => 'text/plain'}, {counter: @@counter}.to_json ]
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: restful_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Avner Cohen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: service_jynx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An HTTP framework for micro-services based environment, build on top
+  of Typheous and Service Jynx
+email:
+- israbirding@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- lib/restful_client.rb
+- lib/restful_client/version.rb
+- lib/restful_client_configuration.rb
+- lib/restful_client_logger.rb
+- lib/restful_client_uri.rb
+- restful_client.gemspec
+- spec/config/restful_services.yml
+- spec/restful_client_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_server.rb
+homepage: https://github.com/AvnerCohen/restful_client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: An HTTP framework for micro-services based environment
+test_files:
+- spec/config/restful_services.yml
+- spec/restful_client_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_server.rb