hyperclient 0.0.8 → 0.1.0

data/test/hyperclient/collection_test.rb

@@ -0,0 +1,39 @@
+require_relative '../test_helper'
+require 'hyperclient/resource'
+
+module Hyperclient
+  describe Collection do
+    let(:representation) do
+      JSON.parse( File.read('test/fixtures/element.json'))
+    end
+
+    let(:collection) do
+      Collection.new(representation)
+    end
+
+    it 'exposes the collection as methods' do
+      collection.title.must_equal 'Real World ASP.NET MVC3'
+      collection.description.must_match(/production/)
+      collection.permitted.must_equal true
+    end
+
+    it 'exposes collection as a hash' do
+      collection['title'].must_equal 'Real World ASP.NET MVC3'
+      collection['description'].must_match(/production/)
+      collection['permitted'].must_equal true
+    end
+
+    it 'correctly responds to methods' do
+      collection.must_respond_to :title
+    end
+
+    it 'acts as enumerable' do
+      names = collection.map do |name, value|
+        name
+      end
+
+      names.must_equal ['_links', 'title', 'description', 'permitted', '_embedded']
+    end
+  end
+end
+

data/test/hyperclient/entry_point_test.rb

@@ -0,0 +1,51 @@
+require_relative '../test_helper'
+require 'hyperclient/entry_point'
+
+module Hyperclient
+  describe EntryPoint do
+    let(:api) 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'
+      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'
+      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'
+      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)
+      end
+    end
+  end
+end

data/test/hyperclient/http_test.rb

@@ -3,33 +3,47 @@ require 'hyperclient/http'
 
 module Hyperclient
   describe HTTP do
-    let (:resource) do
-      resource = MiniTest::Mock.new
-      resource.expect(:url, 'http://api.example.org/productions/1')
+    let(:url) do
+      '/productions/1'
     end
 
-    let (:http) do
+    let(:config) { {base_uri: 'http://api.example.org'} }
+
+    let(:http) do
       HTTP.instance_variable_set("@default_options", {})
-      HTTP.new(resource)
+      HTTP.new(url, config)
+    end
+
+    describe 'url' do
+      it 'merges the resource url with the base uri' do
+        http.url.to_s.must_equal 'http://api.example.org/productions/1'
+      end
+
+      it 'returns the given url if it cannot merge it' do
+        config = {base_uri: nil}
+        http = HTTP.new(url, config)
+        http.url.to_s.must_equal '/productions/1'
+      end
     end
 
     describe 'authentication' do
       it 'sets the authentication options' do
-        stub_request(:get, 'user:pass@api.example.org/productions/1').
-          to_return(body: 'This is the resource')
+        stub_request(:get, 'http://user:pass@api.example.org/productions/1').
+          to_return(body: '{"resource": "This is the resource"}')
+
+        config.update({auth: {type: :basic, user: 'user', password: 'pass'}})
 
-        http = HTTP.new(resource, {auth: {type: :basic, credentials: ['user','pass']}})
-        http.get.must_equal 'This is the resource'
+        http.get.must_equal({'resource' => 'This is the resource'})
       end
     end
 
     describe 'headers' do
       it 'sets headers from the given option' do
-        http = HTTP.new(resource, {headers: {'accept-encoding' => 'deflate, gzip'}})
+        config.update({headers: {'accept-encoding' => 'deflate, gzip'}})
 
-        stub_request(:get, 'api.example.org/productions/1').
+        stub_request(:get, 'http://api.example.org/productions/1').
           with(headers: {'Accept-Encoding' => 'deflate, gzip'}).
-          to_return(body: 'This is the resource')
+          to_return(body: '{"resource": "This is the resource"}')
 
         http.get
       end
@@ -37,14 +51,14 @@ module Hyperclient
 
     describe 'debug' do
       it 'enables debugging' do
-        http = HTTP.new(resource, {debug: true})
+        config.update({debug: true})
 
         http.class.instance_variable_get(:@default_options)[:debug_output].must_equal $stderr
       end
 
       it 'uses a custom stream' do
         stream = StringIO.new
-        http = HTTP.new(resource, {debug: stream})
+        config.update({debug: stream})
 
         http.class.instance_variable_get(:@default_options)[:debug_output].must_equal stream
       end
@@ -52,14 +66,14 @@ module Hyperclient
 
     describe 'get' do
       it 'sends a GET request and returns the response body' do
-        stub_request(:get, 'api.example.org/productions/1').
-          to_return(body: 'This is the resource')
+        stub_request(:get, 'http://api.example.org/productions/1').
+          to_return(body: '{"resource": "This is the resource"}')
 
-        http.get.must_equal 'This is the resource'
+        http.get.must_equal({'resource' => 'This is the resource'})
       end
 
       it 'returns the parsed response' do
