rapidash 0.2.2 → 0.3.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc2547c5c59b614c4e483ade6e06387a5daa74fe
-  data.tar.gz: be96076c18545377419376da043dfb689f319c3f
+  metadata.gz: 9c189f614b87a9f1d01e06b573191ab55cfc5304
+  data.tar.gz: 4e105da2de17bca6c15e66055e9cae54f9f2e502
 SHA512:
-  metadata.gz: a440f140a6e093e5cdd6722251248609ac54400936d692ad9f152b83502413821ce534fb3ccbcc36d4d25138b90a35391060472cdf664ce3aab6df43b89ae299
-  data.tar.gz: 851d7dbbc4f05207fa45c0f64c4db4b44a16f6aa0503bfbb410e2383caffc84ad7dc75639c24e93bfd8f6be5b19a5c230a5eb06622d92234515c0b81569bd31e
+  metadata.gz: cf3736b55a2373d1f29addff7e56904f3a7eed7c457797f984de95f7447a451e1f8d6f097e7e17125da7c0ac3dd9a65cab232090e24ac55c7b02f6290936fbb1
+  data.tar.gz: 2917f78dda7987f293c15d95cc760d901f597aec9d8a300552257f68720cf466d304a239b2dfadbbef07ebed9741c375985c273e5ba271ba8032c891c1d61ebe

data/.travis.yml

@@ -4,3 +4,7 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode

data/lib/faraday/response/raise_rapidash_error.rb

@@ -0,0 +1,13 @@
+require 'faraday'
+
+module Faraday
+  class Response::RaiseRapidashError < Response::Middleware
+
+    def on_complete(env)
+      status = env[:status].to_i
+      klass = Rapidash.response_exception_class || Rapidash::ResponseError
+      raise klass.new(env) if (400..599).include?(status)
+    end
+
+  end
+end

data/lib/rapidash/client.rb

@@ -9,7 +9,7 @@ module Rapidash
     end
 
     class << self
-      attr_accessor :patch, :raise_error
+      attr_accessor :patch, :raise_error, :extension, :encoder
 
       def method(method)
         case method
@@ -36,6 +36,32 @@ module Rapidash
       def raise_errors
         @raise_error = true
       end
+
+      # How should the request body for POST and PUT requests
+      # be formatted.
+      #
+      # Examples:
+      #   class Client < Rapidash::Client
+      #     encode_request_with :json
+      #   end
+      #
+      # Arguments:
+      #
+      # format - Symbol. One of :url_encoded, :multipart, :json
+      #
+      # Returns String of set format
+      def encode_request_with(format)
+        format = format.to_s.to_sym
+
+        unless [:url_encoded, :multipart, :json].include?(format)
+          raise ArgumentError, 'you must pass one of :url_encoded, :multipart or :json to encode_request_with'
+        end
+
+        # Map json to multi_json to make it consistent with MutiJson parsing of responses
+        format = :multi_json if format == :json
+
+        @encoder ||= format
+      end
     end
 
     # Instance methods
@@ -79,5 +105,25 @@ module Rapidash
     def delete(url, options = {})
       request(:delete, url, options)
     end
+
+    private
+
+    def connection_builder
+      lambda do |builder|
+        builder.request self.class.encoder || :url_encoded
+
+        if self.class.respond_to?(:raise_error) && self.class.raise_error
+          builder.use Faraday::Response::RaiseRapidashError
+        end
+
+        builder.use FaradayMiddleware::FollowRedirects
+        builder.use FaradayMiddleware::Mashify
+
+        builder.use FaradayMiddleware::MultiJson::ParseJson, :content_type => /\bjson$/
+        builder.use FaradayMiddleware::ParseXml, :content_type => /\bxml$/
+
+        builder.adapter :net_http
+      end
+    end
   end
 end

data/lib/rapidash/http_client.rb

@@ -1,4 +1,6 @@
 require 'faraday'
+require 'faraday_middleware'
+require 'faraday_middleware/multi_json'
 
 module Rapidash
   module HTTPClient
@@ -13,31 +15,21 @@ module Rapidash
 
     def connection
       raise ConfigurationError.new "Site is required" unless site
