api-client 1.5.0 → 1.5.1

data/lib/api-client/version.rb

@@ -1,5 +1,5 @@
 # High Level Namespace of the library ApiClient.
 module ApiClient
   # Version of the library.
-  VERSION = "1.5.0"
+  VERSION = "1.5.1"
 end

data/spec/api-client/base_spec.rb

@@ -17,6 +17,26 @@ describe ApiClient::Base do
     end
   end
 
+  describe "#remote_object" do
+    context "on a class without remote object specification" do
+      it "should return the class name" do
+        User.remote_object.should == "user"
+      end
+    end
+
+    context "on a class with remote object specification" do
+      it "should return the class name" do
+        Admin.remote_object.should == "user"
+      end
+    end
+  end
+
+  describe "#remote_object=" do
+    it "should set the remote object name" do
+      Admin.remote_object.should == "user"
+    end
+  end
+
   describe "#persisted?" do
     it "should return false" do
       User.new.should_not be_persisted

data/spec/api-client/dispatcher_spec.rb

@@ -1,53 +1,103 @@
 require 'spec_helper'
 
 describe ApiClient::Dispatcher do
-  describe "#_get" do
+  describe "#get" do
     before :each do
       FakeWeb.register_uri(:get, "http://api.example.com/user/5", :status => "200")
     end
 
-    it "should return the response code and body" do
-      ApiClient::Base._get("http://api.example.com/user/5", {}).should be_a(Net::HTTPOK)
+    it "should return the request" do
+      ApiClient::Dispatcher.get("http://api.example.com/user/5", {}).should be_a(Net::HTTPOK)
+    end
+
+    context "when connection is refused" do
+      before :each do
+        FakeWeb.register_uri(:get, "http://api.example.com/user/5", :exception => Errno::ECONNREFUSED)
+      end
+
+      it "should return a ConnectionRefused exception" do
+        lambda { ApiClient::Dispatcher.get('http://api.example.com/user/5') }.should raise_error(ApiClient::Exceptions::ConnectionRefused)
+      end
     end
   end
 
-  describe "#_post" do
+  describe "#post" do
     before :each do
       FakeWeb.register_uri(:post, "http://api.example.com/user/5", :status => "201")
     end
 
-    it "should return the response code and body" do
-      ApiClient::Base._post("http://api.example.com/user/5", {}, {}).should be_a(Net::HTTPCreated)
+    it "should return the request" do
+      ApiClient::Dispatcher.post("http://api.example.com/user/5", {}, {}).should be_a(Net::HTTPCreated)
+    end
+
+    context "when connection is refused" do
+      before :each do
+        FakeWeb.register_uri(:post, "http://api.example.com/user/5", :exception => Errno::ECONNREFUSED)
+      end
+
+      it "should return a ConnectionRefused exception" do
+        lambda { ApiClient::Dispatcher.post('http://api.example.com/user/5', {}) }.should raise_error(ApiClient::Exceptions::ConnectionRefused)
+      end
     end
   end
 
-  describe "#_put" do
+  describe "#put" do
     before :each do
       FakeWeb.register_uri(:put, "http://api.example.com/user/5", :status => "200")
     end
 
-    it "should return the response code and body" do
-      ApiClient::Base._put("http://api.example.com/user/5", {}, {}).should be_a(Net::HTTPOK)
+    it "should return the request" do
+      ApiClient::Dispatcher.put("http://api.example.com/user/5", {}, {}).should be_a(Net::HTTPOK)
+    end
+
+    context "when connection is refused" do
+      before :each do
+        FakeWeb.register_uri(:put, "http://api.example.com/user/5", :exception => Errno::ECONNREFUSED)
+      end
+
+      it "should return a ConnectionRefused exception" do
+        lambda { ApiClient::Dispatcher.put('http://api.example.com/user/5', {}) }.should raise_error(ApiClient::Exceptions::ConnectionRefused)
+      end
     end
   end
 
-  describe "#_patch" do
+  describe "#patch" do
     before :each do
       FakeWeb.register_uri(:patch, "http://api.example.com/user/5", :status => "200")
     end
 