-        stub_request(:get, 'api.example.org/productions/1').
+        stub_request(:get, 'http://api.example.org/productions/1').
           to_return(body: '{"some_json": 12345 }', headers: {content_type: 'application/json'})
 
         http.get.must_equal({'some_json' => 12345})
@@ -68,7 +82,7 @@ module Hyperclient
 
     describe 'post' do
       it 'sends a POST request' do
-        stub_request(:post, 'api.example.org/productions/1').
+        stub_request(:post, 'http://api.example.org/productions/1').
           to_return(body: 'Posting like a big boy huh?', status: 201)
 
         response = http.post({data: 'foo'})
@@ -80,7 +94,7 @@ module Hyperclient
 
     describe 'put' do
       it 'sends a PUT request' do
-        stub_request(:put, 'api.example.org/productions/1').
+        stub_request(:put, 'http://api.example.org/productions/1').
           to_return(body: 'No changes were made', status: 204)
 
         response = http.put({attribute: 'changed'})
@@ -92,7 +106,7 @@ module Hyperclient
 
     describe 'options' do
       it 'sends a OPTIONS request' do
-        stub_request(:options, 'api.example.org/productions/1').
+        stub_request(:options, 'http://api.example.org/productions/1').
           to_return(status: 200, headers: {allow: 'GET, POST'})
 
         response = http.options
@@ -102,7 +116,7 @@ module Hyperclient
 
     describe 'head' do
       it 'sends a HEAD request' do
-        stub_request(:head, 'api.example.org/productions/1').
+        stub_request(:head, 'http://api.example.org/productions/1').
           to_return(status: 200, headers: {content_type: 'application/json'})
 
         response = http.head
@@ -112,7 +126,7 @@ module Hyperclient
 
     describe 'delete' do
       it 'sends a DELETE request' do
-        stub_request(:delete, 'api.example.org/productions/1').
+        stub_request(:delete, 'http://api.example.org/productions/1').
           to_return(body: 'Resource deleted', status: 200)
 
         response = http.delete

data/test/hyperclient/link_collection_test.rb

@@ -0,0 +1,29 @@
+require_relative '../test_helper'
+require 'hyperclient/link_collection'
+
+module Hyperclient
+  describe LinkCollection do
+    let(:entry_point) { stub('Entry point', config: {base_uri: '/'}) }
+
+    let(:representation) do
+      JSON.parse( File.read('test/fixtures/element.json'))
+    end
+
+    let(:links) do
+      LinkCollection.new(representation['_links'], entry_point)
+    end
+
+    it 'is a collection' do
+      LinkCollection.ancestors.must_include Collection
+    end
+
+    it 'initializes the collection with links' do
+      links.must_respond_to :filter
+    end
+
+    it 'returns link objects for each link' do
+      links.filter.must_be_kind_of Link
+      links['self'].must_be_kind_of Link
+    end
+  end
+end

data/test/hyperclient/link_test.rb

@@ -0,0 +1,93 @@
+require_relative '../test_helper'
+require 'hyperclient/link'
+
+module Hyperclient
+  describe Link do
+    let(:entry_point) { stub('Entry point', config: {base_uri: '/'}) }
+
+    describe 'templated?' do
+      it 'returns true if the link is templated' do
+        link = Link.new({'templated' => true}, entry_point)
+
+        link.templated?.must_equal true
+      end
+
+      it 'returns false if the link is not templated' do
+        link = Link.new({}, entry_point)
+
+        link.templated?.must_equal false
+      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)
+
+        Link.expects(:new).with(anything, entry_point, {id: '1'})
+        link.expand(id: '1')
+      end
+
+      it 'raises if no uri variables are given' do
+        link = Link.new({'href' => '/orders{?id}', 'templated' => true}, entry_point)
+
+        proc { link.resource }.must_raise MissingURITemplateVariablesException
+      end
+    end
+
+    describe 'url' do
+      it 'raises when missing required uri_variables' do
+        link = Link.new({'href' => '/orders{?id}', 'templated' => true}, entry_point)
+
+        lambda { link.url }.must_raise MissingURITemplateVariablesException
+      end
+
+      it 'expands an uri template with variables' do
+        link = Link.new({'href' => '/orders{?id}', 'templated' => true}, entry_point, {id: 1})
+
+        link.url.must_equal '/orders?id=1'
+      end
+
+      it 'returns the link when no uri template' do
+        link = Link.new({'href' => '/orders'}, entry_point)
+        link.url.must_equal '/orders'
+      end
+    end
+
+    describe 'method_missing' do
+      before do
+        stub_request(:get, "http://myapi.org/orders").
+          to_return(body: '{"resource": "This is the resource"}')
+        Resource.expects(:new).returns(resource).at_least_once
+      end
+
+      let(:link) { Link.new({'href' => 'http://myapi.org/orders'}, entry_point) }
+      let(:resource) { mock('Resource') }
+
+      it 'delegates unkown methods to the resource' do
+        resource.expects(:embedded)
+
+        link.embedded
+      end
+
+      it 'raises an error when the method does not exist in the resource' do
+        lambda { link.this_method_does_not_exist }.must_raise(NoMethodError)
+      end
+
+      it 'responds to missing methods' do
+        resource.expects(:respond_to?).with('embedded').returns(true)
+        link.respond_to?(:embedded).must_equal true
+      end
+    end
+  end
+end