-      @connection ||= Faraday.new(site)
+
+      @connection ||= Faraday.new(site) do |builder|
+        if login || password
+          builder.use Faraday::Request::BasicAuthentication, login, password
+        end
+
+        connection_builder.call(builder)
+      end
     end
 
     def request(verb, url, options = {})
       url = connection.build_url(normalize_url(url), options[:params]).to_s
-      response = connection.run_request verb, url, options[:body], options[:header] do |request|
-        request.headers.update(:Authorization => connection.basic_auth(login, password)) if login && password
-      end
+      response = connection.run_request(verb, url, options[:body], options[:header])
 
-      process_response(response, verb, options)
-    end
-
-    def process_response(response, verb, options)
-      # "foo"[0] does not work in 1.8.7, "foo"[0,1] is required
-      case response.status.to_s[0, 1]
-      when "5", "4"
-        error = ResponseError.new(response)
-        raise error if self.class.respond_to?(:raise_error) && self.class.raise_error
-        return nil
-      #Handle redirects
-      when "3"
-        request(verb, response.headers["location"], options)
-      when "2"
-        return Response.new(response)
-      end
+      response.body
     end
   end
 end

data/lib/rapidash/oauth_client.rb

@@ -25,7 +25,7 @@ module Rapidash
       options[:raise_errors] = self.class.respond_to?(:raise_error) && self.class.raise_error
       response = oauth_access_token.send(verb.to_sym, "#{site}/#{url}", options)
 
-      Response.new(response)
+      response.body
     end
 
     def access_token_from_code(code, url)
@@ -36,7 +36,7 @@ module Rapidash
     private
 
     def client
-      @oauth_client ||= ::OAuth2::Client.new(uid, secret, :site => site) 
+      @oauth_client ||= ::OAuth2::Client.new(uid, secret, :site => site, :connection_build => connection_builder)
     end
 
     def oauth_access_token

data/lib/rapidash/response_error.rb

@@ -0,0 +1,74 @@
+module Rapidash
+
+  # Rapidash::ResponseError
+  # Exception that gets raised if the response is an error (4xx or 5xx)
+  # Raised by Faraday::Response::RaiseRapidashError
+  # see lib/faraday/response/raise_rapidash_error.rb
+  #
+  # Formats a readable error message including HTTP status, method and requested URL
+  #
+  # Examples:
+  #
+  #   client.posts.create!(title: '')
+  #   Rapidash::ResponseError: 422 POST http://acme.com/api/v1/posts.json
+  #
+  #   begin
+  #     client.posts.create!(title: '')
+  #   rescue Rapidash::ResponseError => response
+  #     response.status # => 422
+  #     response.method # => "POST"
+  #     response.url # => "http://acme.com/api/v1/posts.json"
+  #     response.body # => "{"errors":["title can't be blank", "body can't be blank"]}"
+  #   end
+  #
+  # Hint: Can be easily sub-classed to provide a custom exception handler class
+  # with specific error formatting. Defining an `errors` method that returns a String or Array
+  # will include the errors in the exception message:
+  #
+  #   class MyCustomResponseError < Rapidash::ResponseError
+  #     def errors
+  #       data = JSON.parse(body)
+  #       data['errors']
+  #     end
+  #   end
+  #
+  #   Rapidash.response_exception_class = MyCustomResponseError
+  #
+  #   client.posts.create!(title: '')
+  #   MyCustomResponseError: 422 POST http://acme.com/api/v1/posts.json | Errors: title can't be blank, body can't be blank
+  #
+  #   begin
+  #     client.posts.create!(title: '')
+  #   rescue Rapidash::ResponseError => response
+  #     response.status # => 422
+  #     response.errors # => ["title can't be blank", "body can't be blank"]
+  #   end
+  #
+  class ResponseError < StandardError
+    attr_reader :response, :body, :status, :method, :url
+
+    def initialize(response = nil)
+      @response = response
+
+      @body = response[:body]
+      @status = response[:status].to_i
+      @method = response[:method].to_s.upcase
+      @url = response[:url]
+
+      super(message)
+    end
+
+    private
+
+    def message
+      msg = "#{status} #{method} #{url}"
+
+      if respond_to?(:errors) && !(errors.blank?)
+        errors.map(&:to_s).join(', ') if errors.kind_of?(Array)
+        msg = "#{msg} | Errors: #{errors.to_s}"
+      end
+
+      msg
+    end
+  end
+end

