hyperclient 0.2.0 → 0.3.0

data/lib/hyperclient/link.rb

@@ -1,4 +1,3 @@
-require 'hyperclient/http'
 require 'hyperclient/resource'
 require 'uri_template'
 
@@ -6,11 +5,6 @@ module Hyperclient
   # Internal: The Link is  used to let a Resource interact with the API.
   #
   class Link
-    extend Forwardable
-    # Public: Delegate all HTTP methods (get, post, put, delete, options and
-    # head) to the http connection.
-    def_delegators :http, :get, :post, :put, :delete, :options, :head
-
     # Public: Initializes a new Link.
     #
     # link          - The String with the URI of the link.
@@ -23,15 +17,10 @@ module Hyperclient
       @uri_variables = uri_variables
     end
 
-    # Public: Returns the Resource which the Link is pointing to.
-    def resource
-      @resource ||=Resource.new(http.get, @entry_point)
-    end
-
     # Public: Indicates if the link is an URITemplate or a regular URI.
     #
     # Returns true if it is templated.
-    # Returns false if it nos templated.
+    # Returns false if it not templated.
     def templated?
       !!@link['templated']
     end
@@ -56,12 +45,48 @@ module Hyperclient
       @url ||= URITemplate.new(@link['href']).expand(@uri_variables)
     end
 
-    private
-    # Internal: Returns the HTTP client used to interact with the API.
-    def http
-      @http ||= HTTP.new(url, @entry_point.config)
+    # Public: Returns the Resource which the Link is pointing to.
+    def resource
+      @resource ||=Resource.new(get.body, @entry_point)
+    end
+
+    def connection
+      @entry_point.connection
+    end
+
+    def get
+      connection.get(url)
+    end
+
+    def options
+      connection.run_request(:options, url, nil, nil)
     end
 
+    def head
+      connection.head(url)
+    end
+
+    def delete
+      connection.delete(url)
+    end
+
+    def post(params)
+      connection.post(url, params)
+    end
+
+    def put(params)
+      connection.put(url, params)
+    end
+
+    def patch(params)
+      connection.patch(url, params)
+    end
+
+    def inspect
+      "#<#{self.class.name} #{@link}>"
+    end
+
+    private
     # Internal: Delegate the method to the API if it exists.
     #
     # This allows `api.links.posts.embedded` instead of

data/lib/hyperclient/link_collection.rb

@@ -16,6 +16,7 @@ module Hyperclient
     # entry_point - The EntryPoint object to inject the cofnigutation.
     #
     def initialize(collection, entry_point)
+      raise "Invalid response for LinkCollection. The response was: #{collection.inspect}" if collection && !collection.respond_to?(:inject)
       @collection = (collection || {}).inject({}) do |hash, (name, link)|
         hash.update(name => Link.new(link, entry_point))
       end

data/lib/hyperclient/resource.rb

@@ -19,12 +19,13 @@ module Hyperclient
     attr_reader :embedded
 
     # Public: Delegate all HTTP methods (get, post, put, delete, options and
-    # head) to its Link.
+    # head) to its self link.
     def_delegators :self_link, :get, :post, :put, :delete, :options, :head
 
     # Public: Initializes a Resource.
+    #
     # representation - The hash with the HAL representation of the Resource.
-    # entry_point    - The EntryPoint object to inject the cofnigutation.
+    # entry_point    - The EntryPoint object to inject the configutation.
     def initialize(representation, entry_point)
       @links       = LinkCollection.new(representation['_links'], entry_point)
       @embedded    = ResourceCollection.new(representation['_embedded'], entry_point)
@@ -32,9 +33,13 @@ module Hyperclient
       @entry_point = entry_point
     end
 
+    def inspect
+      "#<#{self.class.name} self_link:#{self_link.inspect} attributes:#{@attributes.inspect}>"
+    end
+
     private
     # Internal: Returns the self Link of the Resource. Used to handle the HTTP
-    # connections.
+    # methods.
     def self_link
       @links['self']
     end

data/lib/hyperclient/version.rb

@@ -1,3 +1,3 @@
 module Hyperclient
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/hyperclient.rb

@@ -1,7 +1,15 @@
+require 'hyperclient/entry_point'
+require "hyperclient/version"
+
 # Public: Hyperclient namespace.
 #
 module Hyperclient
+  # Public: Convenience method to create new EntryPoints.
+  #
+  # url - A String with the url of the API.
+  #
+  # Returns a Hyperclient::EntryPoint
+  def self.new(url)
+    Hyperclient::EntryPoint.new(url)
+  end
 end
-
-require 'hyperclient/entry_point'
-require "hyperclient/version"

data/test/faraday/connection_test.rb

