api_client 0.5.24-java → 0.5.25-java

data/lib/api_client/utils.rb

@@ -0,0 +1,18 @@
+module ApiClient
+
+  module Utils
+
+    def self.deep_merge(hash, other_hash)
+      other_hash.each_pair do |key,v|
+        if hash[key].is_a?(::Hash) and v.is_a?(::Hash)
+          deep_merge hash[key], v
+        else
+          hash[key] = v
+        end
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/api_client/version.rb

@@ -0,0 +1,3 @@
+module ApiClient
+  VERSION = '0.5.25'
+end

data/spec/api_client/base/connection_hook_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  describe '.connection' do
+
+    it "registers a new connection_hook" do
+      ConnectionHookTestProc = lambda {}
+      class ConnectionHookTest < ApiClient::Base
+        connection &ConnectionHookTestProc
+      end
+      ConnectionHookTest.connection_hooks.size.should == 1
+      ConnectionHookTest.connection_hooks.should == [ConnectionHookTestProc]
+    end
+
+  end
+
+end

data/spec/api_client/base/delegation_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  it "delegates methods to scope" do
+    scope = double
+    ApiClient::Base.stub(:scope).and_return(scope)
+    [:fetch, :get, :put, :post, :patch, :delete, :headers, :endpoint, :options, :adapter, :params, :raw].each do |method|
+      scope.should_receive(method)
+      ApiClient::Base.send(method)
+    end
+
+  end
+
+end

data/spec/api_client/base/inheritance_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  describe "subclasses" do
+
+    it "inherit scopes, hooks, namespace and format" do
+
+      class Level1InheritanceTest < ApiClient::Base
+      end
+
+      Level1InheritanceTest.default_scopes.should   == []
+      Level1InheritanceTest.connection_hooks.should == []
+      Level1InheritanceTest.namespace.should        == nil
+      Level1InheritanceTest.format.should           == :json
+
+      Level1InheritanceTest.default_scopes   = ['scope1']
+      Level1InheritanceTest.connection_hooks = ['hook1']
+      Level1InheritanceTest.namespace        'level1'
+      Level1InheritanceTest.format           :xml
+
+      ApiClient::Base.default_scopes.should   == []
+      ApiClient::Base.connection_hooks.should == []
+      ApiClient::Base.namespace.should        == nil
+      ApiClient::Base.format.should           == :json
+
+      class Level2InheritanceTest < Level1InheritanceTest
+        namespace "level2"
+        format    :yaml
+      end
+
+      Level2InheritanceTest.default_scopes.should   == ['scope1']
+      Level2InheritanceTest.connection_hooks.should == ['hook1']
+      Level2InheritanceTest.namespace.should        == 'level2'
+      Level2InheritanceTest.format.should           == :yaml
+
+      Level1InheritanceTest.namespace.should == 'level1'
+      Level1InheritanceTest.format.should    == :xml
+
+    end
+
+  end
+
+end

data/spec/api_client/base/instantiation_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  describe "build" do
+
+    it "instantiates an array of objects and returns an array if passed an array" do
+      result = ApiClient::Base.build [{ :id => 1 }, { :id => 2}]
+      result.should be_an_instance_of(Array)
+      result.first.should be_an_instance_of(ApiClient::Base)
+      result.last.should  be_an_instance_of(ApiClient::Base)
+    end
+
+    it "instantiates an object and returns an object if passed an object" do
+      result = ApiClient::Base.build({ :id => 1 })
+      result.should be_an_instance_of(ApiClient::Base)
+    end
+
+  end
+
+  describe "build_one" do
+
+    it "extracts the attributes from a namespace if a namespace is provided" do
+      ApiClient::Base.stub(:namespace).and_return("base")
+      result = ApiClient::Base.build({ "base" => { :id => 1 } })
+      result.should be_an_instance_of(ApiClient::Base)
+      result.keys.should == ['id']
+      result.id.should   == 1
+    end
+
+  end
+
+  describe "sub hashes" do
+
+    it "are Hashie::Mashes" do
+      result = ApiClient::Base.build({ :id => 1, :subhash => { :foo => 1 } })
+      result.subhash.should be_a(Hashie::Mash)
+    end
+
+  end
+
+  describe "original_scope" do
+
+    it "holds the original scope it was created from" do
+      scope = ApiClient::Base.params(:foo => 1).headers('token' => 'aaa').options("some" => "option")
+
+      instance = scope.build :key => 'value'
+      instance.original_scope.headers.should == {'token' => 'aaa'}
+      instance.original_scope.params.should be_empty
+      instance.original_scope.options.should be_empty
+    end
+
+  end
+
+end

