service-client 0.0.14

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/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+notifications:
+  email: false
+  campfire: "rumspringa:c0a20e6caab984176e5c72f84241b5f419662257@504871"

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+# 0.0.14 / 2013-08-10
+
+* Adds a way to specify Faraday builder
+
+# 0.0.13 / 2013-07-03
+
+* Adds error message to ServiceErrors
+
+# 0.0.12
+
+* Fixes GET request parameter handling in Faraday adapter
+* Adds JSON Content-Type to each request
+
+# 0.0.11
+
+* Escapes hashes and arrays in GET query parameters properly
+
+# 0.0.10
+
+* Makes GET requests use query parameters instead of a JSON body
+
+# 0.0.9
+
+- Does not error out on empty response bodies anymore
+
+# 0.0.8 - 07th November 2012
+
+- Handles 304 - Not Modified responses correctly
+
+# 0.0.7 - 03rd October 2012
+
+- Fixes the wrongly named Authorization HTTP header
+
+# 0.0.6 - 03rd October 2012
+
+- Moves the token to be passed in to each request instead of per client instance
+
+# 0.0.5 - 03rd October 2012
+
+- Adds OAuth authentication
+
+# 0.0.4 - 14th August 2012
+
+- Fixed bug that prevented the default adapter to be used correctly.
+
+# 0.0.3 - 13th August 2012
+
+The start.

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in service-client.gemspec
+gemspec
+
+gem 'rake'
+
+group :development, :test do
+  gem 'realweb'
+  gem 'guard-minitest'
+  gem 'guard-bundler'
+  gem 'rack-test'
+end
+
+platforms :jruby do
+  gem "jruby-openssl"
+end

data/Guardfile