@@ -0,0 +1,29 @@
+require_relative '../test_helper'
+require_relative '../../lib/faraday/connection'
+
+module Faraday
+  describe Connection do
+    describe 'digest_auth' do
+      let(:connection) do
+        Faraday.new('http://api.example.org/') do |builder|
+          builder.request :url_encoded
+          builder.adapter :net_http
+        end
+      end
+
+      it 'inserts the DigestAuth middleware at the top' do
+        connection.digest_auth('user', 'password')
+
+        connection.builder.handlers.first.klass.must_equal Faraday::Request::DigestAuth
+      end
+
+      it 'passes the user and password to the middleware' do
+        connection.digest_auth('user', 'password')
+
+        Faraday::Request::DigestAuth.expects(:new).with(anything, 'user', 'password').returns(stub_everything)
+
+        connection.get('/')
+      end
+    end
+  end
+end

data/test/faraday/digest_authentication_test.rb

@@ -0,0 +1,41 @@
+require_relative '../test_helper'
+require 'faraday/request/digest_authentication'
+
+module Faraday
+  describe Request::DigestAuth do
+    let(:connection) do
+      Faraday.new('http://api.example.org/') do |builder|
+        builder.request :digest, 'USER', 'PASS'
+        builder.adapter :net_http
+      end
+    end
+
+    describe 'when the server does not return a 401' do
+      it 'does nothing' do
+        stub_request(:get, 'http://api.example.org/productions/1').
+          to_return(status: 500, body: 'Foo body')
+
+        response = connection.get('/productions/1')
+        response.body.must_equal 'Foo body'
+      end
+    end
+
+    describe 'when the server returns a 401' do
+      let(:first_call_headers) { 'Digest realm="MyApp", algorithm=MD5' }
+      let(:second_call_headers) { 'Digest username="USER", realm="MyApp", uri="/", algorithm="MD5"' }
+      it 'authenticates using digest' do
+        stub_request(:get, 'http://api.example.org/productions/1').
+          with(body: nil).
+          to_return(status: 401, headers: {'www-authenticate' => first_call_headers})
+
+        stub_request(:get, 'http://api.example.org/productions/1').
+          with(body: "{\"foo\":1}",
+               headers: {'Authorization' => %r{second_call_headers}}).
+               to_return(body: '{"resource": "This is the resource"}',
+                         headers: {content_type: 'application/json'})
+
+        connection.get('/productions/1')
+      end
+    end
+  end
+end

data/test/hyperclient/entry_point_test.rb

@@ -3,48 +3,31 @@ require 'hyperclient/entry_point'
 
 module Hyperclient
   describe EntryPoint do
-    let(:api) do
+    let(:entry_point) do
       EntryPoint.new 'http://my.api.org'
     end
 
-    before do
-      stub_request(:get, "http://my.api.org/").
-          to_return(body: '{"_links": {"self": {"href": "http://my.api.org"}}}', headers: {content_type: 'application/json'})
-    end
-
-    describe 'initialize' do
-      it 'initializes a Resource at the entry point' do
-        api.links['self'].url.must_equal 'http://my.api.org'
+    describe 'connection' do
+      it 'creates a Faraday connection with the entry point url' do
+        entry_point.connection.url_prefix.to_s.must_equal 'http://my.api.org/'
       end
 
-      it 'setups the HTTP config' do
-        options = {:headers => {'accept-encoding' => 'deflate, gzip'}}
-
-        api = EntryPoint.new('http://my.api.org', options)
-
-        api.config[:headers].must_include 'accept-encoding'
+      it 'creates a Faraday connection with the default headers' do
+        entry_point.headers['Content-Type'].must_equal 'application/json'
+        entry_point.headers['Accept'].must_equal 'application/json'
       end
 
-      it 'sets the base_uri for HTTP' do
-        api = EntryPoint.new('http://my.api.org')
-
-        api.config[:base_uri].must_equal 'http://my.api.org'
+      it 'creates a Faraday connection with the default block' do
+        handlers = entry_point.connection.builder.handlers
+        handlers.must_include FaradayMiddleware::EncodeJson
+        handlers.must_include FaradayMiddleware::ParseJson
+        handlers.must_include Faraday::Adapter::NetHttp
       end
     end
 
-    describe 'method missing' do
-      it 'delegates undefined methods to the API when they exist' do
-        Resource.any_instance.expects(:foo).returns 'foo'
-        api.foo.must_equal 'foo'
-      end
-
-      it 'responds to missing methods' do
-        Resource.any_instance.expects(:respond_to?).with('foo').returns(true)
-        api.respond_to?(:foo).must_equal true
-      end
-
-      it 'raises an error when the method does not exist in the API' do
-        lambda { api.this_method_does_not_exist }.must_raise(NoMethodError)
+    describe 'initialize' do
+      it 'sets a Link with the entry point url' do
+        entry_point.url.must_equal 'http://my.api.org'
       end
     end
   end