-    it "should return the response code and body" do
-      ApiClient::Base._patch("http://api.example.com/user/5", {}, {}).should be_a(Net::HTTPOK)
+    it "should return the request" do
+      ApiClient::Dispatcher.patch("http://api.example.com/user/5", {}, {}).should be_a(Net::HTTPOK)
+    end
+
+    context "when connection is refused" do
+      before :each do
+        FakeWeb.register_uri(:patch, "http://api.example.com/user/5", :exception => Errno::ECONNREFUSED)
+      end
+
+      it "should return a ConnectionRefused exception" do
+        lambda { ApiClient::Dispatcher.patch('http://api.example.com/user/5', {}) }.should raise_error(ApiClient::Exceptions::ConnectionRefused)
+      end
     end
   end
 
-  describe "#_delete" do
+  describe "#delete" do
     before :each do
       FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "200")
     end
 
-    it "should return the response code and body" do
-      ApiClient::Base._delete("http://api.example.com/user/5", {}).should be_a(Net::HTTPOK)
+    it "should return the request" do
+      ApiClient::Dispatcher.delete("http://api.example.com/user/5", {}).should be_a(Net::HTTPOK)
+    end
+
+    context "when connection is refused" do
+      before :each do
+        FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :exception => Errno::ECONNREFUSED)
+      end
+
+      it "should return a ConnectionRefused exception" do
+        lambda { ApiClient::Dispatcher.delete('http://api.example.com/user/5', {}) }.should raise_error(ApiClient::Exceptions::ConnectionRefused)
+      end
     end
   end
 end

data/spec/api-client/errors_spec.rb

@@ -1,14 +1,24 @@
 require 'spec_helper'
 
 describe ApiClient::Errors do
+  describe "#add_errors" do
+    before :each do
+      @errors = ApiClient::Errors.new(self).add_errors({:a => 'b'})
+    end
+
+    it "should initialize a new object" do
+      @errors[:a].should == 'b'
+    end
+  end
+
   describe "#unique_messages" do
     before :each do
       @user = User.new
       @user.valid?
     end
 
-    it "should set #a" do
+    it "should set a unique message for each attribute" do
       @user.errors.unique_messages.should == { :a => "can't be blank and is not included in the list" }
     end
   end
-end
+end

data/spec/api-client/parser_spec.rb

@@ -1,18 +1,22 @@
 require 'spec_helper'
 
 describe ApiClient::Parser do
-  describe "#_response" do
+  describe "#response" do
+    before :each do
+      @remote_object = ApiClient::Base.remote_object
+    end
+
     context "with a valid json response" do
       context "without a root node" do
         before :each do
           FakeWeb.register_uri(:post, "http://api.example.com/user/5",
                                :body => { :a => :b }.to_json,
                                :status => "201")
-          @response = ApiClient::Base._post('http://api.example.com/user/5', {}, {})
+          @response = ApiClient::Dispatcher.post('http://api.example.com/user/5', {}, {})
         end
 
         it "should return the response code and the body parsed" do
-          ApiClient::Base._response(@response).should == ['201', { "a" => "b" }]
+          ApiClient::Parser.response(@response, @remote_object).should == { "a" => "b" }
         end
       end
 
@@ -21,11 +25,11 @@ describe ApiClient::Parser do
           FakeWeb.register_uri(:post, "http://api.example.com/user/5",
                                :body => { :base => { :a => :b } }.to_json,
                                :status => "201")
-          @response = ApiClient::Base._post('http://api.example.com/user/5', {}, {})
+          @response = ApiClient::Dispatcher.post('http://api.example.com/user/5', {}, {})
         end
 
         it "should return the response code and the body parsed" do
-          ApiClient::Base._response(@response).should == ['201', { "a" => "b" }]
+          ApiClient::Parser.response(@response, @remote_object).should == { "a" => "b" }
         end
       end
     end
@@ -35,32 +39,80 @@ describe ApiClient::Parser do
         FakeWeb.register_uri(:post, "http://api.example.com/user/5",
                              :body => "wrong",
                              :status => "201")
-        @response = ApiClient::Base._post('http://api.example.com/user/5', {}, {})
+        @response = ApiClient::Dispatcher.post('http://api.example.com/user/5', {}, {})
       end
 