data/lib/rapidash/test_client.rb

@@ -1,13 +1,62 @@
+# Rapidash::TestClient
+# A dummy client for testing with. Create a new test
+# client by including this module and initializing
+# with a set of responses.
+# Example:
+#
+#   class TesterClient
+#    include Rapidash::TestClient
+#   end
+#
+#   responses = {
+#     get: { "foo" => "bar" },
+#     post: { "baz" => "data" }
+#   }
+#
+#   client = TesterClient.new(responses)
+#
+# Example with JSON support:
+#
+#   responses = {
+#     get: { "foo" => '{"some": 123, "json": 456}' }
+#   }
+#
+#   client = TesterClient.new(responses, json: true)
 module Rapidash
   module TestClient
-    attr_accessor :responses
+    attr_reader :responses, :stubs, :json
 
-    def initialize(options = {})
-      @responses = options.delete(:responses)
+    def initialize(responses, options = {})
+      @json = options[:json] || false
+      @responses = responses
+      build_stubs
     end
 
     def request(verb, url, options = {})
-      Response.new(responses[verb][url])
+      connection.send(verb, url, options).body
+    end
+
+    private
+
+    def build_stubs
+      @stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+        responses.each_pair do |verb, req|
+          req.each_pair do |url, body|
+            stub.send(verb, url) { [200, {}, body] }
+          end
+        end
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new do |builder|
+        builder.adapter :test, stubs
+        builder.use FaradayMiddleware::Mashify
+
+        if json
+          builder.use FaradayMiddleware::ParseJson
+        end
+      end
     end
   end
 end

data/lib/rapidash/version.rb

@@ -1,3 +1,3 @@
 module Rapidash
-  VERSION = "0.2.2"
+  VERSION = "0.3.0.beta"
 end

data/lib/rapidash.rb

@@ -1,11 +1,12 @@
 #Required for pluralization and camelcasing
 require "active_support/core_ext/string"
+require "active_support/core_ext/module/attribute_accessors"
+require "json"
 
 require "rapidash/version"
 
-require "rapidash/errors"
-
-require "rapidash/response"
+require "faraday/response/raise_rapidash_error"
+require "rapidash/response_error"
 
 require "rapidash/resourceable"
 require "rapidash/client"
@@ -18,4 +19,7 @@ require "rapidash/oauth_client"
 require "rapidash/test_client"
 
 module Rapidash
+  mattr_accessor :response_exception_class
+
+  class ConfigurationError < StandardError; end
 end

data/rapidash.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rapidash/version'
+require "rapidash/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "rapidash"
@@ -22,11 +22,16 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 2.8"
   spec.add_development_dependency "simplecov", "~> 0.7"
+  spec.add_development_dependency "json"
 
-  spec.add_dependency 'json'
-  spec.add_dependency 'faraday', '~> 0.8'
+  spec.add_dependency "faraday", "~> 0.8"
+  spec.add_dependency "faraday_middleware", "~> 0.9"
+  spec.add_dependency "faraday_middleware-multi_json", "~> 0.0"
   spec.add_dependency "oauth2", "~>0.6"
   spec.add_dependency "hashie", "~>1.2"
-  spec.add_dependency "activesupport", "~>3.0"
-
+  if RUBY_VERSION < "1.9.3"
+    spec.add_dependency "activesupport", "~> 3.0"
+  else
+    spec.add_dependency "activesupport", ">= 3.0.0"
+  end
 end