data/spec/api_client/base/marshalling_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe "Marshaling of ApiClient objects" do
+  ConnectionProc = Proc.new {}
+  AlwaysProc = Proc.new {}
+
+  class Entity < ApiClient::Base
+    connection &ConnectionProc
+    always &AlwaysProc
+
+    def mutated_state?
+      @state == "mutated"
+    end
+
+    def mutate_state!
+      @state = "mutated"
+    end
+  end
+
+  it "is marshallable by default" do
+    scope = Entity.params(:foo => 1).headers("token" => "aaa").options("some" => "option")
+    entity = scope.build :key => "value"
+
+    entity.mutated_state?.should == false
+    entity.mutate_state!
+    entity.mutated_state?.should == true
+
+    reloaded = Marshal.load(Marshal.dump(entity))
+
+    reloaded.should == entity
+    reloaded.mutated_state?.should == true
+  end
+end

data/spec/api_client/base/parsing_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+require "multi_xml"
+
+describe ApiClient::Base do
+
+  it "parses json if json is set as format" do
+    ApiClient::Base.stub(:format).and_return(:json)
+    parsed = ApiClient::Base.parse('{"a":"1"}')
+    parsed.should == {"a"=> "1"}
+  end
+
+  it "parses xml if xml is set as format" do
+    ApiClient::Base.stub(:format).and_return(:xml)
+    parsed = ApiClient::Base.parse('<a>1</a>')
+    parsed.should == {"a"=> "1"}
+  end
+
+  it "returns the string if parser is not found" do
+    ApiClient::Base.stub(:format).and_return(:unknown)
+    parsed = ApiClient::Base.parse('a:1')
+    parsed.should == "a:1"
+  end
+
+  it "extracts the body of a Faraday::Response if it is provided" do
+    response = Faraday::Response.new(:body => '{"a": "1"}')
+    ApiClient::Base.stub(:format).and_return(:json)
+    parsed = ApiClient::Base.parse(response)
+    parsed.should == {"a"=> "1"}
+  end
+
+  it "returns nil if the response is 204" do
+    response = Faraday::Response.new(:body => nil, :status => 204)
+    ApiClient::Base.stub(:format).and_return(:json)
+    parsed = ApiClient::Base.parse(response)
+    parsed.should == nil
+  end
+end

data/spec/api_client/base/scoping_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  describe '.always' do
+
+    it "registers a new default_scope" do
+      AlwaysTestProc = lambda {}
+      class AlwaysTest < ApiClient::Base
+        always &AlwaysTestProc
+      end
+      AlwaysTest.default_scopes.size.should == 1
+      AlwaysTest.default_scopes.should == [AlwaysTestProc]
+    end
+
+  end
+
+  describe '.scope' do
+
+    it "returns a ApiClient::Scope instance" do
+      ApiClient::Base.scope.should be_an_instance_of(ApiClient::Scope)
+    end
+
+  end
+
+  describe '.scope_thread_attribute_name' do
+
+    it "returns the key under which all .scoped calls should be stored" do
+      ApiClient::Base.scope_thread_attribute_name.should == "ApiClient::Base_scope"
+    end
+
+  end
+
+  describe '.scoped' do
+
+    it "stores the scope in the thread context, attached to class name" do
+      mock_scope3 = double
+      ApiClient::Base.scoped(mock_scope3) do
+        Thread.new {
+          mock_scope2 = double
+          ApiClient::Base.scoped(mock_scope2) do
+            ApiClient::Base.scope.should == mock_scope2
+            Thread.current[ApiClient::Base.scope_thread_attribute_name].should == [mock_scope2]
+          end
+        }
+        ApiClient::Base.scope.should == mock_scope3
+        Thread.current[ApiClient::Base.scope_thread_attribute_name].should == [mock_scope3]
+      end
+      Thread.new {
+        mock_scope = double
+        ApiClient::Base.scoped(mock_scope) do
+          ApiClient::Base.scope.should == mock_scope
+          Thread.current[ApiClient::Base.scope_thread_attribute_name].should == [mock_scope]
+        end
+      }
+    end
+
+  end
+
+end