-      it "should return the response code and a nil body" do
-        ApiClient::Base._response(@response).should == ['201', nil]
+      it "should return the response code and an empty hash" do
+        ApiClient::Parser.response(@response, @remote_object).should == {}
       end
     end
-  end
 
-  describe "#remote_object" do
-    context "on a class without remote object specification" do
-      it "should return the class name" do
-        User.remote_object.should == "user"
+    context "with a response code of" do
+      context "401" do
+        before :each do
+          FakeWeb.register_uri(:get, "http://api.example.com/user/5", :status => "401")
+          @response = ApiClient::Dispatcher.get('http://api.example.com/user/5')
+        end
+
+        it "should return a Unauthorized exception" do
+          lambda { ApiClient::Parser.response(@response, @remote_object) }.should raise_error(ApiClient::Exceptions::Unauthorized)
+        end
       end
-    end
 
-    context "on a class with remote object specification" do
-      it "should return the class name" do
-        Admin.remote_object.should == "user"
+      context "403" do
+        before :each do
+          FakeWeb.register_uri(:get, "http://api.example.com/user/5", :status => "403")
+          @response = ApiClient::Dispatcher.get('http://api.example.com/user/5')
+        end
+
+        it "should return a Forbidden exception" do
+          lambda { ApiClient::Parser.response(@response, @remote_object) }.should raise_error(ApiClient::Exceptions::Forbidden)
+        end
       end
-    end
-  end
 
-  describe "#remote_object=" do
-    it "should set the remote object name" do
-      Admin.remote_object.should == "user"
+      context "404" do
+        before :each do
+          FakeWeb.register_uri(:get, "http://api.example.com/user/5", :status => "404")
+          @response = ApiClient::Dispatcher.get('http://api.example.com/user/5')
+        end
+
+        it "should return a NotFound exception" do
+          lambda { ApiClient::Parser.response(@response, @remote_object) }.should raise_error(ApiClient::Exceptions::NotFound)
+        end
+      end
+
+      context "500" do
+        before :each do
+          FakeWeb.register_uri(:get, "http://api.example.com/user/5", :status => "500")
+          @response = ApiClient::Dispatcher.get('http://api.example.com/user/5')
+        end
+
+        it "should return a InternalServerError exception" do
+          lambda { ApiClient::Parser.response(@response, @remote_object) }.should raise_error(ApiClient::Exceptions::InternalServerError)
+        end
+      end
+
+      context "502" do
+        before :each do
+          FakeWeb.register_uri(:get, "http://api.example.com/user/5", :status => "502")
+          @response = ApiClient::Dispatcher.get('http://api.example.com/user/5')
+        end
+
+        it "should return a BadGateway exception" do
+          lambda { ApiClient::Parser.response(@response, @remote_object) }.should raise_error(ApiClient::Exceptions::BadGateway)
+        end
+      end
+
+      context "503" do
+        before :each do
+          FakeWeb.register_uri(:get, "http://api.example.com/user/5", :status => "503")
+          @response = ApiClient::Dispatcher.get('http://api.example.com/user/5')
+        end
+
+        it "should return a ServiceUnavailable exception" do
+          lambda { ApiClient::Parser.response(@response, @remote_object) }.should raise_error(ApiClient::Exceptions::ServiceUnavailable)
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: api-client
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-16 00:00:00.000000000 Z
+date: 2012-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -141,11 +141,6 @@ files:
 - lib/api-client/exceptions/unauthorized.rb
 - lib/api-client/parser.rb
 - lib/api-client/version.rb
-- spec/api-client/base/delete_spec.rb
-- spec/api-client/base/get_spec.rb
-- spec/api-client/base/patch_spec.rb
-- spec/api-client/base/post_spec.rb
-- spec/api-client/base/put_spec.rb
 - spec/api-client/base_spec.rb
 - spec/api-client/dispatcher_spec.rb
 - spec/api-client/errors_spec.rb
@@ -163,12 +158,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3101266763150892507
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3101266763150892507
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24