data/spec/faraday/raise_rapidash_error_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Faraday::Response::RaiseRapidashError do
+  context "successful response" do
+    let(:env) { { :status => '200' } }
+
+    it "should not raise an exception" do
+      expect {
+        subject.on_complete(env)
+      }.to_not raise_exception(Rapidash::ResponseError)
+    end
+  end
+
+  context "error response" do
+    let(:env) { { :status => '404', :method => 'post', :url => 'http://acme.com/api/posts' } }
+
+    it "should raise an exception" do
+      expect {
+        subject.on_complete(env)
+      }.to raise_exception(Rapidash::ResponseError)
+    end
+
+    describe "custom reponse error" do
+      before :each do
+        class MyCustomResponseError < Rapidash::ResponseError; end
+        Rapidash.response_exception_class = MyCustomResponseError
+      end
+
+      it "should raise a custom excpetion class if specified" do
+        expect {
+          subject.on_complete(env)
+        }.to raise_exception(MyCustomResponseError)
+      end
+
+      after :each do
+        Rapidash.response_exception_class = nil
+      end
+    end
+  end
+end

data/spec/rapidash/client_spec.rb

@@ -1,10 +1,5 @@
 require 'spec_helper'
 
-class Client < Rapidash::Client
-  method :test
-end
-
-
 class OAuthClientTester < Rapidash::Client
   method :oauth
 end
@@ -25,13 +20,13 @@ class HTTPClientErrorTester < HTTPClientTester
   raise_errors
 end
 
-class TestClientTester
+class TestClientTester < Rapidash::Client
   method :test
 end
 
 describe Rapidash::Client do
 
-  let!(:subject) { Client.new }
+  let(:test_client) { TestClientTester.new({}) }
 
   describe "#method" do
     it "should include the HTTPClient" do
@@ -45,8 +40,7 @@ describe Rapidash::Client do
     end
 
     it "should include the OAuthClient" do
-      client = TestClientTester.new
-      client.class.ancestors.should include(Rapidash::TestClient)
+      test_client.class.ancestors.should include(Rapidash::TestClient)
     end
 
     it "should raise an error on anything else" do
@@ -85,61 +79,75 @@ describe Rapidash::Client do
 
   describe ".site=" do
     it "should clear the connection variable after set new site" do
-      subject.instance_variable_get(:@connection).should eql(nil)
-      subject.site = "foo"
-      subject.instance_variable_set(:@connection, "Not nil")
+      test_client.instance_variable_get(:@connection).should eql(nil)
+      test_client.site = "foo"
+      test_client.instance_variable_set(:@connection, "Not nil")
 
-      subject.site = "bar"
-      subject.instance_variable_get(:@connection).should eql(nil)
+      test_client.site = "bar"
+      test_client.instance_variable_get(:@connection).should eql(nil)
     end
 
     it "should set the site variable" do
-      subject.instance_variable_get(:@site).should eql(nil)
-      subject.site = "foo"
-      subject.instance_variable_get(:@site).should eql("foo")
+      test_client.instance_variable_get(:@site).should eql(nil)
+      test_client.site = "foo"
+      test_client.instance_variable_get(:@site).should eql("foo")
     end
   end
 
+  describe ".encode_request_with" do
+    let(:klass) { test_client.class }
+
+    it "should set encoder for valid argument" do
+      klass.encode_request_with(:json)
+      expect(klass.encoder).to eq :json
+    end
+
+    it "should raise exception for invalid argument" do
+      expect {
+        klass.encode_request_with(:wibble)
+      }.to raise_exception(ArgumentError)
+    end
+  end
 
   describe ".get" do
     it "should call request" do
-      subject.should_receive(:request).with(:get, "foo", {})
-      subject.get("foo")
+      test_client.should_receive(:request).with(:get, "foo", {})
+      test_client.get("foo")
     end
   end
 
   describe ".post" do
     it "should call request" do
-      subject.should_receive(:request).with(:post, "foo", {})
-      subject.post("foo")
+      test_client.should_receive(:request).with(:post, "foo", {})
+      test_client.post("foo")
     end
   end
 
   describe ".put" do
     it "should call request" do
-      subject.should_receive(:request).with(:put, "foo", {})
-      subject.put("foo")
+      test_client.should_receive(:request).with(:put, "foo", {})
+      test_client.put("foo")
     end
   end
 
   describe ".patch" do
     it "should call request" do
-      subject.should_receive(:request).with(:patch, "foo", {})
-      subject.patch("foo")
+      test_client.should_receive(:request).with(:patch, "foo", {})
+      test_client.patch("foo")
     end
   end
 
   describe ".delete" do
     it "should call request" do