data/spec/api_client/base_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  it "is a subclass of Hashie::Mash" do
+    ApiClient::Base.should inherit_from(Hashie::Mash)
+  end
+
+  it "responds to #id" do
+    subject.should respond_to("id")
+  end
+
+  class StrictApi < ApiClient::Base
+    def accessor_of_x
+      self.x
+    end
+
+    def strict_attr_reader?
+      true
+    end
+  end
+
+  class StrictDescendant < StrictApi
+  end
+
+  context "when used in an array" do
+
+    subject { [StrictApi.new] }
+
+    it "does not break Array#flatten" do
+      lambda { subject.flatten }.should_not raise_error
+    end
+
+  end
+
+  describe "#inspect" do
+
+    it "has a nice inspect" do
+      subject.update(:id => 1).inspect.should == '#<ApiClient::Base id: 1>'
+    end
+
+    it "presents all fields in inspect" do
+      subject.update(:id => 1, :foo => 'OMG')
+      subject.inspect.should == '#<ApiClient::Base id: 1, foo: "OMG">'
+    end
+
+    it "inspects subobjects properly" do
+      subject.update(:id => 1, :sub => [1,2])
+      subject.inspect.should == '#<ApiClient::Base id: 1, sub: #<Hashie::Array [1, 2]>>'
+    end
+
+    it "makes sure id is the first key" do
+
+      subject.update(:foo => 'OMG', :id => 1)
+      subject.inspect.should == '#<ApiClient::Base id: 1, foo: "OMG">'
+    end
+
+  end
+
+  describe "strict_read" do
+    it "fails if the key is missing and strict_read is set" do
+      api = StrictApi.new
+      lambda { api.missing }.should raise_error do |error|
+        error_type = error.class.to_s
+        error_type.should match(/KeyError|IndexError/)
+      end
+    end
+
+    it "doesn't fail if strict_read is not set" do
+      api = ApiClient::Base.new
+      api.missing
+    end
+
+    it "doesn't fail if the key was set after object was created" do
+      api = StrictApi.new
+      lambda { api.not_missing = 1 }.should_not raise_error
+      api.not_missing.should == 1
+    end
+
+    it "doesn't fail for predicate methods if key is not set" do
+      api = StrictApi.new
+      lambda { api.missing? }.should_not raise_error
+      api.missing?.should be_false
+    end
+
+    it "allows to call methods" do
+      api = StrictApi.new(:x => 14)
+      api.accessor_of_x.should == 14
+    end
+
+    it "calling method which asks for missing attribute fails" do
+      api = StrictApi.new
+      lambda { api.accessor_of_x }.should raise_error do |error|
+        error_type = error.class.to_s
+        error_type.should match(/KeyError|IndexError/)
+      end
+    end
+
+    it "passes strict api configuration to subclasses" do
+      api = StrictDescendant.new
+      lambda { api.missing }.should raise_error do |error|
+        error_type = error.class.to_s
+        error_type.should match(/KeyError|IndexError/)
+      end
+    end
+  end
+end

data/spec/api_client/connection/abstract_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe ApiClient::Connection::Abstract do
+
+  class ConnectionSubclass < ApiClient::Connection::Abstract
+  end
+
+  it "does not raise an error when instantiating a subclass" do
+    lambda {
+      ConnectionSubclass.new("http://google.com")
+    }.should_not raise_error()
+  end
+
+  it "raises an error when instantiating directly and not as a subclass" do
+    lambda {
+      ApiClient::Connection::Abstract.new("http://google.com")
+    }.should raise_error("Cannot instantiate abstract class")
+  end
+
+end
+

data/spec/api_client/connection/basic_spec.rb