data/spec/api-client/base/delete_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe ApiClient::Base do
-  let(:user) { User.new(:a => "a", :b => "b") }
-
-  describe "#delete" do
-    context "when connection is refused" do
-      before :each do
-        FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :exception => Errno::ECONNREFUSED)
-      end
-
-      it "should return a ConnectionRefused exception" do
-        lambda { ApiClient::Base.delete('http://api.example.com/user/5') }.should raise_error(ApiClient::Exceptions::ConnectionRefused)
-      end
-    end
-
-    context "when response code is 401" do
-      before :each do
-        FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "401")
-      end
-
-      it "should return a Unauthorized exception" do
-        lambda { ApiClient::Base.delete('http://api.example.com/user/5') }.should raise_error(ApiClient::Exceptions::Unauthorized)
-      end
-    end
-
-    context "when response code is 403" do
-      before :each do
-        FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "403")
-      end
-
-      it "should return a Forbidden exception" do
-        lambda { ApiClient::Base.delete('http://api.example.com/user/5') }.should raise_error(ApiClient::Exceptions::Forbidden)
-      end
-    end
-
-    context "when response code is 404" do
-      before :each do
-        FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "404")
-      end
-
-      it "should return a NotFound exception" do
-        lambda { ApiClient::Base.delete('http://api.example.com/user/5') }.should raise_error(ApiClient::Exceptions::NotFound)
-      end
-    end
-
-    context "when response code is 500" do
-      before :each do
-        FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "500")
-      end
-
-      it "should return a InternalServerError exception" do
-        lambda { ApiClient::Base.delete('http://api.example.com/user/5') }.should raise_error(ApiClient::Exceptions::InternalServerError)
-      end
-    end
-
-    context "when response code is 502" do
-      before :each do
-        FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "502")
-      end
-
-      it "should return a BadGateway exception" do
-        lambda { ApiClient::Base.delete('http://api.example.com/user/5') }.should raise_error(ApiClient::Exceptions::BadGateway)
-      end
-    end
-
-    context "when response code is 503" do
-      before :each do
-        FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "503")
-      end
-
-      it "should return a ServiceUnavailable exception" do
-        lambda { ApiClient::Base.delete('http://api.example.com/user/5') }.should raise_error(ApiClient::Exceptions::ServiceUnavailable)
-      end
-    end
-
-    context "when response code is 2xx" do
-      context "without any specifications" do
-        before :each do
-          FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "201", :body => '{"a": "a", "b": "b"}')
-          User.stub(:new).and_return(user)
-        end
-
-        it "should return a object initialized with the response" do
-          User.delete('http://api.example.com/user/5').should == user
-        end
-      end
-
-      context "with a specified port" do
-        before :each do
-          FakeWeb.register_uri(:delete, "http://api.example.com:3001/user/5", :status => "201", :body => '{"a": "a", "b": "b"}')
-          User.stub(:new).and_return(user)
-        end
-
-        it "should return a object initialized with the response" do
-          User.delete('http://api.example.com:3001/user/5', {}).should == user
-        end
-      end
-
-      context "with a specified remote object name" do
-        before :each do
-          FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "201", :body => '{"user": {"a": "a", "b": "b"} }')
-          Admin.stub(:new).and_return(user)
-        end
-
-        it "should return a object initialized with the response" do
-          Admin.delete('http://api.example.com/user/5', {}).should == user
-        end
-      end
-
-      context "with a collection" do
-        before :each do
-          FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "201", :body => '{"users": [ {"a": "a", "b": "b"}, {"a": "a", "b": "b"} ] }')
-          User.stub(:new).and_return(user)
-        end
-
-        it "should return a collection of objects initialized with the response" do
-          User.delete('http://api.example.com/user/5', {}).should == [ user, user ]
-        end
-      end
-
-      context "with a collection and a specified remote object name" do
-        before :each do
-          FakeWeb.register_uri(:delete, "http://api.example.com/user/5", :status => "201", :body => '{"users": [ {"a": "a", "b": "b"}, {"a": "a", "b": "b"} ] }')
-          Admin.stub(:new).and_return(user)
-        end
-
-        it "should return a collection of objects initialized with the response" do
-          Admin.delete('http://api.example.com/user/5', {}).should == [ user, user ]
-        end
-      end
-    end
-  end
-end