-      subject.should_receive(:request).with(:delete, "foo", {})
-      subject.delete("foo")
+      test_client.should_receive(:request).with(:delete, "foo", {})
+      test_client.delete("foo")
     end
   end
 
   describe ".normalize_url" do
     it "should use the instance extension if set" do
-      subject.extension = :json
-      subject.normalize_url("users").should eql("users.json")
+      test_client.extension = :json
+      test_client.normalize_url("users").should eql("users.json")
     end
 
     it "should use the class extension if set" do
@@ -147,7 +155,7 @@ describe Rapidash::Client do
     end
 
     it "should return the url if no extension if set" do
-      subject.normalize_url("users").should eql("users")
+      test_client.normalize_url("users").should eql("users")
     end
   end
 end

data/spec/rapidash/http_client_spec.rb

@@ -46,64 +46,25 @@ describe Rapidash::HTTPClient do
     end
 
     describe "authorization" do
-      let!(:options) { { :login => "login", :password => "password" } }
-      let!(:subject) { HTTPTester.new(options) }
+      let!(:subject) { HTTPTester.new(:login => "login", :password => "password") }
 
-      it "should authorize with login and password" do
-        subject.should_receive(:process_response).with("response", :get, {})
-        subject.connection.should_receive(:basic_auth).with(options[:login], options[:password])
-        subject.connection.stub_chain('app.call').and_return("response")
-        subject.request(:get, "foo")
+      it "should delegate to Faraday's basic auth" do
+        expect(subject.connection.builder.handlers).to include(Faraday::Request::BasicAuthentication)
       end
     end
 
-    it "should call response" do
-        subject.should_receive(:process_response).with("response", :get, {})
-      subject.connection.should_receive(:run_request).with(:get, "http://example.com/foo", nil, nil).and_return("response")
-        subject.request(:get, "foo")
-    end
-  end
-
-  describe ".process_response" do
-
-    let!(:valid_response) { OpenStruct.new(:status => "200")}
-    let!(:redirect_response) { OpenStruct.new(:status => "301", :headers => {"location" => "http://example.com/redirect"})}
-    let!(:error_response) { OpenStruct.new(:status => "404")}
-
-    before(:each) do
-      subject.site = "http://example.com"
-    end
+    describe "without authorization" do
+      let!(:subject) { HTTPTester.new() }
 
-    describe "valid response" do
-      before(:each) do
-        Rapidash::Response.should_receive(:new).and_return("response")
-      end
-        
-      it "should return a response object" do
-        response = subject.process_response(valid_response, :get, {})
-        response.should eql("response")
-      end
-
-      it "should perform a redirect" do
-        subject.should_receive(:request).with(:get, "http://example.com/redirect", anything).and_return(subject.process_response(valid_response, :get, {}))
-        response = subject.process_response(redirect_response, :get, {})
-        response.should eql("response")
+      it "should delegate to Faraday's basic auth" do
+        expect(subject.connection.builder.handlers).to_not include(Faraday::Request::BasicAuthentication)
       end
     end
 
-    describe "error response" do
-      it "should not raise an error by default" do
-        response = subject.process_response(error_response, :get, {})
-        response.should be_nil
-      end
-
-      it "should raise an error if the option is set" do
-          subject = HTTPErrorTester.new
-          expect {
-            response = subject.process_response(error_response, :get, {})
-          }.to raise_error(Rapidash::ResponseError)
-      end
-
+    it "should call response" do
+      response = double(:body => "response")
+      subject.connection.should_receive(:run_request).with(:get, "http://example.com/foo", nil, nil).and_return(response)
+      subject.request(:get, "foo")
     end
   end
 end

data/spec/rapidash/integration/test_client_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 module Integration
-
   class Repo < Rapidash::Base
   end
 
@@ -14,29 +13,17 @@ module Integration
     method :test
     resource :users
   end
-
 end
 
