api_client 0.1.0

data/lib/api_client/scope.rb

@@ -0,0 +1,101 @@
+
+module ApiClient
+
+  class Scope
+    extend ApiClient::Mixins::Configuration
+    extend ApiClient::Mixins::Delegation
+
+    delegate     :scoped, :to => :scopeable
+
+    dsl_accessor :endpoint, :adapter, :return_self => true
+
+    attr_reader  :scopeable
+
+    def initialize(scopeable)
+      @scopeable  = scopeable
+      @params     = {}
+      @headers    = {}
+      @options    = {}
+      @hooks      = @scopeable.connection_hooks || []
+      @scopeable.default_scopes.each do |default_scope|
+        self.instance_eval(&default_scope)
+      end
+    end
+
+    def connection
+      klass       = Connection.const_get((@adapter || Connection.default).to_s.capitalize)
+      @connection = klass.new(@endpoint , @options || {})
+      @hooks.each { |hook| hook.call(@connection) }
+      @connection
+    end
+
+    # 3 Pillars of scoping
+    # options - passed on the the adapter
+    # params  - converted to query or request body
+    # headers - passed on to the request
+    def options(new_options = nil)
+      return @options if new_options.nil?
+      ApiClient::Utils.deep_merge(@options, new_options)
+      self
+    end
+
+    def params(options = nil)
+      return @params if options.nil?
+      ApiClient::Utils.deep_merge(@params, options)  if options
+      self
+    end
+    alias :scope :params
+
+    def headers(options = nil)
+      return @headers if options.nil?
+      ApiClient::Utils.deep_merge(@headers, options) if options
+      self
+    end
+
+    # Half-level :)
+    # This is a swiss-army knife kind of method, extremely useful
+    def fetch(path, options = {})
+      scoped(self) do
+        @scopeable.build get(path, options)
+      end
+    end
+
+    # Low-level connection methods
+
+    def request(method, path, options = {})
+      raw = options.delete(:raw)
+      params(options)
+      response = connection.send method, path, @params, @headers
+      raw ? response : @scopeable.parse(response)
+    end
+
+    def get(path, options = {})
+      request(:get, path, options)
+    end
+
+    def post(path, options = {})
+      request(:post, path, options)
+    end
+
+    def put(path, options = {})
+      request(:put, path, options)
+    end
+
+    def delete(path, options = {})
+      request(:delete, path, options)
+    end
+
+    # Dynamic delegation of scopeable methods
+    def method_missing(method, *args, &block)
+      if @scopeable.respond_to?(method)
+        @scopeable.scoped(self) do
+          @scopeable.send(method, *args, &block)
+        end
+      else
+        super
+      end
+    end
+
+  end
+
+end

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.1.0"
+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 = mock
+    ApiClient::Base.stub(:scope).and_return(scope)
+    [:fetch, :get, :put, :post, :delete, :headers, :endpoint, :options, :adapter, :params].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,54 @@
+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_an_instance_of(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')
+      instance = scope.build :key => 'value'
+      instance.original_scope.should == scope
+
+    end
+
+  end
+
+end

data/spec/api_client/base/parsing_spec.rb

@@ -0,0 +1,36 @@
+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
+
+
+
+
+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 = mock
+      ApiClient::Base.scoped(mock_scope3) do
+        Thread.new {
+          mock_scope2 = mock
+          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 = mock
+        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,17 @@
+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
+
+  it "has a nice inspect" do
+    subject.update(:id => 1).inspect.should == '#<ApiClient::Base id: 1>'
+  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("Cannot instantiate abstract class")
+  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,135 @@
+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 = mock
+    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)
+    end
+
+    it "can perform GET requests" do
+      @instance.handler.should_receive(:get).with("/home?param=1&nested[param]=1", @headers).and_return(@response)
+      @instance.get "/home", { :param => 1, :nested => { :param => 1 } }, @headers
+    end
+
+    it "can perform POST requests" do
+      @instance.handler.should_receive(:post).with("/home", @params, @headers).and_return(@response)
+      @instance.post "/home", @params, @headers
+    end
+
+    it "can perform PUT requests" do
+      @instance.handler.should_receive(:put).with("/home", @params, @headers).and_return(@response)
+      @instance.put "/home", @params, @headers
+    end
+
+    it "can perform DELETE requests" do
+      @instance.handler.should_receive(:delete).with("/home?param=1&nested[param]=1", @headers).and_return(@response)
+      @instance.delete "/home", @params, @headers
+    end
+
+  end
+
+  describe "#handle_response" do
+
+    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, nil
+      }.should raise_error(ApiClient::Errors::ConnectionFailed)
+    end
+
+    it "raises an ApiClient::Errors::Unauthorized if status is 401" do
+      @response.env[:status] = 401
+      lambda {
+        @instance.send :handle_response, @response
+      }.should raise_error(ApiClient::Errors::Unauthorized)
+    end
+
+    it "raises an ApiClient::Errors::Forbidden if status is 403" do
+      @response.env[:status] = 403
+      lambda {
+        @instance.send :handle_response, @response
+      }.should raise_error(ApiClient::Errors::Forbidden)
+    end
+
+    it "raises an ApiClient::Errors::NotFound if status is 404" do
+      @response.env[:status] = 404
+      lambda {
+        @instance.send :handle_response, @response
+      }.should raise_error(ApiClient::Errors::NotFound)
+    end
+
+    it "raises an ApiClient::Errors::BadRequest if status is 400" do
+      @response.env[:status] = 400
+      lambda {
+        @instance.send :handle_response, @response
+      }.should raise_error(ApiClient::Errors::BadRequest)
+    end
+
+    it "raises an ApiClient::Errors::Unsupported if status is 406" do
+      @response.env[:status] = 406
+      lambda {
+        @instance.send :handle_response, @response
+      }.should raise_error(ApiClient::Errors::Unsupported)
+    end
+
+    it "raises an ApiClient::Errors::Unsupported if status is 422" do
+      @response.env[:status] = 422
+      lambda {
+        @instance.send :handle_response, @response
+      }.should raise_error(ApiClient::Errors::UnprocessableEntity)
+    end
+
+    it "raises an ApiClient::Errors::Unsupported if status is 300..399" do
+      @response.env[:status] = 302
+      @response.env[:response_headers] = { 'Location' => "https://google.com" }
+      lambda {
+        @instance.send :handle_response, @response
+      }.should raise_error(ApiClient::Errors::Redirect)
+    end
+
+    it "raises an ApiClient::Errors::ServerError if status is 500..599" do
+      @response.env[:status] = 502
+      lambda {
+        @instance.send :handle_response, @response
+      }.should raise_error(ApiClient::Errors::ServerError)
+    end
+
+  end
+
+end