data/test/hyperclient/resource_collection_test.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+require 'hyperclient/resource_collection'
+
+module Hyperclient
+  describe ResourceCollection do
+    let(:entry_point) { stub('Entry point', config: {base_uri: '/'}) }
+
+    let(:representation) do
+      JSON.parse( File.read('test/fixtures/element.json'))
+    end
+
+    let(:resources) do
+      ResourceCollection.new(representation['_embedded'], entry_point)
+    end
+
+    it 'is a collection' do
+      ResourceCollection.ancestors.must_include Collection
+    end
+
+    it 'initializes the collection with resources' do
+      resources.must_respond_to :author
+      resources.must_respond_to :episodes
+    end
+
+    it 'returns resource objects for each resource' do
+      resources.author.must_be_kind_of Resource
+    end
+
+    it 'also builds arras of resource' do
+      resources.episodes.must_be_kind_of Array
+      resources.episodes.first.must_be_kind_of Resource
+    end
+  end
+end

data/test/hyperclient/resource_test.rb

@@ -3,66 +3,60 @@ require 'hyperclient/resource'
 
 module Hyperclient
   describe Resource do
-    let(:representation) do
-      File.read('test/fixtures/element.json')
-    end
-
-    let(:parsed_representation) do
-      JSON.parse(representation)
-    end
+    let(:entry_point) { mock('Entry point') }
 
-    before do
-      Resource.entry_point = 'http://api.example.org'
-    end
+    describe 'initialize' do
+      it 'initializes its links' do
+        LinkCollection.expects(:new).with({"self" => { "href" => "/orders/523" }}, entry_point)
 
-    describe 'url' do
-      it 'merges the resource url with the entry point' do
-        resource = Resource.new('/path/to/resource')
-        resource.url.to_s.must_equal 'http://api.example.org/path/to/resource'
+        Resource.new({'_links' => {"self" => { "href" => "/orders/523" } }}, entry_point)
       end
 
-      it 'returns the given url if it cannot merge it' do
-        resource = Resource.new('/search={terms}')
-        resource.url.to_s.must_equal '/search={terms}'
-      end
-    end
+      it 'initializes its attributes' do
+        Attributes.expects(:new).with({foo: :bar})
 
-    describe 'initialize' do
-      before do
-        stub_request(:get, 'http://api.example.org')
+        Resource.new({foo: :bar}, entry_point)
       end
 
-      it 'initializes the representation when one is given' do
-        resource = Resource.new('/', {representation: JSON.parse(representation)})
+      it 'initializes links' do
+        ResourceCollection.expects(:new).with({"orders" => []}, entry_point)
 
-        assert_not_requested(:get, 'http://api.example.org/')
+        Resource.new({'_embedded' => {"orders" => [] }}, entry_point)
       end
+    end
 
-      it 'sets the resource name' do
-        resource = Resource.new('/', {name: 'posts'})
-
-        resource.name.must_equal 'posts'
+    describe 'accessors' do
+      let(:resource) do
+        Resource.new({}, entry_point)
       end
-    end
 
-    describe 'reload' do
-      before do
-        stub_request(:get, "http://api.example.org/productions/1").
-          to_return(:status => 200, :body => representation, headers: {content_type: 'application/json'})
+      describe 'links' do
+        it 'returns a LinkCollection' do
+          resource.links.must_be_kind_of LinkCollection
+        end
       end
 
-      it 'retrives itself from the API' do
-        resource = Resource.new('/productions/1')
-        resource.reload
+      describe 'attributes' do
+        it 'returns a Attributes' do
+          resource.attributes.must_be_kind_of Attributes
+        end
+      end
 
-        assert_requested(:get, 'http://api.example.org/productions/1', times: 1)
+      describe 'embedded' do
+        it 'returns a ResourceCollection' do
+          resource.embedded.must_be_kind_of ResourceCollection
+        end
       end
+    end
 
-      it 'returns itself' do
-        resource = Resource.new('/productions/1')
+    it 'uses its self Link to handle HTTP connections' do
+      self_link = mock('Self Link')
+      self_link.expects(:get)
 
-        resource.reload.must_equal resource
-      end
+      LinkCollection.expects(:new).returns({'self' => self_link})
+      resource = Resource.new({}, entry_point)
+
+      resource.get
     end
   end
 end