@@ -0,0 +1,191 @@
+require "spec_helper"
+
+describe ApiClient::Connection::Basic do
+
+  it "has a nice inspect" do
+    instance = ApiClient::Connection::Basic.new("http://google.com")
+    instance.inspect.should == '#<ApiClient::Connection::Basic endpoint: "http://google.com">'
+  end
+
+  it "adds basic middlewares to faraday" do
+    instance = ApiClient::Connection::Basic.new("http://google.com")
+    instance.handler.builder.handlers.collect(&:name).should == ["Faraday::Request::UrlEncoded", "Faraday::Adapter::NetHttp"]
+  end
+
+  it "adds the logger middlewares to faraday if ApiClient.logger is available" do
+    logger = double
+    ApiClient.stub(:logger).and_return(logger)
+    instance = ApiClient::Connection::Basic.new("http://google.com")
+    instance.handler.builder.handlers.collect(&:name).should == [
+      "ApiClient::Connection::Middlewares::Request::Logger",
+      "Faraday::Request::UrlEncoded",
+      "Faraday::Adapter::NetHttp"
+    ]
+
+  end
+
+  it "creates a Faraday object on initialize" do
+    instance = ApiClient::Connection::Basic.new("http://google.com")
+    instance.handler.should be_an_instance_of(Faraday::Connection)
+  end
+
+  describe "requests" do
+
+    before do
+      @instance = ApiClient::Connection::Basic.new("http://google.com")
+      @headers  = { "header" => "token" }
+      @params   = { "param" => "1", "nested" => { "param" => "1" } }
+      @response = Faraday::Response.new(:status => 200)
+      @faraday_request_params = double
+      @faraday_request = double(:params => @faraday_request_params)
+    end
+
+    it "can perform GET requests" do
+      @instance.handler.
+        should_receive(:run_request).
+        with(:get, '/home', nil, @headers).
+        and_yield(@faraday_request).
+        and_return(@response)
+      @faraday_request_params.should_receive(:update).with(@params)
+      @instance.get "/home", @params, @headers
+    end
+
+    it "can perform POST requests" do
+      @instance.handler.
+        should_receive(:run_request).
+        with(:post, '/home', @params, @headers).
+        and_return(@response)
+      @instance.post "/home", @params, @headers
+    end
+
+    it "can perform PATCH requests" do
+      @instance.handler.
+        should_receive(:run_request).
+        with(:patch, '/home', @params, @headers).
+        and_return(@response)
+      @instance.patch "/home", @params, @headers
+    end
+
+    it "can perform PUT requests" do
+      @instance.handler.
+        should_receive(:run_request).
+        with(:put, '/home', @params, @headers).
+        and_return(@response)
+      @instance.put "/home", @params, @headers
+    end
+
+    it "can perform DELETE requests" do
+      @instance.handler.
+        should_receive(:run_request).
+        with(:delete, '/home', nil, @headers).
+        and_yield(@faraday_request).
+        and_return(@response)
+      @faraday_request_params.should_receive(:update).with(@params)
+      @instance.delete "/home", @params, @headers
+    end
+
+  end
+
+  describe "#handle_response" do
+    let(:request) { double }
+
+    before do
+      @instance = ApiClient::Connection::Basic.new("http://google.com")
+      @response = Faraday::Response.new(:status => 200)
+    end
+
+    it "raises an ApiClient::Errors::ConnectionFailed if there is no response" do
+      lambda {
+        @instance.send :handle_response, request, nil
+      }.should raise_error(ApiClient::Errors::ConnectionFailed, "ApiClient::Errors::ConnectionFailed")
+    end
+
+    it "raises an ApiClient::Errors::Unauthorized if status is 401" do
+      @response.env[:status] = 401
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::Unauthorized, "Status code: 401")
+    end
+
+    it "raises an ApiClient::Errors::Forbidden if status is 403" do
+      @response.env[:status] = 403
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::Forbidden, "Status code: 403")
+    end
+
+    it "raises an ApiClient::Errors::NotFound if status is 404" do
+      @response.env[:status] = 404
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::NotFound, "Status code: 404")
+    end
+
+    it "raises an ApiClient::Errors::BadRequest if status is 400" do
+      @response.env[:status] = 400
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::BadRequest, "Status code: 400")
+    end
+
+    it "raises an ApiClient::Errors::Unsupported if status is 406" do
+      @response.env[:status] = 406
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::Unsupported, "Status code: 406")
+    end
+
+    it "raises an ApiClient::Errors::Conflict if status is 409" do
+      @response.env[:status] = 409
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::Conflict, "Status code: 409")
+    end
+
+    it "raises an ApiClient::Errors::Gone if status is 410" do
+      @response.env[:status] = 410
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::Gone, "Status code: 410")
+    end
+
+    it "raises an ApiClient::Errors::Unsupported if status is 422" do
+      @response.env[:status] = 422
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::UnprocessableEntity, @response.body)
+    end
+
+    it "raises an ApiClient::Errors::Locked if status is 423" do
+      @response.env[:status] = 423
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::Locked, @response.body)
+    end
+
+    it "raises an ApiClient::Errors::TooManyRequests if status is 429" do
+      @response.env[:status] = 429
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::TooManyRequests, @response.body)
+    end
+
+    it "raises an ApiClient::Errors::Unsupported if status is 300..399" do
+      location = "https://google.com"
+      @response.env[:status] = 302
+      @response.env[:response_headers] = { 'Location' => location }
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::Redirect, location)
+    end
+
+    it "raises an ApiClient::Errors::ServerError if status is 500..599" do
+      @response.env[:status] = 502
+      lambda {
+        @instance.send :handle_response, request, @response
+      }.should raise_error(ApiClient::Errors::ServerError, "Status code: 502")
+    end
+
+  end
+
+end