api-client 1.5.0 → 1.5.1

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

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe ApiClient::Base do
-  let(:user) { User.new(:a => "a", :b => "b") }
-
-  describe "#get" do
-    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::Base.get('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(:get, "http://api.example.com/user/5", :status => "401")
-      end
-
-      it "should return a Unauthorized exception" do
-        lambda { ApiClient::Base.get('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(:get, "http://api.example.com/user/5", :status => "403")
-      end
-
-      it "should return a Forbidden exception" do
-        lambda { ApiClient::Base.get('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(:get, "http://api.example.com/user/5", :status => "404")
-      end
-
-      it "should return a NotFound exception" do
-        lambda { ApiClient::Base.get('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(:get, "http://api.example.com/user/5", :status => "500")
-      end
-
-      it "should return a InternalServerError exception" do
-        lambda { ApiClient::Base.get('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(:get, "http://api.example.com/user/5", :status => "502")
-      end
-
-      it "should return a BadGateway exception" do
-        lambda { ApiClient::Base.get('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(:get, "http://api.example.com/user/5", :status => "503")
-      end
-
-      it "should return a ServiceUnavailable exception" do
-        lambda { ApiClient::Base.get('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(:get, "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.get('http://api.example.com/user/5').should == user
-        end
-      end
-
-      context "with a specified port" do
-        before :each do
-          FakeWeb.register_uri(:get, "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.get('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(:get, "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.get('http://api.example.com/user/5', {}).should == user
-        end
-      end
-
-      context "with a collection" do
-        before :each do
-          FakeWeb.register_uri(:get, "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.get('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(:get, "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.get('http://api.example.com/user/5', {}).should == [ user, user ]
-        end
-      end
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe ApiClient::Base do
-  let(:user) { User.new(:a => "a", :b => "b") }
-
-  describe "#patch" do
-    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::Base.patch('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(:patch, "http://api.example.com/user/5", :status => "401")
-      end
-
-      it "should return a Unauthorized exception" do
-        lambda { ApiClient::Base.patch('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(:patch, "http://api.example.com/user/5", :status => "403")
-      end
-
-      it "should return a Forbidden exception" do
-        lambda { ApiClient::Base.patch('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(:patch, "http://api.example.com/user/5", :status => "404")
-      end
-
-      it "should return a NotFound exception" do
-        lambda { ApiClient::Base.patch('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(:patch, "http://api.example.com/user/5", :status => "500")
-      end
-
-      it "should return a InternalServerError exception" do
-        lambda { ApiClient::Base.patch('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(:patch, "http://api.example.com/user/5", :status => "502")
-      end
-
-      it "should return a BadGateway exception" do
-        lambda { ApiClient::Base.patch('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(:patch, "http://api.example.com/user/5", :status => "503")
-      end
-
-      it "should return a ServiceUnavailable exception" do
-        lambda { ApiClient::Base.patch('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(:patch, "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.patch('http://api.example.com/user/5', {}).should == user
-        end
-      end
-
-      context "with a specified port" do
-        before :each do
-          FakeWeb.register_uri(:patch, "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.patch('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(:patch, "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.patch('http://api.example.com/user/5', {}).should == user
-        end
-      end
-
-      context "with a collection" do
-        before :each do
-          FakeWeb.register_uri(:patch, "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.patch('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(:patch, "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.patch('http://api.example.com/user/5', {}).should == [ user, user ]
-        end
-      end
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe ApiClient::Base do
-  let(:user) { User.new(:a => "a", :b => "b") }
-
-  describe "#post" do
-    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::Base.post('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(:post, "http://api.example.com/user/5", :status => "401")
-      end
-
-      it "should return a Unauthorized exception" do
-        lambda { ApiClient::Base.post('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(:post, "http://api.example.com/user/5", :status => "403")
-      end
-
-      it "should return a Forbidden exception" do
-        lambda { ApiClient::Base.post('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(:post, "http://api.example.com/user/5", :status => "404")
-      end
-
-      it "should return a NotFound exception" do
-        lambda { ApiClient::Base.post('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(:post, "http://api.example.com/user/5", :status => "500")
-      end
-
-      it "should return a InternalServerError exception" do
-        lambda { ApiClient::Base.post('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(:post, "http://api.example.com/user/5", :status => "502")
-      end
-
-      it "should return a BadGateway exception" do
-        lambda { ApiClient::Base.post('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(:post, "http://api.example.com/user/5", :status => "503")
-      end
-
-      it "should return a ServiceUnavailable exception" do
-        lambda { ApiClient::Base.post('http://api.example.com/user/5', {}) }.should raise_error(ApiClient::Exceptions::ServiceUnavailable)
-      end
-    end
-
-    context "when response code is 2xx" do
-      context "without a specified port" do
-        before :each do
-          FakeWeb.register_uri(:post, "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.post('http://api.example.com/user/5', {}).should == user
-        end
-      end
-
-      context "with a specified port" do
-        before :each do
-          FakeWeb.register_uri(:post, "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.post('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(:post, "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.post('http://api.example.com/user/5', {}).should == user
-        end
-      end
-
-      context "with a collection" do
-        before :each do
-          FakeWeb.register_uri(:post, "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.post('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(:post, "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.post('http://api.example.com/user/5', {}).should == [ user, user ]
-        end
-      end
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe ApiClient::Base do
-  let(:user) { User.new(:a => "a", :b => "b") }
-
-  describe "#put" do
-    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::Base.put('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(:put, "http://api.example.com/user/5", :status => "401")
-      end
-
-      it "should return a Unauthorized exception" do
-        lambda { ApiClient::Base.put('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(:put, "http://api.example.com/user/5", :status => "403")
-      end
-
-      it "should return a Forbidden exception" do
-        lambda { ApiClient::Base.put('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(:put, "http://api.example.com/user/5", :status => "404")
-      end
-
-      it "should return a NotFound exception" do
-        lambda { ApiClient::Base.put('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(:put, "http://api.example.com/user/5", :status => "500")
-      end
-
-      it "should return a InternalServerError exception" do
-        lambda { ApiClient::Base.put('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(:put, "http://api.example.com/user/5", :status => "502")
-      end
-
-      it "should return a BadGateway exception" do
-        lambda { ApiClient::Base.put('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(:put, "http://api.example.com/user/5", :status => "503")
-      end
-
-      it "should return a ServiceUnavailable exception" do
-        lambda { ApiClient::Base.put('http://api.example.com/user/5', {}) }.should raise_error(ApiClient::Exceptions::ServiceUnavailable)
-      end
-    end
-
-    context "when response code is 2xx" do
-      context "without a specified port" do
-        before :each do
-          FakeWeb.register_uri(:put, "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.put('http://api.example.com/user/5', {}).should == user
-        end
-      end
-
-      context "with any specifications" do
-        before :each do
-          FakeWeb.register_uri(:put, "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.put('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(:put, "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.put('http://api.example.com/user/5', {}).should == user
-        end
-      end
-
-      context "with a collection" do
-        before :each do
-          FakeWeb.register_uri(:put, "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.put('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(:put, "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.put('http://api.example.com/user/5', {}).should == [ user, user ]
-        end
-      end
-    end
-  end
-end