-gazler = OpenStruct.new({
-  :headers => { "content-type" => "application/json" },
-  :body => { :name => "Gary Rennie" }.to_json
-})
-
-repos = OpenStruct.new({
-  :headers => { "content-type" => "application/json" },
-  :body => [ { :name => "Githug" } ].to_json
-})
-
 responses = {
   :get => {
-    "members/Gazler" => gazler,
-    "members/Gazler/repos" => repos,
+    "members/Gazler" => { :name => "Gary Rennie" }.to_json,
+    "members/Gazler/repos" => [{ :name => "Githug" }].to_json,
   }
 }
 
 describe "An actual Rapidash Client" do
-
-  let!(:client) { Integration::Client.new(:responses => responses) }
+  let(:client) { Integration::Client.new(responses, :json => true) }
 
   it "should get the user from the API" do
     client.users!("Gazler").name.should eql("Gary Rennie")

data/spec/rapidash/oauth_client_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-class OAuthTester
+class OAuthTester < Rapidash::Client
   include Rapidash::OAuthClient
 end
 
@@ -11,11 +11,6 @@ class OAuthErrorTester < OAuthTester
 end
 
 describe Rapidash::OAuthClient do
-
-  before(:each) do
-    Rapidash::Response.stub(:new).and_return(Hashie::Mash.new)
-  end
-
   let(:options) {
     {
       :uid => "foo",
@@ -67,45 +62,19 @@ describe Rapidash::OAuthClient do
   end
 
   describe ".request" do
-
-    let(:request) { mock }
+    let(:request) { mock(:body => 'data') }
 
     describe "object returned from API call" do
-
       before(:each) do
         subject.stub(:oauth_access_token).and_return(request)
         subject.stub(:normalize_url).with("me").and_return("me")
-        request.stub(:get)
+        request.stub(:get) { request }
       end
 
       it "should return a Hashie::Mash" do
-        subject.request(:get, "me").class.should eql(Hashie::Mash)
-      end
-
-    end
-
-    describe "when errors are set" do
-      it "should call oauth_access_token.send with errors set" do
-        subject = OAuthErrorTester.new(options)
-        subject.stub(:normalize_url).and_return("error")
-        subject.stub(:oauth_access_token).and_return(request)
-        request.should_receive(:send).with(:get, "http://example.com/error", {:raise_errors => true})
-        subject.request(:get, "error")
-      end
-      
-    end
-
-    describe "when a body is set" do
-      it "should call oauth_access_token.send with errors set" do
-        subject.stub(:normalize_url).and_return("users")
-        subject.stub(:oauth_access_token).and_return(request)
-        request.should_receive(:send).with(:get, "http://example.com/users", {:body => {"foo" => "bar"}.to_json, :raise_errors => false})
-        subject.request(:get, "error", :body => {"foo" => "bar"})
+        subject.request(:get, "me").should eq 'data'
       end
-      
     end
-
-
   end
 end
 

data/spec/rapidash/response_error_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+class MyCustomResponseError < Rapidash::ResponseError
+  def errors
+    if body.kind_of?(Array)
+      body.join(', ')
+    else
+      body
+    end
+  end
+end
+
+describe Rapidash::ResponseError do
+
+  context "standard response error class" do
+    let(:response) { Rapidash::ResponseError.new(env) }
+    let(:env) { { :status => '404', :method => 'post', :url => 'http://acme.com/api/posts', :body => 'Page not found' } }
+
+    describe ".initialize" do
+      it "should set attributes" do
+        expect(response.status).to eq 404
+        expect(response.method).to eq 'POST'
+        expect(response.url).to eq 'http://acme.com/api/posts'
+        expect(response.body).to eq 'Page not found'
+      end
+    end
+
+    describe "#message" do
+      it "should create a formatted error message" do
+        message = response.send(:message)
+        expect(message).to eq '404 POST http://acme.com/api/posts'
+      end
+    end
+  end
+
+  context "custom error class with #errors method" do
+    before :each do
+      Rapidash.response_exception_class = MyCustomResponseError
+    end
+
+    let(:response) { MyCustomResponseError.new(env) }
+    let(:env) { { :status => '404', :method => 'post', :url => 'http://acme.com/api/posts', :body => ['name cannot be blank', 'content cannot be blank'] } }
+
+    it "should call #errors" do
+      response.should_receive(:errors)
+      response.send(:message)
+    end
+
+    it "should create a formatted error message" do
+      message = response.send(:message)
+      expect(message).to eq '404 POST http://acme.com/api/posts | Errors: name cannot be blank, content cannot be blank'
+    end
+
+    after :each do
+      Rapidash.response_exception_class = nil
+    end
+
+  end
+end

data/spec/rapidash/test_client_spec.rb

@@ -1,26 +1,29 @@
 require "spec_helper"
 
-class TestClientTester
+class TesterClient
   include Rapidash::TestClient
 end
 
-describe Rapidash::HTTPClient do
+describe Rapidash::TestClient do
+  let(:responses) do
+    { :get => { "foo" => "bar" } }
+  end
 
-  let!(:responses) { 
-    {
-      :get => {
-        "foo" => "response"
-      }
-    } 
-  }
+  let(:client) { TesterClient.new(responses) }
 
-  let!(:subject) { TestClientTester.new(:responses => responses) }
+  describe ".new" do
+    let(:stubs) { client.stubs }
 
-  describe ".request" do
-    it "should do something" do
-      Rapidash::Response.should_receive(:new).with("response")
-      subject.request(:get, "foo")
+    it "should create Faraday test stubs" do
+      expect(stubs).to be_a Faraday::Adapter::Test::Stubs
     end
   end
 
+  describe "#request" do
+    let(:response) { client.request(:get, '/foo') }
+
+    it "should respond with the correct data" do
+      expect(response).to eq 'bar'
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rapidash
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0.beta
 platform: ruby
 authors:
 - Gary 'Gazler' Rennie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2013-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,7 +73,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -94,6 +94,34 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware-multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: oauth2
   requirement: !ruby/object:Gem::Requirement
@@ -126,16 +154,16 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.0.0
 description: Evolve your API
 email:
 - gazler@gmail.com
@@ -151,25 +179,26 @@ files:
 - README.md
 - Rakefile
 - examples/github.rb
+- lib/faraday/response/raise_rapidash_error.rb
 - lib/rapidash.rb
 - lib/rapidash/base.rb
 - lib/rapidash/client.rb
-- lib/rapidash/errors.rb
 - lib/rapidash/http_client.rb
 - lib/rapidash/oauth_client.rb
 - lib/rapidash/resourceable.rb
-- lib/rapidash/response.rb
+- lib/rapidash/response_error.rb
 - lib/rapidash/test_client.rb
 - lib/rapidash/urlable.rb
 - lib/rapidash/version.rb
 - rapidash.gemspec
+- spec/faraday/raise_rapidash_error_spec.rb
 - spec/rapidash/base_spec.rb
 - spec/rapidash/client_spec.rb
 - spec/rapidash/http_client_spec.rb
 - spec/rapidash/integration/test_client_spec.rb
 - spec/rapidash/oauth_client_spec.rb
 - spec/rapidash/resourceable_spec.rb
-- spec/rapidash/response_spec.rb
+- spec/rapidash/response_error_spec.rb
 - spec/rapidash/test_client_spec.rb
 - spec/rapidash/urlable_spec.rb
 - spec/spec_helper.rb
@@ -188,23 +217,24 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.2
 signing_key: 
 specification_version: 4
 summary: An opinionated core for creating clients for RESTful APIs quickly
 test_files:
+- spec/faraday/raise_rapidash_error_spec.rb
 - spec/rapidash/base_spec.rb
 - spec/rapidash/client_spec.rb
 - spec/rapidash/http_client_spec.rb
 - spec/rapidash/integration/test_client_spec.rb
 - spec/rapidash/oauth_client_spec.rb
 - spec/rapidash/resourceable_spec.rb
-- spec/rapidash/response_spec.rb
+- spec/rapidash/response_error_spec.rb
 - spec/rapidash/test_client_spec.rb
 - spec/rapidash/urlable_spec.rb
 - spec/spec_helper.rb

data/lib/rapidash/errors.rb

@@ -1,5 +0,0 @@
-module Rapidash
-  class ParseError < StandardError; end
-  class ConfigurationError < StandardError; end
-  class ResponseError < StandardError; end
-end

data/lib/rapidash/response.rb

@@ -1,29 +0,0 @@
-require 'json'
-require 'hashie'
-
-module Rapidash
-  class Response
-    class << self
-      def new(response)
-        return nil unless response.body
-        return nil if response.body.empty?
-        return nil if response.body == "null"
-        type = response.headers["content-type"]
-        body = JSON.parse(response.body)
-        if body.kind_of?(Hash)
-          return Hashie::Mash.new(body)
-        elsif body.kind_of?(Array)
-          output = []
-          body.each do |el|
-            output << Hashie::Mash.new(el)
-          end
-          return output
-        end
-      rescue JSON::ParserError => e
-        raise ParseError.new("Failed to parse content for type: #{type}")
-      end
-    end
-
-  end
-end
-

data/spec/rapidash/response_spec.rb

@@ -1,145 +0,0 @@
-require 'json'
-require "spec_helper"
-
-def valid_response_object
-  body = {"foo" => "bar" }.to_json
-  OpenStruct.new({
-    :headers => {
-      "content-type" => "application/json"
-    },
-    :body => body
-  })
-end
-
-def valid_html_response_object
-  body = {"foo" => "bar" }.to_json
-  OpenStruct.new({
-    :headers => {
-      "content-type" => "text/html"
-    },
-    :body => body
-  })
-end
-
-def valid_js_response_object
-  body = {"foo" => "bar" }.to_json
-  OpenStruct.new({
-    :headers => {
-      "content-type" => "text/javascript"
-    },
-    :body => body
-  })
-end
-
-def valid_null_response_object
-  body = nil.to_json
-  OpenStruct.new({
-    :headers => {
-      "content-type" => "application/json"
-    },
-    :body => body
-  })
-end
-
-def valid_empty_response_object
-  body = ""
-  OpenStruct.new({
-    :headers => {
-      "content-type" => "application/json"
-    },
-    :body => body
-  })
-end
-
-
-def valid_response_array
-  body = [{"foo" => "bar" }, {"baz" => "bra"}].to_json
-  OpenStruct.new({
-    :headers => {
-      "content-type" => "application/json"
-    },
-    :body => body
-  })
-end
-
-
-def invalid_response
-  OpenStruct.new({
-    :headers => {
-      "content-type" => "application/xml"
-    },
-    :body => "<xml>something</xml>"
-  })
-end
-
-def invalid_js_response_object
-  OpenStruct.new({
-    :headers => {
-      "content-type" => "text/javascript"
-    },
-    :body => "<xml>something</xml>"
-  })
-end
-
-def nil_response
-  OpenStruct.new({
-    :body => nil
-  })
-end
-
-describe Rapidash::Response do
-
-  describe "#new" do
-    it "should parse JSON Objects" do
-      response = Rapidash::Response.new(valid_response_object)
-      response.foo.should eql("bar")
-    end
-    
-    it "should parse JSON Objects returned with javascript type" do
-      response = Rapidash::Response.new(valid_js_response_object)
-      response.foo.should eql("bar")
-    end
-    
-    it "should parse JSON Objects returned with html type" do
-      response = Rapidash::Response.new(valid_html_response_object)
-      response.foo.should eql("bar")
-    end        
-
-    it "should parse a JSON null" do
-      response = Rapidash::Response.new(valid_null_response_object)
-      response.should eql(nil)
-    end
-
-    it "should parse an empty body" do
-      response = Rapidash::Response.new(valid_empty_response_object)
-      response.should eql(nil)
-    end
-
-
-    it "should parse JSON Arrays" do
-      response = Rapidash::Response.new(valid_response_array)
-      response[0].foo.should eql("bar")
-      response[1].baz.should eql("bra")
-    end
-
-    it "should return nil if the response has no body" do
-      response = Rapidash::Response.new(nil_response)
-      response.should eql(nil)
-    end
-
-
-    it "should raise an error on a non-json response" do
-      expect {
-        Rapidash::Response.new(invalid_response)
-      }.to raise_error(Rapidash::ParseError)
-    end
-    
-    it "should raise an error on a non-json response body" do
-      expect {
-        Rapidash::Response.new(invalid_js_response_object)
-      }.to raise_error(Rapidash::ParseError)
-    end    
-  end
-
-
-end