data/test/hyperclient/link_test.rb

@@ -1,9 +1,12 @@
 require_relative '../test_helper'
 require 'hyperclient/link'
+require 'hyperclient/entry_point'
 
 module Hyperclient
   describe Link do
-    let(:entry_point) { stub('Entry point', config: {base_uri: '/'}) }
+    let(:entry_point) do
+      EntryPoint.new('http://api.example.org/')
+    end
 
     describe 'templated?' do
       it 'returns true if the link is templated' do
@@ -19,17 +22,6 @@ module Hyperclient
       end
     end
 
-    describe 'resource' do
-      let(:http) { mock('HTTP', get: {}) }
-
-      it 'builds a resource with the hyperlink representation' do
-        HTTP.expects(:new).returns(http, {})
-        Resource.expects(:new).with({}, entry_point)
-
-        Link.new({}, entry_point).resource
-      end
-    end
-
     describe 'expand' do
       it 'buils a Link with the templated URI representation' do
         link = Link.new({'href' => '/orders{?id}', 'templated' => true}, entry_point)
@@ -64,6 +56,95 @@ module Hyperclient
       end
     end
 
+    describe 'resource' do
+      it 'builds a resource with the link href representation' do
+        Resource.expects(:new).with({}, entry_point)
+
+        link = Link.new({'href' => '/'}, entry_point)
+        link.expects(:get).returns(mock(body: {}))
+
+        link.resource
+      end
+    end
+
+    describe 'connection' do
+      it 'returns the entry point connection' do
+        Link.new({}, entry_point).connection.must_equal entry_point.connection
+      end
+    end
+
+    describe 'get' do
+      it 'sends a GET request with the link url' do
+        link = Link.new({'href' => '/productions/1'}, entry_point)
+
+        entry_point.connection.expects(:get).with('/productions/1')
+        link.get
+      end
+    end
+
+    describe 'options' do
+      it 'sends a OPTIONS request with the link url' do
+        link = Link.new({'href' => '/productions/1'}, entry_point)
+
+        entry_point.connection.expects(:run_request).with(:options, '/productions/1', nil, nil)
+        link.options
+      end
+    end
+
+    describe 'head' do
+      it 'sends a HEAD request with the link url' do
+        link = Link.new({'href' => '/productions/1'}, entry_point)
+
+        entry_point.connection.expects(:head).with('/productions/1')
+        link.head
+      end
+    end
+
+    describe 'delete' do
+      it 'sends a DELETE request with the link url' do
+        link = Link.new({'href' => '/productions/1'}, entry_point)
+
+        entry_point.connection.expects(:delete).with('/productions/1')
+        link.delete
+      end
+    end
+
+    describe 'post' do
+      it 'sends a POST request with the link url and params' do
+        link = Link.new({'href' => '/productions/1'}, entry_point)
+
+        entry_point.connection.expects(:post).with('/productions/1', {'foo' => 'bar'})
+        link.post({'foo' => 'bar'})
+      end
+    end
+
+    describe 'put' do
+      it 'sends a PUT request with the link url and params' do
+        link = Link.new({'href' => '/productions/1'}, entry_point)
+
+        entry_point.connection.expects(:put).with('/productions/1', {'foo' => 'bar'})
+        link.put({'foo' => 'bar'})
+      end
+    end
+
+    describe 'patch' do
+      it 'sends a PATCH request with the link url and params' do
+        link = Link.new({'href' => '/productions/1'}, entry_point)
+
+        entry_point.connection.expects(:patch).with('/productions/1', {'foo' => 'bar'})
+        link.patch({'foo' => 'bar'})
+      end
+    end
+
+    describe 'inspect' do
+      it 'outputs a custom-friendly output' do
+        link = Link.new({'href'=>'/productions/1'}, 'foo')
+
+        link.inspect.must_include 'Link'
+        link.inspect.must_include '"href"=>"/productions/1"'
+      end
+    end
+
     describe 'method_missing' do
       before do
         stub_request(:get, "http://myapi.org/orders").

data/test/hyperclient_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'hyperclient'
+
+describe Hyperclient do
+  describe 'new' do
+    it 'creates a new EntryPoint with the url' do
+      Hyperclient::EntryPoint.expects(:new).with('http://api.example.org')
+
+      Hyperclient.new('http://api.example.org')
+    end
+  end
+end

data/test/test_helper.rb

@@ -9,7 +9,7 @@ gem 'minitest'
 
 require 'minitest/spec'
 require 'minitest/autorun'
-require 'mocha'
+require 'mocha/setup'
 require 'turn'
 require 'webmock/minitest'
 require 'json'