@@ -0,0 +1,10 @@
+guard :bundler do
+  watch('Gemfile')
+end
+
+guard 'minitest' do
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})  { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})  { |m| "spec/client_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Thorben Schröder
+
+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,117 @@
+# Service::Client
+
+Service::Client is a generic client gem to access our services. It is the base for explicit clients for each service so that those explicit clients are easy and fast to implement and maintain.
+
+This gem should not be used as an "end-user solution".
+
+## Usage
+
+### Client creation
+
+Each client must be instantiated with a base URL to a service.
+
+```ruby
+client = Service::Client.new('http://some=service.example.com/')
+```
+
+### Creating routes
+
+A client route describes a single REST HTTP end-point at the service.
+
+```ruby
+client.urls.add(:author, :post, '/authors/')
+client.urls.add(:author, :get,  '/authors/:id:')
+client.urls.add(:review, :post,  '/author/:author_id:/books/:book_id:')
+```
+
+### Requests
+
+```ruby
+client.post(client.urls.author, token, name: 'Peter Lustig')
+client.get(client.urls.author(123), token)
+client.post(client.urls.review(author_id: 123, book_id: 456), token, name: 'Ronald Review', comment: 'This book is the bomb!')
+```
+
+Each ``Service::Client`` instance supports the ``get``, ``post``, ``put`` and ``delete`` methods. They all share the same method signature of:
+
+```ruby
+client.method(URL, TOKEN, BODY_HASH)
+```
+
+The URL is a relative URL to the base url the client has been created with. TOKEN is an OAuth token to authenticat the request. The BODY_HASH is any Ruby hash. The hash becomes the body of the HTTP request after it has been dumped to JSON.
+
+The ``client.urls`` method makes all the created routes available as an easy to use URL builder. The URL builder takes zero arguments when the URL does not have any arguments. It can also take an array of the URL paramters in their respective order or a hash to built the URL by it's named parameters.
+
+### Response
+
+#### Success
+
+If the HTTP response comes with a 200 status code, the client returns a ``Service::Client::Response`` object. That allows you to query for the JSON decoded data that came along with the body of the HTTP response. If the body was empty that data is just ``true``. You can also reach for the raw HTTP response:
+
+```ruby
+response = client.get(client.urls.author(123), token)
+puts "retrieved a book written by #{response.data['name']} with an HTTP status code of #{response.raw.status}"
+```
+
+#### Redirections
+
+For any redirecting responses the client raises a ``Service::Client::Redirection`` which can be queried for the redirection location:
+
+```ruby
+begin
+  client.get(client.urls.author(123), token)
+rescue Client::Service::Redirection => redirection
+  puts "The client has been redirected to: #{redirection.location}"
+end
+```
+
+#### Errors
+
+For any other response codes the client raises a ``Service::Client::ServiceError`` if the response body was a JSON encoded object with an ``error`` key on the root level.
+
+```ruby
+begin
+  client.get(client.urls.author(678), token)
+rescue Client::Service::ServiceError => e
+  puts "A service error has occured. Error description: #{e.error}"
+end
+```
+
+If the body was not JSON encoded at all or did not include the ``error`` key on the root level a ``Service::Client::ResponseError`` is raised.
+
+```ruby
+begin
+  client.get(client.urls.author(678), token)
+rescue Client::Service::Error => e
+  puts "An error has occured. Error code: #{e.response.status} Error body: #{e.response.body}"
+end
+```
+
+### Raw HTTP requests
+
+The client exposes an interface that can be used to issue raw HTTP requests to any URL relative to the given base URL at creation time.
+
+```ruby
+response = client.raw.post('/authors/123/books', JSON.dump({title: 'The guide to a higher enlightment', isbn: '1234567'}))
+```
+
+The raw client supports the ``get``, ``post``, ``put`` and ``delete`` methods. They all share the same method signature of:
+
+```ruby
+client.raw.method(URL, BODY, OPTIONS)
+```
+
+The options are a hash. Possible arguments are:
+
+* **``headers``**: A hash (string:string) to set the request headers.
+
+### Raw responses
+
+Raw requests return a ``Rack::Response`` object that makes it easy to access the status code, headers and body of the response.
+
+```ruby
+response = client.raw.get('/author/123/books')
+response.body   # "[{title: 'The guide to a higher enlightment', isbn: '1234567', id: 456}, {title: 'Some book', isbn: '23464527', id: 789}]"
+response.status # 200
+response.header # {"Some-Header" => "Some Value", "Another-Header" => "Another Value"}
+```

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :test

data/lib/service-client.rb

@@ -0,0 +1,103 @@
+require "service-client/version"
+require "service-client/error"
+require "service-client/routing_error"
+require "service-client/service_error"
+require "service-client/response_error"
+require "service-client/raw_interface"
+require "service-client/adapter/faraday"
+require "service-client/url_pattern"
+require "service-client/bound_route"
+require "service-client/route"
+require "service-client/route_collection"
+require "service-client/base_response"
+require "service-client/response"
+require "service-client/redirection"
+
+require 'json'
+require 'cgi'
+
+module Service
+  class Client
+    attr_reader :base_url
+
+    def initialize(base_url)
+      @base_url = base_url
+    end
+
+    def raw
+      @raw_interface ||= RawInterface.new(self)
+    end
+
+    def routes
+      @routes ||= RouteCollection.new
+    end
+    alias urls routes
+
+    def get(bound_route, token, body_hash = nil)
+      request(:get, token, bound_route, body_hash)
+    end
+
+    def put(bound_route, token, body_hash = nil)
+      request(:put, token, bound_route, body_hash)
+    end
+
+    def post(bound_route, token, body_hash = nil)
+      request(:post, token, bound_route, body_hash)
+    end
+
+    def delete(bound_route, token, body_hash = nil)
+      request(:delete, token, bound_route, body_hash)
+    end
+
+    protected
+    def request(method, token, bound_route, body_hash)
+      url = bound_route.url_for_method(method)
+
+      body = nil
+      if method == :get
+        url = append_body_hash_to_url(url, body_hash)
+      else
+        body = body_hash ? JSON.dump(body_hash) : ''
+      end
+
+      headers = {
+        'AUTHORIZATION' => "Bearer #{token}",
+        'Content-Type' => 'application/json'
+      }
+
+      raw_response = raw.request(method, url, body, headers: headers)
+      case raw_response.status
+      when 200, 201, 304
+       Response.new(raw_response)
+      when 301, 302, 303, 307
+        raise Redirection.new(raw_response)
+      else
+        error = nil
+        begin
+          error = JSON.parse(raw_response.body.first)['error']
+        rescue JSON::ParserError
+          # treat invalid JSON the same as non-present error field
+        end
+        if error
+          raise ServiceError.new(error)
+        else
+          raise ResponseError.new(raw_response)
+        end
+      end
+    end
+
+    def append_body_hash_to_url(url, body_hash)
+      return url if !body_hash || body_hash.empty?
+
+      uri = URI.parse(url)
+
+      if body_hash && !body_hash.empty?
+        uri.query += '&' if uri.query
+        uri.query ||= ''
+        uri.query += Faraday::Utils.build_nested_query(body_hash)
+      end
+
+      uri.to_s
+    end
+  end
+end

data/lib/service-client/adapter/faraday.rb

@@ -0,0 +1,61 @@
+require 'faraday'
+require 'uri'
+require 'rack'
+
+module Service
+  class Client::Adapter
+    class Faraday
+      def initialize(options = {})
+        @adapter = options.delete :adapter
+        @builder = options.delete :builder
+      end
+
+      def request(method, url, body, options)
+        uri = URI.parse(url)
+
+        connection = create_connection(uri)
+
+        response = send_request(connection, method, uri, body, options)
+
+        Rack::Response.new(response.body || '', response.status, response.headers)
+      end
+
+      protected
+      def send_request(connection, method, uri, body, options)
+        connection.send(method) do |request|
+          request.url path(uri)
+          request.body = body
+          if method == :get && uri.query
+            request.params = ::Faraday::Utils.parse_nested_query(uri.query)
+          end
+          request.headers = options[:headers] || {}
+        end
+      end
+
+      def path(uri)
+        "#{uri.path}"
+      end
+
+      def base_url(uri)
+        "#{uri.scheme}://#{auth(uri)}#{uri.host}:#{uri.port}"
+      end
+
+      def auth(uri)
+        (uri.user && uri.password) ? "#{uri.user}:#{uri.password}@" : ''
+      end
+
+      def create_connection(uri)
+        ::Faraday.new(:url => base_url(uri)) do |faraday|
+          # if this returns false it skips the adapter selection later
+          builder_response = @builder ? @builder.call(faraday) : true
+
+          if @adapter && builder_response
+            faraday.adapter *@adapter
+          else
+            faraday.adapter ::Faraday.default_adapter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/service-client/base_response.rb

@@ -0,0 +1,9 @@
+module Service::Client::BaseResponse
+  def initialize(raw_response)
+    @raw_response = raw_response
+  end
+
+  def raw
+    @raw_response
+  end
+end

data/lib/service-client/bound_route.rb

@@ -0,0 +1,40 @@
+class Service::Client::BoundRoute
+  def initialize(route, args)
+    @route = route
+    @args = args || []
+  end
+
+  def url_for_method(method)
+    pattern = @route.pattern_for(method)
+
+    raise Service::Client::RoutingError.new("Method #{method} unsupported!") unless pattern
+
+    pattern.filled_with(options_for_pattern(pattern))
+  end
+
+  protected
+  def options_for_pattern(pattern)
+    if args_are_a_hash?
+      @args.first
+    else
+      options_for_pattern_from_args_array(pattern)
+    end
+  end
+
+  def args_are_a_hash?
+    @args.size == 1 && @args.first.kind_of?(Hash)
+  end
+
+  def options_for_pattern_from_args_array(pattern)
+    if @args.size != pattern.placeholders.size
+      raise Service::Client::RoutingError.new("Number of URL arguments does not match! Given: #{@args.inspect} Expected: #{pattern.placeholders.inspect}")
+    end
+
+    cloned_args = @args.clone
+    options = {}
+    pattern.placeholders.each do |placeholder|
+      options[placeholder] = cloned_args.shift
+    end
+    options
+  end
+end

data/lib/service-client/error.rb

@@ -0,0 +1,4 @@
+class Service::Client
+  class Error < StandardError
+  end
+end

data/lib/service-client/raw_interface.rb

@@ -0,0 +1,48 @@
+require 'uri'
+
+module Service
+  class Client
+    class RawInterface
+      def initialize(client)
+        @client = client
+      end
+
+      def get(url, body, options)
+        request(:get, url, body, options)
+      end
+
+      def put(url, body, options)
+        request(:put, url, body, options)
+      end
+
+      def post(url, body, options)
+        request(:post, url, body, options)
+      end
+
+      def delete(url, body, options)
+        request(:delete, url, body, options)
+      end
+
+      def adapter
+        @adapter ||= default_adapter
+      end
+
+      def adapter=(new_adapter)
+        @adapter = new_adapter
+      end
+
+      def request(method, url, body, options)
+        adapter.request(method, absolutize_url(url), body, options)
+      end
+
+      protected
+      def default_adapter
+        Adapter::Faraday.new
+      end
+
+      def absolutize_url(url)
+        URI::join(@client.base_url, url).to_s
+      end
+    end
+  end
+end

data/lib/service-client/redirection.rb

@@ -0,0 +1,7 @@
+class Service::Client::Redirection < Exception
+  include Service::Client::BaseResponse
+
+  def location
+    raw.header.detect {|k,v| k.to_s.downcase == 'location'}.last
+  end
+end

data/lib/service-client/response.rb

@@ -0,0 +1,13 @@
+require 'json'
+
+class Service::Client::Response
+  include Service::Client::BaseResponse
+
+  attr_reader :data
+
+  def initialize(raw_response)
+    super(raw_response)
+    body = raw.body.first
+    @data = body.empty? ? true : JSON.parse(body)
+  end
+end

data/lib/service-client/response_error.rb

@@ -0,0 +1,7 @@
+class Service::Client::ResponseError < Service::Client::Error
+  attr_reader :response
+
+  def initialize(response)
+    @response = response
+  end
+end

data/lib/service-client/route.rb

@@ -0,0 +1,18 @@
+class Service::Client::Route
+  def add_pattern(method, pattern)
+    patterns[method] = Service::Client::UrlPattern.new(pattern)
+  end
+
+  def bind(*args)
+    Service::Client::BoundRoute.new(self, args)
+  end
+
+  def pattern_for(method)
+    patterns[method]
+  end
+
+  protected
+  def patterns
+    @patterns ||= {}
+  end
+end

data/lib/service-client/route_collection.rb

@@ -0,0 +1,18 @@
+class Service::Client::RouteCollection
+  def add(name, method, pattern)
+    name = name.to_sym
+
+    route = routes[name] ||= Service::Client::Route.new
+    route.add_pattern(method, pattern)
+  end
+
+  protected
+  def routes
+    @routes ||= {}
+  end
+
+  def method_missing(name, *args)
+    raise Service::Client::RoutingError.new("No route named #{name}") unless route = routes[name.to_sym]
+    route.bind(*args)
+  end
+end

data/lib/service-client/routing_error.rb

@@ -0,0 +1,2 @@
+class Service::Client::RoutingError < Service::Client::Error
+end

data/lib/service-client/service_error.rb

@@ -0,0 +1,8 @@
+class Service::Client::ServiceError < Service::Client::Error
+  attr_reader :error
+
+  def initialize(error)
+    super(error)
+    @error = error
+  end
+end

data/lib/service-client/url_pattern.rb

@@ -0,0 +1,20 @@
+class Service::Client::UrlPattern
+  def initialize(pattern)
+    @pattern = pattern
+    @pattern.scan(/:([^:]+):/).each do |placeholder|
+      placeholders << placeholder.first.to_sym
+    end
+  end
+
+  def filled_with(options)
+    url = @pattern.clone
+    placeholders.each do |placeholder|
+      url.gsub!(/:#{Regexp.escape(placeholder.to_s)}:/, options[placeholder].to_s)
+    end
+    url
+  end
+
+  def placeholders
+    @placeholders ||= []
+  end
+end

data/lib/service-client/version.rb

@@ -0,0 +1,5 @@
+module Service
+  class Client
+    VERSION = "0.0.14"
+  end
+end

data/service-client.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/service-client/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Thorben Schröder"]
+  gem.email         = ["stillepost@gmail.com"]
+  gem.description   = %q{Service::Client is a generic client gem to access our services. It is the base for explicit clients for each service so that those explicit clients are easy and fast to implement and maintain.}
+  gem.summary       = %q{Service::Client is a generic client gem to access our services.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "service-client"
+  gem.require_paths = ["lib"]
+  gem.version       = Service::Client::VERSION
+
+  gem.add_dependency 'faraday', '0.8.1'
+  gem.add_dependency 'json'
+end

data/spec/adapter/faraday_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../spec_helper'
+require 'realweb'
+require 'json'
+
+describe Service::Client::Adapter::Faraday do
+  before do
+    $__service_client_test_server ||= RealWeb.start_server_in_thread(File.expand_path("../test_server.ru", __FILE__))
+    @server = $__service_client_test_server
+    @url = @server.base_uri.to_s
+    @adapter = Service::Client::Adapter::Faraday.new
+  end
+
+  after do
+    unless $__service_client_stop_defined
+      self.class.class_eval do
+        at_exit do
+          puts "Shutting down server"
+          $__service_client_test_server.stop
+        end
+      end
+    end
+    $__service_client_stop_defined = true
+  end
+
+  headers = {
+    'USER-AGENT' => 'service-client-spec',
+    'REFERER' => 'http://super.example.com/'
+  }
+  body = 'This is a test'
+  [:get, :put, :post, :delete].each do |method|
+    it "sends correct #{method} requests" do
+      response = @adapter.request(method, @url, body, {headers: headers})
+      response.status.must_equal 200
+      request = JSON.parse(response.body.first)
+      request['body'].must_equal body
+      request['method'].must_equal method.to_s.upcase
+      headers.each do |key, value|
+        request['headers'][key].must_equal value
+      end
+    end
+  end
+
+  it "can use other Faraday adapters" do
+    ran = false
+    app = lambda {|env| ran = true; [200, {'Content-Type' => 'text/html'}, ["ran"]]}
+    adapter = Service::Client::Adapter::Faraday.new(adapter: [:rack, app])
+    adapter.request(:get, 'http://example.com/adapter_change', '', {})
+    ran.must_equal true
+  end
+
+  describe 'faraday builder' do
+    it 'can be used' do
+      ran = false
+      builder_called = false
+      app = lambda {|env| ran = true; [200, {'Content-Type' => 'text/html'}, ["ran"]]}
+      adapter = Service::Client::Adapter::Faraday.new(adapter: [:rack, app], builder: lambda {|faraday| builder_called = true})
+      adapter.request(:get, 'http://example.com/adapter_change', '', {})
+      ran.must_equal true
+      builder_called.must_equal true
+    end
+
+    it 'can skip the adapter call' do
+      ran = false
+      builder_called = false
+      app = lambda {|env| ran = true; [200, {'Content-Type' => 'text/html'}, ["ran"]]}
+      adapter = Service::Client::Adapter::Faraday.new(adapter: [:rack, app], builder: lambda {|faraday| builder_called = true; false})
+      adapter.request(:get, 'http://example.com/adapter_change', '', {})
+      # must be false because the rack adapter is not used as the builder returns false
+      ran.must_equal false
+      builder_called.must_equal true
+    end
+  end
+end

data/spec/adapter/test_server.ru

@@ -0,0 +1,13 @@
+require 'json'
+
+run lambda {|env|
+  request = Rack::Request.new(env)
+  method = request.request_method
+  headers = Hash[env.select {|k,v| k =~ /^HTTP_/}.map {|k,v| [k.gsub(/^HTTP_/, '').gsub('_', '-'), v]}]
+  body = request.body.read
+  [200, { 'Content-Type' => 'application/json' }, [JSON.dump(
+    method: method,
+    headers: headers,
+    body: body
+  )]]
+}

data/spec/client_spec.rb

@@ -0,0 +1,195 @@
+require_relative './spec_helper'
+require 'json'
+
+TOKEN = '123'
+
+def must_send_request(method, url, json = nil, options = {}, &blck)
+  @client.raw.adapter.expect :request, Rack::Response.new('', 200, {}), [method, url, json ? JSON.dump(json) : nil, options]
+  yield
+  @client.raw.adapter.verify
+  @client.raw.adapter = MiniTest::Mock.new
+end
+
+def must_raise_response_error(body)
+  raw_response = Rack::Response.new(body, 500, {})
+  @client.raw.adapter.expect :request, raw_response, [:get, 'http://example.com/authors/123', body, {}]
+  begin
+    @client.get(@client.urls.author(123), TOKEN)
+    flunk "Must raise Service::Client::ResponseError but didn't!"
+   rescue Service::Client::ResponseError => e
+     e.response.status.must_equal 500
+     e.response.body.must_equal [body]
+   end
+end
+
+describe Service::Client do
+  before do
+    @client = Service::Client.new('http://example.com')
+    @client.raw.adapter = MiniTest::Mock.new
+  end
+
+  describe "raw interface" do
+    it "is exposed" do
+      @client.raw.must_be_instance_of Service::Client::RawInterface
+    end
+
+    args = ['/bla', :body, :options]
+    url, body, options = args
+    [:get, :put, :post, :delete].each do |method|
+      it "passes #{method} requests through to the HTTP adapter" do
+        @client.raw.adapter.expect :request, true, [method, 'http://example.com/bla', body, options]
+        @client.raw.send(method, *args)
+        @client.raw.adapter.verify
+      end
+    end
+  end
+
+  it "uses the faraday adapter as a default" do
+    Service::Client.new('http://example.com').raw.adapter.must_be_instance_of Service::Client::Adapter::Faraday
+  end
+
+  describe "high level interface" do
+    before do
+      @client.urls.add(:author, :post, '/authors/')
+      @client.urls.add(:author, :get,  '/authors/:id:')
+      @client.urls.add(:author_with_query, :get,  '/authors/:id:/another-fixed-part?blub=1')
+      @client.urls.add(:review, :post,  '/authors/:author_id:/books/:book_id:')
+    end
+
+    it "calls the right url with the right method after adding it" do
+      must_send_request(:post, 'http://example.com/authors/', {name: 'Peter Lustig'}, headers: {'AUTHORIZATION' => "Bearer #{TOKEN}", 'Content-Type' => 'application/json'}) do
+        @client.post(@client.urls.author, TOKEN, name: 'Peter Lustig')
+      end
+
+      must_send_request(:get, 'http://example.com/authors/123', nil, headers: {'AUTHORIZATION' => "Bearer #{TOKEN}", 'Content-Type' => 'application/json'}) do
+        @client.get(@client.urls.author(123), TOKEN)
+      end
+
+      must_send_request(:post, 'http://example.com/authors/123/books/456', {name: 'Ronald Review', comment: 'This book is the bomb!'}, headers: {'AUTHORIZATION' => "Bearer #{TOKEN}", 'Content-Type' => 'application/json'}) do
+        @client.post(@client.urls.review(author_id: 123, book_id: 456), TOKEN, name: 'Ronald Review', comment: 'This book is the bomb!')
+      end
+
+      must_send_request(:post, 'http://example.com/authors/123/books/456', {name: 'Ronald Review', comment: 'This book is the bomb!'}, headers: {'AUTHORIZATION' => "Bearer #{TOKEN}", 'Content-Type' => 'application/json'}) do
+        @client.post(@client.urls.review(123, 456), TOKEN, name: 'Ronald Review', comment: 'This book is the bomb!')
+      end
+    end
+
+    it "uses query parameters instead of JSON bodies for GET requests" do
+      must_send_request(:get, 'http://example.com/authors/123?some=arguments&are=cool%26not%3Dbody&array%5B%5D=12&array%5B%5D=gla&hash%5Bblub%5D=123&hash%5Bbla%5D=moep', nil, headers: {'AUTHORIZATION' => "Bearer #{TOKEN}", 'Content-Type' => 'application/json'}) do
+        @client.get(@client.urls.author(123), TOKEN, {some: 'arguments', are: "cool&not=body", array: ["12", 'gla'], hash: {"blub" => "123", "bla" => "moep"}})
+      end
+
+      must_send_request(:get, 'http://example.com/authors/123/another-fixed-part?blub=1&some=arguments&are=cool%26not%3Dbody', nil, headers: {'AUTHORIZATION' => "Bearer #{TOKEN}", 'Content-Type' => 'application/json'}) do
+        @client.get(@client.urls.author_with_query(123), TOKEN, {some: 'arguments', are: "cool&not=body"})
+      end
+    end
+
+    it "raises an error when no route for a given method/resource combination exist" do
+      lambda {
+        @client.post(@client.urls.author(123), TOKEN)
+      }.must_raise Service::Client::RoutingError
+
+      lambda {
+        @client.get(@client.urls.author, TOKEN)
+      }.must_raise Service::Client::RoutingError
+
+      lambda {
+        @client.get(@client.urls.review(123, 456), TOKEN, name: 'Ronald Review', comment: 'This book is the bomb!')
+      }.must_raise Service::Client::RoutingError
+
+      lambda {
+        @client.get(@client.urls.comments, TOKEN)
+      }.must_raise Service::Client::RoutingError
+    end
+
+    describe "responses" do
+      describe "successful" do
+        statuses = [200, 201]
+        statuses.each do |status|
+          describe "with status #{status}" do
+            before do
+              @body = JSON.dump(name: 'Peter Lustig', age: 76)
+              @headers = {}
+              raw_response = Rack::Response.new(@body, status, @headers)
+              @client.raw.adapter.expect :request, raw_response, [:get, 'http://example.com/authors/123', '', {}]
+              @response = @client.get(@client.urls.author(123), TOKEN)
+            end
+
+            it "has the raw data" do
+              @response.raw.status.must_equal status
+              @response.raw.body.must_equal [@body]
+              @headers.each do |key, value|
+                @response.raw.header[key].must_equal value
+              end
+            end
+
+            it "parses them" do
+              @response.data['name'].must_equal 'Peter Lustig'
+              @response.data['age'].must_equal 76
+            end
+
+            it "returns true for data if the response is empty" do
+              raw_response = Rack::Response.new('', status, {})
+              @client.raw.adapter.expect :request, raw_response, [:get, 'http://example.com/authors/456', '', {}]
+              @response = @client.get(@client.urls.author(456), TOKEN)
+              @response.data.must_equal true
+            end
+          end
+        end
+      end
+
+      describe "redirections" do
+        statuses = [301, 302, 303, 307]
+        statuses.each do |status|
+          it "raises a Service::Client::Redirection with the location for HTTP status #{status}" do
+            @client.raw.adapter.expect :request, Rack::Response.new('', status, {Location: 'http://example.com/somewhere/else'}), [:get, 'http://example.com/authors/123', '', {}]
+
+            begin
+              @client.get(@client.urls.author(123), TOKEN)
+              flunk "Must raise Service::Client::Redirection but didn't!"
+            rescue Service::Client::Redirection => e
+              e.location.must_equal 'http://example.com/somewhere/else'
+            end
+          end
+        end
+      end
+
+      describe "errors" do
+        describe "when error field is present" do
+          before do
+            @body = JSON.dump(error: 'This is why!')
+          end
+
+          error_states = [400, 401, 403, 404, 500]
+          error_states.each do |error_state|
+            it "raises an Service::Client::ServiceError for HTTP status code #{error_state}" do
+              raw_response = Rack::Response.new(@body, error_state, {})
+              @client.raw.adapter.expect :request, raw_response, [:get, 'http://example.com/authors/123', @body, {}]
+
+              begin
+                @client.get(@client.urls.author(123), TOKEN)
+                flunk "Must raise Service::Client::ServiceError but didn't!"
+              rescue Service::Client::ServiceError => e
+                e.error.must_equal 'This is why!'
+              end
+            end
+          end
+        end
+
+        describe "raises Service::Client::ResponseError when body is" do
+          it "empty" do
+            must_raise_response_error('')
+          end
+
+          it "invalid JSON" do
+            must_raise_response_error('some stuff but not json')
+          end
+
+          it "valid JSON but has no error field" do
+            must_raise_response_error(JSON.dump(missing: 'error', field: true))
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+Bundler.setup
+
+require 'minitest/autorun'
+
+require 'service-client'

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: service-client
+version: !ruby/object:Gem::Version
+  version: 0.0.14
+  prerelease: 
+platform: ruby
+authors:
+- Thorben Schröder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: json
+  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'
+description: Service::Client is a generic client gem to access our services. It is
+  the base for explicit clients for each service so that those explicit clients are
+  easy and fast to implement and maintain.
+email:
+- stillepost@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/service-client.rb
+- lib/service-client/adapter/faraday.rb
+- lib/service-client/base_response.rb
+- lib/service-client/bound_route.rb
+- lib/service-client/error.rb
+- lib/service-client/raw_interface.rb
+- lib/service-client/redirection.rb
+- lib/service-client/response.rb
+- lib/service-client/response_error.rb
+- lib/service-client/route.rb
+- lib/service-client/route_collection.rb
+- lib/service-client/routing_error.rb
+- lib/service-client/service_error.rb
+- lib/service-client/url_pattern.rb
+- lib/service-client/version.rb
+- service-client.gemspec
+- spec/adapter/faraday_spec.rb
+- spec/adapter/test_server.ru
+- spec/client_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Service::Client is a generic client gem to access our services.
+test_files:
+- spec/adapter/faraday_spec.rb
+- spec/adapter/test_server.ru
+- spec/client_spec.rb
+- spec/spec_helper.rb